Add regression test for decode_from_read_unbuffered_with bug

diff --git a/io/src/lib.rs b/io/src/lib.rs
index f51e8b79..5d9d5d0f 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -947,4 +947,64 @@ mod tests {
         let decoded = result.unwrap();
         assert_eq!(decoded.0, [1, 2, 3, 4]);
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn decode_from_read_unbuffered_partial_consume() {
+        use encoding::DecoderStatus;
+
+        // Consumes one byte per push_bytes call. Returns Ready after
+        // it has accumulated 4 bytes. Checks for correct behaviour on
+        // partial consumption in push_bytes.
+        #[derive(Default)]
+        struct OneAtATimeDecoder {
+            buf: Vec<u8>,
+        }
+
+        #[derive(Debug, PartialEq)]
+        struct OneAtATime(Vec<u8>);
+
+        #[derive(Debug)]
+        struct OneAtATimeError;
+
+        impl Decoder for OneAtATimeDecoder {
+            type Output = OneAtATime;
+            type Error = OneAtATimeError;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> core::result::Result<DecoderStatus, Self::Error> {
+                if self.buf.len() < 4 && !bytes.is_empty() {
+                    self.buf.push(bytes[0]);
+                    *bytes = &bytes[1..];
+                }
+                if self.buf.len() == 4 {
+                    Ok(DecoderStatus::Ready)
+                } else {
+                    Ok(DecoderStatus::NeedsMore)
+                }
+            }
+
+            fn end(self) -> core::result::Result<Self::Output, Self::Error> {
+                if self.buf.len() == 4 {
+                    Ok(OneAtATime(self.buf))
+                } else {
+                    Err(OneAtATimeError)
+                }
+            }
+
+            fn read_limit(&self) -> usize { 4 - self.buf.len() }
+        }
+
+        impl Decode for OneAtATime {
+            type Decoder = OneAtATimeDecoder;
+        }
+
+        let data = [0x11, 0x22, 0x33, 0x44];
+        let cursor = Cursor::new(&data);
+        let decoded: OneAtATime =
+            decode_from_read_unbuffered_with::<_, _, 16>(cursor).expect("decode succeeds");
+        assert_eq!(decoded.0, vec![0x11, 0x22, 0x33, 0x44]);
+    }
 }