proptesting

Author: edg-l

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nom_bencode"
-version = "0.1.4"
+version = "0.2.0"
 authors = ["Edgar <git@edgarluque.com>"]
 description = "A bencode parser written with nom."
 repository = "https://github.com/edg-l/nom-bencode/"

benches/bencode_bench.rs

@@ -1,10 +1,11 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use nom_bencode::*;
 
-static SOURCE_BYTES_22KB: &'static [u8] = include_bytes!("../test-assets/big-buck-bunny.torrent");
-static SOURCE_BYTES_113KB: &'static [u8] = include_bytes!("../test-assets/private.torrent");
-static SOURCE_BYTES_218KB: &'static [u8] = include_bytes!("../test-assets/multi-file.torrent");
+static SOURCE_BYTES_22KB: &[u8] = include_bytes!("../test-assets/big-buck-bunny.torrent");
+static SOURCE_BYTES_113KB: &[u8] = include_bytes!("../test-assets/private.torrent");
+static SOURCE_BYTES_218KB: &[u8] = include_bytes!("../test-assets/multi-file.torrent");
 
-fn parse_source(src: &[u8]) -> Result<Vec<nom_bencode::Value>, nom_bencode::Error<&[u8]>> {
+fn parse_source(src: &[u8]) -> Result<Vec<Value>, Err<BencodeError<&[u8]>>> {
     nom_bencode::parse(src)
 }
 

src/error.rs renamed to src/errors.rs

@@ -1,11 +1,12 @@
-use nom::{
-    error::{ParseError, ErrorKind},
-};
+//! Errors produced by this library.
+
+use nom::error::{ErrorKind, ParseError};
 use std::{fmt::Debug, num::ParseIntError};
 
 /// Parser Errors.
 #[derive(Debug, thiserror::Error)]
 pub enum BencodeError<I> {
+    /// A error from a nom parser.
     #[error("a nom error: {1:?}")]
     Nom(I, ErrorKind),
     /// A integer has an invalid form, e.g -0.
@@ -29,12 +30,11 @@ impl<I> ParseError<I> for BencodeError<I> {
     }
 }
 
-
 impl<I> From<BencodeError<I>> for nom::Err<BencodeError<I>> {
     fn from(value: BencodeError<I>) -> Self {
         match value {
-            value @ BencodeError::Nom(_, _) => nom::Err::Error(value),
-            value => nom::Err::Failure(value),
+            value @ BencodeError::Nom(_, _) => Self::Error(value),
+            value => Self::Failure(value),
         }
     }
 }

src/lib.rs

@@ -25,28 +25,27 @@
 //! }
 //! ```
 
-/*
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
 #![deny(warnings)]
 #![deny(clippy::nursery)]
 #![deny(clippy::pedantic)]
 #![deny(clippy::all)]
- */
 
-use error::BencodeError;
+pub use errors::BencodeError;
 use nom::{
     branch::alt,
     bytes::complete::take,
     character::complete::{char, digit1},
     combinator::{eof, recognize},
     multi::{many0, many_till},
     sequence::{delimited, pair, preceded},
-    Err, IResult,
+    IResult,
 };
 use std::{collections::HashMap, fmt::Debug};
 
-pub mod error;
+pub mod errors;
+pub use nom::Err;
 
 type BenResult<'a> = IResult<&'a [u8], Value<'a>, BencodeError<&'a [u8]>>;
 
@@ -179,7 +178,7 @@ pub fn parse(source: &[u8]) -> Result<Vec<Value>, Err<BencodeError<&[u8]>>> {
 mod tests {
     use crate::{parse, BencodeError, Value};
     use assert_matches::assert_matches;
-    use proptest::prelude::*;
+    use proptest::{collection::vec, prelude::*};
 
     #[test]
     fn test_integer() {
@@ -379,10 +378,85 @@ mod tests {
         let _ = parse(include_bytes!("../test-assets/multi-file.torrent")).unwrap();
     }
 
+    prop_compose! {
+        fn bencode_bytes()(s in vec(any::<u8>(), 1..100)) -> Vec<u8> {
+            let mut data: Vec<u8> = Vec::with_capacity(s.len() + 5);
+            data.extend(format!("{}:", s.len()).as_bytes());
+            data.extend(s);
+            data
+        }
+    }
+
+    prop_compose! {
+        fn bencode_integer()(s in any::<i64>()) -> Vec<u8> {
+            format!("i{s}e").as_bytes().to_vec()
+        }
+    }
+
+    prop_compose! {
+        fn bencode_list()(s in vec((bencode_integer(), bencode_bytes()), 1..100)) -> Vec<u8> {
+            let mut data: Vec<u8> = Vec::with_capacity(s.len() + 2);
+            data.extend(b"l");
+            for (i, (a, b)) in s.iter().enumerate() {
+                if i % 2 == 0 {
+                    data.extend(a);
+                    data.extend(b);
+                } else {
+                    data.extend(b);
+                    data.extend(a);
+                }
+
+            }
+            data.extend(b"e");
+            data
+        }
+    }
+
+    prop_compose! {
+        fn bencode_dict()(s in vec((bencode_bytes(), bencode_bytes()), 1..100)) -> Vec<u8> {
+            let mut data: Vec<u8> = Vec::with_capacity(s.len() + 2);
+            data.extend(b"d");
+            for (i, (a, b)) in s.iter().enumerate() {
+                if i % 2 == 0 {
+                    data.extend(a);
+                    data.extend(b);
+                } else {
+                    data.extend(b);
+                    data.extend(a);
+                }
+            }
+            data.extend(b"e");
+            data
+        }
+    }
+
     proptest! {
         #[test]
-        fn doesnt_panic(s in any::<Vec<u8>>()) {
+        fn proptest_doesnt_panic_or_overflow(s in any::<Vec<u8>>()) {
             parse(&s).ok();
         }
+
+        #[test]
+        fn proptest_parse_integer(s in bencode_integer()) {
+            prop_assert!(Value::parse_integer(&s).is_ok());
+        }
+
+        #[test]
+        fn proptest_parse_bytes(s in bencode_bytes()) {
+            let mut data: Vec<u8> = Vec::with_capacity(s.len() + 5);
+            data.extend(format!("{}:", s.len()).as_bytes());
+            data.extend(s);
+            prop_assert!(Value::parse_bytes(&data).is_ok());
+        }
+
+        #[test]
+        fn proptest_parse_list(s in bencode_list()) {
+            prop_assert!(Value::parse_list(&s).is_ok());
+        }
+
+        #[test]
+        fn proptest_parse_dict(s in bencode_dict()) {
+            prop_assert!(Value::parse_dict(&s).is_ok());
+        }
     }
 }