deprecate driver mode

lib/bolero-engine/src/lib.rs

@@ -1,6 +1,6 @@
 pub use anyhow::Error;
 pub use bolero_generator::{
-    driver::{self, Driver, DriverMode},
+    driver::{self, Driver},
     TypeGenerator, ValueGenerator,
 };
 

lib/bolero-engine/src/shrink/tests.rs

@@ -6,17 +6,15 @@ macro_rules! shrink_test {
         #[test]
         fn $name() {
             #[allow(unused_imports)]
-            use bolero_generator::{driver::DriverMode, gen, ValueGenerator};
+            use bolero_generator::{gen, ValueGenerator};
 
             panic::forward_panic(true);
             panic::capture_backtrace(true);
 
             let mut test = crate::ClonedGeneratorTest::new($check, $gen);
             let input = ($input).to_vec();
 
-            let options = driver::Options::default()
-                .with_driver_mode(DriverMode::Forced)
-                .with_shrink_time(Duration::from_secs(1));
+            let options = driver::Options::default().with_shrink_time(Duration::from_secs(1));
 
             let failure = Shrinker::new(&mut test, input, None, &options)
                 .shrink()

lib/bolero-generator/src/arbitrary.rs

@@ -82,20 +82,20 @@ mod tests {
     }
 
     #[derive(Clone, Debug, PartialEq, Eq)]
-    struct UnlikelyToBeValid(u128);
+    struct RandomlyValid(bool);
 
-    impl<'a> arbitrary::Arbitrary<'a> for UnlikelyToBeValid {
-        fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<UnlikelyToBeValid> {
-            let v = u.arbitrary::<u128>()?;
-            if v >= 1024 {
+    impl<'a> arbitrary::Arbitrary<'a> for RandomlyValid {
+        fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+            let v: bool = u.arbitrary()?;
+            if !v {
                 return Err(arbitrary::Error::IncorrectFormat);
             }
-            Ok(UnlikelyToBeValid(v))
+            Ok(Self(v))
         }
     }
 
     #[test]
-    fn unlikely_to_be_valid() {
-        let _ = generator_test!(gen_arbitrary::<UnlikelyToBeValid>());
+    fn randomly_valid() {
+        let _ = generator_test!(gen_arbitrary::<RandomlyValid>());
     }
 }

lib/bolero-generator/src/driver.rs

@@ -163,6 +163,7 @@ pub trait Driver: Sized {
 
 /// Byte exhaustion strategy for the driver
 #[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[deprecated = "Driver mode should no longer used by generator implementations"]
 pub enum DriverMode {
     /// When the driver bytes are exhausted, the driver will fail fill input bytes.
     /// This is useful for fuzz engines that want accurate mapping of inputs to coverage.
@@ -175,7 +176,6 @@ pub enum DriverMode {
 
 #[derive(Clone, Debug, Default)]
 pub struct Options {
-    driver_mode: Option<DriverMode>,
     shrink_time: Option<core::time::Duration>,
     max_depth: Option<usize>,
     max_len: Option<usize>,
@@ -186,11 +186,6 @@ impl Options {
     pub const DEFAULT_MAX_LEN: usize = 4096;
     pub const DEFAULT_SHRINK_TIME: core::time::Duration = core::time::Duration::from_secs(1);
 
-    pub fn with_driver_mode(mut self, driver_mode: DriverMode) -> Self {
-        self.driver_mode = Some(driver_mode);
-        self
-    }
-
     pub fn with_shrink_time(mut self, shrink_time: core::time::Duration) -> Self {
         self.shrink_time = Some(shrink_time);
         self
@@ -206,11 +201,6 @@ impl Options {
         self
     }
 
-    pub fn set_driver_mode(&mut self, driver_mode: DriverMode) -> &mut Self {
-        self.driver_mode = Some(driver_mode);
-        self
-    }
-
     pub fn set_shrink_time(&mut self, shrink_time: core::time::Duration) -> &mut Self {
         self.shrink_time = Some(shrink_time);
         self
@@ -241,11 +231,6 @@ impl Options {
         self.shrink_time
     }
 
-    #[inline]
-    pub fn driver_mode(&self) -> Option<DriverMode> {
-        self.driver_mode
-    }
-
     #[inline]
     pub fn max_depth_or_default(&self) -> usize {
         self.max_depth.unwrap_or(Self::DEFAULT_MAX_DEPTH)
@@ -271,7 +256,6 @@ impl Options {
             };
         }
 
-        merge!(driver_mode);
         merge!(max_depth);
         merge!(max_len);
         merge!(shrink_time);

lib/bolero-generator/src/driver/bytes.rs

@@ -2,22 +2,19 @@ use super::*;
 
 #[derive(Debug)]
 pub struct ByteSliceDriver<'a> {
-    mode: DriverMode,
     input: &'a [u8],
     depth: usize,
     max_depth: usize,
 }
 
 impl<'a> ByteSliceDriver<'a> {
     pub fn new(input: &'a [u8], options: &Options) -> Self {
-        let mode = options.driver_mode.unwrap_or(DriverMode::Direct);
         let max_depth = options.max_depth_or_default();
         let len = options.max_len_or_default().min(input.len());
         let input = &input[..len];
 
         Self {
             input,
-            mode,
             depth: 0,
             max_depth,
         }
@@ -30,11 +27,6 @@ impl<'a> ByteSliceDriver<'a> {
 }
 
 impl<'a> FillBytes for ByteSliceDriver<'a> {
-    #[inline]
-    fn mode(&self) -> DriverMode {
-        self.mode
-    }
-
     #[inline]
     fn peek_bytes(&mut self, offset: usize, bytes: &mut [u8]) -> Option<()> {
         match self.input.len().checked_sub(offset) {

lib/bolero-generator/src/driver/macros.rs

@@ -19,15 +19,7 @@ macro_rules! gen_float {
                 return Some(<$ty>::from_le_bytes(bytes));
             }
 
-            // if we're in direct mode, just sample a value and check if it's within the provided range
-            if FillBytes::mode(self) == DriverMode::Direct {
-                return self
-                    .$name(Bound::Unbounded, Bound::Unbounded)
-                    .filter(|value| (min, max).contains(value));
-            }
-
             // TODO make this all less biased
-
             if let Some(value) = self
                 .$name(Bound::Unbounded, Bound::Unbounded)
                 .filter(|value| (min, max).contains(value))

lib/bolero-generator/src/driver/rng.rs

@@ -12,7 +12,6 @@ pub struct Rng<R: RngCore> {
     max_depth: usize,
     consumed_len: usize,
     max_len: usize,
-    mode: DriverMode,
     #[allow(dead_code)] // this isn't used in no_std mode
     buffer: Buffer,
 }
@@ -25,7 +24,6 @@ impl<R: RngCore> Rng<R> {
             max_depth: options.max_depth_or_default(),
             consumed_len: 0,
             max_len: options.max_len_or_default(),
-            mode: options.driver_mode.unwrap_or(DriverMode::Forced),
             buffer: Default::default(),
         }
     }
@@ -34,7 +32,7 @@ impl<R: RngCore> Rng<R> {
     fn fill_bytes(&mut self, bytes: &mut [u8]) -> Option<()> {
         let len = bytes.len().min(self.remaining_len());
         let (to_rng, to_fill) = bytes.split_at_mut(len);
-        fill_bytes(&mut self.rng, to_rng, self.mode)?;
+        fill_bytes(&mut self.rng, to_rng)?;
         to_fill.fill(0);
         Some(())
     }
@@ -51,7 +49,7 @@ impl<R: RngCore> Rng<R> {
 
     #[inline]
     fn fill_buffer(&mut self, len: usize) -> Option<&[u8]> {
-        self.buffer.fill(len, &mut self.rng, self.mode)?;
+        self.buffer.fill(len, &mut self.rng)?;
         Some(self.buffer.slice_mut(len))
     }
 }
@@ -64,20 +62,15 @@ impl<R: RngCore> AsRef<R> for Rng<R> {
 }
 
 #[inline]
-fn fill_bytes<R: RngCore>(rng: &mut R, bytes: &mut [u8], mode: DriverMode) -> Option<()> {
-    match mode {
-        DriverMode::Direct => RngCore::try_fill_bytes(rng, bytes).ok(),
-        DriverMode::Forced => {
-            if RngCore::try_fill_bytes(rng, bytes).is_err() {
-                // if the rng fails to fill the remaining bytes, then we just start returning 0s
-                for byte in bytes.iter_mut() {
-                    *byte = 0;
-                }
-            }
-
-            Some(())
+fn fill_bytes<R: RngCore>(rng: &mut R, bytes: &mut [u8]) -> Option<()> {
+    if RngCore::try_fill_bytes(rng, bytes).is_err() {
+        // if the rng fails to fill the remaining bytes, then we just start returning 0s
+        for byte in bytes.iter_mut() {
+            *byte = 0;
         }
     }
+
+    Some(())
 }
 
 macro_rules! impl_sample {
@@ -98,11 +91,6 @@ impl<R: RngCore> FillBytes for Rng<R> {
     // prefer sampling the larger values since it's faster to pull from the RNG
     const SHOULD_SHRINK: bool = false;
 
-    #[inline]
-    fn mode(&self) -> DriverMode {
-        self.mode
-    }
-
     #[inline]
     fn peek_bytes(&mut self, _offset: usize, bytes: &mut [u8]) -> Option<()> {
         self.fill_bytes(bytes)
@@ -195,12 +183,7 @@ mod buffer_alloc {
         pub const MAX_CAPACITY: usize = isize::MAX as _;
 
         #[inline]
-        pub fn fill<R: RngCore>(
-            &mut self,
-            len: usize,
-            rng: &mut R,
-            mode: DriverMode,
-        ) -> Option<()> {
+        pub fn fill<R: RngCore>(&mut self, len: usize, rng: &mut R) -> Option<()> {
             let data = &mut self.bytes;
 
             let initial_len = data.len();
@@ -213,7 +196,7 @@ mod buffer_alloc {
             // extend the random bytes
             data.try_reserve(len).ok()?;
             data.resize(len, 0);
-            fill_bytes(rng, &mut data[initial_len..], mode)?;
+            fill_bytes(rng, &mut data[initial_len..])?;
 
             Some(())
         }
@@ -253,12 +236,7 @@ mod buffer_no_alloc {
         pub const MAX_CAPACITY: usize = 256;
 
         #[inline]
-        pub fn fill<R: RngCore>(
-            &mut self,
-            len: usize,
-            rng: &mut R,
-            mode: DriverMode,
-        ) -> Option<()> {
+        pub fn fill<R: RngCore>(&mut self, len: usize, rng: &mut R) -> Option<()> {
             if cfg!(test) {
                 assert!(len <= Self::MAX_CAPACITY);
             }
@@ -271,7 +249,7 @@ mod buffer_no_alloc {
             }
 
             // extend the random bytes
-            fill_bytes(rng, &mut self.bytes[initial_len..], mode)?;
+            fill_bytes(rng, &mut self.bytes[initial_len..])?;
             self.len = len;
 
             Some(())

lib/bolero-generator/src/lib.rs

@@ -268,6 +268,9 @@ pub mod prelude {
         TypeGenerator, TypeGeneratorWithParams, ValueGenerator,
     };
 
+    #[allow(deprecated)]
+    pub use crate::driver::DriverMode;
+
     #[cfg(feature = "arbitrary")]
     pub use crate::gen_arbitrary;
 }

lib/bolero-generator/src/testing.rs

@@ -2,12 +2,12 @@
 macro_rules! generator_test {
     ($gen:expr) => {{
         use $crate::{
-            driver::{ByteSliceDriver, DriverMode, Options, Rng},
+            driver::{ByteSliceDriver, Options, Rng},
             *,
         };
         let gen = $gen;
 
-        let options = Options::default().with_driver_mode(DriverMode::Forced);
+        let options = Options::default();
 
         let mut rng_driver = Rng::new(rand::thread_rng(), &options);
 
@@ -19,7 +19,6 @@ macro_rules! generator_test {
             .unwrap();
 
         {
-            let options = options.clone().with_driver_mode(DriverMode::Direct);
             for input in inputs.iter() {
                 if let Some(value) =
                     ValueGenerator::generate(&gen, &mut ByteSliceDriver::new(input, &options))
@@ -39,8 +38,8 @@ macro_rules! generator_test {
             }
         }
 
-        // keep track of failed forced inputs and make sure they didn't all fail
-        let mut failed_forced = 0;
+        // keep track of failed inputs and make sure they didn't all fail
+        let mut failed = 0;
 
         for input in inputs.iter() {
             if let Some(value) =
@@ -58,11 +57,11 @@ macro_rules! generator_test {
                     "a mutation with the same input should produce the original"
                 );
             } else {
-                failed_forced += 1;
+                failed += 1;
             }
         }
 
-        assert_ne!(failed_forced, inputs.len(), "all the forced inputs failed");
+        assert_ne!(failed, inputs.len(), "all the inputs failed");
 
         ValueGenerator::generate(&gen, &mut rng_driver)
     }};
@@ -72,12 +71,12 @@ macro_rules! generator_test {
 macro_rules! generator_no_clone_test {
     ($gen:expr) => {{
         use $crate::{
-            driver::{ByteSliceDriver, DriverMode, Options, Rng},
+            driver::{ByteSliceDriver, Options, Rng},
             *,
         };
         let gen = $gen;
 
-        let options = Options::default().with_driver_mode(DriverMode::Forced);
+        let options = Options::default();
 
         let mut rng_driver = Rng::new(rand::thread_rng(), &options);
 
@@ -89,7 +88,6 @@ macro_rules! generator_no_clone_test {
             .unwrap();
 
         {
-            let options = options.clone().with_driver_mode(DriverMode::Direct);
             for input in inputs.iter() {
                 if let Some(mut value) =
                     ValueGenerator::generate(&gen, &mut ByteSliceDriver::new(input, &options))
@@ -105,7 +103,7 @@ macro_rules! generator_no_clone_test {
         }
 
         // keep track of failed forced inputs and make sure they didn't all fail
-        let mut failed_forced = 0;
+        let mut failed = 0;
 
         for input in inputs.iter() {
             if let Some(mut value) =
@@ -118,11 +116,11 @@ macro_rules! generator_no_clone_test {
                 )
                 .expect("mutation with same driver should produce a value");
             } else {
-                failed_forced += 1;
+                failed += 1;
             }
         }
 
-        assert_ne!(failed_forced, inputs.len(), "all the forced inputs failed");
+        assert_ne!(failed, inputs.len(), "all the inputs failed");
 
         ValueGenerator::generate(&gen, &mut rng_driver)
     }};