Code coverage support for tests (scrypto coverage command)

assets/template/.gitignore

@@ -1 +1,2 @@
 /target
+/coverage

radix-engine-common/Cargo.toml

@@ -51,6 +51,8 @@ radix_engine_fuzzing = ["arbitrary", "serde", "bnum/arbitrary", "bnum/serde", "s
 resource_tracker=[]
 full_math_benches = [ "dep:rug", "dep:ethnum"]
 
+coverage = []
+
 # Ref: https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
 [lib]
 doctest = false

radix-engine-common/src/constants/transaction_execution.rs

@@ -26,10 +26,16 @@ pub const MAX_TRACK_SUBSTATE_TOTAL_BYTES: usize = 64 * 1024 * 1024;
 pub const MAX_SUBSTATE_KEY_SIZE: usize = 1024;
 
 /// The maximum substate read and write size.
+#[cfg(not(feature = "coverage"))]
 pub const MAX_SUBSTATE_VALUE_SIZE: usize = 2 * 1024 * 1024;
+#[cfg(feature = "coverage")]
+pub const MAX_SUBSTATE_VALUE_SIZE: usize = 64 * 1024 * 1024;
 
 /// The maximum invoke payload size.
+#[cfg(not(feature = "coverage"))]
 pub const MAX_INVOKE_PAYLOAD_SIZE: usize = 1 * 1024 * 1024;
+#[cfg(feature = "coverage")]
+pub const MAX_INVOKE_PAYLOAD_SIZE: usize = 32 * 1024 * 1024;
 
 /// The proposer's share of tips
 pub const TIPS_PROPOSER_SHARE_PERCENTAGE: u8 = 100;

radix-engine-common/src/constants/wasm.rs

@@ -1,5 +1,8 @@
 /// The maximum memory size (per call frame): 64 * 64KiB = 4MiB
+#[cfg(not(feature = "coverage"))]
 pub const MAX_MEMORY_SIZE_IN_PAGES: u32 = 64;
+#[cfg(feature = "coverage")]
+pub const MAX_MEMORY_SIZE_IN_PAGES: u32 = 512;
 
 /// The maximum initial table size
 pub const MAX_INITIAL_TABLE_SIZE: u32 = 1024;

radix-engine/Cargo.toml

@@ -95,6 +95,9 @@ radix_engine_tests = []
 
 full_wasm_benchmarks = []
 
+# This flag disables package size limit, memory size limit and fee limit
+coverage = [ "radix-engine-common/coverage" ]
+
 # Ref: https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options
 [lib]
 doctest = false

radix-engine/src/transaction/transaction_executor.rs

@@ -59,6 +59,7 @@ pub struct CostingParameters {
 }
 
 impl Default for CostingParameters {
+    #[cfg(not(feature = "coverage"))]
     fn default() -> Self {
         Self {
             execution_cost_unit_price: EXECUTION_COST_UNIT_PRICE_IN_XRD.try_into().unwrap(),
@@ -71,6 +72,19 @@ impl Default for CostingParameters {
             archive_storage_price: ARCHIVE_STORAGE_PRICE_IN_XRD.try_into().unwrap(),
         }
     }
+    #[cfg(feature = "coverage")]
+    fn default() -> Self {
+        Self {
+            execution_cost_unit_price: Decimal::zero(),
+            execution_cost_unit_limit: u32::MAX,
+            execution_cost_unit_loan: u32::MAX,
+            finalization_cost_unit_price: Decimal::zero(),
+            finalization_cost_unit_limit: u32::MAX,
+            usd_price: USD_PRICE_IN_XRD.try_into().unwrap(),
+            state_storage_price: Decimal::zero(),
+            archive_storage_price: Decimal::zero(),
+        }
+    }
 }
 
 impl CostingParameters {

radix-engine/src/utils/coverage.rs

@@ -0,0 +1,29 @@
+use crate::types::*;
+use std::env;
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::Path;
+
+#[cfg(feature = "coverage")]
+pub fn save_coverage_data(blueprint_name: &String, coverage_data: &Vec<u8>) {
+    if let Some(dir) = env::var_os("COVERAGE_DIRECTORY") {
+        let mut file_path = Path::new(&dir).to_path_buf();
+        file_path.push(blueprint_name);
+
+        // Check if the blueprint directory exists, if not create it
+        if !file_path.exists() {
+            // error is ignored because when multiple tests are running it may fail
+            fs::create_dir(&file_path).ok();
+        }
+
+        // Write .profraw binary data
+        let file_name = hash(&coverage_data);
+        let file_name: String = file_name.0[..16]
+            .iter()
+            .map(|byte| format!("{:02x}", byte))
+            .collect();
+        file_path.push(format!("{}.profraw", file_name));
+        let mut file = File::create(file_path).unwrap();
+        file.write_all(&coverage_data).unwrap();
+    }
+}

radix-engine/src/utils/mod.rs

@@ -1,8 +1,12 @@
+#[cfg(feature = "coverage")]
+mod coverage;
 mod macros;
 mod native_blueprint_call_validator;
 mod package_extractor;
 mod panics;
 
+#[cfg(feature = "coverage")]
+pub use coverage::*;
 pub use macros::*;
 pub use native_blueprint_call_validator::*;
 pub use package_extractor::*;

radix-engine/src/vm/wasm/prepare.rs

@@ -983,15 +983,18 @@ impl WasmModule {
         mut self,
         rules: &R,
     ) -> Result<Self, PrepareError> {
-        let backend = gas_metering::host_function::Injector::new(
-            MODULE_ENV_NAME,
-            COSTING_CONSUME_WASM_EXECUTION_UNITS_FUNCTION_NAME,
-        );
-        gas_metering::inject(&mut self.module, backend, rules).map_err(|err| {
-            PrepareError::RejectedByInstructionMetering {
-                reason: err.to_string(),
-            }
-        })?;
+        #[cfg(not(feature = "coverage"))]
+        {
+            let backend = gas_metering::host_function::Injector::new(
+                MODULE_ENV_NAME,
+                COSTING_CONSUME_WASM_EXECUTION_UNITS_FUNCTION_NAME,
+            );
+            gas_metering::inject(&mut self.module, backend, rules).map_err(|err| {
+                PrepareError::RejectedByInstructionMetering {
+                    reason: err.to_string(),
+                }
+            })?;
+        }
 
         Ok(self)
     }

radix-engine/src/vm/wasm/wasmer.rs

@@ -1,5 +1,7 @@
 use crate::errors::InvokeError;
 use crate::types::*;
+#[cfg(feature = "coverage")]
+use crate::utils::save_coverage_data;
 use crate::vm::wasm::constants::*;
 use crate::vm::wasm::errors::*;
 use crate::vm::wasm::traits::*;
@@ -835,13 +837,40 @@ impl WasmInstance for WasmerInstance {
             .map_err(|e| {
                 let err: InvokeError<WasmRuntimeError> = e.into();
                 err
-            })?;
+            });
+
+        let result = match return_data {
+            Ok(data) => {
+                if let Some(v) = data.as_ref().get(0).and_then(|x| x.i64()) {
+                    read_slice(&self.instance, Slice::transmute_i64(v))
+                        .map_err(InvokeError::SelfError)
+                } else {
+                    Err(InvokeError::SelfError(WasmRuntimeError::InvalidWasmPointer))
+                }
+            }
+            Err(err) => Err(err),
+        };
 
-        if let Some(v) = return_data.as_ref().get(0).and_then(|x| x.i64()) {
-            read_slice(&self.instance, Slice::transmute_i64(v)).map_err(InvokeError::SelfError)
-        } else {
-            Err(InvokeError::SelfError(WasmRuntimeError::InvalidWasmPointer))
+        #[cfg(feature = "coverage")]
+        if let Ok(dump_coverage) = self.instance.exports.get_function("dump_coverage") {
+            if let Ok(blueprint_buffer) = runtime.actor_get_blueprint_name() {
+                let blueprint_name =
+                    String::from_utf8(runtime.buffer_consume(blueprint_buffer.id()).unwrap())
+                        .unwrap();
+
+                let mut ret = dump_coverage
+                    .call(&[])
+                    .unwrap()
+                    .as_ref()
+                    .get(0)
+                    .and_then(|x| x.i64())
+                    .unwrap();
+                let coverage_data = read_slice(&self.instance, Slice::transmute_i64(ret)).unwrap();
+                save_coverage_data(&blueprint_name, &coverage_data);
+            }
         }
+
+        result
     }
 }
 

radix-engine/src/vm/wasm/wasmi.rs

@@ -11,6 +11,8 @@ use wasmi::*;
 
 use crate::errors::InvokeError;
 use crate::types::*;
+#[cfg(feature = "coverage")]
+use crate::utils::save_coverage_data;
 use crate::vm::wasm::constants::*;
 use crate::vm::wasm::errors::*;
 use crate::vm::wasm::traits::*;
@@ -1537,21 +1539,47 @@ impl WasmInstance for WasmiInstance {
             .collect();
         let mut ret = [Value::I64(0)];
 
-        let _result = func
+        let call_result = func
             .call(self.store.as_context_mut(), &input, &mut ret)
             .map_err(|e| {
                 let err: InvokeError<WasmRuntimeError> = e.into();
                 err
-            })?;
-
-        match i64::try_from(ret[0]) {
-            Ok(ret) => read_slice(
-                self.store.as_context_mut(),
-                self.memory,
-                Slice::transmute_i64(ret),
-            ),
-            _ => Err(InvokeError::SelfError(WasmRuntimeError::InvalidWasmPointer)),
+            });
+
+        let result = match call_result {
+            Ok(_) => match i64::try_from(ret[0]) {
+                Ok(ret) => read_slice(
+                    self.store.as_context_mut(),
+                    self.memory,
+                    Slice::transmute_i64(ret),
+                ),
+                _ => Err(InvokeError::SelfError(WasmRuntimeError::InvalidWasmPointer)),
+            },
+            Err(err) => Err(err),
+        };
+
+        #[cfg(feature = "coverage")]
+        if let Ok(dump_coverage) = self.get_export_func("dump_coverage") {
+            if let Ok(blueprint_buffer) = runtime.actor_get_blueprint_name() {
+                let blueprint_name =
+                    String::from_utf8(runtime.buffer_consume(blueprint_buffer.id()).unwrap())
+                        .unwrap();
+
+                let mut ret = [Value::I64(0)];
+                dump_coverage
+                    .call(self.store.as_context_mut(), &[], &mut ret)
+                    .unwrap();
+                let coverage_data = read_slice(
+                    self.store.as_context_mut(),
+                    self.memory,
+                    Slice::transmute_i64(i64::try_from(ret[0]).unwrap()),
+                )
+                .unwrap();
+                save_coverage_data(&blueprint_name, &coverage_data);
+            }
         }
+
+        result
     }
 }
 

