Split crates/fuzzing/tests/oom.rs into multiple modules

crates/fuzzing/tests/oom/arc.rs

@@ -0,0 +1,14 @@
+#![cfg(arc_try_new)]
+
+use std::sync::Arc;
+use wasmtime::Result;
+use wasmtime_environ::collections::try_new;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+pub(crate) fn try_new_arc() -> Result<()> {
+    OomTest::new().test(|| {
+        let _arc = try_new::<Arc<u32>>(42)?;
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/bforest_map.rs

@@ -0,0 +1,19 @@
+use super::Key;
+use cranelift_bforest::{Map, MapForest};
+use wasmtime::Result;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn bforest_map() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut forest = MapForest::new();
+        let mut map = Map::new();
+        for i in 0..100 {
+            map.try_insert(Key(i), i, &mut forest, &())?;
+        }
+        for i in 0..100 {
+            assert_eq!(map.get(Key(i), &forest, &()), Some(i));
+        }
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/bforest_set.rs

@@ -0,0 +1,19 @@
+use super::Key;
+use cranelift_bforest::{Set, SetForest};
+use wasmtime::Result;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn bforest_set() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut forest = SetForest::new();
+        let mut set = Set::new();
+        for i in 0..100 {
+            set.try_insert(Key(i), &mut forest, &())?;
+        }
+        for i in 0..100 {
+            assert!(set.contains(Key(i), &forest, &()));
+        }
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/bit_set.rs

@@ -0,0 +1,20 @@
+use cranelift_bitset::CompoundBitSet;
+use wasmtime::Result;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn compound_bit_set_try_with_capacity() -> Result<()> {
+    OomTest::new().test(|| {
+        let _bitset = CompoundBitSet::<usize>::try_with_capacity(32)?;
+        Ok(())
+    })
+}
+
+#[test]
+fn compound_bit_set_try_ensure_capacity() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut bitset = CompoundBitSet::new();
+        bitset.try_ensure_capacity(100)?;
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/boxed.rs

@@ -0,0 +1,11 @@
+use wasmtime::Result;
+use wasmtime_environ::collections::try_new;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn try_new_box() -> Result<()> {
+    OomTest::new().test(|| {
+        let _box = try_new::<Box<u32>>(36)?;
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/btree_map.rs

@@ -0,0 +1,49 @@
+use wasmtime::Result;
+use wasmtime_environ::collections::{BTreeMap, btree_map::Entry};
+use wasmtime_fuzzing::oom::OomTest;
+
+type M = BTreeMap<usize, f32>;
+
+#[test]
+fn btree_map() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut m = M::new();
+
+        m.insert(100, 100.0)?;
+
+        m.entry(0).or_insert(99.0)?;
+        m.entry(0).or_default()?;
+
+        match m.entry(1) {
+            Entry::Occupied(_) => unreachable!(),
+            Entry::Vacant(e) => {
+                let e = e.insert_entry(42.0)?;
+                e.insert(43.0);
+            }
+        };
+
+        match m.entry(1) {
+            Entry::Occupied(e) => {
+                e.remove_entry();
+            }
+            Entry::Vacant(_) => unreachable!(),
+        }
+
+        match m.entry(2) {
+            Entry::Occupied(_) => unreachable!(),
+            Entry::Vacant(e) => {
+                e.insert(99.0)?;
+            }
+        };
+
+        let _ = m.iter().count();
+        let _ = m.iter_mut().count();
+        let _ = m.keys().count();
+        let _ = m.values().count();
+        let _ = m.values_mut().count();
+        let _ = m.range(..3).count();
+        let _ = m.range_mut(..3).count();
+
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/config.rs

@@ -0,0 +1,11 @@
+use wasmtime::{Config, Result};
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn config_new() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut config = Config::new();
+        config.enable_compiler(false);
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/engine.rs

@@ -0,0 +1,14 @@
+#![cfg(arc_try_new)]
+
+use wasmtime::{Config, Engine, Result};
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn engine_new() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut config = Config::new();
+        config.enable_compiler(false);
+        let _ = Engine::new(&config)?;
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/entity_set.rs

@@ -0,0 +1,22 @@
+use super::Key;
+use wasmtime::Result;
+use wasmtime_environ::collections::TryEntitySet;
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn try_entity_set_ensure_capacity() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut set = TryEntitySet::<Key>::new();
+        set.ensure_capacity(100)?;
+        Ok(())
+    })
+}
+
+#[test]
+fn try_entity_set_insert() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut set = TryEntitySet::<Key>::new();
+        set.insert(Key::from_u32(256))?;
+        Ok(())
+    })
+}

crates/fuzzing/tests/oom/error.rs

