Refactor unit tests [3/3] (#1540)

* Refactor of tests in sierra-emu

* Refacor of unit tests in types/array.rs

* Refactor of tests for types/felt252_dict.rs

* Refactor of remaining unit tests

* Increment coverage partitions

* Revert "Increment coverage partitions"

This reverts commit 9af42cc.

* Fix clippy

* Remove unused dependency

* Compile debug_utils programs when running tests

* Fix path for sierra-emu make target

* Modify script so it only runs debug_utils tests

* Remove missing load_cairo

* Remove debug println statement from load_program

* Add missing final newlines to Cairo test files

* Fix type tests to use get_compiled_program

---------

Co-authored-by: gabrielbosio <gabrielbosio95@gmail.com>
Co-authored-by: Gabriel Bosio <38794644+gabrielbosio@users.noreply.github.com>

Author: DiegoCivi

Cargo.lock

@@ -39,7 +39,6 @@ smallvec.workspace = true
 starknet-crypto.workspace = true
 starknet-curve.workspace = true
 starknet-types-core.workspace = true
-tempfile.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["env-filter"] }

debug_utils/sierra-emu/Cargo.toml

@@ -17,10 +17,12 @@ check:
 .PHONY: check
 
 test:
+	python3 ../../scripts/compile_test_data.py --mode sierra-emu
 	cargo test --all-features
 .PHONY: test
 
 test-no-corelib:
+	python3 ../../scripts/compile_test_data.py --mode sierra-emu
 	cargo test --all-features -- --skip test_corelib
 .PHONY: test-no-corelib
 

debug_utils/sierra-emu/Makefile

@@ -1,59 +1,10 @@
 #![cfg(test)]
 
-use std::{fs, path::Path, sync::Arc};
-
-use cairo_lang_compiler::{
-    compile_prepared_db, db::RootDatabase, diagnostics::DiagnosticsReporter,
-    project::setup_project, CompilerConfig,
-};
-use cairo_lang_filesystem::{db::init_dev_corelib, ids::CrateInput};
-use cairo_lang_sierra::program::Program;
+use cairo_lang_sierra::program::{Program, VersionedProgram};
+use std::{fs, sync::Arc};
 
 use crate::{starknet::StubSyscallHandler, Value, VirtualMachine};
 
