add cargo fuzz target (#21)

Author: danieleades

benches/sherlock.rs

@@ -13,7 +13,9 @@ pub struct StringModel {
 impl StringModel {
     #[must_use]
     pub fn new(symbols: usize) -> Self {
-        let fenwick_model = FenwickModel::with_symbols(symbols, 1 << 20);
+        let fenwick_model = FenwickModel::builder(symbols, 1 << 20)
+            .panic_on_saturation()
+            .build();
         Self { fenwick_model }
     }
 }

examples/fenwick_adaptive.rs

@@ -18,7 +18,9 @@ pub struct StringModel {
 impl StringModel {
     #[must_use]
     pub fn new(alphabet: Vec<char>) -> Self {
-        let fenwick_model = FenwickModel::with_symbols(alphabet.len(), 1 << 20);
+        let fenwick_model = FenwickModel::builder(alphabet.len(), 1 << 20)
+            .panic_on_saturation()
+            .build();
         Self {
             alphabet,
             fenwick_model,

fenwick-model/src/simple.rs

@@ -10,17 +10,38 @@ use crate::ValueError;
 pub struct FenwickModel {
     weights: Weights,
     max_denominator: u64,
+    panic_on_saturation: bool,
 }
 
-impl FenwickModel {
-    #[must_use]
-    pub fn with_symbols(symbols: usize, max_denominator: u64) -> Self {
-        let weights = Weights::new(symbols);
+pub struct Builder {
+    model: FenwickModel,
+}
 
-        Self {
+impl Builder {
+    fn new(n_symbols: usize, max_denominator: u64) -> Self {
+        let weights = Weights::new(n_symbols);
+        let model = FenwickModel {
             weights,
             max_denominator,
-        }
+            panic_on_saturation: false,
+        };
+        Self { model }
+    }
+
+    pub fn panic_on_saturation(mut self) -> Self {
+        self.model.panic_on_saturation = true;
+        self
+    }
+
+    pub fn build(self) -> FenwickModel {
+        self.model
+    }
+}
+
+impl FenwickModel {
+    #[must_use]
+    pub fn builder(n_symbols: usize, max_denominator: u64) -> Builder {
+        Builder::new(n_symbols, max_denominator)
     }
 }
 
@@ -57,10 +78,12 @@ impl Model for FenwickModel {
     }
 
     fn update(&mut self, symbol: Option<&Self::Symbol>) {
-        debug_assert!(
-            self.denominator() < self.max_denominator,
-            "hit max denominator!"
-        );
+        if self.panic_on_saturation {
+            debug_assert!(
+                self.denominator() < self.max_denominator,
+                "hit max denominator!"
+            );
+        }
         if self.denominator() < self.max_denominator {
             self.weights.update(symbol.copied(), 1);
         }

fuzz/.gitignore

@@ -0,0 +1,3 @@
+target
+corpus
+artifacts

fuzz/Cargo.lock

@@ -0,0 +1,25 @@
+[package]
+name = "arithmetic-coding-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2018"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+arithmetic-coding = { path = ".." }
+bitstream-io = "1.2.0"
+fenwick-model = { path = "../fenwick-model" }
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "fuzz_target_1"
+path = "fuzz_targets/fuzz_target_1.rs"
+test = false
+doc = false

fuzz/Cargo.toml

@@ -0,0 +1,12 @@
+#![no_main]
+use fenwick_model::simple::FenwickModel;
+use libfuzzer_sys::fuzz_target;
+
+mod round_trip;
+
+fuzz_target!(|data: &[u8]| {
+    let model = FenwickModel::with_symbols(256, 1 << 20);
+    let input: Vec<usize> = data.into_iter().copied().map(usize::from).collect();
+
+    round_trip::round_trip(model, input);
+});

fuzz/fuzz_targets/fuzz_target_1.rs

@@ -0,0 +1,40 @@
+use arithmetic_coding::{Decoder, Encoder, Model};
+use bitstream_io::{BigEndian, BitReader, BitWrite, BitWriter};
+
+pub fn round_trip<M>(model: M, input: Vec<M::Symbol>)
+where
+    M: Model + Clone,
+    M::Symbol: PartialEq + std::fmt::Debug + Clone,
+{
+    let buffer = encode(model.clone(), input.clone());
+    let output = decode(model, &buffer);
+
+    assert_eq!(input, output);
+}
+
+fn encode<M>(model: M, input: Vec<M::Symbol>) -> Vec<u8>
+where
+    M: Model,
+{
+    let mut bitwriter = BitWriter::endian(Vec::new(), BigEndian);
+    let mut encoder = Encoder::<M>::new(model);
+
+    encoder.encode_all(input, &mut bitwriter).expect("failed to encode data!");
+    bitwriter.byte_align().expect("failed to byte-align the stream");
+
+    bitwriter.into_writer()
+}
+
+fn decode<M>(model: M, buffer: &[u8]) -> Vec<M::Symbol>
+where
+    M: Model,
+{
+    let bitreader = BitReader::endian(buffer, BigEndian);
+    let mut decoder = Decoder::new(model, bitreader).expect("failed to initialise decoder");
+    let mut output = Vec::new();
+
+    while let Some(symbol) = decoder.decode_symbol().expect("failed to encode symbol!") {
+        output.push(symbol);
+    }
+    output
+}

fuzz/fuzz_targets/round_trip.rs

@@ -0,0 +1,12 @@
+use fenwick_model::simple::FenwickModel;
+
+mod common;
+
+#[test]
+fn round_trip() {
+    let model = FenwickModel::builder(256, 1 << 20).build();
+    let bytes: &[u8] = &[220, 255, 255];
+    let input: Vec<usize> = bytes.iter().copied().map(usize::from).collect();
+
+    common::round_trip(model, input);
+}