Add optional Arbitrary impls

This enables us to use structure-aware fuzzing for more efficient
coverage of serialize/parse roundtripping.

https://rust-fuzz.github.io/book/cargo-fuzz/structure-aware-fuzzing.html

Cargo.toml

@@ -13,6 +13,7 @@ keywords = ["http-header", "structured-header", ]
 exclude = ["tests/**", ".github/*"]
 
 [dependencies]
+arbitrary = { version = "1.4.1", optional = true, features = ["derive"] }
 base64 = "0.22.1"
 indexmap = "2"
 ref-cast = "1.0.23"
@@ -26,3 +27,6 @@ base32 = "0.5.1"
 [[bench]]
 name = "bench"
 harness = false
+
+[features]
+arbitrary = ["dep:arbitrary", "indexmap/arbitrary"]

fuzz/Cargo.toml

@@ -12,6 +12,7 @@ libfuzzer-sys = "0.4"
 
 [dependencies.sfv]
 path = ".."
+features = ["arbitrary"]
 
 [[bin]]
 name = "parse_dictionary"
@@ -33,3 +34,24 @@ path = "fuzz_targets/parse_item.rs"
 test = false
 doc = false
 bench = false
+
+[[bin]]
+name = "roundtrip_item"
+path = "fuzz_targets/roundtrip_item.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "roundtrip_list"
+path = "fuzz_targets/roundtrip_list.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "roundtrip_dictionary"
+path = "fuzz_targets/roundtrip_dictionary.rs"
+test = false
+doc = false
+bench = false

fuzz/fuzz_targets/parse_dictionary.rs

@@ -1,18 +1,7 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use sfv::SerializeValue as _;
 
 fuzz_target!(|data: &[u8]| {
-    if let Ok(dict) = sfv::Parser::from_bytes(data).parse_dictionary() {
-        let serialized = dict.serialize_value();
-        if dict.is_empty() {
-            assert!(serialized.is_err());
-        } else {
-            assert_eq!(
-                sfv::Parser::from_bytes(serialized.unwrap().as_bytes()).parse_dictionary(),
-                Ok(dict)
-            );
-        }
-    }
+    let _ = sfv::Parser::from_bytes(data).parse_dictionary();
 });

fuzz/fuzz_targets/parse_item.rs

@@ -1,14 +1,7 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use sfv::SerializeValue as _;
 
 fuzz_target!(|data: &[u8]| {
-    if let Ok(item) = sfv::Parser::from_bytes(data).parse_item() {
-        let serialized = item.serialize_value().unwrap();
-        assert_eq!(
-            sfv::Parser::from_bytes(serialized.as_bytes()).parse_item(),
-            Ok(item)
-        );
-    }
+    let _ = sfv::Parser::from_bytes(data).parse_item();
 });

fuzz/fuzz_targets/parse_list.rs

@@ -1,18 +1,7 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use sfv::SerializeValue as _;
 
 fuzz_target!(|data: &[u8]| {
-    if let Ok(list) = sfv::Parser::from_bytes(data).parse_list() {
-        let serialized = list.serialize_value();
-        if list.is_empty() {
-            assert!(serialized.is_err());
-        } else {
-            assert_eq!(
-                sfv::Parser::from_bytes(serialized.unwrap().as_bytes()).parse_list(),
-                Ok(list)
-            );
-        }
-    }
+    let _ = sfv::Parser::from_bytes(data).parse_list();
 });

fuzz/fuzz_targets/roundtrip_dictionary.rs

@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use sfv::SerializeValue as _;
+
+fuzz_target!(|dict: sfv::Dictionary| {
+    let serialized = dict.serialize_value();
+    if dict.is_empty() {
+        assert!(serialized.is_err());
+    } else {
+        assert_eq!(
+            sfv::Parser::from_bytes(serialized.unwrap().as_bytes()).parse_dictionary(),
+            Ok(dict)
+        );
+    }
+});

fuzz/fuzz_targets/roundtrip_item.rs

@@ -0,0 +1,12 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use sfv::SerializeValue as _;
+
+fuzz_target!(|item: sfv::Item| {
+    let serialized = item.serialize_value().unwrap();
+    assert_eq!(
+        sfv::Parser::from_bytes(serialized.as_bytes()).parse_item(),
+        Ok(item)
+    );
+});

fuzz/fuzz_targets/roundtrip_list.rs

@@ -0,0 +1,16 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use sfv::SerializeValue as _;
+
+fuzz_target!(|list: sfv::List| {
+    let serialized = list.serialize_value();
+    if list.is_empty() {
+        assert!(serialized.is_err());
+    } else {
+        assert_eq!(
+            sfv::Parser::from_bytes(serialized.unwrap().as_bytes()).parse_list(),
+            Ok(list)
+        );
+    }
+});

