Rewrite test in proptest, remove quickcheck dep

crates/flat/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 repository = "https://github.com/txpipe/aiken/crates/flat"
 homepage = "https://github.com/txpipe/aiken"
 license = "Apache-2.0"
-authors = ["Lucas Rosa <x@rvcas.dev>", "Kasey White <kwhitemsg@gmail.com>"]
+authors = ["Lucas Rosa <x@rvcas.dev>", "Kasey White <kwhitemsg@gmail.com>" ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -15,5 +15,4 @@ anyhow = "1.0.57"
 thiserror = "1.0.31"
 
 [dev-dependencies]
-quickcheck = "1"
-quickcheck_macros = "1"
+proptest = "1.0.0"

crates/flat/tests/flat_test.rs

@@ -1,15 +1,14 @@
-#[cfg(test)]
-extern crate quickcheck;
-
-#[cfg(test)]
-#[macro_use(quickcheck)]
-extern crate quickcheck_macros;
-
 #[cfg(test)]
 mod test {
     use flat_rs::filler::Filler;
     use flat_rs::{decode, encode};
-    use quickcheck::Arbitrary;
+    use proptest::prelude::*;
+
+    prop_compose! {
+        fn arb_big_vec()(size in 255..300, element in any::<u8>()) -> Vec<u8> {
+            (0..size).map(|_| element).collect()
+        }
+    }
 
     #[test]
     fn encode_bool() {
@@ -41,83 +40,70 @@ mod test {
         assert_eq!(decoded, 3_u8);
     }
 
-    #[quickcheck]
-    fn encode_isize(x: isize) -> bool {
-        let bytes = encode(&x).unwrap();
-        let decoded: isize = decode(&bytes).unwrap();
-        decoded == x
-    }
-
-    #[quickcheck]
-    fn encode_usize(x: usize) -> bool {
-        let bytes = encode(&x).unwrap();
-        let decoded: usize = decode(&bytes).unwrap();
-        decoded == x
-    }
-
-    #[quickcheck]
-    fn encode_char(c: char) -> bool {
-        let bytes = encode(&c).unwrap();
-        let decoded: char = decode(&bytes).unwrap();
-        decoded == c
-    }
-
-    #[quickcheck]
-    fn encode_string(str: String) -> bool {
-        let bytes = encode(&str).unwrap();
-        let decoded: String = decode(&bytes).unwrap();
-        decoded == str
-    }
-
-    #[quickcheck]
-    fn encode_vec_u8(xs: Vec<u8>) -> bool {
-        let bytes = encode(&xs).unwrap();
-        let decoded: Vec<u8> = decode(&bytes).unwrap();
-        decoded == xs
-    }
-
-    #[derive(Clone, Debug)]
-    struct BigChunk(Vec<u8>);
-
-    impl Arbitrary for BigChunk {
-        fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-            let num_of_element = g.choose(&[257]).unwrap();
-
-            let vec = (0..*num_of_element).map(|_| u8::arbitrary(g)).collect();
-
-            BigChunk(vec)
+    proptest! {
+        #[test]
+        fn encode_isize(x: isize) {
+            let bytes = encode(&x).unwrap();
+            let decoded: isize = decode(&bytes).unwrap();
+            assert_eq!(decoded, x);
         }
-    }
 
-    #[quickcheck]
-    fn encode_big_vec_u8(xs: BigChunk) -> bool {
-        let xs = xs.0;
-        let bytes = encode(&xs).unwrap();
-        let decoded: Vec<u8> = decode(&bytes).unwrap();
-        decoded == xs
-    }
+        #[test]
+        fn encode_usize(x: usize) {
+            let bytes = encode(&x).unwrap();
+            let decoded: usize = decode(&bytes).unwrap();
+            assert_eq!(decoded, x);
+        }
 
-    #[quickcheck]
-    fn encode_arr_u8(xs: Vec<u8>) -> bool {
-        let bytes = encode(&xs.as_slice()).unwrap();
-        let decoded: Vec<u8> = decode(&bytes).unwrap();
-        decoded == xs
-    }
+        #[test]
+        fn encode_char(c: char) {
+            let bytes = encode(&c).unwrap();
+            let decoded: char = decode(&bytes).unwrap();
+            assert_eq!(decoded, c);
+        }
 
-    #[quickcheck]
-    fn encode_big_arr_u8(xs: BigChunk) -> bool {
-        let xs = xs.0;
-        let bytes = encode(&xs.as_slice()).unwrap();
-        let decoded: Vec<u8> = decode(&bytes).unwrap();
-        decoded == xs
-    }
+        #[test]
+        fn encode_string(str: String) {
+            let bytes = encode(&str).unwrap();
+            let decoded: String = decode(&bytes).unwrap();
+            assert_eq!(decoded, str);
+        }
 
-    #[quickcheck]
-    fn encode_boxed(c: char) -> bool {
-        let boxed = Box::new(c);
-        let bytes = encode(&boxed).unwrap();
-        let decoded: char = decode(&bytes).unwrap();
-        decoded == c
+        #[test]
+        fn encode_vec_u8(xs: Vec<u8>) {
+            let bytes = encode(&xs).unwrap();
+            let decoded: Vec<u8> = decode(&bytes).unwrap();
+            assert_eq!(decoded, xs);
+        }
+
+        #[test]
+        fn encode_big_vec_u8(xs in arb_big_vec()) {
+            let bytes = encode(&xs).unwrap();
+            let decoded: Vec<u8> = decode(&bytes).unwrap();
+            assert_eq!(decoded, xs);
+        }
+
+        #[test]
+        fn encode_arr_u8(xs: Vec<u8>) {
+            let bytes = encode(&xs.as_slice()).unwrap();
+            let decoded: Vec<u8> = decode(&bytes).unwrap();
+            assert_eq!(decoded, xs);
+        }
+
+        #[test]
+        fn encode_big_arr_u8(xs in arb_big_vec()) {
+            let bytes = encode(&xs.as_slice()).unwrap();
+            let decoded: Vec<u8> = decode(&bytes).unwrap();
+            assert_eq!(decoded, xs);
+        }
+
+        #[test]
+        fn encode_boxed(c: char) {
+            let boxed = Box::new(c);
+            let bytes = encode(&boxed).unwrap();
+            let decoded: char = decode(&bytes).unwrap();
+            assert_eq!(decoded, c);
+        }
     }
 
     #[test]

crates/flat/tests/zigzag_test.rs

@@ -1,25 +1,21 @@
-#[cfg(test)]
-extern crate quickcheck;
-
-#[cfg(test)]
-#[macro_use(quickcheck)]
-extern crate quickcheck_macros;
-
 #[cfg(test)]
 mod test {
     use flat_rs::zigzag::{to_isize, to_usize};
+    use proptest::prelude::*;
 
-    #[quickcheck]
-    fn zigzag(i: isize) -> bool {
-        let u = to_usize(i);
-        let converted_i = to_isize(u);
-        converted_i == i
-    }
+    proptest! {
+        #[test]
+        fn zigzag(i: isize) {
+            let u = to_usize(i);
+            let converted_i = to_isize(u);
+            assert_eq!(converted_i, i);
+        }
 
-    #[quickcheck]
-    fn zagzig(u: usize) -> bool {
-        let i = to_isize(u);
-        let converted_u = to_usize(i);
-        converted_u == u
+        #[test]
+        fn zagzig(u: usize) {
+            let i = to_isize(u);
+            let converted_u = to_usize(i);
+            assert_eq!(converted_u, u);
+        }
     }
 }