A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use std::iter;
use wasmtime::Result;
use wasmtime_environ::collections::{TryCollect, TryVec, try_vec};
use wasmtime_fuzzing::oom::OomTest;
#[test]
fn try_vec_with_capacity() -> Result<()> {
OomTest::new().test(|| {
let _v = wasmtime_environ::collections::TryVec::<usize>::with_capacity(100)?;
Ok(())
})
}
#[test]
fn try_vec_reserve() -> Result<()> {
OomTest::new().test(|| {
let mut v = wasmtime_environ::collections::TryVec::<usize>::new();
v.reserve(10)?;
Ok(())
})
}
#[test]
fn try_vec_reserve_exact() -> Result<()> {
OomTest::new().test(|| {
let mut v = wasmtime_environ::collections::TryVec::<usize>::new();
v.reserve_exact(3)?;
Ok(())
})
}
#[test]
fn try_vec_push() -> Result<()> {
OomTest::new().test(|| {
let mut v = wasmtime_environ::collections::TryVec::new();
v.push(42)?;
Ok(())
})
}
#[test]
fn try_vec_and_boxed_slice() -> Result<()> {
use wasmtime_core::alloc::TryVec;
OomTest::new().test(|| {
// Nonzero-sized type.
let mut vec = TryVec::new();
vec.push(1)?;
let slice = vec.into_boxed_slice()?; // len > 0, cap > 0
let mut vec = TryVec::from(slice);
vec.pop();
let slice = vec.into_boxed_slice()?; // len = 0, cap > 0
let vec = TryVec::from(slice);
let _slice = vec.into_boxed_slice()?; // len = 0, cap = 0
let mut vec = TryVec::new();
vec.reserve_exact(3)?;
vec.push(2)?;
vec.push(2)?;
vec.push(2)?;
let _slice = vec.into_boxed_slice()?; // len = cap, len > 0
for i in 0..12 {
let mut vec = TryVec::new();
for j in 0..i {
vec.push(j)?;
}
let _slice = vec.into_boxed_slice()?; // len ?= cap
}
// Zero-sized type.
let mut vec = TryVec::new();
vec.push(())?;
let slice = vec.into_boxed_slice()?; // len > 0, cap > 0
let mut vec = TryVec::from(slice);
vec.pop();
let slice = vec.into_boxed_slice()?; // len = 0, cap > 0
let vec = TryVec::from(slice);
let _ = vec.into_boxed_slice()?; // len = 0, cap = 0
Ok(())
})
}
#[test]
fn try_vec_shrink_to_fit() -> Result<()> {
use wasmtime_core::alloc::TryVec;
#[derive(Default)]
struct ZeroSized;
#[derive(Default)]
struct NonZeroSized {
_unused: usize,
}
fn do_test<T: Default>() -> Result<()> {
// len == cap == 0
let mut v = TryVec::<T>::new();
v.shrink_to_fit()?;
// len == 0 < cap
let mut v = TryVec::<T>::with_capacity(4)?;
v.shrink_to_fit()?;
// 0 < len < cap
let mut v = TryVec::with_capacity(4)?;
v.push(T::default())?;
v.shrink_to_fit()?;
// 0 < len == cap
let mut v = TryVec::new();
v.reserve_exact(2)?;
v.push(T::default())?;
v.push(T::default())?;
v.shrink_to_fit()?;
Ok(())
}
OomTest::new().test(|| do_test::<ZeroSized>())?;
OomTest::new().test(|| do_test::<NonZeroSized>())?;
Ok(())
}
#[test]
fn try_vec_resize() -> Result<()> {
OomTest::new().test(|| {
let mut v = TryVec::new();
v.resize(10, 'a')?; // Grow.
v.resize(1, 'b')?; // Truncate.
v.resize(1, 'c')?; // Same length.
v.resize(3, 'd')?; // Grow again.
assert_eq!(&*v, &['a', 'd', 'd']);
Ok(())
})
}
#[test]
fn try_vec_try_collect() -> Result<()> {
OomTest::new().test(|| {
iter::repeat(1).take(0).try_collect::<TryVec<_>, _>()?;
iter::repeat(1).take(1).try_collect::<TryVec<_>, _>()?;
iter::repeat(1).take(100).try_collect::<TryVec<_>, _>()?;
iter::repeat(()).take(100).try_collect::<TryVec<_>, _>()?;
Ok(())
})
}
#[test]
fn try_vec_extend() -> Result<()> {
use wasmtime_core::alloc::{TryExtend, TryVec};
OomTest::new().test(|| {
let mut vec = TryVec::new();
vec.try_extend([])?;
vec.try_extend([1])?;
vec.try_extend([1, 2, 3, 4])?;
let mut vec = TryVec::new();
vec.try_extend([])?;
vec.try_extend([()])?;
vec.try_extend([(), (), ()])?;
Ok(())
})
}
#[test]
fn try_vec_macro_elems() -> Result<()> {
OomTest::new().test(|| {
let v = try_vec![100, 200, 300, 400]?;
assert_eq!(&*v, &[100, 200, 300, 400]);
Ok(())
})
}
#[test]
fn try_vec_macro_elem_len() -> Result<()> {
OomTest::new().test(|| {
let v = try_vec![100; 3]?;
assert_eq!(&*v, &[100, 100, 100]);
Ok(())
})
}