[anodized-fmt] test: basic fuzzing (#141)

- Add test utils to fuzz `anodized-fmt`'s whitespace invariance.
- Set up a simple fuzz target: `fmt_ws_invariant`.
- Add a basic `fuzz/README.md`.

Author: mkovaxx

Cargo.toml

@@ -5,6 +5,8 @@ members = [
     "crates/anodized-fmt",
     "crates/anodized-logic",
     "crates/anodized-macros",
+    "crates/test-util",
+    "fuzz",
 ]
 resolver = "2"
 
@@ -28,8 +30,10 @@ keywords = [
 
 [workspace.dependencies]
 anodized-core = { version = "0.5.1", path = "crates/anodized-core" }
+anodized-fmt = { version = "0.5.1", path = "crates/anodized-fmt" }
 anodized-logic = { version = "0.5.1", path = "crates/anodized-logic" }
 anodized-macros = { version = "0.5.1", path = "crates/anodized-macros" }
+test-util = { path = "crates/test-util" }
 num-bigint = "0.4.6"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 quote = "1.0"

crates/test-util/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "test-util"
+version = "0.0.0"
+publish = false
+edition = "2024"
+
+[dependencies]
+arbitrary = { version = "1", features = ["derive"] }

crates/test-util/src/fmt.rs

@@ -0,0 +1,132 @@
+//! This module contains utilities meant only for testing.
+//! Do not use outside of tests.
+
+use arbitrary::Arbitrary;
+
+/// A template to generate formatting variations of a piece of code.
+#[derive(Debug, Clone)]
+pub struct Template(Vec<Span>);
+
+#[derive(Debug, Clone)]
+pub enum Span {
+    /// A fixed string.
+    F(String),
+    /// Zero or more whitespace characters.
+    Z,
+    /// One or more whitespace characters.
+    P,
+}
+
+/// Describes a variation the template can generate.
+#[derive(Debug, Clone, Arbitrary)]
+pub struct Variation(Vec<Whitespace>);
+
+impl Default for Variation {
+    fn default() -> Self {
+        Variation(vec![])
+    }
+}
+
+impl Template {
+    /// New empty template.
+    pub fn new() -> Self {
+        Template(vec![])
+    }
+
+    /// Add a placeholder for zero or more whitespace characters.
+    pub fn z(mut self) -> Self {
+        self.0.push(Span::Z);
+        self
+    }
+
+    /// Add a placeholder for one or more whitespace characters.
+    pub fn p(mut self) -> Self {
+        self.0.push(Span::P);
+        self
+    }
+
+    /// Add a fixed span of text.
+    pub fn fixed(mut self: Self, text: &str) -> Self {
+        self.0.push(Span::F(text.to_string()));
+        self
+    }
+
+    /// Add tokens, replacing each internal span of whitespace with a `.z()`.
+    pub fn tokens(mut self: Self, text: &str) -> Self {
+        for (i, non_whitespace) in text.split_whitespace().enumerate() {
+            if i > 0 {
+                self.0.push(Span::Z);
+            }
+            self.0.push(Span::F(non_whitespace.to_string()));
+        }
+        self
+    }
+}
+
+impl Template {
+    /// Generates an instantiation of the template based on variation information.
+    pub fn generate(&self, variation: Variation) -> String {
+        let mut output = String::new();
+
+        let mut whitespaces = variation.0.into_iter();
+
+        for span in &self.0 {
+            match span {
+                Span::F(text) => output.push_str(text),
+                Span::Z => {
+                    let whitespace = whitespaces.next().unwrap_or_default();
+                    output.push_str(&whitespace.to_string());
+                }
+                Span::P => {
+                    let whitespace = whitespaces.next().unwrap_or_default();
+                    output.push_str(&whitespace.to_non_empty_string());
+                }
+            }
+        }
+
+        output
+    }
+}
+
+/// A non-empty sequence of whitespace characters.
+#[derive(Debug, Clone, Arbitrary)]
+pub struct Whitespace(Vec<WsChar>, WsChar);
+
+impl Default for Whitespace {
+    fn default() -> Self {
+        Whitespace(vec![], WsChar::Space)
+    }
+}
+
+impl Whitespace {
+    fn to_string(self: Whitespace) -> String {
+        self.0.into_iter().map(|w| char::from(w)).collect()
+    }
+
+    fn to_non_empty_string(self: Whitespace) -> String {
+        self.0
+            .into_iter()
+            .chain(std::iter::once(self.1))
+            .map(|w| char::from(w))
+            .collect()
+    }
+}
+
+/// A code point Rust recognizes as whitespace.
+#[derive(Debug, Clone, Copy, Arbitrary)]
+pub enum WsChar {
+    Space,
+    Tab,
+    Newline,
+    // TODO: expand
+}
+
+impl From<WsChar> for char {
+    fn from(value: WsChar) -> Self {
+        match value {
+            WsChar::Space => ' ',
+            WsChar::Tab => '\t',
+            WsChar::Newline => '\n',
+        }
+    }
+}

crates/test-util/src/lib.rs

@@ -0,0 +1 @@
+pub mod fmt;

fuzz/.gitignore

@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage

fuzz/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "fuzz"
+version = "0.0.0"
+publish = false
+edition = "2024"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+anodized-fmt.workspace = true
+test-util.workspace = true
+
+libfuzzer-sys = "0.4"
+pretty_assertions = "1"
+
+[[bin]]
+name = "fmt_ws_invariant"
+path = "fuzz_targets/fmt_ws_invariant.rs"
+test = false
+doc = false
+bench = false

fuzz/README.md

@@ -0,0 +1,11 @@
+# Fuzz Targets for Testing Anodized Components
+
+## fmt_ws_invariant
+
+Tests that spec formatting is invariant to whitespace changes.
+
+**IMPORTANT**: Due to `proc-macro2` special-casing its behavior based on `cfg(fuzzing)` which `cargo-fuzz` sets by default, it must be run with the `--no-cfg-fuzzing` option as follows:
+
+```sh
+cargo +nightly fuzz run --no-cfg-fuzzing fmt_ws_invariant
+```

fuzz/fuzz_targets/fmt_ws_invariant.rs

@@ -0,0 +1,50 @@
+#![no_main]
+
+use std::sync::OnceLock;
+
+use libfuzzer_sys::fuzz_target;
+use pretty_assertions::assert_eq;
+
+use anodized_fmt::{Config, format_file};
+use test_util::fmt::{Template, Variation};
+
+static TEMPLATE: OnceLock<Template> = OnceLock::new();
+
+/// Build a template for the following fragment:
+///
+///     #[spec(
+///         // precondition
+///         requires: x > 0,
+///         // postcondition
+///         ensures: *output > 0,
+///     )]
+///     fn func(x: i32) -> i32 { todo!() }
+///
+#[rustfmt::skip]
+fn make_template() -> Template {
+    Template::new()
+        .fixed("#[spec(\n")
+        .z().fixed("// precondition\n")
+        .z().tokens("requires : x > 0 ,").fixed("\n")
+        .z().fixed("// postcondition\n")
+        .z().tokens("ensures : * output > 0 ,").fixed("\n")
+        .z().fixed(")]\n")
+        .fixed("fn func(x: i32) -> i32 { todo!() }\n")
+}
+
+fuzz_target!(
+    init: {
+        TEMPLATE.set(make_template()).unwrap();
+    },
+    |variation: Variation| {
+        let template = TEMPLATE.get().unwrap();
+        let default_input = template.generate(Variation::default());
+        let variant_input = template.generate(variation);
+
+        let config = Config::default();
+        let fmt_default = format_file(&default_input, &config).expect("formatting default");
+        let fmt_variant = format_file(&variant_input, &config).expect("formatting variant");
+
+        assert_eq!(fmt_variant, fmt_default);
+    }
+);