fix: make all structured input unbounded by default (#301)

Author: Copilot

lib/bolero/src/lib.rs

@@ -289,6 +289,14 @@ impl<G, Engine, InputOwnership> TestTarget<G, Engine, InputOwnership> {
         self.driver_options.set_exhaustive(true);
         self
     }
+
+    fn as_unbounded_options(&self) -> bolero_generator::driver::Options {
+        let mut options = self.driver_options.clone();
+        if options.max_len().is_none() {
+            options.set_max_len(usize::MAX);
+        }
+        options
+    }
 }
 
 impl<G: generator::ValueGenerator, Engine, InputOwnership> TestTarget<G, Engine, InputOwnership> {
@@ -439,8 +447,9 @@ where
         E: Engine<bolero_engine::BorrowedGeneratorTest<F, G, G::Output>>,
         bolero_engine::BorrowedGeneratorTest<F, G, G::Output>: Test,
     {
+        let options = self.as_unbounded_options();
         let test = bolero_engine::BorrowedGeneratorTest::new(test, self.generator);
-        self.engine.run(test, self.driver_options)
+        self.engine.run(test, options)
     }
 }
 
@@ -454,8 +463,9 @@ where
         E: Engine<bolero_engine::ClonedGeneratorTest<F, G, G::Output>>,
         bolero_engine::ClonedGeneratorTest<F, G, G::Output>: Test,
     {
+        let options = self.as_unbounded_options();
         let test = bolero_engine::ClonedGeneratorTest::new(test, self.generator);
-        self.engine.run(test, self.driver_options)
+        self.engine.run(test, options)
     }
 }
 
@@ -478,7 +488,8 @@ impl<E> TestTarget<ByteSliceGenerator, E, BorrowedInput> {
         R: bolero_engine::IntoResult,
         E: bolero_engine::ScopedEngine,
     {
-        self.engine.run(test, self.driver_options)
+        let options = self.as_unbounded_options();
+        self.engine.run(test, options)
     }
 }
 

lib/bolero/src/tests.rs

@@ -197,3 +197,37 @@ fn scope_exhaustive_panic_test() {
         assert!(any::<bool>(), "oops");
     });
 }
+
+/// This test verifies that run() uses unbounded entropy by default (max_len = usize::MAX)
+#[test]
+fn scope_unbounded_entropy_test() {
+    check!().with_iterations(1).run(|| {
+        // Generate 1000 u64 values, which requires 8000 bytes of entropy
+        // This exceeds the default max_len of 4096 bytes
+        for _ in 0..1000 {
+            let _: u64 = any();
+        }
+
+        for _ in 0..1000 {
+            if any() {
+                return;
+            }
+        }
+
+        panic!("did not generate non-empty entropy as expected");
+    });
+}
+
+/// Verify that when max_len is explicitly set, it is still respected
+#[test]
+fn scope_explicit_max_len_test() {
+    check!().with_max_len(100).with_iterations(5).run(|| {
+        for _ in 0..1000 {
+            let _: u64 = any();
+        }
+
+        for _ in 0..1000 {
+            assert_eq!(any::<u8>(), 0u8);
+        }
+    });
+}