scrypto-unit/Cargo.toml

@@ -28,6 +28,7 @@ lru = ["radix-engine/lru", "radix-engine-queries/lru"]
 
 rocksdb = ["radix-engine-stores/rocksdb"]
 post_run_db_check = []
+coverage = ["radix-engine/coverage"]
 
 [lib]
 doctest = false

scrypto-unit/src/test_runner.rs

@@ -79,31 +79,7 @@ impl Compile {
         package_dir: P,
         env_vars: sbor::rust::collections::BTreeMap<String, String>,
     ) -> (Vec<u8>, PackageDefinition) {
-        // Build
-        let status = Command::new("cargo")
-            .envs(env_vars)
-            .current_dir(package_dir.as_ref())
-            .args([
-                "build", 
-                "--target",
-                "wasm32-unknown-unknown",
-                "--release",
-                "--features", 
-                "scrypto/log-error,scrypto/log-warn,scrypto/log-info,scrypto/log-debug,scrypto/log-trace"
-            ])
-            .status()
-            .unwrap_or_else(|error| {
-                panic!(
-                    "Compiling \"{:?}\" failed with \"{:?}\"",
-                    package_dir.as_ref(),
-                    error
-                )
-            });
-        if !status.success() {
-            panic!("Failed to compile package: {:?}", package_dir.as_ref());
-        }
-
-        // Find wasm path
+        // Find wasm name
         let mut cargo = package_dir.as_ref().to_owned();
         cargo.push("Cargo.toml");
         let wasm_name = if cargo.exists() {
@@ -122,12 +98,79 @@ impl Compile {
                 .to_owned()
                 .replace("-", "_")
         };
-        let mut path = PathBuf::from_str(&get_cargo_target_directory(&cargo)).unwrap(); // Infallible;
+
+        let mut path = PathBuf::from_str(&get_cargo_target_directory(&cargo)).unwrap();
         path.push("wasm32-unknown-unknown");
         path.push("release");
-        path.push(wasm_name);
+        path.push(&wasm_name);
         path.set_extension("wasm");
 
+        #[cfg(feature = "coverage")]
+        // Check if binary exists in coverage directory, if it doesn't only then build it
+        {
+            let mut coverage_path = PathBuf::from_str(&get_cargo_target_directory(&cargo)).unwrap();
+            coverage_path.pop();
+            coverage_path.push("coverage");
+            coverage_path.push("wasm32-unknown-unknown");
+            coverage_path.push("release");
+            coverage_path.push(wasm_name);
+            coverage_path.set_extension("wasm");
+            if coverage_path.is_file() {
+                let code = fs::read(&coverage_path).unwrap_or_else(|err| {
+                    panic!(
+                        "Failed to read built WASM from path {:?} - {:?}",
+                        &path, err
+                    )
+                });
+                coverage_path.set_extension("rpd");
+                let definition = fs::read(&coverage_path).unwrap_or_else(|err| {
+                    panic!(
+                        "Failed to read package definition from path {:?} - {:?}",
+                        &coverage_path, err
+                    )
+                });
+                let definition = manifest_decode(&definition).unwrap_or_else(|err| {
+                    panic!(
+                        "Failed to parse package definition from path {:?} - {:?}",
+                        &coverage_path, err
+                    )
+                });
+                return (code, definition);
+            }
+        };
+
+        // Build
+        let features = vec![
+            "scrypto/log-error",
+            "scrypto/log-warn",
+            "scrypto/log-info",
+            "scrypto/log-debug",
+            "scrypto/log-trace",
+        ];
+
+        let status = Command::new("cargo")
+            .envs(env_vars)
+            .current_dir(package_dir.as_ref())
+            .args([
+                "build",
+                "--target",
+                "wasm32-unknown-unknown",
+                "--release",
+                "--features",
+                &features.join(","),
+            ])
+            .status()
+            .unwrap_or_else(|error| {
+                panic!(
+                    "Compiling \"{:?}\" failed with \"{:?}\"",
+                    package_dir.as_ref(),
+                    error
+                )
+            });
+        if !status.success() {
+            panic!("Failed to compile package: {:?}", package_dir.as_ref());
+        }
+
         // Extract schema
         let code = fs::read(&path).unwrap_or_else(|err| {
             panic!(