Skip to main content

bolero_generator_hydro/std/
mod.rs

1#![allow(clippy::implicit_hasher)]
2
3use crate::{alloc_generators::CollectionGenerator, Driver, TypeGenerator, ValueGenerator};
4use core::{hash::Hash, ops::RangeInclusive};
5use std::{
6    collections::{HashMap, HashSet},
7    sync::Mutex,
8};
9
10const DEFAULT_LEN_RANGE: RangeInclusive<usize> = 0..=32;
11
12// TODO support BuildHasher
13
14impl_values_collection_generator!(HashSet, HashSetGenerator, DEFAULT_LEN_RANGE, [Hash, Eq]);
15
16impl<T: Hash + Eq> CollectionGenerator for HashSet<T> {
17    type Item = T;
18
19    fn mutate_collection<D: Driver, G>(
20        &mut self,
21        driver: &mut D,
22        new_len: usize,
23        item_gen: &G,
24    ) -> Option<()>
25    where
26        G: ValueGenerator<Output = Self::Item>,
27    {
28        let prev = core::mem::take(self);
29
30        // mutate the existing items
31        for mut item in prev.into_iter().take(new_len) {
32            item_gen.mutate(driver, &mut item)?;
33            self.insert(item);
34        }
35
36        for _ in 0..(new_len - self.len()) {
37            self.insert(item_gen.generate(driver)?);
38        }
39
40        Some(())
41    }
42}
43
44#[test]
45fn hash_set_type_test() {
46    let _ = generator_test!(produce::<HashSet<u8>>());
47}
48
49#[test]
50fn hash_set_with_len_test() {
51    let results = generator_test!(produce::<HashSet<u8>>().with().len(8usize));
52    assert!(results.into_iter().any(|r| r.len() == 8));
53}
54
55#[test]
56fn hash_set_with_values_test() {
57    let _ = generator_test!(produce::<HashSet<_>>().with().values(4u16..6));
58}
59
60impl_key_values_collection_generator!(HashMap, HashMapGenerator, DEFAULT_LEN_RANGE, [Hash, Eq]);
61
62#[test]
63fn hash_map_type_test() {
64    let _ = generator_test!(produce::<HashMap<u8, u8>>());
65}
66
67impl<T: TypeGenerator> TypeGenerator for Mutex<T> {
68    fn generate<D: Driver>(driver: &mut D) -> Option<Self> {
69        Some(Self::new(driver.produce()?))
70    }
71
72    fn mutate<D: Driver>(&mut self, driver: &mut D) -> Option<()> {
73        if let Ok(value) = self.get_mut() {
74            value.mutate(driver)?;
75            return Some(());
76        }
77
78        *self = Self::generate(driver)?;
79        Some(())
80    }
81}
82
83#[test]
84fn mutex_type_test() {
85    let _ = generator_no_clone_test!(produce::<Mutex<u8>>());
86}