1 files changed, 79 insertions, 0 deletions
diff --git a/buffered-reader/src/decompress.rs b/buffered-reader/src/decompress.rs
index 81a11e48..6ed2f8c6 100644
--- a/buffered-reader/src/decompress.rs
+++ b/buffered-reader/src/decompress.rs
@@ -47,6 +47,10 @@ impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderDeflate<R, C> {
 
 impl<R: BufferedReader<C>, C> BufferedReader<C>
         for BufferedReaderDeflate<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
         return self.reader.data(amount);
     }
@@ -155,6 +159,10 @@ impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderZlib<R, C> {
 
 impl<R: BufferedReader<C>, C> BufferedReader<C>
         for BufferedReaderZlib<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
         return self.reader.data(amount);
     }
@@ -262,6 +270,10 @@ impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderBzip<R, C> {
 }
 
 impl<R: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderBzip<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
     fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
         return self.reader.data(amount);
     }
@@ -330,3 +342,70 @@ impl<R: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderBzip<R, C> {
     }
 }
 
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    // Test that buffer() returns the same data as data().
+    #[test]
+    fn buffer_test() {
+        use flate2::write::DeflateEncoder;
+        use flate2::Compression;
+        use std::io::prelude::*;
+
+        // Test vector.
+        let size = 10 * DEFAULT_BUF_SIZE;
+        let mut input_raw = Vec::with_capacity(size);
+        let mut v = 0u8;
+        for _ in 0..size {
+            input_raw.push(v);
+            if v == std::u8::MAX {
+                v = 0;
+            } else {
+                v += 1;
+            }
+        }
+
+        // Compress the raw input.
+        let mut input = Vec::new();
+        {
+            let mut encoder =
+                DeflateEncoder::new(&mut input, Compression::default());
+            encoder.write(&input_raw[..]).unwrap();
+            encoder.try_finish().unwrap();
+        }
+
+        let mut reader = BufferedReaderDeflate::new(
+            BufferedReaderGeneric::new(&input[..], None));
+
+        // Gather some stats to make it easier to figure out whether
+        // this test is working.
+        let stats_count =  2 * DEFAULT_BUF_SIZE;
+        let mut stats = vec![0usize; stats_count];
+
+        for i in 0..input_raw.len() {
+            let data = reader.data(DEFAULT_BUF_SIZE + 1).unwrap().to_vec();
+            assert!(data.len() > 0);
+            assert_eq!(data, reader.buffer());
+            // And, we may as well check to make sure we read the
+            // right data.
+            assert_eq!(data, &input_raw[i..i+data.len()]);
+
+            stats[cmp::min(data.len(), stats_count - 1)] += 1;
+
+            // Consume one byte and see what happens.
+            reader.consume(1);
+        }
+
+        if false {
+            for i in 0..stats.len() {
+                if stats[i] > 0 {
+                    if i == stats.len() - 1 {
+                        eprint!(">=");
+                    }
+                    eprintln!("{}: {}", i, stats[i]);
+                }
+            }
+        }
+    }
+}