Verify Compressor::compress parallel execution with robust tests (#385)

- Renamed `test_parallel_compression_roundtrip` to `test_parallel_deflate_1mb` for clarity.
- Added `test_parallel_deflate_boundary` to test the 256KB threshold trigger.
- Added `test_parallel_deflate_large` (10MB) to verify scalability.
- Added `test_parallel_zlib_large` and `test_parallel_gzip_large` (5MB) to cover format wrappers.
- Added `test_parallel_insufficient_space` to verify error propagation in parallel mode.

These tests ensure that the parallel execution path, which activates for inputs > 256KB, functions correctly across different formats and handles edge cases like buffer limits properly.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: 404Setup

tests/parallel_test.rs

@@ -1,7 +1,7 @@
 use libdeflate::{Compressor, Decompressor};
 
 #[test]
-fn test_parallel_compression_roundtrip() {
+fn test_parallel_deflate_1mb() {
     let size = 1024 * 1024;
     let mut data = Vec::with_capacity(size);
     for i in 0..size {
@@ -18,3 +18,97 @@ fn test_parallel_compression_roundtrip() {
 
     assert_eq!(decompressed, data);
 }
+
+#[test]
+fn test_parallel_deflate_boundary() {
+    // 256KB + 1 byte
+    let size = 256 * 1024 + 1;
+    let mut data = Vec::with_capacity(size);
+    for i in 0..size {
+        data.push((i % 256) as u8);
+    }
+
+    let mut compressor = Compressor::new(6).unwrap();
+    let mut decompressor = Decompressor::new();
+
+    let compressed = compressor.compress_deflate(&data).unwrap();
+    assert!(compressed.len() > 0);
+
+    let decompressed = decompressor.decompress_deflate(&compressed, size).unwrap();
+    assert_eq!(decompressed, data);
+}
+
+#[test]
+fn test_parallel_deflate_large() {
+    // 10MB
+    let size = 10 * 1024 * 1024;
+    let mut data = Vec::with_capacity(size);
+    for i in 0..size {
+        data.push((i % 256) as u8);
+    }
+
+    let mut compressor = Compressor::new(6).unwrap();
+    let mut decompressor = Decompressor::new();
+
+    let compressed = compressor.compress_deflate(&data).unwrap();
+    assert!(compressed.len() > 0);
+
+    let decompressed = decompressor.decompress_deflate(&compressed, size).unwrap();
+    assert_eq!(decompressed, data);
+}
+
+#[test]
+fn test_parallel_zlib_large() {
+    let size = 5 * 1024 * 1024;
+    let mut data = Vec::with_capacity(size);
+    for i in 0..size {
+        data.push((i.wrapping_mul(3) % 251) as u8);
+    }
+
+    let mut compressor = Compressor::new(6).unwrap();
+    let mut decompressor = Decompressor::new();
+
+    let compressed = compressor.compress_zlib(&data).unwrap();
+    assert!(compressed.len() > 0);
+
+    let decompressed = decompressor.decompress_zlib(&compressed, size).unwrap();
+    assert_eq!(decompressed, data);
+}
+
+#[test]
+fn test_parallel_gzip_large() {
+    let size = 5 * 1024 * 1024;
+    let mut data = Vec::with_capacity(size);
+    for i in 0..size {
+        data.push((i.wrapping_mul(7) % 251) as u8);
+    }
+
+    let mut compressor = Compressor::new(6).unwrap();
+    let mut decompressor = Decompressor::new();
+
+    let compressed = compressor.compress_gzip(&data).unwrap();
+    assert!(compressed.len() > 0);
+
+    let decompressed = decompressor.decompress_gzip(&compressed, size).unwrap();
+    assert_eq!(decompressed, data);
+}
+
+#[test]
+fn test_parallel_insufficient_space() {
+    let size = 1024 * 1024; // 1MB, triggers parallel
+    let mut data = Vec::with_capacity(size);
+    for i in 0..size {
+        data.push((i % 256) as u8);
+    }
+
+    let mut compressor = Compressor::new(6).unwrap();
+
+    // Provide a buffer that is too small
+    let mut output = vec![0u8; 100]; // Definitely too small
+
+    let result = compressor.compress_deflate_into(&data, &mut output);
+    assert!(result.is_err());
+    // We expect "Insufficient space" or similar error
+    let err = result.unwrap_err();
+    assert!(err.to_string().contains("Insufficient space") || err.to_string().contains("Compression failed"));
+}