Quelle  tests.rs

extern crate arrayvec;
#[macro_use] extern crate matches;

use arrayvec::ArrayVec;
use arrayvec::ArrayString;
use std::mem;
use arrayvec::CapacityError;

use std::collections::HashMap;


#[test]
fn test_simple() {
    use std::ops::Add;

    let mut vec: ArrayVec<Vec<i32>,  3> = ArrayVec::new();

    vec.push(vec![1, 2, 3, 4]);
    vec.push(vec![10]);
    vec.push(vec![-1, 13, -2]);

    for elt in &vec {
        assert_eq!(elt.iter().fold(0, Add::add), 10);
    }

    let sum_len = vec.into_iter().map(|x| x.len()).fold(0, Add::add);
    assert_eq!(sum_len, 8);
}

#[test]
fn test_capacity_left() {
    let mut vec: ArrayVec<usize,  4> = ArrayVec::new();
    assert_eq!(vec.remaining_capacity(), 4);
    vec.push(1);
    assert_eq!(vec.remaining_capacity(), 3);
    vec.push(2);
    assert_eq!(vec.remaining_capacity(), 2);
    vec.push(3);
    assert_eq!(vec.remaining_capacity(), 1);
    vec.push(4);
    assert_eq!(vec.remaining_capacity(), 0);
}

#[test]
fn test_extend_from_slice() {
    let mut vec: ArrayVec<usize,  10> = ArrayVec::new();

    vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
    assert_eq!(vec.len(), 3);
    assert_eq!(&vec[..], &[1, 2, 3]);
    assert_eq!(vec.pop(), Some(3));
    assert_eq!(&vec[..], &[1, 2]);
}

#[test]
fn test_extend_from_slice_error() {
    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 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>, _> = (&[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();
    for _ in 0..N {
        assert!(vec.try_push(1u8).is_ok());
    }
    assert!(vec.try_push(0).is_err());
    assert_eq!(vec.len(), N);
}

#[test]
fn test_iter() {
    let mut iter = ArrayVec::from([1, 2, 3]).into_iter();
    assert_eq!(iter.size_hint(), (3, Some(3)));
    assert_eq!(iter.next_back(), Some(3));
    assert_eq!(iter.next(), Some(1));
    assert_eq!(iter.next_back(), Some(2));
    assert_eq!(iter.size_hint(), (0, Some(0)));
    assert_eq!(iter.next_back(), None);
}

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

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

    #[derive(Clone)]
    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);
        }
    }

    {
        let mut array = ArrayVec::<Bump,  128>::new();
        array.push(Bump(flag));
        array.push(Bump(flag));
    }
    assert_eq!(flag.get(), 2);

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

    {
        let mut array = ArrayVec::<_,  3>::new();
        array.push(vec![Bump(flag)]);
        array.push(vec![Bump(flag), Bump(flag)]);
        array.push(vec![]);
        let push4 = array.try_push(vec![Bump(flag)]);
        assert_eq!(flag.get(), 0);
        drop(push4);
        assert_eq!(flag.get(), 1);
        drop(array.pop());
        assert_eq!(flag.get(), 1);
        drop(array.pop());
        assert_eq!(flag.get(), 3);
    }

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

    // test into_inner
    flag.set(0);
    {
        let mut array = ArrayVec::<_,  3>::new();
        array.push(Bump(flag));
        array.push(Bump(flag));
        array.push(Bump(flag));
        let inner = array.into_inner();
        assert!(inner.is_ok());
        assert_eq!(flag.get(), 0);
        drop(inner);
        assert_eq!(flag.get(), 3);
    }

    // test take
    flag.set(0);
    {
        let mut array1 = ArrayVec::<_,  3>::new();
        array1.push(Bump(flag));
        array1.push(Bump(flag));
        array1.push(Bump(flag));
        let array2 = array1.take();
        assert_eq!(flag.get(), 0);
        drop(array1);
        assert_eq!(flag.get(), 0);
        drop(array2);
        assert_eq!(flag.get(), 3);
    }

    // test cloning into_iter
    flag.set(0);
    {
        let mut array = ArrayVec::<_,  3>::new();
        array.push(Bump(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();
        assert_eq!(flag.get(), 1);
        drop(clone);
        assert_eq!(flag.get(), 3);
        drop(iter);
        assert_eq!(flag.get(), 5);
    }
}

#[test]
fn test_drop_panics() {
    use std::cell::Cell;
    use std::panic::catch_unwind;
    use std::panic::AssertUnwindSafe;

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

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

    // Panic in the first drop
    impl<'a> Drop for Bump<'a> {
        fn drop(&mut self) {
            let n = self.0.get();
            self.0.set(n + 1);
            if n == 0 {
                panic!("Panic in Bump's drop");
            }
        }
    }
    // check if rust is new enough
    flag.set(0);
    {
        let array = vec![Bump(flag), Bump(flag)];
        let res = catch_unwind(AssertUnwindSafe(|| {
            drop(array);
        }));
        assert!(res.is_err());
    }

    if flag.get() != 2 {
        println!("test_drop_panics: skip, this version of Rust doesn't continue in drop_in_place");
        return;
    }

    flag.set(0);
    {
        let mut array = ArrayVec::<Bump,  128>::new();
        array.push(Bump(flag));
        array.push(Bump(flag));
        array.push(Bump(flag));

        let res = catch_unwind(AssertUnwindSafe(|| {
            drop(array);
        }));
        assert!(res.is_err());
    }
    // Check that all the elements drop, even if the first drop panics.
    assert_eq!(flag.get(), 3);


    flag.set(0);
    {
        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));

        let i = 2;
        let tail_len = array.len() - i;

        let res = catch_unwind(AssertUnwindSafe(|| {
            array.truncate(i);
        }));
        assert!(res.is_err());
        // Check that all the tail elements drop, even if the first drop panics.
        assert_eq!(flag.get(), tail_len as i32);
    }


}

