bolero_generator/alloc/
mod.rs

1#[macro_use]
2pub mod collections;
3
4pub use collections::CollectionGenerator;
5
6pub mod boxed;
7pub mod string;
8pub mod sync;
9
10use crate::{Driver, TypeGenerator, ValueGenerator};
11pub use alloc::{
12    borrow::{Cow, ToOwned},
13    collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque},
14    vec::Vec,
15};
16
17pub(crate) const DEFAULT_LEN_RANGE: core::ops::RangeInclusive<usize> = 0..=64;
18
19impl_values_collection_generator!(BinaryHeap, BinaryHeapGenerator, DEFAULT_LEN_RANGE, [Ord]);
20
21impl<T: Ord> CollectionGenerator for BinaryHeap<T> {
22    type Item = T;
23
24    fn mutate_collection<D: Driver, G>(
25        &mut self,
26        driver: &mut D,
27        new_len: usize,
28        item_gen: &G,
29    ) -> Option<()>
30    where
31        G: ValueGenerator<Output = Self::Item>,
32    {
33        let prev = core::mem::take(self);
34
35        for mut item in prev.into_iter().take(new_len) {
36            item_gen.mutate(driver, &mut item)?;
37            self.push(item);
38        }
39
40        for _ in 0..(new_len - self.len()) {
41            self.push(item_gen.generate(driver)?);
42        }
43
44        Some(())
45    }
46}
47
48#[test]
49fn binary_heap_test() {
50    let _ = generator_no_clone_test!(produce::<BinaryHeap<u8>>());
51}
52
53impl_values_collection_generator!(BTreeSet, BTreeSetGenerator, DEFAULT_LEN_RANGE, [Ord]);
54
55impl<T: Ord> CollectionGenerator for BTreeSet<T> {
56    type Item = T;
57
58    fn mutate_collection<D: Driver, G>(
59        &mut self,
60        driver: &mut D,
61        new_len: usize,
62        item_gen: &G,
63    ) -> Option<()>
64    where
65        G: ValueGenerator<Output = Self::Item>,
66    {
67        let prev = core::mem::take(self);
68        for mut item in prev.into_iter().take(new_len) {
69            item_gen.mutate(driver, &mut item)?;
70            self.insert(item);
71        }
72
73        for _ in 0..(new_len - self.len()) {
74            self.insert(item_gen.generate(driver)?);
75        }
76
77        Some(())
78    }
79}
80
81#[test]
82fn btree_set_test() {
83    let _ = generator_test!(produce::<BTreeSet<u8>>());
84}
85
86impl_values_collection_generator!(LinkedList, LinkedListGenerator, DEFAULT_LEN_RANGE);
87
88impl<T> CollectionGenerator for LinkedList<T> {
89    type Item = T;
90
91    fn mutate_collection<D: Driver, G>(
92        &mut self,
93        driver: &mut D,
94        new_len: usize,
95        item_gen: &G,
96    ) -> Option<()>
97    where
98        G: ValueGenerator<Output = Self::Item>,
99    {
100        for item in self.iter_mut().take(new_len) {
101            item_gen.mutate(driver, item)?;
102        }
103
104        if let Some(to_add) = new_len.checked_sub(self.len()) {
105            for _ in 0..to_add {
106                self.push_back(item_gen.generate(driver)?);
107            }
108        } else {
109            // remove extras
110            for item in self.split_off(new_len) {
111                item_gen.driver_cache(driver, item);
112            }
113        }
114
115        #[cfg(test)]
116        assert_eq!(self.len(), new_len);
117
118        Some(())
119    }
120}
121
122#[test]
123fn linked_list_test() {
124    let _ = generator_test!(produce::<LinkedList<u8>>());
125}
126
127impl_values_collection_generator!(VecDeque, VecDequeGenerator, DEFAULT_LEN_RANGE);
128
129impl<T> CollectionGenerator for VecDeque<T> {
130    type Item = T;
131
132    fn mutate_collection<D: Driver, G>(
133        &mut self,
134        driver: &mut D,
135        new_len: usize,
136        item_gen: &G,
137    ) -> Option<()>
138    where
139        G: ValueGenerator<Output = Self::Item>,
140    {
141        for item in self.iter_mut().take(new_len) {
142            item_gen.mutate(driver, item)?;
143        }
144
145        if let Some(to_add) = new_len.checked_sub(self.len()) {
146            self.reserve(to_add);
147            for _ in 0..to_add {
148                self.push_back(item_gen.generate(driver)?);
149            }
150        } else {
151            // remove extras
152            for item in self.drain(new_len..) {
153                item_gen.driver_cache(driver, item);
154            }
155        }
156
157        #[cfg(test)]
158        assert_eq!(self.len(), new_len);
159
160        Some(())
161    }
162}
163
164#[test]
165fn vecdeque_test() {
166    let _ = generator_test!(produce::<VecDeque<u8>>());
167}
168
169impl_values_collection_generator!(Vec, VecGenerator, DEFAULT_LEN_RANGE);
170
171impl<T> CollectionGenerator for Vec<T> {
172    type Item = T;
173
174    fn mutate_collection<D: Driver, G>(
175        &mut self,
176        driver: &mut D,
177        new_len: usize,
178        item_gen: &G,
179    ) -> Option<()>
180    where
181        G: ValueGenerator<Output = Self::Item>,
182    {
183        for item in self.iter_mut().take(new_len) {
184            item_gen.mutate(driver, item)?;
185        }
186
187        if let Some(to_add) = new_len.checked_sub(self.len()) {
188            self.reserve(to_add);
189            for _ in 0..to_add {
190                self.push(item_gen.generate(driver)?);
191            }
192        } else {
193            // remove extras
194            for item in self.drain(new_len..) {
195                item_gen.driver_cache(driver, item);
196            }
197        }
198
199        #[cfg(test)]
200        assert_eq!(self.len(), new_len);
201
202        Some(())
203    }
204}
205
206#[test]
207fn vec_type_test() {
208    let _ = generator_test!(produce::<Vec<u8>>());
209}
210
211#[test]
212fn vec_with_len_test() {
213    let results = generator_test!(produce::<Vec<u8>>().with().len(8usize));
214    assert!(results.into_iter().all(|v| v.len() == 8));
215}
216
217#[test]
218fn vec_with_values_test() {
219    let _ = generator_test!(produce::<Vec<_>>().with().values(4u16..6));
220}
221
222#[test]
223fn vec_gen_test() {
224    let _ = generator_test!(vec![produce::<u8>()]);
225}
226
227impl_key_values_collection_generator!(BTreeMap, BTreeMapGenerator, DEFAULT_LEN_RANGE, [Ord]);
228
229#[test]
230fn btree_map_type_test() {
231    let _ = generator_test!(produce::<BTreeMap<u8, u8>>());
232}
233
234pub type Bytes = Vec<u8>;
235pub type BytesGenerator<L> = VecGenerator<crate::TypeValueGenerator<u8>, L>;
236
237pub type Chars = Vec<char>;
238pub type CharsGenerator<L> = VecGenerator<crate::TypeValueGenerator<char>, L>;
239
240impl<T> TypeGenerator for Cow<'static, T>
241where
242    T: ToOwned + ?Sized,
243    <T as ToOwned>::Owned: TypeGenerator,
244{
245    fn generate<D: Driver>(driver: &mut D) -> Option<Self> {
246        Some(Cow::Owned(driver.produce()?))
247    }
248}
bolero_generator/alloc/mod.rs

bolero_generator/alloc/
mod.rs