@@ -0,0 +1,109 @@
+use std::{
+    fmt::{self, Write},
+    sync::atomic::{AtomicU32, Ordering::SeqCst},
+};
+use wasmtime::{Error, Result, error::OutOfMemory, format_err};
+use wasmtime_fuzzing::oom::OomTest;
+
+fn ok_if_not_oom(error: Error) -> Result<()> {
+    if error.is::<OutOfMemory>() {
+        Err(error)
+    } else {
+        Ok(())
+    }
+}
+
+#[test]
+fn error_new() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::new(u8::try_from(u32::MAX).unwrap_err());
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn error_msg() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("ouch");
+        ok_if_not_oom(error)
+    })
+}
+
+static X: AtomicU32 = AtomicU32::new(42);
+
+#[test]
+fn error_fmt() -> Result<()> {
+    OomTest::new().test(|| {
+        let x = X.load(SeqCst);
+        let error = format_err!("ouch: {x}");
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn error_context() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn error_chain() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        for _ in error.chain() {
+            // Nothing to do here, just exercising the iteration.
+        }
+        ok_if_not_oom(error)
+    })
+}
+
+struct Null;
+impl Write for Null {
+    fn write_str(&mut self, _s: &str) -> fmt::Result {
+        Ok(())
+    }
+}
+
+#[test]
+fn display_fmt_error() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        write!(&mut Null, "{error}").unwrap();
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn alternate_display_fmt_error() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        write!(&mut Null, "{error:?}").unwrap();
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn debug_fmt_error() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        write!(&mut Null, "{error:?}").unwrap();
+        ok_if_not_oom(error)
+    })
+}
+
+#[test]
+fn alternate_debug_fmt_error() -> Result<()> {
+    OomTest::new().test(|| {
+        let error = Error::msg("hello");
+        let error = error.context("goodbye");
+        write!(&mut Null, "{error:#?}").unwrap();
+        ok_if_not_oom(error)
+    })
+}

crates/fuzzing/tests/oom/func_type.rs

@@ -0,0 +1,47 @@
+#![cfg(arc_try_new)]
+
+use std::iter;
+use wasmtime::{Config, Engine, FuncType, Result, ValType};
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn func_type_try_new() -> Result<()> {
+    let mut config = Config::new();
+    config.enable_compiler(false);
+    let engine = Engine::new(&config)?;
+
+    // Run this OOM test a few times to make sure that we leave the engine's
+    // type registry in a good state when failing to register new types.
+    for i in 1..6 {
+        OomTest::new().test(|| {
+            let ty1 = FuncType::try_new(
+                &engine,
+                iter::repeat(ValType::ANYREF).take(i),
+                iter::repeat(ValType::ANYREF).take(i),
+            )?;
+            assert_eq!(ty1.params().len(), i);
+            assert_eq!(ty1.results().len(), i);
+
+            let ty2 = FuncType::try_new(
+                &engine,
+                iter::repeat(ValType::ANYREF).take(i),
+                iter::repeat(ValType::ANYREF).take(i),
+            )?;
+            assert_eq!(ty2.params().len(), i);
+            assert_eq!(ty2.results().len(), i);
+
+            let ty3 = FuncType::try_new(&engine, [], [])?;
+            assert_eq!(ty3.params().len(), 0);
+            assert_eq!(ty3.results().len(), 0);
+
+            assert!(
+                !FuncType::eq(&ty2, &ty3),
+                "{ty2:?} should not be equal to {ty3:?}"
+            );
+
+            Ok(())
+        })?;
+    }
+
+    Ok(())
+}

crates/fuzzing/tests/oom/hash_map.rs

@@ -0,0 +1,47 @@
+use wasmtime::Result;
+use wasmtime_environ::collections::{TryClone, TryHashMap};
+use wasmtime_fuzzing::oom::OomTest;
+
+#[test]
+fn try_hash_map_with_capacity() -> Result<()> {
+    OomTest::new().test(|| {
+        let _s = TryHashMap::<usize, usize>::with_capacity(100)?;
+        Ok(())
+    })
+}
+
+#[test]
+fn try_hash_map_reserve() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut map = TryHashMap::<usize, usize>::new();
+        map.reserve(100)?;
+        Ok(())
+    })
+}
+
+#[test]
+fn try_hash_map_insert() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut map = TryHashMap::<usize, usize>::new();
+        for i in 0..1024 {
+            map.insert(i, i * 2)?;
+        }
+        for i in 0..1024 {
+            map.insert(i, i * 2)?;
+        }
+        Ok(())
+    })
+}
+
+#[test]
+fn try_hash_map_try_clone() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut map = TryHashMap::new();
+        for i in 0..10 {
+            map.insert(i, i * 2)?;
+        }
+        let map2 = map.try_clone()?;
+        assert_eq!(map, map2);
+        Ok(())
+    })
+}