Add capabilties test for functions reserved to zlib-implementations.

Some of these tests were previously gated and placed in such a way
that `zlib-rs` was able to switch from its C-bindings to using
its Rust API without implementing all zlib-implementation specific
methods.

The exstiing tests were unable to see this, and this commit adds
a new capabiltiies test that will test these methods in all
implementations but the `miniz_oxide`, which truly doesn't
support them.

Author: Byron

src/mem.rs

@@ -212,8 +212,8 @@ impl Compress {
     /// # Panics
     ///
     /// If `window_bits` does not fall into the range 9 ..= 15,
-    /// `new_with_window_bits` will panic.
-    #[cfg(feature = "any_zlib")]
+    /// this function will panic.
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     pub fn new_with_window_bits(
         level: Compression,
         zlib_header: bool,
@@ -239,8 +239,8 @@ impl Compress {
     /// # Panics
     ///
     /// If `window_bits` does not fall into the range 9 ..= 15,
-    /// `new_with_window_bits` will panic.
-    #[cfg(feature = "any_zlib")]
+    /// this function will panic.
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     pub fn new_gzip(level: Compression, window_bits: u8) -> Compress {
         assert!(
             window_bits > 8 && window_bits < 16,
@@ -415,8 +415,8 @@ impl Decompress {
     /// # Panics
     ///
     /// If `window_bits` does not fall into the range 9 ..= 15,
-    /// `new_with_window_bits` will panic.
-    #[cfg(feature = "any_zlib")]
+    /// this function will panic.
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     pub fn new_with_window_bits(zlib_header: bool, window_bits: u8) -> Decompress {
         assert!(
             window_bits > 8 && window_bits < 16,
@@ -435,8 +435,8 @@ impl Decompress {
     /// # Panics
     ///
     /// If `window_bits` does not fall into the range 9 ..= 15,
-    /// `new_with_window_bits` will panic.
-    #[cfg(feature = "any_zlib")]
+    /// this function will panic.
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     pub fn new_gzip(window_bits: u8) -> Decompress {
         assert!(
             window_bits > 8 && window_bits < 16,
@@ -663,7 +663,7 @@ mod tests {
     use crate::write;
     use crate::{Compression, Decompress, FlushDecompress};
 
-    #[cfg(feature = "any_zlib")]
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     use crate::{Compress, FlushCompress};
 
     #[test]
@@ -723,87 +723,7 @@ mod tests {
         assert!(dst.starts_with(string));
     }
 
-    #[cfg(feature = "any_zlib")]
-    #[test]
-    fn set_dictionary_with_zlib_header() {
-        let string = "hello, hello!".as_bytes();
-        let dictionary = "hello".as_bytes();
-
-        let mut encoded = Vec::with_capacity(1024);
-
-        let mut encoder = Compress::new(Compression::default(), true);
-
-        let dictionary_adler = encoder.set_dictionary(&dictionary).unwrap();
-
-        encoder
-            .compress_vec(string, &mut encoded, FlushCompress::Finish)
-            .unwrap();
-
-        assert_eq!(encoder.total_in(), string.len() as u64);
-        assert_eq!(encoder.total_out(), encoded.len() as u64);
-
-        let mut decoder = Decompress::new(true);
-        let mut decoded = [0; 1024];
-        let decompress_error = decoder
-            .decompress(&encoded, &mut decoded, FlushDecompress::Finish)
-            .expect_err("decompression should fail due to requiring a dictionary");
-
-        let required_adler = decompress_error.needs_dictionary()
-            .expect("the first call to decompress should indicate a dictionary is required along with the required Adler-32 checksum");
-
-        assert_eq!(required_adler, dictionary_adler,
-            "the Adler-32 checksum should match the value when the dictionary was set on the compressor");
-
-        let actual_adler = decoder.set_dictionary(&dictionary).unwrap();
-
-        assert_eq!(required_adler, actual_adler);
-
-        // Decompress the rest of the input to the remainder of the output buffer
-        let total_in = decoder.total_in();
-        let total_out = decoder.total_out();
-
-        let decompress_result = decoder.decompress(
-            &encoded[total_in as usize..],
-            &mut decoded[total_out as usize..],
-            FlushDecompress::Finish,
-        );
-        assert!(decompress_result.is_ok());
-
-        assert_eq!(&decoded[..decoder.total_out() as usize], string);
-    }
-
-    #[cfg(feature = "any_zlib")]
-    #[test]
-    fn set_dictionary_raw() {
-        let string = "hello, hello!".as_bytes();
-        let dictionary = "hello".as_bytes();
-
-        let mut encoded = Vec::with_capacity(1024);
-
-        let mut encoder = Compress::new(Compression::default(), false);
-
-        encoder.set_dictionary(&dictionary).unwrap();
-
-        encoder
-            .compress_vec(string, &mut encoded, FlushCompress::Finish)
-            .unwrap();
-
-        assert_eq!(encoder.total_in(), string.len() as u64);
-        assert_eq!(encoder.total_out(), encoded.len() as u64);
-
-        let mut decoder = Decompress::new(false);
-
-        decoder.set_dictionary(&dictionary).unwrap();
-
-        let mut decoded = [0; 1024];
-        let decompress_result = decoder.decompress(&encoded, &mut decoded, FlushDecompress::Finish);
-
-        assert!(decompress_result.is_ok());
-
-        assert_eq!(&decoded[..decoder.total_out() as usize], string);
-    }
-
-    #[cfg(feature = "any_zlib")]
+    #[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
     #[test]
     fn test_gzip_flate() {
         let string = "hello, hello!".as_bytes();

tests/capabilities.rs

@@ -0,0 +1,240 @@
+//! Validate that certain feature-gated functionality is still available.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+use flate2::{Compress, Compression, Decompress, FlushCompress, FlushDecompress};
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn compress_new_with_window_bits_is_present_and_works() {
+    let string = "hello world".as_bytes();
+
+    // Test with window_bits = 9 (minimum)
+    let mut encoded = Vec::with_capacity(1024);
+    let mut encoder = Compress::new_with_window_bits(Compression::default(), true, 9);
+    encoder
+        .compress_vec(string, &mut encoded, FlushCompress::Finish)
+        .unwrap();
+    assert_ne!(encoded.len(), 0);
+
+    let mut decoder = Decompress::new_with_window_bits(true, 9);
+    let mut decoded = [0; 1024];
+    decoder
+        .decompress(&encoded, &mut decoded, FlushDecompress::Finish)
+        .unwrap();
+    assert_eq!(&decoded[..string.len()], string);
+
+    // Test with window_bits = 15 (maximum)
+    let mut encoded = Vec::with_capacity(1024);
+    let mut encoder = Compress::new_with_window_bits(Compression::default(), false, 15);
+    encoder
+        .compress_vec(string, &mut encoded, FlushCompress::Finish)
+        .unwrap();
+    assert_ne!(encoded.len(), 0);
+
+    let mut decoder = Decompress::new_with_window_bits(false, 15);
+    let mut decoded = [0; 1024];
+    decoder
+        .decompress(&encoded, &mut decoded, FlushDecompress::Finish)
+        .unwrap();
+    assert_eq!(&decoded[..string.len()], string);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn decompress_new_gzip_window_bits_is_present_and_works() {
+    let string = "hello world".as_bytes();
+
+    // Test with different window_bits values
+    for window_bits in [9, 12, 15] {
+        let mut encoded = Vec::with_capacity(1024);
+        let mut encoder = Compress::new_gzip(Compression::default(), window_bits);
+        encoder
+            .compress_vec(string, &mut encoded, FlushCompress::Finish)
+            .unwrap();
+
+        let mut decoder = Decompress::new_gzip(window_bits);
+        let mut decoded = [0; 1024];
+        decoder
+            .decompress(&encoded, &mut decoded, FlushDecompress::Finish)
+            .unwrap();
+        assert_eq!(
+            &decoded[..string.len()],
+            string,
+            "Failed with window_bits={}",
+            window_bits
+        );
+    }
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+#[should_panic(expected = "window_bits must be within 9 ..= 15")]
+fn compress_new_with_window_bits_invalid_low() {
+    let _ = Compress::new_with_window_bits(Compression::default(), true, 8);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+#[should_panic(expected = "window_bits must be within 9 ..= 15")]
+fn compress_new_with_window_bits_invalid_high() {
+    let _ = Compress::new_with_window_bits(Compression::default(), true, 16);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+#[should_panic(expected = "window_bits must be within 9 ..= 15")]
+fn compress_new_gzip_invalid_low() {
+    let _ = Compress::new_gzip(Compression::default(), 8);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+#[should_panic(expected = "window_bits must be within 9 ..= 15")]
+fn compress_new_gzip_invalid_high() {
+    let _ = Compress::new_gzip(Compression::default(), 16);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn set_dictionary_with_zlib_header() {
+    let string = "hello, hello!".as_bytes();
+    let dictionary = "hello".as_bytes();
+
+    let mut encoded = Vec::with_capacity(1024);
+
+    let mut encoder = Compress::new(Compression::default(), true);
+
+    let dictionary_adler = encoder.set_dictionary(&dictionary).unwrap();
+
+    encoder
+        .compress_vec(string, &mut encoded, FlushCompress::Finish)
+        .unwrap();
+
+    assert_eq!(encoder.total_in(), string.len() as u64);
+    assert_eq!(encoder.total_out(), encoded.len() as u64);
+
+    let mut decoder = Decompress::new(true);
+    let mut decoded = [0; 1024];
+    let decompress_error = decoder
+        .decompress(&encoded, &mut decoded, FlushDecompress::Finish)
+        .expect_err("decompression should fail due to requiring a dictionary");
+
+    let required_adler = decompress_error.needs_dictionary()
+        .expect("the first call to decompress should indicate a dictionary is required along with the required Adler-32 checksum");
+
+    assert_eq!(required_adler, dictionary_adler,
+               "the Adler-32 checksum should match the value when the dictionary was set on the compressor");
+
+    let actual_adler = decoder.set_dictionary(&dictionary).unwrap();
+
+    assert_eq!(required_adler, actual_adler);
+
+    // Decompress the rest of the input to the remainder of the output buffer
+    let total_in = decoder.total_in();
+    let total_out = decoder.total_out();
+
+    let decompress_result = decoder.decompress(
+        &encoded[total_in as usize..],
+        &mut decoded[total_out as usize..],
+        FlushDecompress::Finish,
+    );
+    assert!(decompress_result.is_ok());
+
+    assert_eq!(&decoded[..decoder.total_out() as usize], string);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn set_dictionary_raw() {
+    let string = "hello, hello!".as_bytes();
+    let dictionary = "hello".as_bytes();
+
+    let mut encoded = Vec::with_capacity(1024);
+
+    let mut encoder = Compress::new(Compression::default(), false);
+
+    encoder.set_dictionary(&dictionary).unwrap();
+
+    encoder
+        .compress_vec(string, &mut encoded, FlushCompress::Finish)
+        .unwrap();
+
+    assert_eq!(encoder.total_in(), string.len() as u64);
+    assert_eq!(encoder.total_out(), encoded.len() as u64);
+
+    let mut decoder = Decompress::new(false);
+
+    decoder.set_dictionary(&dictionary).unwrap();
+
+    let mut decoded = [0; 1024];
+    let decompress_result = decoder.decompress(&encoded, &mut decoded, FlushDecompress::Finish);
+
+    assert!(decompress_result.is_ok());
+
+    assert_eq!(&decoded[..decoder.total_out() as usize], string);
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn compression_levels_are_effective() {
+    let input = b"hello hello hello hello hello hello hello hello";
+
+    // Compress with no compression
+    let mut encoded_none = Vec::new();
+    Compress::new(Compression::none(), true)
+        .compress_vec(input, &mut encoded_none, FlushCompress::Finish)
+        .unwrap();
+
+    // Compress with best compression
+    let mut encoded_best = Vec::new();
+    Compress::new(Compression::best(), true)
+        .compress_vec(input, &mut encoded_best, FlushCompress::Finish)
+        .unwrap();
+
+    assert!(
+        encoded_best.len() <= encoded_none.len(),
+        "best compression produced larger output than no compression: best={}, none={}",
+        encoded_best.len(),
+        encoded_none.len(),
+    );
+}
+
+// Unsupported for `miniz_oxide`.
+#[cfg(any(feature = "any_zlib", feature = "zlib-rs"))]
+#[test]
+fn set_level_is_effective() {
+    let input = b"hello hello hello hello hello hello hello hello";
+    let no_compression = Compression::none();
+    let best_compression = Compression::best();
+
+    // Compress with no compression
+    let mut encoded_none = Vec::new();
+    let mut compress = Compress::new(best_compression, true);
+    compress.set_level(no_compression).unwrap();
+    compress
+        .compress_vec(input, &mut encoded_none, FlushCompress::Finish)
+        .unwrap();
+
+    // Compress with best compression
+    let mut encoded_best = Vec::new();
+    let mut compress = Compress::new(no_compression, true);
+    compress.set_level(best_compression).unwrap();
+    compress
+        .compress_vec(input, &mut encoded_best, FlushCompress::Finish)
+        .unwrap();
+
+    assert!(
+        encoded_best.len() <= encoded_none.len(),
+        "best compression produced larger output than no compression: best={}, none={}",
+        encoded_best.len(),
+        encoded_none.len(),
+    );
+}