#[test]
fn test_extend() {
    let mut range = 0..10;

    let mut array: ArrayVec<_,  5> = range.by_ref().take(5).collect();
    assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
    assert_eq!(range.next(), Some(5));

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

    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]);
}

#[should_panic]
#[test]
fn test_extend_capacity_panic_1() {
    let mut range = 0..10;

    let _: ArrayVec<_,  5> = range.by_ref().collect();
}

#[should_panic]
#[test]
fn test_extend_capacity_panic_2() {
    let mut range = 0..10;

    let mut array: ArrayVec<_,  5> = range.by_ref().take(5).collect();
    assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
    assert_eq!(range.next(), Some(5));
    array.extend(range.by_ref().take(1));
}

#[test]
fn test_is_send_sync() {
    let data = ArrayVec::<Vec<i32>,  5>::new();
    &data as &dyn Send;
    &data as &dyn Sync;
}

#[test]
fn test_compact_size() {
    // 4 bytes + padding + length
    type ByteArray = ArrayVec<u8,  4>;
    println!("{}", mem::size_of::<ByteArray>());
    assert!(mem::size_of::<ByteArray>() <= 2 * mem::size_of::<u32>());

    // just length
    type EmptyArray = ArrayVec<u8,  0>;
    println!("{}", mem::size_of::<EmptyArray>());
    assert!(mem::size_of::<EmptyArray>() <= mem::size_of::<u32>());

    // 3 elements + padding + length
    type QuadArray = ArrayVec<u32,  3>;
    println!("{}", mem::size_of::<QuadArray>());
    assert!(mem::size_of::<QuadArray>() <= 4 * 4 + mem::size_of::<u32>());
}

#[test]
fn test_still_works_with_option_arrayvec() {
    type RefArray = ArrayVec<&'static i32,  2>;
    let array = Some(RefArray::new());
    assert!(array.is_some());
    println!("{:?}", array);
}

#[test]
fn test_drain() {
    let mut v = ArrayVec::from([0; 8]);
    v.pop();
    v.drain(0..7);
    assert_eq!(&v[..], &[]);

    v.extend(0..8);
    v.drain(1..4);
    assert_eq!(&v[..], &[0, 4, 5, 6, 7]);
    let u: ArrayVec<_,  3> = v.drain(1..4).rev().collect();
    assert_eq!(&u[..], &[6, 5, 4]);
    assert_eq!(&v[..], &[0, 7]);
    v.drain(..);
    assert_eq!(&v[..], &[]);
}

#[test]
fn test_drain_range_inclusive() {
    let mut v = ArrayVec::from([0; 8]);
    v.drain(0..=7);
    assert_eq!(&v[..], &[]);

    v.extend(0..8);
    v.drain(1..=4);
    assert_eq!(&v[..], &[0, 5, 6, 7]);
    let u: ArrayVec<_,  3> = v.drain(1..=2).rev().collect();
    assert_eq!(&u[..], &[6, 5]);
    assert_eq!(&v[..], &[0, 7]);
    v.drain(..);
    assert_eq!(&v[..], &[]);
}

#[test]
#[should_panic]
fn test_drain_range_inclusive_oob() {
    let mut v = ArrayVec::from([0; 0]);
    v.drain(0..=0);
}

#[test]
fn test_retain() {
    let mut v = ArrayVec::from([0; 8]);
    for (i, elt) in v.iter_mut().enumerate() {
        *elt = i;
    }
    v.retain(|_| true);
    assert_eq!(&v[..], &[0, 1, 2, 3, 4, 5, 6, 7]);
    v.retain(|elt| {
        *elt /= 2;
        *elt % 2 == 0
    });
    assert_eq!(&v[..], &[0, 0, 2, 2]);
    v.retain(|_| false);
    assert_eq!(&v[..], &[]);
}

#[test]
#[should_panic]
fn test_drain_oob() {
    let mut v = ArrayVec::from([0; 8]);
    v.pop();
    v.drain(0..8);
}

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

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

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

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

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

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

