Adding more tests

crates/flat/tests/flat_test.rs

@@ -5,46 +5,74 @@ extern crate quickcheck;
 #[macro_use(quickcheck)]
 extern crate quickcheck_macros;
 
-use flat_rs::{decode, encode};
-
 #[cfg(test)]
 mod test {
+    use flat_rs::filler::Filler;
+    use flat_rs::{decode, encode};
     use quickcheck::Arbitrary;
 
     #[test]
     fn encode_bool() {
-        let bytes = crate::encode(&true).unwrap();
+        let bytes = encode(&true).unwrap();
 
         assert_eq!(bytes, vec![0b10000001]);
 
-        let decoded: bool = crate::decode(bytes.as_slice()).unwrap();
+        let decoded: bool = decode(bytes.as_slice()).unwrap();
 
         assert_eq!(decoded, true);
 
-        let bytes = crate::encode(&false).unwrap();
+        let bytes = encode(&false).unwrap();
 
         assert_eq!(bytes, vec![0b00000001]);
 
-        let decoded: bool = crate::decode(bytes.as_slice()).unwrap();
+        let decoded: bool = decode(bytes.as_slice()).unwrap();
 
         assert_eq!(decoded, false);
     }
 
     #[test]
     fn encode_u8() {
-        let bytes = crate::encode(&3_u8).unwrap();
+        let bytes = encode(&3_u8).unwrap();
 
         assert_eq!(bytes, vec![0b00000011, 0b00000001]);
 
-        let decoded: u8 = crate::decode(bytes.as_slice()).unwrap();
+        let decoded: u8 = decode(bytes.as_slice()).unwrap();
 
         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 = crate::encode(&xs).unwrap();
-        let decoded: Vec<u8> = crate::decode(&bytes).unwrap();
+        let bytes = encode(&xs).unwrap();
+        let decoded: Vec<u8> = decode(&bytes).unwrap();
         decoded == xs
     }
 
@@ -53,22 +81,60 @@ mod test {
 
     impl Arbitrary for BigChunk {
         fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-            let num_of_element = g.choose(&[255, 256, 244, 100]).unwrap();
+            let num_of_element = g.choose(&[257]).unwrap();
 
-            let mut vec = Vec::with_capacity(*num_of_element);
-            for _ in 1..*num_of_element {
-                vec.push(u8::arbitrary(g));
-            }
+            let vec = (0..*num_of_element).map(|_| u8::arbitrary(g)).collect();
 
             BigChunk(vec)
         }
     }
 
     #[quickcheck]
-    fn encode_write_blk(xs: BigChunk) -> bool {
+    fn encode_big_vec_u8(xs: BigChunk) -> bool {
         let xs = xs.0;
-        let bytes = crate::encode(&xs).unwrap();
-        let decoded: Vec<u8> = crate::decode(&bytes).unwrap();
+        let bytes = encode(&xs).unwrap();
+        let decoded: Vec<u8> = decode(&bytes).unwrap();
         decoded == xs
     }
+
+    #[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
+    }
+
+    #[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
+    }
+
+    #[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_filler() {
+        let bytes = encode(&Filler::FillerEnd).unwrap();
+
+        assert_eq!(bytes, vec![0b0000001, 0b00000001]);
+
+        let bytes = encode(&Filler::FillerStart(Box::new(Filler::FillerEnd))).unwrap();
+
+        assert_eq!(bytes, vec![0b0000001, 0b00000001]);
+
+        let bytes = encode(&Filler::FillerStart(Box::new(Filler::FillerStart(
+            Box::new(Filler::FillerEnd),
+        ))))
+        .unwrap();
+
+        assert_eq!(bytes, vec![0b0000001, 0b00000001]);
+    }
 }

crates/flat/tests/zigzag_test.rs

@@ -0,0 +1,18 @@
+#[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};
+
+    #[quickcheck]
+    fn zigzag(i: isize) -> bool {
+        let u = to_usize(i);
+        let converted_i = to_isize(u);
+        converted_i == i
+    }
+}