Dearbitrary

.github/workflows/rust.yml

@@ -25,6 +25,13 @@ jobs:
       run: cargo test --verbose --all-features --all
     - name: Build Examples
       run: cargo build --examples --all-features --all
+  kani:
+    name: Kani Verification
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: rustup update
+    - uses: model-checking/kani-github-action
   clippy:
     name: Clippy
     runs-on: ubuntu-latest

Cargo.toml

@@ -40,3 +40,9 @@ members = ["./fuzz"]
 
 [dev-dependencies]
 exhaustigen = "0.1.0"
+
+[target.'cfg(kani)'.dependencies]
+paste = "1.0"
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(kani)'] }

fuzz/fuzz_targets/int_in_range.rs

@@ -12,27 +12,27 @@ fn fuzz(data: &[u8]) -> Result<()> {
     let mut u = Unstructured::new(data);
 
     let choices = [
-        assert_in_range::<u8>,
-        assert_in_range::<i8>,
-        assert_in_range::<u16>,
-        assert_in_range::<i16>,
-        assert_in_range::<u32>,
-        assert_in_range::<i32>,
-        assert_in_range::<u64>,
-        assert_in_range::<i64>,
-        assert_in_range::<u64>,
-        assert_in_range::<i64>,
-        assert_in_range::<u128>,
-        assert_in_range::<i128>,
+        assert_in_range::<u8, 1>,
+        assert_in_range::<i8, 1>,
+        assert_in_range::<u16, 2>,
+        assert_in_range::<i16, 2>,
+        assert_in_range::<u32, 4>,
+        assert_in_range::<i32, 4>,
+        assert_in_range::<u64, 8>,
+        assert_in_range::<i64, 8>,
+        assert_in_range::<u64, 8>,
+        assert_in_range::<i64, 8>,
+        assert_in_range::<u128, 16>,
+        assert_in_range::<i128, 16>,
     ];
 
     let f = u.choose(&choices[..])?;
     f(&mut u)
 }
 
-fn assert_in_range<'a, 'b, T>(u: &'a mut Unstructured<'b>) -> Result<()>
+fn assert_in_range<'a, 'b, T, const BYTES: usize>(u: &'a mut Unstructured<'b>) -> Result<()>
 where
-    T: Arbitrary<'b> + Int + Display,
+    T: Arbitrary<'b> + Int<BYTES> + Display,
 {
     let range = RangeInclusive::<T>::arbitrary(u)?;
     let start = *range.start();

src/back_note.md

@@ -0,0 +1,2 @@
+Length information is generally encoded here.
+See [UnstructuredBuilder::extend_from_dearbitrary_iter_rev_with_length]

src/dearbitrary/error.rs

@@ -0,0 +1,41 @@
+use std::{error, fmt};
+
+/// An enumeration of dearbitrartion errors
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// The instance's size is unsupported by its corresponding [Arbitrary] type
+    TooLarge,
+    /// The instance's details are too specific to this platform to be represented by its corresponding [Arbitrary] type,
+    TooSpecific
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::TooLarge => write!(
+                f,
+                "This type instance is too large to be losslessly reconstructed by Arbitrary after dearbitration."
+            ),
+            Error::TooSpecific => write!(
+                f,
+                "This type instance is too specific to the platform to be lossly reconstructed by Arbitrary after dearbitration on other platforms."
+            ),
+        }
+    }
+}
+
+impl error::Error for Error {}
+
+/// A `Result` with the error type fixed as `arbitrary::Error`.
+///
+/// Either an `Ok(T)` or `Err(arbitrary::Error)`.
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn can_use_custom_error_types_with_result() -> super::Result<(), String> {
+        Ok(())
+    }
+}

src/dearbitrary/mod.rs

@@ -0,0 +1,2 @@
+mod error;
+pub use error::*;