fix(Unstructured)!: don't produce meaningless data if exhausted

src/lib.rs

@@ -1166,15 +1166,17 @@ mod test {
 
     #[test]
     fn finite_buffer_fill_buffer() {
-        let x = [1, 2, 3, 4];
+        let x = [1, 2, 3, 4, 5];
         let mut rb = Unstructured::new(&x);
         let mut z = [0; 2];
         rb.fill_buffer(&mut z).unwrap();
         assert_eq!(z, [1, 2]);
         rb.fill_buffer(&mut z).unwrap();
         assert_eq!(z, [3, 4]);
         rb.fill_buffer(&mut z).unwrap();
-        assert_eq!(z, [0, 0]);
+        assert_eq!(z, [5, 0]);
+
+        assert!(rb.fill_buffer(&mut z).is_err());
     }
 
     #[test]

src/unstructured.rs

@@ -468,28 +468,32 @@ impl<'a> Unstructured<'a> {
     /// `Arbitrary` implementations like `<Vec<u8>>::arbitrary` and
     /// `String::arbitrary` over using this method directly.
     ///
-    /// If this `Unstructured` does not have enough underlying data to fill the
-    /// whole `buffer`, it pads the buffer out with zeros.
+    /// If this `Unstructured` only has enough underlying data to fill only part of
+    /// the whole `buffer`, it pads the rest of the buffer with zeros. If the
+    /// `Unstructured` is completely exhausted, an error is returned.
     ///
     /// # Example
     ///
     /// ```
     /// use arbitrary::Unstructured;
     ///
-    /// let mut u = Unstructured::new(&[1, 2, 3, 4]);
+    /// let mut u = Unstructured::new(&[1, 2, 3]);
     ///
     /// let mut buf = [0; 2];
     ///
     /// assert!(u.fill_buffer(&mut buf).is_ok());
     /// assert_eq!(buf, [1, 2]);
     ///
     /// assert!(u.fill_buffer(&mut buf).is_ok());
-    /// assert_eq!(buf, [3, 4]);
+    /// assert_eq!(buf, [3, 0]);
     ///
-    /// assert!(u.fill_buffer(&mut buf).is_ok());
-    /// assert_eq!(buf, [0, 0]);
+    /// assert!(u.fill_buffer(&mut buf).is_err());
     /// ```
     pub fn fill_buffer(&mut self, buffer: &mut [u8]) -> Result<()> {
+        if self.is_empty() {
+            return Err(Error::NotEnoughData);
+        }
+
         let n = std::cmp::min(buffer.len(), self.data.len());
         buffer[..n].copy_from_slice(&self.data[..n]);
         for byte in buffer[n..].iter_mut() {

tests/derive.rs

@@ -135,6 +135,17 @@ fn recursive() {
     );
 }
 
+#[test]
+fn recursive_first_variant() {
+    #[derive(PartialEq, Eq, Debug, Arbitrary)]
+    enum Nat {
+        Succ(Box<Nat>),
+        Zero,
+    }
+
+    assert!(Nat::arbitrary(&mut Unstructured::new(&[])).is_err());
+}
+
 #[derive(Arbitrary, Debug)]
 struct Generic<T> {
     inner: T,