add more tests

Author: RogerKSI

.gitignore

@@ -1,3 +1,4 @@
 **/target
 **/*.rs.bk
 Cargo.lock
+**/reports

README.md

@@ -6,3 +6,7 @@ The standard libraries for building BandChain oracle scripts. Code in this packa
 - `kit` - standard libraries for BandChain oracle scripts
     - `ext` - a library is helper package for writing the oracle scripts 
     - `oei` - a library containing functions for querying data from BandChain
+
+## Coverage test
+- `owasm-crypto` - cargo tarpaulin --out Html --output-dir reports/crypto --packages owasm-crypto
+- `owasm-vm` - cargo tarpaulin --out Html --output-dir reports/vm --packages owasm-vm

packages/crypto/src/ecvrf.rs

@@ -395,6 +395,11 @@ mod tests {
                     .unwrap()
             )
         );
+        assert_eq!(decode_point(&decode("").unwrap()), Err(CryptoError::invalid_hash_format()));
+        assert_eq!(
+            decode_point(&decode("11").unwrap()),
+            Err(CryptoError::invalid_point_on_curve())
+        );
     }
 
     #[test]
@@ -728,6 +733,11 @@ mod tests {
                     .unwrap(),
             )
         );
+
+        assert_eq!(
+            scalar_multiply(&(Mpz::zero(), Mpz::zero()), &Mpz::zero(),),
+            (Mpz::zero(), Mpz::one(),)
+        );
     }
 
     #[test]
@@ -812,5 +822,16 @@ mod tests {
             ).unwrap(),
             true
         );
+
+        let zero_vec: Vec<u8> = vec![0; 200];
+
+        assert_eq!(
+            ecvrf_verify(&zero_vec[0..30], &zero_vec[0..1], &zero_vec[0..1]),
+            Err(CryptoError::invalid_pubkey_format())
+        );
+        assert_eq!(
+            ecvrf_verify(&zero_vec[0..32], &zero_vec[0..1], &zero_vec[0..1]),
+            Err(CryptoError::invalid_proof_format())
+        );
     }
 }

packages/crypto/src/error.rs

@@ -5,7 +5,7 @@ use thiserror::Error;
 
 pub type CryptoResult<T> = core::result::Result<T, CryptoError>;
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, PartialEq)]
 pub enum CryptoError {
     #[error("Crypto error: {msg}")]
     GenericErr {
@@ -100,6 +100,15 @@ mod tests {
         }
     }
 
+    #[test]
+    fn invalid_point_on_curve_works() {
+        let error = CryptoError::invalid_point_on_curve();
+        match error {
+            CryptoError::InvalidPointOnCurve { .. } => {}
+            _ => panic!("wrong error type!"),
+        }
+    }
+
     #[test]
     fn invalid_hash_format_works() {
         let error = CryptoError::invalid_hash_format();
@@ -126,4 +135,13 @@ mod tests {
             _ => panic!("wrong error type!"),
         }
     }
+
+    #[test]
+    fn code_works() {
+        assert_eq!(CryptoError::invalid_point_on_curve().code(), 2);
+        assert_eq!(CryptoError::invalid_hash_format().code(), 3);
+        assert_eq!(CryptoError::invalid_proof_format().code(), 4);
+        assert_eq!(CryptoError::invalid_pubkey_format().code(), 5);
+        assert_eq!(CryptoError::generic_err("test").code(), 10);
+    }
 }

packages/kit/src/ext/cmp.rs

@@ -21,3 +21,50 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_equal() {
+        let a: f64 = 3.4;
+        let b: f64 = 3.4;
+        assert_eq!(fcmp(&a, &b), Ordering::Equal);
+    }
+
+    #[test]
+    fn test_less() {
+        let a: f64 = 2.4;
+        let b: f64 = 3.4;
+        assert_eq!(fcmp(&a, &b), Ordering::Less);
+    }
+
+    #[test]
+    fn test_greater() {
+        let a: f64 = 4.4;
+        let b: f64 = 3.4;
+        assert_eq!(fcmp(&a, &b), Ordering::Greater);
+    }
+
+    #[test]
+    fn test_nan_nan() {
+        let a: f64 = f64::NAN;
+        let b: f64 = f64::NAN;
+        assert_eq!(fcmp(&a, &b), Ordering::Equal);
+    }
+
+    #[test]
+    fn test_nan_value() {
+        let a: f64 = f64::NAN;
+        let b: f64 = 3.4;
+        assert_eq!(fcmp(&a, &b), Ordering::Greater);
+    }
+
+    #[test]
+    fn test_value_nan() {
+        let a: f64 = 3.4;
+        let b: f64 = f64::NAN;
+        assert_eq!(fcmp(&a, &b), Ordering::Less);
+    }
+}

packages/vm/src/cache.rs

@@ -80,7 +80,7 @@ impl Cache {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::*;
     use std::io::{Read, Write};
     use std::process::Command;

packages/vm/src/calls.rs

@@ -53,7 +53,7 @@ where
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use crate::cache::CacheOptions;
 
     use super::*;
@@ -159,7 +159,7 @@ mod test {
                     (i64.const 1)
                     (i64.const 1)
                     (i64.const 1048576)
-                    (i64.const 4)                  
+                    (i64.const 4)
                     call 0
 
                     (local.set $idx (i32.const 0))
@@ -172,7 +172,7 @@ mod test {
                 )
                 (func (;"execute": Resolves with result "beeb";))
                 (memory (export "memory") 17)
-                (data (i32.const 1048576) "beeb")              
+                (data (i32.const 1048576) "beeb")
                 (export "prepare" (func 1))
                 (export "execute" (func 2)))
             "#,
@@ -186,6 +186,7 @@ mod test {
     }
 
     #[test]
+    #[cfg(not(tarpaulin))]
     fn test_out_of_gas() {
         let wasm = wat2wasm(
             r#"(module

packages/vm/src/compile.rs

@@ -112,7 +112,7 @@ fn inject_stack_height(module: Module) -> Result<Module, Error> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::*;
 
     use assert_matches::assert_matches;

packages/vm/src/error.rs

@@ -43,3 +43,14 @@ impl Display for Error {
         write!(f, "{:?}", self)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fmt_works() {
+        assert_eq!(format!("{}", Error::NoError), "NoError");
+        assert_eq!(format!("{}", Error::SpanTooSmallError), "SpanTooSmallError");
+    }
+}

packages/vm/src/vm.rs

@@ -158,7 +158,7 @@ where
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use std::{
         io::{Read, Write},
         process::Command,