src/decimal.rs

@@ -8,6 +8,7 @@ use std::fmt;
 ///
 /// [decimal]: <https://httpwg.org/specs/rfc8941.html#decimal>
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Decimal(Integer);
 
 impl Decimal {

src/integer.rs

@@ -2,18 +2,27 @@ use crate::{BareItem, RefBareItem};
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 
+const RANGE_I64: std::ops::RangeInclusive<i64> = -999_999_999_999_999..=999_999_999_999_999;
+
 /// A structured field value [integer].
 ///
 /// [integer]: <https://httpwg.org/specs/rfc8941.html#integer>
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Integer(i64);
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+pub struct Integer(
+    #[cfg_attr(
+        feature = "arbitrary",
+        arbitrary(with = |u: &mut arbitrary::Unstructured| u.int_in_range(RANGE_I64))
+    )]
+    i64,
+);
 
 impl Integer {
     /// The minimum value for a parsed or serialized integer: `-999_999_999_999_999`.
-    pub const MIN: Self = Self(-999_999_999_999_999);
+    pub const MIN: Self = Self(*RANGE_I64.start());
 
     /// The maximum value for a parsed or serialized integer: `999_999_999_999_999`.
-    pub const MAX: Self = Self(999_999_999_999_999);
+    pub const MAX: Self = Self(*RANGE_I64.end());
 
     /// `0`.
     ///
@@ -86,7 +95,7 @@ macro_rules! impl_conversion {
 
             fn try_from(v: $t) -> Result<Integer, OutOfRangeError> {
                 match i64::try_from(v) {
-                    Ok(v) if (Integer::MIN.0..=Integer::MAX.0).contains(&v) => Ok(Integer(v)),
+                    Ok(v) if RANGE_I64.contains(&v) => Ok(Integer(v)),
                     _ => Err(OutOfRangeError),
                 }
             }

src/key.rs

@@ -217,3 +217,25 @@ impl Borrow<str> for KeyRef {
         self.as_str()
     }
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for &'a KeyRef {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        KeyRef::from_str(<&str>::arbitrary(u)?).map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+
+    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
+        (1, None)
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for Key {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        <&KeyRef>::arbitrary(u).map(ToOwned::to_owned)
+    }
+
+    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
+        (1, None)
+    }
+}

src/lib.rs

@@ -210,6 +210,7 @@ type SFVResult<T> = std::result::Result<T, &'static str>;
 // bare-item = sf-integer / sf-decimal / sf-string / sf-token
 //             / sf-binary / sf-boolean
 #[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Item {
     /// Value of `Item`.
     pub bare_item: BareItem,
@@ -258,6 +259,7 @@ pub type Parameters = IndexMap<Key, BareItem>;
 
 /// Represents a member of `List` or `Dictionary` structured field value.
 #[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum ListEntry {
     /// Member of `Item` type.
     Item(Item),
@@ -281,6 +283,7 @@ impl From<InnerList> for ListEntry {
 // inner-list    = "(" *SP [ sf-item *( 1*SP sf-item ) *SP ] ")"
 //                 parameters
 #[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct InnerList {
     /// `Items` that `InnerList` contains. Can be empty.
     pub items: Vec<Item>,
@@ -305,6 +308,7 @@ impl InnerList {
 
 /// `BareItem` type is used to construct `Items` or `Parameters` values.
 #[derive(Debug, PartialEq, Clone)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum BareItem {
     /// Decimal number
     // sf-decimal  = ["-"] 1*12DIGIT "." 1*3DIGIT
@@ -457,6 +461,7 @@ pub(crate) enum Num {
 
 /// Similar to `BareItem`, but used to serialize values via `RefItemSerializer`, `RefListSerializer`, `RefDictSerializer`.
 #[derive(Debug, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub enum RefBareItem<'a> {
     Integer(Integer),
     Decimal(Decimal),

src/string.rs

@@ -197,3 +197,17 @@ impl Borrow<str> for StringRef {
         self.as_str()
     }
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for &'a StringRef {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        StringRef::from_str(<&str>::arbitrary(u)?).map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for String {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        <&StringRef>::arbitrary(u).map(ToOwned::to_owned)
+    }
+}

src/token.rs

@@ -221,3 +221,17 @@ impl Borrow<str> for TokenRef {
         self.as_str()
     }
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for &'a TokenRef {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        TokenRef::from_str(<&str>::arbitrary(u)?).map_err(|_| arbitrary::Error::IncorrectFormat)
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for Token {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        <&TokenRef>::arbitrary(u).map(ToOwned::to_owned)
+    }
+}