A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Add an OOM-handling `BTreeMap` implementation (#12712)
Nick Fitzgeraldbb3de558fade
diff --git a/Cargo.lock b/Cargo.lockindex 9990d17cea..22dce19730 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4714,6 +4714,7 @@ dependencies = ["arbtest","clap","cpp_demangle",+ "cranelift-bforest","cranelift-bitset","cranelift-entity","env_logger 0.11.5",diff --git a/crates/core/src/slab.rs b/crates/core/src/slab.rsindex 6c2375ccce..f7b7fd50fc 100644--- a/crates/core/src/slab.rs+++ b/crates/core/src/slab.rs@@ -508,4 +508,14 @@ impl<T> Slab<T> {Entry::Free { .. } => None,})}++ /// Clear all of the values from inside this slab.+ ///+ /// Does not deallocate internal storage.+ #[inline]+ pub fn clear(&mut self) {+ self.len = 0;+ self.free = None;+ self.entries.clear();+ }}diff --git a/crates/environ/Cargo.toml b/crates/environ/Cargo.tomlindex 5a90788b58..9a92d5fdff 100644--- a/crates/environ/Cargo.toml+++ b/crates/environ/Cargo.toml@@ -23,6 +23,7 @@ postcard = { workspace = true }cpp_demangle = { version = "0.4.3", optional = true }cranelift-entity = { workspace = true, features = ['enable-serde'] }cranelift-bitset = { workspace = true, features = ['enable-serde'] }+cranelift-bforest = { workspace = true }hashbrown = { workspace = true, features = ["default-hasher"] }wasmparser = { workspace = true, features = ['validate', 'serde', 'features'] }indexmap = { workspace = true, features = ["serde"] }@@ -57,6 +58,10 @@ arbitrary = { workspace = true, features = ["derive"] }name = "factc"required-features = ['component-model', 'compile']+[[example]]+name = "btrees"+required-features = ["std"]+[features]anyhow = ["wasmtime-core/anyhow"]backtrace = ["std", "wasmtime-core/backtrace"]diff --git a/crates/environ/examples/btrees.rs b/crates/environ/examples/btrees.rsnew file mode 100644index 0000000000..e93fb1812d--- /dev/null+++ b/crates/environ/examples/btrees.rs@@ -0,0 +1,50 @@+use std::{collections::BTreeMap, str::FromStr};+use wasmtime_environ::{+ collections,+ error::{Context as _, Result, bail, format_err},+};++type Key = [u128; 2];+type Value = [u8; 16];++trait Map {+ fn insert(&mut self, key: Key, value: Value) -> Result<()>;+}++impl Map for BTreeMap<Key, Value> {+ fn insert(&mut self, key: Key, value: Value) -> Result<()> {+ BTreeMap::insert(self, key, value);+ Ok(())+ }+}++impl Map for collections::BTreeMap<Key, Value> {+ fn insert(&mut self, key: Key, value: Value) -> Result<()> {+ collections::BTreeMap::insert(self, key, value)?;+ Ok(())+ }+}++fn main() -> Result<()> {+ let kind = std::env::args()+ .nth(1)+ .ok_or_else(|| format_err!("must provide first argument: 'std' or 'bforest'"))?;++ let mut map: Box<dyn Map> = match kind.as_str() {+ "std" => Box::new(BTreeMap::new()),+ "bforest" => Box::new(collections::BTreeMap::new()),+ _ => bail!("first argument must be either 'std' or 'bforest', got: '{kind}'"),+ };++ let n = std::env::args().nth(2);+ let n = n.as_deref().unwrap_or("1000");+ let n = u128::from_str(n).context("failed to parse second argument as `u32` integer")?;++ println!("Inserting {n} entries into `{kind}`-based `BTreeMap`...");++ for i in 0..n {+ map.insert([i, i], [0; 16])?;+ }++ Ok(())+}diff --git a/crates/environ/src/collections.rs b/crates/environ/src/collections.rsindex 69fc7f4517..6411723dd4 100644--- a/crates/environ/src/collections.rs+++ b/crates/environ/src/collections.rs@@ -1,5 +1,6 @@//! Fallible, OOM-handling collections.+pub mod btree_map;mod entity_set;mod hash_map;mod hash_set;@@ -7,6 +8,7 @@ mod index_map;mod primary_map;mod secondary_map;+pub use btree_map::BTreeMap;pub use entity_set::EntitySet;pub use hash_map::HashMap;pub use hash_set::HashSet;diff --git a/crates/environ/src/collections/btree_map.rs b/crates/environ/src/collections/btree_map.rsnew file mode 100644index 0000000000..29b795ff41--- /dev/null+++ b/crates/environ/src/collections/btree_map.rs@@ -0,0 +1,923 @@+//! OOM-handling `BTreeMap` implementation.++use crate::error::OutOfMemory;+use core::{mem, ops::RangeBounds, ptr::NonNull};+use wasmtime_core::slab::{Id, Slab};++/// Like `std::collections::BTreeMap` but its methods return errors on+/// allocation failure.+pub struct BTreeMap<K, V>+where+ K: Copy,+{+ values: Slab<V>,+ forest: cranelift_bforest::MapForest<K, Id>,+ map: cranelift_bforest::Map<K, Id>,+}++impl<K, V> Default for BTreeMap<K, V>+where+ K: Copy,+{+ fn default() -> Self {+ Self {+ values: Default::default(),+ forest: cranelift_bforest::MapForest::new(),+ map: Default::default(),+ }+ }+}++impl<K, V> BTreeMap<K, V>+where+ K: Copy,+{+ /// Same as [`std::collections::BTreeMap::new`].+ pub fn new() -> Self {+ Self::default()+ }++ /// Same as [`std::collections::BTreeMap::len`].+ pub fn len(&self) -> usize {+ self.values.len()+ }++ /// Same as [`std::collections::BTreeMap::is_empty`].+ pub fn is_empty(&self) -> bool {+ self.map.is_empty()+ }++ fn get_id(&self, key: K) -> Option<Id>+ where+ K: Ord,+ {+ self.map.get(key, &self.forest, &())+ }++ /// Same as [`std::collections::BTreeMap::contains_key`].+ pub fn contains_key(&self, key: K) -> bool+ where+ K: Ord,+ {+ self.get_id(key).is_some()+ }++ /// Same as [`std::collections::BTreeMap::get`].+ pub fn get(&self, key: K) -> Option<&V>+ where+ K: Ord,+ {+ let id = self.get_id(key)?;+ Some(&self.values[id])+ }++ /// Same as [`std::collections::BTreeMap::get_mut`].+ pub fn get_mut(&mut self, key: K) -> Option<&mut V>+ where+ K: Ord,+ {+ let id = self.get_id(key)?;+ Some(&mut self.values[id])+ }++ /// Same as [`std::collections::BTreeMap::insert`] but returns an error on+ /// allocation failure.+ pub fn insert(&mut self, key: K, value: V) -> Result<Option<V>, OutOfMemory>+ where+ K: Ord,+ {+ if let Some(id) = self.get_id(key) {+ return Ok(Some(mem::replace(&mut self.values[id], value)));+ }++ let id = self.values.alloc(value)?;+ match self.map.try_insert(key, id, &mut self.forest, &()) {+ Ok(old) => {+ debug_assert!(old.is_none());+ Ok(None)+ }+ Err(oom) => {+ self.values.dealloc(id);+ Err(oom)+ }+ }+ }++ /// Same as [`std::collections::BTreeMap::remove`].+ pub fn remove(&mut self, key: K) -> Option<V>+ where+ K: Ord,+ {+ let id = self.map.remove(key, &mut self.forest, &())?;+ Some(self.values.dealloc(id))+ }++ /// Same as [`std::collections::BTreeMap::clear`].+ ///+ /// Does not deallocate the underlying storage.+ pub fn clear(&mut self) {+ self.values.clear();+ // NB: Do not do `self.map.clear(&mut self.forest)` because that is+ // designed to work in scenarios where multiple maps are sharing the+ // same forest (which we are not doing here) and will actually traverse+ // the b-tree's nodes and deallocate each of them one at a time. For our+ // single-map-in-the-forest case, it is equivalent, but much faster, to+ // simply clear the forest itself and reset the map to its default,+ // empty state.+ self.forest.clear();+ self.map = Default::default();+ }++ /// Same as [`std::collections::BTreeMap::iter`].+ pub fn iter(&self) -> BTreeMapIter<'_, K, V> {+ BTreeMapIter {+ inner: self.map.iter(&self.forest),+ values: &self.values,+ }+ }++ /// Same as [`std::collections::BTreeMap::iter`].+ pub fn iter_mut(&mut self) -> BTreeMapIterMut<'_, K, V> {+ BTreeMapIterMut {+ inner: self.map.iter(&self.forest),+ values: &mut self.values,+ }+ }++ /// Same as [`std::collections::BTreeMap::keys`].+ pub fn keys(&self) -> BTreeMapKeys<'_, K, V> {+ BTreeMapKeys { inner: self.iter() }+ }++ /// Same as [`std::collections::BTreeMap::values`].+ pub fn values(&self) -> BTreeMapValues<'_, K, V> {+ BTreeMapValues { inner: self.iter() }+ }++ /// Same as [`std::collections::BTreeMap::values_mut`].+ pub fn values_mut(&mut self) -> BTreeMapValuesMut<'_, K, V> {+ BTreeMapValuesMut {+ inner: self.iter_mut(),+ }+ }++ /// Same as [`std::collections::BTreeMap::range`].+ pub fn range<R>(&self, range: R) -> BTreeMapRange<'_, K, V, R>+ where+ K: Ord,+ R: RangeBounds<K>,+ {+ BTreeMapRange {+ inner: self.map.range(range, &self.forest, &()),+ values: &self.values,+ }+ }++ /// Same as [`std::collections::BTreeMap::range_mut`].+ pub fn range_mut<R>(&mut self, range: R) -> BTreeMapRangeMut<'_, K, V, R>+ where+ K: Ord,+ R: RangeBounds<K>,+ {+ BTreeMapRangeMut {+ inner: self.map.range(range, &self.forest, &()),+ values: &mut self.values,+ }+ }++ /// Same as [`std::collections::BTreeMap::entry`].+ pub fn entry(&mut self, key: K) -> Entry<'_, K, V>+ where+ K: Ord,+ {+ let mut cursor = self.map.cursor_mut(&mut self.forest, &());+ match cursor.goto(key) {+ Some(_) => Entry::Occupied(OccupiedEntry {+ cursor,+ values: &mut self.values,+ }),+ None => Entry::Vacant(VacantEntry {+ key,+ cursor,+ values: &mut self.values,+ }),+ }+ }+}++impl<'a, K, V> IntoIterator for &'a BTreeMap<K, V>+where+ K: Copy,+{+ type Item = (K, &'a V);+ type IntoIter = BTreeMapIter<'a, K, V>;++ fn into_iter(self) -> Self::IntoIter {+ self.iter()+ }+}++/// An iterator over `(K, &V)` pairs returned by [`BTreeMap::iter`].+pub struct BTreeMapIter<'a, K, V>+where+ K: Copy,+{+ inner: cranelift_bforest::MapIter<'a, K, Id>,+ values: &'a Slab<V>,+}++impl<'a, K, V> Iterator for BTreeMapIter<'a, K, V>+where+ K: Copy,+{+ type Item = (K, &'a V);++ fn next(&mut self) -> Option<Self::Item> {+ let (key, id) = self.inner.next()?;+ Some((key, &self.values[id]))+ }++ fn size_hint(&self) -> (usize, Option<usize>) {+ self.inner.size_hint()+ }+}++impl<'a, K, V> IntoIterator for &'a mut BTreeMap<K, V>+where+ K: Copy,+{+ type Item = (K, &'a mut V);+ type IntoIter = BTreeMapIterMut<'a, K, V>;++ fn into_iter(self) -> Self::IntoIter {+ self.iter_mut()+ }+}++/// An iterator over `(K, &mut V)` pairs returned by [`BTreeMap::iter_mut`].+pub struct BTreeMapIterMut<'a, K, V>+where+ K: Copy,+{+ inner: cranelift_bforest::MapIter<'a, K, Id>,+ values: &'a mut Slab<V>,+}++impl<'a, K, V> Iterator for BTreeMapIterMut<'a, K, V>+where+ K: Copy,+{+ type Item = (K, &'a mut V);++ fn next(&mut self) -> Option<Self::Item> {+ let (key, id) = self.inner.next()?;+ let val = &mut self.values[id];++ // Safety: It is okay to extend the borrow from `&'1 mut self` to `&'a`+ // because each entry is associated with a unique `id` and we will never+ // return multiple mutable borrows of the same value.+ let val = unsafe { NonNull::from(val).as_mut() };++ Some((key, val))+ }++ fn size_hint(&self) -> (usize, Option<usize>) {+ self.inner.size_hint()+ }+}++impl<K, V> IntoIterator for BTreeMap<K, V>+where+ K: Copy + Ord,+{+ type Item = (K, V);+ type IntoIter = BTreeMapIntoIter<K, V>;++ fn into_iter(self) -> Self::IntoIter {+ BTreeMapIntoIter {+ inner: self.map.into_iter(self.forest),+ values: self.values,+ }+ }+}++/// An iterator over `(K, V)` pairs returned by [`BTreeMap::into_iter`].+pub struct BTreeMapIntoIter<K, V>+where+ K: Copy,+{+ inner: cranelift_bforest::MapIntoIter<K, Id>,+ values: Slab<V>,+}++impl<K, V> Iterator for BTreeMapIntoIter<K, V>+where+ K: Copy + Ord,+{+ type Item = (K, V);++ fn next(&mut self) -> Option<Self::Item> {+ let (key, id) = self.inner.next()?;+ let value = self.values.dealloc(id);+ Some((key, value))+ }++ fn size_hint(&self) -> (usize, Option<usize>) {+ let len = self.values.len();+ (len, Some(len))+ }+}++/// An iterator over keys returned by [`BTreeMap::keys`].+pub struct BTreeMapKeys<'a, K, V>+where+ K: Copy,+{+ inner: BTreeMapIter<'a, K, V>,+}++impl<'a, K, V> Iterator for BTreeMapKeys<'a, K, V>+where+ K: Copy,+{+ type Item = K;++ fn next(&mut self) -> Option<Self::Item> {+ let (k, _v) = self.inner.next()?;+ Some(k)+ }+}++/// An iterator over shared values returned by [`BTreeMap::values`].+pub struct BTreeMapValues<'a, K, V>+where+ K: Copy,+{+ inner: BTreeMapIter<'a, K, V>,+}++impl<'a, K, V> Iterator for BTreeMapValues<'a, K, V>+where+ K: Copy,+{+ type Item = &'a V;++ fn next(&mut self) -> Option<Self::Item> {+ let (_k, v) = self.inner.next()?;+ Some(v)+ }+}++/// An iterator over mutable values returned by [`BTreeMap::values_mut`].+pub struct BTreeMapValuesMut<'a, K, V>+where+ K: Copy,+{+ inner: BTreeMapIterMut<'a, K, V>,+}++impl<'a, K, V> Iterator for BTreeMapValuesMut<'a, K, V>+where+ K: Copy,+{+ type Item = &'a mut V;++ fn next(&mut self) -> Option<Self::Item> {+ let (_k, v) = self.inner.next()?;+ Some(v)+ }+}++/// A range iterator of `(K, &'a V)` items returned by [`BTreeMap::range`].+pub struct BTreeMapRange<'a, K, V, R>+where+ K: Copy + Ord,+ R: RangeBounds<K>,+{+ inner: cranelift_bforest::MapRange<'a, K, Id, R, ()>,+ values: &'a Slab<V>,+}++impl<'a, K, V, R> Iterator for BTreeMapRange<'a, K, V, R>+where+ K: Copy + Ord,+ R: RangeBounds<K>,+{+ type Item = (K, &'a V);++ fn next(&mut self) -> Option<Self::Item> {+ let (key, id) = self.inner.next()?;+ Some((key, &self.values[id]))+ }+}++/// A range iterator of `(K, &'a V)` items returned by [`BTreeMap::range`].+pub struct BTreeMapRangeMut<'a, K, V, R>+where+ K: Copy + Ord,+ R: RangeBounds<K>,+{+ inner: cranelift_bforest::MapRange<'a, K, Id, R, ()>,+ values: &'a mut Slab<V>,+}++impl<'a, K, V, R> Iterator for BTreeMapRangeMut<'a, K, V, R>+where+ K: Copy + Ord,+ R: RangeBounds<K>,+{+ type Item = (K, &'a mut V);++ fn next(&mut self) -> Option<Self::Item> {+ let (key, id) = self.inner.next()?;+ let val = &mut self.values[id];++ // Safety: It is okay to extend the borrow from `&'1 mut self` to `&'a`+ // because each entry is associated with a unique `id` and we will never+ // return multiple mutable borrows of the same value.+ let val = unsafe { NonNull::from(val).as_mut() };++ Some((key, val))+ }+}++/// Same as [`std::collections::btree_map::Entry`].+#[allow(missing_docs, reason = "self explanatory")]+pub enum Entry<'a, K, V>+where+ K: Copy + Ord,+{+ Occupied(OccupiedEntry<'a, K, V>),+ Vacant(VacantEntry<'a, K, V>),+}++impl<'a, K, V> Entry<'a, K, V>+where+ K: Copy + Ord,+{+ /// Same as [`std::collections::btree_map::Entry::or_insert`] but returns an+ /// error on allocation failure.+ pub fn or_insert(self, default: V) -> Result<&'a mut V, OutOfMemory> {+ self.or_insert_with(|| default)+ }++ /// Same as [`std::collections::btree_map::Entry::or_insert_with`] but+ /// returns an error on allocation failure.+ pub fn or_insert_with<F>(self, default: F) -> Result<&'a mut V, OutOfMemory>+ where+ F: FnOnce() -> V,+ {+ self.or_insert_with_key(|_| default())+ }++ /// Same as [`std::collections::btree_map::Entry::or_insert_with_key`] but+ /// returns an error on allocation failure.+ pub fn or_insert_with_key<F>(self, default: F) -> Result<&'a mut V, OutOfMemory>+ where+ F: FnOnce(K) -> V,+ {+ match self {+ Entry::Occupied(e) => {+ let id = e.cursor.value().unwrap();+ Ok(&mut e.values[id])+ }+ Entry::Vacant(mut e) => {+ let id = e.values.alloc(default(e.key))?;+ match e.cursor.try_insert(e.key, id) {+ Ok(old) => {+ debug_assert!(old.is_none());+ Ok(&mut e.values[id])+ }+ Err(oom) => {+ e.values.dealloc(id);+ Err(oom)+ }+ }+ }+ }+ }++ /// Same as [`std::collections::btree_map::Entry::key`].+ pub fn key(&self) -> K {+ match self {+ Entry::Occupied(e) => e.cursor.key().unwrap(),+ Entry::Vacant(e) => e.key,+ }+ }++ /// Same as [`std::collections::btree_map::Entry::and_modify`].+ pub fn and_modify<F>(self, f: F) -> Self+ where+ F: FnOnce(&mut V),+ {+ match self {+ Entry::Occupied(mut e) => {+ f(e.get_mut());+ Entry::Occupied(e)+ }+ e @ Entry::Vacant(_) => e,+ }+ }++ /// Same as [`std::collections::btree_map::Entry::and_modify`] but returns+ /// an error on allocation failure.+ pub fn insert_entry(self, value: V) -> Result<OccupiedEntry<'a, K, V>, OutOfMemory> {+ match self {+ Entry::Occupied(e) => Ok(e),+ Entry::Vacant(e) => e.insert_entry(value),+ }+ }++ /// Same as [`std::collections::btree_map::Entry::or_default`] but returns+ /// an error on allocation failure.+ pub fn or_default(self) -> Result<&'a mut V, OutOfMemory>+ where+ V: Default,+ {+ self.or_insert_with(Default::default)+ }+}++/// Same as [`std::collections::btree_map::OccupiedEntry`].+pub struct OccupiedEntry<'a, K, V>+where+ K: Copy + Ord,+{+ cursor: cranelift_bforest::MapCursorMut<'a, K, Id, ()>,+ values: &'a mut Slab<V>,+}++impl<'a, K, V> OccupiedEntry<'a, K, V>+where+ K: Copy + Ord,+{+ /// Same as [`std::collections::btree_map::OccupiedEntry::key`].+ pub fn key(&self) -> K {+ self.cursor.key().unwrap()+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::remove_entry`].+ pub fn remove_entry(mut self) -> (K, V) {+ let key = self.key();+ let id = self.cursor.remove().unwrap();+ let value = self.values.dealloc(id);+ (key, value)+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::get`].+ pub fn get(&self) -> &V {+ let id = self.cursor.value().unwrap();+ &self.values[id]+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::get_mut`].+ pub fn get_mut(&mut self) -> &mut V {+ let id = self.cursor.value().unwrap();+ &mut self.values[id]+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::into_mut`].+ pub fn into_mut(self) -> &'a mut V {+ let id = self.cursor.value().unwrap();+ &mut self.values[id]+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::insert`].+ pub fn insert(self, value: V) -> V {+ let id = self.cursor.value().unwrap();+ mem::replace(&mut self.values[id], value)+ }++ /// Same as [`std::collections::btree_map::OccupiedEntry::remove`].+ pub fn remove(mut self) -> V {+ let id = self.cursor.remove().unwrap();+ self.values.dealloc(id)+ }+}++/// Same as [`std::collections::btree_map::VacantEntry`].+pub struct VacantEntry<'a, K, V>+where+ K: Copy + Ord,+{+ key: K,+ cursor: cranelift_bforest::MapCursorMut<'a, K, Id, ()>,+ values: &'a mut Slab<V>,+}++impl<'a, K, V> VacantEntry<'a, K, V>+where+ K: Copy + Ord,+{+ /// Same as [`std::collections::btree_map::VacantEntry::key`].+ pub fn key(&self) -> K {+ self.key+ }++ /// Same as [`std::collections::btree_map::VacantEntry::into_key`].+ pub fn into_key(self) -> K {+ self.key+ }++ /// Same as [`std::collections::btree_map::VacantEntry::insert`] but returns+ /// an error on allocation failure.+ pub fn insert(self, value: V) -> Result<&'a mut V, OutOfMemory> {+ Ok(self.insert_entry(value)?.into_mut())+ }++ /// Same as [`std::collections::btree_map::VacantEntry::insert_entry`] but+ /// returns an error on allocation failure.+ pub fn insert_entry(mut self, value: V) -> Result<OccupiedEntry<'a, K, V>, OutOfMemory> {+ let id = self.values.alloc(value)?;+ match self.cursor.try_insert(self.key, id) {+ Ok(old) => {+ debug_assert!(old.is_none());+ Ok(OccupiedEntry {+ cursor: self.cursor,+ values: self.values,+ })+ }+ Err(oom) => {+ self.values.dealloc(id);+ Err(oom)+ }+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::error::Result;+ use alloc::{vec, vec::Vec};++ type M = BTreeMap<usize, f32>;++ #[test]+ fn new() -> Result<()> {+ let m = M::new();+ assert!(m.is_empty());+ Ok(())+ }++ #[test]+ fn len() -> Result<()> {+ let mut m = M::new();+ for i in 0..10 {+ assert_eq!(m.len(), i);+ m.insert(i, i as f32)?;+ }+ assert_eq!(m.len(), 10);+ for i in 0..10 {+ assert_eq!(m.len(), 10 - i);+ m.remove(i);+ }+ assert_eq!(m.len(), 0);+ Ok(())+ }++ #[test]+ fn is_empty() -> Result<()> {+ let mut m = M::new();+ assert!(m.is_empty());+ m.insert(42, 42.0)?;+ assert!(!m.is_empty());+ m.remove(42);+ assert!(m.is_empty());+ Ok(())+ }++ #[test]+ fn contains_key() -> Result<()> {+ let mut m = M::new();+ assert!(!m.contains_key(36));+ assert!(!m.contains_key(42));+ m.insert(42, 42.0)?;+ assert!(!m.contains_key(36));+ assert!(m.contains_key(42));+ m.remove(42);+ assert!(!m.contains_key(36));+ assert!(!m.contains_key(42));+ Ok(())+ }++ #[test]+ fn get() -> Result<()> {+ let mut m = M::new();+ assert!(m.get(36).is_none());+ assert!(m.get(42).is_none());+ m.insert(42, 42.0)?;+ assert!(m.get(36).is_none());+ assert_eq!(m.get(42), Some(&42.0));+ m.remove(42);+ assert!(m.get(36).is_none());+ assert!(m.get(42).is_none());+ Ok(())+ }++ #[test]+ fn get_mut() -> Result<()> {+ let mut m = M::new();+ assert!(m.get_mut(36).is_none());+ assert!(m.get_mut(42).is_none());+ m.insert(42, 42.0)?;+ assert!(m.get_mut(36).is_none());+ assert_eq!(m.get_mut(42).copied(), Some(42.0));+ *m.get_mut(42).unwrap() = 99.0;+ assert_eq!(m.get_mut(42).copied(), Some(99.0));+ m.remove(42);+ assert!(m.get_mut(36).is_none());+ assert!(m.get_mut(42).is_none());+ Ok(())+ }++ #[test]+ fn insert() -> Result<()> {+ let mut m = M::new();+ let old = m.insert(11, 0.0)?;+ assert!(old.is_none());+ let old = m.insert(11, 1.0)?;+ assert_eq!(old, Some(0.0));+ Ok(())+ }++ #[test]+ fn remove() -> Result<()> {+ let mut m = M::new();+ let old = m.remove(10);+ assert!(old.is_none());+ m.insert(10, 123.0)?;+ let old = m.remove(10);+ assert_eq!(old, Some(123.0));+ Ok(())+ }++ #[test]+ fn clear() -> Result<()> {+ let mut m = M::new();+ for i in 0..10 {+ m.insert(i, i as f32)?;+ }+ m.clear();+ assert!(m.is_empty());+ for i in 0..10 {+ assert!(m.get(i).is_none());+ }+ Ok(())+ }++ #[test]+ fn iter() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(+ m.iter().collect::<Vec<_>>(),+ vec![(0, &0.0), (1, &1.0), (2, &2.0), (3, &3.0), (4, &4.0)],+ );+ Ok(())+ }++ #[test]+ fn iter_mut() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(+ m.iter_mut()+ .map(|(k, v)| (k, mem::replace(v, 0.0)))+ .collect::<Vec<_>>(),+ vec![(0, 0.0), (1, 1.0), (2, 2.0), (3, 3.0), (4, 4.0)],+ );+ for i in 0..5 {+ assert_eq!(m.get(i), Some(&0.0));+ }+ Ok(())+ }++ #[test]+ fn keys() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(m.keys().collect::<Vec<_>>(), vec![0, 1, 2, 3, 4]);+ Ok(())+ }++ #[test]+ fn values() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(+ m.values().collect::<Vec<_>>(),+ vec![&0.0, &1.0, &2.0, &3.0, &4.0],+ );+ Ok(())+ }++ #[test]+ fn values_mut() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(+ m.values_mut()+ .map(|v| mem::replace(v, 0.0))+ .collect::<Vec<_>>(),+ vec![0.0, 1.0, 2.0, 3.0, 4.0],+ );+ assert_eq!(+ m.values().collect::<Vec<_>>(),+ vec![&0.0, &0.0, &0.0, &0.0, &0.0],+ );+ Ok(())+ }++ #[test]+ fn range() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(m.range(..2).collect::<Vec<_>>(), vec![(0, &0.0), (1, &1.0)]);+ assert_eq!(m.range(3..).collect::<Vec<_>>(), vec![(3, &3.0), (4, &4.0)]);+ assert_eq!(+ m.range(1..3).collect::<Vec<_>>(),+ vec![(1, &1.0), (2, &2.0)],+ );+ assert_eq!(+ m.range(2..=3).collect::<Vec<_>>(),+ vec![(2, &2.0), (3, &3.0)],+ );+ assert_eq!(m.range(5..).collect::<Vec<_>>(), vec![]);+ assert_eq!(m.range(..0).collect::<Vec<_>>(), vec![]);+ Ok(())+ }++ #[test]+ fn range_mut() -> Result<()> {+ let mut m = M::new();+ for i in 0..5 {+ m.insert(i, i as f32)?;+ }+ assert_eq!(+ m.range_mut(1..3)+ .map(|(k, v)| (k, mem::replace(v, 99.0)))+ .collect::<Vec<_>>(),+ vec![(1, 1.0), (2, 2.0)],+ );+ assert_eq!(+ m.values().copied().collect::<Vec<_>>(),+ vec![0.0, 99.0, 99.0, 3.0, 4.0]+ );+ Ok(())+ }++ #[test]+ fn entry() -> Result<()> {+ let mut m = M::new();++ let v = m.entry(0).or_insert(99.0)?;+ assert_eq!(*v, 99.0);++ let v = m.entry(0).or_insert(0.0)?;+ assert_eq!(*v, 99.0);++ let e = match m.entry(1) {+ Entry::Occupied(_) => unreachable!(),+ Entry::Vacant(e) => e.insert_entry(42.0)?,+ };+ assert_eq!(e.key(), 1);+ assert_eq!(e.get(), &42.0);+ let old = e.insert(43.0);+ assert_eq!(old, 42.0);+ assert_eq!(m.get(1), Some(&43.0));++ let e = match m.entry(1) {+ Entry::Occupied(e) => e,+ Entry::Vacant(_) => unreachable!(),+ };+ assert_eq!(e.key(), 1);+ assert_eq!(e.get(), &43.0);+ let (k, v) = e.remove_entry();+ assert_eq!(k, 1);+ assert_eq!(v, 43.0);+ assert!(m.get(1).is_none());++ let e = match m.entry(2) {+ Entry::Occupied(_) => unreachable!(),+ Entry::Vacant(e) => e,+ };+ assert_eq!(e.key(), 2);+ let v = e.insert(99.0)?;+ assert_eq!(*v, 99.0);++ Ok(())+ }+}diff --git a/crates/fuzzing/tests/oom.rs b/crates/fuzzing/tests/oom.rsindex 992ea29d1a..d1d5d1fa4a 100644--- a/crates/fuzzing/tests/oom.rs+++ b/crates/fuzzing/tests/oom.rs@@ -1068,3 +1068,49 @@ fn bforest_set() -> Result<()> {Ok(())})}++#[test]+fn btree_map() -> Result<()> {+ use collections::btree_map::Entry;+ type M = collections::BTreeMap<usize, f32>;+ 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(())+ })+}