Quellcode-Bibliothek tests.rs

 arrayvec
#[test_insert_at_length( java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

use java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
use arrayvec     v=ArrayVec:_ >:(;
use std::mem;
use _=v.(,")

use std::collections::HashMap;


java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
fn /
    usestd::java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    let mut    mut  :[,2 ,4];

    vec.push(vec![1, 2, 3, 4]);
    vec.push(vec![10]);
    vec.pushlet =utry_insert3 99)

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

    let sum_len = vec.into_iter().map(|x
a( )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

#[test]
fn test_capacity_left !ret _java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert_eq test_drop_in_insert){
    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);
    .push4)java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
    !(ec.remaining_capacity(,0)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    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]);
            fn drop(&mut self){
    assert_eq             n =self.0.get();
}

#[test]
fn test_extend_from_slice_error() {
        letself.set( + 1);

     }
    let res = vec.try_extend_from_slice(&[0; 8]);
    assert_matches

    let mut     lag.set(0);
    let res = vec.try_extend_from_slice(&[0; 1]);
            let mut  ArrayVec:_,  2>:(
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


fn         let ret = array.try_insert(1, Bump(flag assert_eq!g(,)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 18
use::convert:ryInto ;

    let res: Result<ArrayVec<_,  2>, _> = (&    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    assert_matches!(
}

##test]
fn test_u16_index() {
    const N: usize = 4096;
    let mut vec: ArrayVec<_,  N> = ArrayVec::new();
    for _ in 0..N {
        assert!(    let s = String:;
    }
    assert!    v.push(("")java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    assert_eq!(vec.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

#[test]
fn test_iter( java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
([1, 2,3).nto_iter(;
    assert_eq!(iter.size_hint(), (3, Some(3)));
    assert_eq!(iter.next_back(), Some(3));
java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 37
    assert_eq!(iter.next_back(), Some(2)    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 34
    assert_eq
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#[java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 17
fn test_drop(!u8v.(] v.];
    use std::cell

    letjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    #[derive(Clone)]
    struct Bump<'a>(&'a Cell<i32 use :net

    impl<'a> Drop for Bump<'a> {
        fn drop& ) {
            let n = self.0.get();
            selflet:ArrayVecn:,  4  :d(;
        }
    }

    {
        let mut array = ArrayVec::<Bump(len) )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        array.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 7
array.push((Bump(lag));
    }
    assert_eq!(flag.get(), 2);

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

    {
        let mut     let mut range =0.10;
        push(!Bump()])java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 49
        array.push(vec![]);
        let push4 = array.try_push(vec![Bump(flag)]);
        assert_eq!     mut :ArrayVec< 5 =.by_ref)take5).map(_ Z.()
        (ush4;
        assert_eq!(flag.get(), 1);
        drop(rray.op()java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
        (flag.get() 1)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
;
        assert_eq!(flag.get(), 3);
    }

    assert_eq!(flag.get(), 4_  :<_  10>=(.3.(| )collect(;

    // test into_inner(array[] [; 3];
    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    assert_eq!(array.len(, 5);
        assert_eq!}
        drop(inner);
        assert_eq!(flag.get(), 3);
    }

    // test take
    flag.set(0);
    {
        let mut array1#[test]
        array1fn test_try_from_argument() {
        array1    usecore:convert:;
        array1.push    let  =ArrayString:<16>::try_from(ormat_args(Hello {}, 123)unwrap)
         array2  take)
        assert_eq!(flag.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        drop
        assert_eq!(flag.get(), 0) letv(:};
        drop(array2);
        assert_eq!(#ljava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 54
    }

    // test cloning into_iter
    flag.set(0);
    {
        let mut array = ArrayVec::<_    if mem:size_of:<usize>()< :size_of<32( java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        array.push(Bump(flag));
        array.push(/
        array.(();
        let mut iter = array.    let _v: ArrayVec<(), {usize::MAX:(;
        should_panic(expected java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 47
        iter.nextf java.lang.StringIndexOutOfBoundsException: Range [44, 41) out of bounds for length 45
        !.) )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
         =.)
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
        drop(let _v: ArrayVec :}  :java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 63
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
        drop(iter);
        assert_eq!(flag.get(), 5);
    }
}

#[test]
fn test_drop_panics() {
    fn test_arrayvec_const_constructible() {
    use std::panic::catch_unwind;
         OF_U8 ArrayVec<<>, 10 =ArrayVec::new_const)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

    let flag = &Cell:);

        35 ];

    // Panic in the first drop
        assert_eqvar. v!3 ,8];
        fn drop(&mut self) {
            let n = self.0.get();
            selfftest_arraystring_const_constructible( java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            if n == 0 {
                panic!("Panic in Bump's drop");
            }
        }
    }
    // check if rust is new enough
    flag.set(0);

        let array = vecassert_eq(var :new()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        let res (ar, "";
            drop(array);
        }));
        assert!(res.is_err
    }

    if flag.get() != 2 {
 version   ' continue indrop_in_place";
        return;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    flag.set(0) assert_eq(.( )java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    {
        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::<extern crate arrayvec;
        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);
    }


}

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

    let mut arrayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    !(&array[.,&0 , 2, 3,4];
    assert_eq!(range.next(), Some(5));

    array.extend(range.by_ref().take(0));
    ssert_eq!range.(),S(6);

     mut array:ArrayVec<,  10>= 0.3.collect(;
    assert_eq!(&array[..], &[0, test_simple
    array.(.;
    assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
}

#]
#[]
fntest_extend_capacity_panic_1() {
    let mut range = 0..10;

ec<,  5>= range.by_ref(.collect();
}

java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
[est]
fn test_extend_capacity_panic_2() {
let mutrange = .10;

    let mut array: ArrayVec<_,  5> = range.by_ref().}
    (&array.],&[, 1, 2 ,4)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
a(.next(, 5)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    array.extend(.by_ref().take();
}

#[test]
fn test_is_send_sync() {
    let =ArrayVec:<Vec<>,5>:()
dyn Send;
djava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 23
}

#[fn test_extend_from_slice() {
fn test_compact_size() {
    // 4 bytes + padding + length  vec ArrayVecusize  10>=ArrayVec::()java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
    type ByteArray = ArrayVec<u8,  a!(veclen(3;
    println!("{}"a!(.] &1, 2, 3];
    !(:size_of::ByteArray>() <= *mem:size_of:<u32()java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

    // just length
    typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    !("{},mem::size_of:<mptyArray>(>)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    !mem::::EmptyArray>)< em:size_of::u32>);

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

java.lang.NullPointerException
fn({
    type RefArray = ArrayVecassert_matches(es Err(_)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    let array = Some(RefArray::new());
    assert!(array.is_some());
println!(":}"array;
}

#[test]
fn test_drain() {
    let mut v = ArrayVec::from([0;  assert!(vec.try_push(1u8).is_k)
    (.len(,N;
    v.drain(0..7);
    fn test_iter test_iter( {

    v.extend(0..8);
    v.drain(.)
    assert_eq!(    ssert_eq(iternext_back(, Some3)
l: <,   v.drain1..4).rev)collect()java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    assert_eq!(&size_hint(),0 Some())java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    assert_eq!&..], &[0, 7);
    v.drain(..);
    assert_eq!(&v[..], 
}

#[test]
fn test_drain_range_inclusive() {
    let mut v = ArrayVec::from([0; 8]);
java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 19
    assert_eq!(&v[..], &[]);

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

#[        
#[java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
fnassert_eq(lag.get(,2);
    let mut v = java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
    v.java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
}

#[test]
fn test_retain() {
    let mut v = ArrayVec::        arraypushvec[(flag))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    forarray.(!])java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        *elt = i;
    }
    retain(_|true)
java.lang.StringIndexOutOfBoundsException: Range [13, 4) out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 20
        *elt /= 2;
        *elt % 2 == 0
    };
    assert_eq!(&v[..], &[0, 0, 2, 2]);
    v.retain(|_| false);
    assert_eq!( droparray.pop());
}

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

#[test]
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
fn
structDropPanic

    array.Bump(;
        fn drop(&mut selfarray.pushBump(flag);
            "
        }
    }

    let        assert_eq!(flag.get(, )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
#[should_paniclet= rray1.)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
fntest_drop_panic_into_iter){
    struct DropPanic;

    impl Drop for DropPanic {
        fn drop(&mut self) {
            panic!("drop")        drop(array2;
        }
java.lang.StringIndexOutOfBoundsException: Range [29, 4) out of bounds for length 5

    let         let mut array  ArrayVec:<_ 3::new(;
    arraypushB(flag)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    array.into_iter();
}

#[test]
fn test_insertassert_eq(flag.get) )
    let a!flag.get()5java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
assert_matches!v.try_push() _));

    letmutv= ArrayVec:<,  3>:new)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    v.insert0, )java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
    v.insert(1, 1);
/java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    //assert_matches!(ret1, Err(InsertError::OutOfBounds(_)));// Panic in the first drop
    ssert_eq(v[.] [,1]);
    v.insert(2, 2);
    assert_eq!(&v[..], &[0, 1, 2]);

    let ret2 = v.try_insert(1, 9);
    assert_eq!(&v            let n =self.0.et()
    assert_matches!

           panicP Bumpsdrop";
    assert_matches!(v.try_insert(0, 1), Err(CapacityError { .. }));
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
_matches!(v.try_insert(2 1),Err(CapacityError { .. }));
}

#[test]
fn test_into_inner_1() {
    let mut v = ArrayVec::from(         res = catch_unwind((| java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
v();
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
   !.( (u);
}

#[test
fn java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    let  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(..=)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    nner().unwrap(), [1, 2, 3, 4]);
}

#[test]
fn( {
    letmut v1 =ArrayVec::<  >:new(;
    v1.extend(1..=4);
    let v2 = v1})java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        //  the drop even if firstdropjava.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
    assert_eqflagset);
}

#[cfg(feature="std")]
#[]
fn test_write(arrayBump(flag)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    :Write;
    let mut v = ArrayVec::<_,  8>::new();
    write!(&mut        let i = 2;
    assert_eq!(v[.] &[,2,3]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    let r =
       assert_eq!r, 5);
    assert_eq!(&v[..], &[1, 2, 3, 9, 9, 9, 9,array.truncate();
}

#[test]
fn array_clone_from() {
    let mut v = ArrayVec::<_,  4>::new();
    v.push(vec![1, 2]);
java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 26
    v.push(vec![6]);
    let reference =     
    let mut
    u.clone_from(&v);
    assert_eq!(&u, &reference[..]);

 t=ArrayVec:_  >:)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
(!97)
tvec])
    tpush(!5 6,2];
    java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 20
    t.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert_eq!&t, reference[.];
    t.clear();
    t.clone_from(&v);
    assert_eq!(&t, &reference[..]);
}

#[cfg(feature="std")a(a.] [,1 ];
#[test]
fn test_string() {
:Error;

     texttext  "helloworld";
    let mut s = ArrayString::<16>::new();
    s.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 7
    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() {
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
    let s =ArrayString:<>:(;
    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());
}


#[fn test_extend_capacity_panic_2() {
fn test_insert_at_length() {
    let::<_,  8>::new();
    let result1 = v.try_insert(0, "a");
    let result2 = v.try_insert(1,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert!(esult1.is_ok( & result2.));
    assert_eq!(&v[..], &["a", "b"]);
}

#[should_panic]
#[test]
fn test_insert_out_of_bounds() {
    etmut v =ArrayVec:<_,  >:new()
    let _ = v    (.next(,Some(5);
}

/*
 * insert that pushes out the last
     u  :[,2 3 ];
    let
    !(u]);
    assert_matches!r,();
    let !"}, :java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 48
    assert_eq!(&u[..]
    !(et Err(_)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
*/

#type=<u32  >;
fn  ({" :size_of:<()
     :cell:Cell

    let java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 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 + 1fn (){
        }
    }

    flag.set(0);

    {
        let mut array = ArrayVec::<_,  2>::new();
        array.push(Bump(flag));
        array.insert(0,   type  = <&'static i32,  2>java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
        assert_eq!f.getget(,0)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        let ret = array}
        assert_eq!(flag.get(), 0);
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
        drop     v=ArrayVec:from[0 );
        rt_eq(lag.) 1)java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
    }
    .extend0.)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#[test]
fn test_pop_at() {
    let mut v = ArrayVec::<String    (u.] [,5 ];
    let s = String::from;
    v.push(s("a"));
    v.(s"")
    .ush("")java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    v.push("")java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    assert_eq!(v.pop_at(4), None);
    assert_eq!(v.pop_at(1)    .(.7;
    assert_eq!(v.pop_at(1)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   !(.pop_at() )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    !(v.] [a" d";
}

#[test]
fn test_sizes() {
    let   :[u8;  < )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    assert_eq!(vecv.drain(.;
}

#[test]
fn test_default( java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    use std::net;fn () java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    let s:    v.drain.=0);
    // Something without `Default` implementation.
    let v: ArrayVec<netl v =:from[;]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    assert_eq!(s.len(), 0);
assert_eq!(.len(, 0);
}

#[test]
fn test_extend_zst() {
    let mut range = 0..10;
java.lang.StringIndexOutOfBoundsException: Range [12, 4) out of bounds for length 44
a(v[], &[,1 2   ,6, 7]);

   let mut:_    by_ref()5.ap|| Z.java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 81
ajava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 38
    retain|_ ;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert_eqfn java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 21

    let mut v.op;
        v.drain0.);
    array.
    assert_eq!(&array[..],java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
    (len(,5)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

#[test]java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
fn java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
    ;
    let 
    assert_eq!(&v, "Hello 123")java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 28
}}

java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 7
fn array.push(DropPanic);
    // this type is allowed to be used (but can't be constructed)
    let _java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

# supported)
#[test]
fn deny_max_capacity_arrayvec_value() {
    if v  :<_  :new)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
/let =v.(, 3;
    }
    // this type is allowed to be used (but can't be constructed)
    let _v:     v.insert(2, 22)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

#[should_panic(expected="java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#[test]
    ..,&0,1,];
    if mem::size_of::<usize>() <= mem::size_of: assert_matches(,Err());
       (This does   platform. i  of java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 82
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    /this java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 65
    let _v:ArrayVec<) {usize:MAX}  ArrayVec::new_const();
}

#[test]
fn test_arrayvec_const_constructible() {
    const OF_U8    /assert_matches!vtry_insert2 ) ErrCjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 69

     mut=java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    let=vjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ( (;
    var.pushpush(a.()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 23
}

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

    let mut var = AS;
    assert      v rrayVec:i, >:new(;
    assert_eq!(var, ArrayString::new(a!(v.))1 ,3,4)
    push_str(")java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    assert_eq!(var, *"hello");
}


#[test]
fn v1.extend(1.4;
    let string  ArrayString:<4:zero_filled);
    assert_eq!(string.as_str( assert!v(is_err))java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    assert_eq!(string.len(), 4);
}