ci: enable fuzzing the rust implementation under very specific edge cases (#55)

I found a set of edgecases under which the rust implementation does not
crash..

They are very specific though..

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: CommanderStorm

.github/workflows/ci.yml

@@ -57,6 +57,7 @@ jobs:
           components: rustfmt
       - run: just ci_mode=0 ci-test-msrv  # Ignore warnings in MSRV
   fuzz:
+    name: Fuzz
     runs-on: ubuntu-latest
 
     env:
@@ -87,7 +88,6 @@ jobs:
       #  --target x86_64-unknown-linux-gnu is necessary to not default to musl, which is not supported by cargo-fuzz.
       - run: cargo fuzz build --target x86_64-unknown-linux-gnu ${{ matrix.fuzz_target }}
       - run: cargo fuzz run --target x86_64-unknown-linux-gnu ${{ matrix.fuzz_target }} -- -max_total_time=${{ env.FUZZ_TIME }}
-        if: ${{ matrix.fuzz_target != 'fastpfor_rust' }} # fastpfor_rust does not pass this
 
       # Upload fuzzing artifacts on failure for post-mortem debugging.
       - uses: actions/upload-artifact@v4

fuzz/fuzz_targets/fastpfor_cpp.rs

@@ -34,12 +34,21 @@ fuzz_target!(|data: FuzzInput| {
     assert_eq!(dec_slice.len(), input.len());
 });
 
-#[derive(arbitrary::Arbitrary, Debug)]
+#[derive(arbitrary::Arbitrary)]
 struct FuzzInput {
     data: Vec<u32>,
     codec: FuzzCodec,
 }
 
+impl std::fmt::Debug for FuzzInput {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FuzzInput")
+            .field("data_length", &self.data.len())
+            .field("codec", &self.codec)
+            .finish()
+    }
+}
+
 #[derive(Clone, Copy, Eq, PartialEq, arbitrary::Arbitrary, Debug)]
 enum FuzzCodec {
     BP32Codec,

fuzz/fuzz_targets/fastpfor_rust.rs

@@ -2,36 +2,50 @@
 
 use std::io::Cursor;
 
-use fastpfor::rust::{BLOCK_SIZE_256, DEFAULT_PAGE_SIZE, FastPFOR, Integer};
+use fastpfor::rust::{FastPFOR, Integer, BLOCK_SIZE_128, BLOCK_SIZE_256, DEFAULT_PAGE_SIZE};
 use libfuzzer_sys::fuzz_target;
+use std::num::NonZeroU32;
 
-fuzz_target!(|input_data: Vec<u32>| {
-    let mut codec = FastPFOR::new(DEFAULT_PAGE_SIZE, BLOCK_SIZE_256);
+fuzz_target!(|data: FuzzInput| {
+    let input = data.data;
+    let block_size = NonZeroU32::from(data.codec);
+    let mut codec = FastPFOR::new(DEFAULT_PAGE_SIZE, block_size);
 
-    // Limit input size to avoid timeouts
-    let input_data: Vec<u32> = input_data.into_iter().take(10_000).collect();
+    // TODO: empty input is encoded as empty, which does not match the CPP version
+    if input.is_empty() {
+        return;
+    }
+
+    // TODO: only multiples of block size seem to be exported from the compress - decompress cycle
+    let bs = block_size.get() as usize;
+    if input.len() < bs {
+        return;
+    }
+    let last_block_size_multiple = input.len() / bs * bs;
+    let input = input
+        .into_iter()
+        .take(last_block_size_multiple as usize)
+        .collect::<Vec<_>>();
 
     // Allocate output buffer with generous size
-    let mut compressed = vec![0u32; input_data.len() * 2 + 1024];
+    let mut compressed = vec![0u32; input.len() * 2 + 1024];
 
     // Compress the data
     let mut output_offset = Cursor::new(0);
     codec
         .compress(
-            &input_data,
-            input_data.len() as u32,
+            &input,
+            input.len() as u32,
             &mut Cursor::new(0),
             &mut compressed,
             &mut output_offset,
         )
         .unwrap();
     let compressed_size = output_offset.position() as u32;
-    if !input_data.is_empty() {
-        assert!(compressed_size != 0, "compression should not be empty");
-    }
+    assert!(compressed_size != 0, "compression should not be empty");
 
     // Now decompress
-    let mut decompressed = vec![0u32; input_data.len()];
+    let mut decompressed = vec![0u32; input.len()];
     let mut output_offset = Cursor::new(0);
 
     codec
@@ -46,21 +60,50 @@ fuzz_target!(|input_data: Vec<u32>| {
     let decompressed_length = output_offset.position() as usize;
 
     // Verify roundtrip
-    if decompressed_length + input_data.len() < 200 {
+    assert_eq!(decompressed_length, input.len());
+    if decompressed_length + input.len() < 200 {
         assert_eq!(
-            input_data,
+            input,
             decompressed[..decompressed_length],
-            "Decompressed length mismatch: expected {}, got {decompressed_length}",
-            input_data.len()
+            "Decompressed mismatch: expected {}, got {decompressed_length}",
+            input.len()
         );
     } else {
-        for (i, (&original, &decoded)) in input_data.iter().zip(decompressed.iter()).enumerate() {
+        for (i, (&original, &decoded)) in input.iter().zip(decompressed.iter()).enumerate() {
             assert_eq!(
                 original, decoded,
                 "Mismatch at position {}: expected {}, got {}",
                 i, original, decoded
             );
         }
     }
-    assert_eq!(decompressed_length, input_data.len());
 });
+
+#[derive(arbitrary::Arbitrary)]
+struct FuzzInput {
+    data: Vec<u32>,
+    codec: FuzzCodec,
+}
+
+impl std::fmt::Debug for FuzzInput {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FuzzInput")
+            .field("data_length", &self.data.len())
+            .field("codec", &self.codec)
+            .finish()
+    }
+}
+
+#[derive(arbitrary::Arbitrary, Debug, Clone, Copy, PartialEq, Eq)]
+enum FuzzCodec {
+    FastPFOR256,
+    FastPFOR128,
+}
+impl From<FuzzCodec> for NonZeroU32 {
+    fn from(codec: FuzzCodec) -> Self {
+        match codec {
+            FuzzCodec::FastPFOR256 => BLOCK_SIZE_256,
+            FuzzCodec::FastPFOR128 => BLOCK_SIZE_128,
+        }
+    }
+}