-#[macro_export]
-macro_rules! load_cairo {
-    ( $( $program:tt )+ ) => {
-        $crate::test_utils::load_cairo_from_str(stringify!($($program)+))
-    };
-}
-
-pub(crate) fn load_cairo_from_str(cairo_str: &str) -> (String, Program) {
-    let mut file = tempfile::Builder::new()
-        .prefix("test_")
-        .suffix(".cairo")
-        .tempfile()
-        .unwrap();
-    let mut db = RootDatabase::default();
-
-    fs::write(&mut file, cairo_str).unwrap();
-
-    init_dev_corelib(
-        &mut db,
-        Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap()).join("corelib/src"),
-    );
-
-    let main_crate_ids = {
-        let crate_inputs = setup_project(&mut db, file.path()).unwrap();
-        CrateInput::into_crate_ids(&db, crate_inputs)
-    };
-
-    let sierra_with_dbg = compile_prepared_db(
-        &db,
-        main_crate_ids,
-        CompilerConfig {
-            diagnostics_reporter: DiagnosticsReporter::stderr(),
-            replace_ids: true,
-            ..Default::default()
-        },
-    )
-    .unwrap();
-
-    let module_name = file.path().with_extension("");
-    let module_name = module_name.file_name().unwrap().to_str().unwrap();
-    (module_name.to_string(), sierra_with_dbg.program)
-}
-
 pub fn run_test_program(sierra_program: Program) -> Vec<Value> {
     let function = sierra_program
         .funcs
@@ -85,3 +36,11 @@ pub fn run_test_program(sierra_program: Program) -> Vec<Value> {
         .cloned()
         .collect()
 }
+
+pub fn load_program(path: &str) -> Program {
+    let program_path = format!("{}/../../{}.sierra.json", env!("CARGO_MANIFEST_DIR"), path);
+    let versioned_program =
+        serde_json::from_str::<VersionedProgram>(&fs::read_to_string(program_path).unwrap())
+            .unwrap();
+    versioned_program.into_v1().unwrap().program
+}

debug_utils/sierra-emu/src/test_utils.rs

@@ -292,50 +292,20 @@ pub fn eval_trim(
 #[cfg(test)]
 mod tests {
 
-    use num_bigint::BigInt;
-
     use super::Value;
-
-    use crate::{load_cairo, test_utils::run_test_program};
+    use crate::test_utils::{load_program, run_test_program};
+    use num_bigint::BigInt;
 
     #[test]
     fn test_bounded_int_sub() {
-        let (_, program) = load_cairo!(
-            #[feature("bounded-int-utils")]
-            use core::internal::bounded_int::{self, SubHelper, BoundedInt};
-
-            impl U8BISub of SubHelper<u8, u8> {
-                type Result = BoundedInt<-255, 255>;
-            }
-
-            extern fn bounded_int_sub<Lhs, Rhs, impl H: SubHelper<Lhs, Rhs>>(
-                lhs: Lhs, rhs: Rhs,
-            ) -> H::Result nopanic;
-
-            fn main() -> BoundedInt<-255, 255> {
-                bounded_int_sub(0_u8, 255_u8)
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/bounded_int_sub");
 
         run_test_program(program);
     }
 
     #[test]
     fn test_trim_i8() {
-        let (_, program) = load_cairo!(
-            #[feature("bounded-int-utils")]
-            use core::internal::bounded_int::{self, BoundedInt};
-            use core::internal::OptionRev;
-
-            fn main() -> BoundedInt<-127, 127> {
-                let num = match bounded_int::trim_min::<i8>(1) {
-                    OptionRev::Some(n) => n,
-                    OptionRev::None => 1,
-                };
-
-                num
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/bounded_int_trim_i8");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();
@@ -349,20 +319,7 @@ mod tests {
 
     #[test]
     fn test_trim_u32() {
-        let (_, program) = load_cairo!(
-            #[feature("bounded-int-utils")]
-            use core::internal::bounded_int::{self, BoundedInt};
-            use core::internal::OptionRev;
-
-            fn main() -> BoundedInt<0, 4294967294> {
-                let num = match bounded_int::trim_max::<u32>(0xfffffffe) {
-                    OptionRev::Some(n) => n,
-                    OptionRev::None => 0,
-                };
-
-                num
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/bounded_int_trim_u32");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();
@@ -376,20 +333,8 @@ mod tests {
 
     #[test]
     fn test_trim_none() {
-        let (_, program) = load_cairo!(
-            #[feature("bounded-int-utils")]
-            use core::internal::bounded_int::{self, BoundedInt};
-            use core::internal::OptionRev;
-
-            fn main() -> BoundedInt<-32767, 32767> {
-                let num = match bounded_int::trim_min::<i16>(-0x8000) {
-                    OptionRev::Some(n) => n,
-                    OptionRev::None => 0,
-                };
-
-                num
-            }
-        );
+        let program =
+            load_program("test_data_artifacts/programs/debug_utils/bounded_int_trim_none");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();

debug_utils/sierra-emu/src/vm/bounded_int.rs

@@ -432,17 +432,14 @@ fn eval_byte_reverse(
 
 #[cfg(test)]
 mod test {
-    use crate::{load_cairo, test_utils::run_test_program, Value};
+    use crate::{
+        test_utils::{load_program, run_test_program},
+        Value,
+    };
 
     #[test]
     fn test_diff_14_m2() {
-        let (_, program) = load_cairo!(
-            pub extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
-
-            fn main() -> Result<u8, u8> {
-                i8_diff(14, -2)
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/int_diff_14_m2");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();
@@ -456,13 +453,7 @@ mod test {
 
     #[test]
     fn test_diff_m14_m2() {
-        let (_, program) = load_cairo!(
-            pub extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
-
-            fn main() -> Result<u8, u8> {
-                i8_diff(-14, -2)
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/int_diff_m14_m2");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();
@@ -476,13 +467,7 @@ mod test {
 
     #[test]
     fn test_diff_m2_0() {
-        let (_, program) = load_cairo!(
-            pub extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
-
-            fn main() -> Result<u8, u8> {
-                i8_diff(-2, 0)
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/int_diff_m2_0");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();
@@ -496,13 +481,7 @@ mod test {
 
     #[test]
     fn test_diff_2_10() {
-        let (_, program) = load_cairo!(
-            pub extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
-
-            fn main() -> Result<u8, u8> {
-                i8_diff(2, 10)
-            }
-        );
+        let program = load_program("test_data_artifacts/programs/debug_utils/int_diff_2_10");
 
         let result = run_test_program(program);
         let result = result.last().unwrap();

debug_utils/sierra-emu/src/vm/int.rs

@@ -1,8 +1,10 @@
 import os
 import subprocess
+import argparse
 
-src_root = "test_data"
-dst_root = "test_data_artifacts"
+parser = argparse.ArgumentParser()
+parser.add_argument("--mode", help="Defines which cairo files to compile")
+args = parser.parse_args()
 
 subprocess.run(
     [
@@ -26,13 +28,13 @@ def get_dst_path(src_path):
     return dst_path
 
 
-def compile_cairo_project(src_path):
+def compile_cairo_project(src_path, binary_path):
     dst_path = get_dst_path(src_path)
 
     print(f"compiling project {src_path} into {dst_path}")
     subprocess.run(
         [
-            "target/debug/compile-cairo-project",
+            binary_path,
             src_path,
             dst_path + ".sierra.json",
             dst_path + ".sierra",
@@ -82,8 +84,15 @@ def walk(subdir, f):
                     filepath = os.path.join(dirpath, filename)
                     f(filepath)
 
-
-walk("programs", lambda p: compile_cairo_project(p))
-walk("contracts", lambda p: compile_cairo_contract(p))
-walk("tests", lambda p: compile_cairo_tests(p, starknet=False))
-walk("tests_starknet", lambda p: compile_cairo_tests(p, starknet=True))
+ 
+if args.mode == "sierra-emu":
+    src_root = "../../test_data"
+    dst_root = "../../test_data_artifacts"
+    walk("programs/debug_utils", lambda p: compile_cairo_project(p, "../../target/debug/compile-cairo-project"))
+else:
+    src_root = "test_data"
+    dst_root = "test_data_artifacts"
+    walk("programs", lambda p: compile_cairo_project(p, "target/debug/compile-cairo-project"))
+    walk("contracts", lambda p: compile_cairo_contract(p))
+    walk("tests", lambda p: compile_cairo_tests(p, starknet=False))
+    walk("tests_starknet", lambda p: compile_cairo_tests(p, starknet=True))

scripts/compile_test_data.py

@@ -87,19 +87,15 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{load_cairo, values::Value};
+    use crate::{utils::testing::load_program, values::Value};
     use starknet_types_core::felt::Felt;
 
     #[test]
     fn test_aot_compile_and_insert() {
         let native_context = NativeContext::new();
         let mut cache = AotProgramCache::new(&native_context);
 
-        let (_, program) = load_cairo! {
-            fn run_test() -> felt252 {
-                42
-            }
-        };
+        let program = load_program("test_data_artifacts/programs/aot_program");
 
         let function_id = &program.funcs.first().expect("should have a function").id;
         let executor = cache.compile_and_insert((), &program, OptLevel::default());

src/cache/aot.rs

@@ -704,27 +704,16 @@ fn parse_result(
 mod tests {
     use super::*;
     use crate::{
-        context::NativeContext, include_contract, load_cairo, starknet_stub::StubSyscallHandler,
-        OptLevel,
+        context::NativeContext, include_contract, starknet_stub::StubSyscallHandler,
+        utils::testing::load_program, OptLevel,
     };
     use cairo_lang_sierra::program::Program;
     use rstest::*;
     use starknet_types_core::felt::Felt;
 
     #[fixture]
     fn program() -> Program {
-        let (_, program) = load_cairo! {
-            use starknet::{SyscallResultTrait, get_block_hash_syscall};
-
-            fn run_test() -> felt252 {
-                42
-            }
-
-            fn get_block_hash() -> felt252 {
-                get_block_hash_syscall(1).unwrap_syscall()
-            }
-        };
-        program
+        load_program("test_data_artifacts/programs/executor_program")
     }
 
     #[fixture]