#[test]
fn test_insert() {
    let mut v = ArrayVec::from([]);
    assert_matches!(v.try_push(1), Err(_));

    let mut v = ArrayVec::<_,  3>::new();
    v.insert(0, 0);
    v.insert(1, 1);
    //let ret1 = v.try_insert(3, 3);
    //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, 1, 2]);
    assert_matches!(ret2, Err(_));

    let mut v = ArrayVec::from([2]);
    assert_matches!(v.try_insert(0, 1), Err(CapacityError { .. }));
    assert_matches!(v.try_insert(1, 1), Err(CapacityError { .. }));
    //assert_matches!(v.try_insert(2, 1), Err(CapacityError { .. }));
}

#[test]
fn test_into_inner_1() {
    let mut v = ArrayVec::from([1, 2]);
    v.pop();
    let u = v.clone();
    assert_eq!(v.into_inner(), Err(u));
}

#[test]
fn test_into_inner_2() {
    let mut v = ArrayVec::<String,  4>::new();
    v.push("a".into());
    v.push("b".into());
    v.push("c".into());
    v.push("d".into());
    assert_eq!(v.into_inner().unwrap(), ["a", "b", "c", "d"]);
}

#[test]
fn test_into_inner_3() {
    let mut v = ArrayVec::<i32,  4>::new();
    v.extend(1..=4);
    assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]);
}

#[test]
fn test_take() {
    let mut v1 = ArrayVec::<i32,  4>::new();
    v1.extend(1..=4);
    let v2 = v1.take();
    assert!(v1.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());
}


extern cratearrayvec;
fn ){
    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() {
letmut   ArrayVec:<, 8:new);
    let   v.ry_insert1 "est");
}

/* :ops:Add;
 
let  u= ArrayVec:from(1 2, 3 )
    ret  u.try_insert(,;

    assert_matches    }

        ssert_eq!sum_len,8;
    assert_matches!ret,Err());
*/

#[test]
fn( java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    vec();

assert_eq(ec) );

    }

    impl<'aletmut ,> java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
op 
let java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 33
     .0n);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

fset0;

    {
 array=:<,  2::ew(;
        array.push(Bump(flag))}
        array.insert(0, Bump(flag));
        assert_eq#[test]]
java.lang.StringIndexOutOfBoundsException: Range [17, 8) out of bounds for length 50
       assert_eq!flag.et(,0;
        assert_matches!(ret, Err(_));
        drop(ret);
        assert_eq!(flag.get(),     std:T as_java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       }
    assert_eq!(flag.get(), 3);
}

[java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
fn test_pop_at() {
    let mut v = ArrayVec::<String,  4>::new();
:from
   (a);
    v.push(s("b"));
    v.push(s("c"));
    v.push(s(

    fn){
    assert_eq!(v.pop_at(1),     let mut iter = ArrayVec::from ].nto_iter)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        assert_eq!(iter.next(), Some(1));
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; .en),&v[.);
}

#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   usestd:;
    let s:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // Something without `Default` implementation.fn (mut self java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     v ArrayVec<et:TcpStream,  >=Default:efault)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
    assert_eq!(v.(,0;
}

#[test]
fn        (java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
let  .10
    #[derivearray.(vec[flag];
            array.push(vec![Bump(flag), Bump(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 27

letarray _, >=rangeby_ref()(.map||Z)collect)
    assert_eq!(&array[dropp)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
drop(.(;

    array.assert_eq!flagget,1;
    assert_eq!(range.nextjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

   letmutarray:ArrayVec_  10> 0.)map(||Z.collect(;
    assert_eq!&[.,&Z3)
        java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 31
assert_eq);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


{
 ::TryFrom
v :(!"{" ).(;
    assert_eq!(&v, "Hello 123")        let= array1.take(;
}

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

#should_panic(expected="argest supported capacity")]
#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
::usize( =mem:size_of::u>){
        panic!("This test does not work on this platform. 'largest supported capacity'");
    }
    / this type is allowed to be used (but can't be constructed)push(Bumpflag);
}> = ArrayVec:new);
}

#[="indexout of bounds")]
#[test]
ndeny_max_capacity_arrayvec_value_const() {
    if mem::size_of::<usize>() <= mem::        assert_eq!flag.et(,1;
        let clone iter.lone(;
    }
    // this type is allowed to be used (but can't be constructed)
    <(),{usize:MAX}>=ArrayVec::ew_const();
}

 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 40
const:ArrayVecVecu8,> :(;

    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
pty();
    assert_eq!(var, 
    var.push(vec![3, ,8)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    !([.],[ec[,5 ])java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

#[test]
n ({
    const AS: ArrayString<10> =java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

    letjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    assert
    !var,ArrayString:();
    var.push_str("hello");
    assert_eq!(ar,*hello)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}


#[test]
fn         println!("test_drop_panics: skip, thisofRustdoesntcontinue )
    }
    assert_eq!(string.as_str
   !(stringlen(,4;
}