Use SierraGenerator for testing (part 5)

src/arch.rs

@@ -195,6 +195,20 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
                     .as_ptr()
                     .to_bytes(buffer, find_dict_drop_override)?
             }
+            #[cfg(test)]
+            (Value::Felt252DictEntry { .. }, CoreTypeConcrete::Felt252DictEntry(_)) => {
+                let abi_ptr = self.value.to_ptr(
+                    self.arena,
+                    self.registry,
+                    self.type_id,
+                    find_dict_drop_override,
+                )?;
+
+                let abi = unsafe { abi_ptr.cast::<crate::runtime::FeltDictEntry>().as_ref() };
+
+                abi.dict.to_bytes(buffer, find_dict_drop_override)?;
+                abi.value_ptr.to_bytes(buffer, find_dict_drop_override)?;
+            }
             (
                 Value::Secp256K1Point(Secp256k1Point { x, y, is_infinity }),
                 CoreTypeConcrete::Starknet(StarknetTypeConcrete::Secp256Point(

src/execution_result.rs

@@ -31,7 +31,8 @@ pub struct BuiltinStats {
 }
 
 /// The result of the JIT execution.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(not(test), derive(serde::Serialize, serde::Deserialize))]
 pub struct ExecutionResult {
     pub remaining_gas: Option<u64>,
     pub return_value: Value,

src/libfuncs/felt252.rs

@@ -332,36 +332,45 @@ pub fn build_is_zero<'ctx, 'this>(
 #[cfg(test)]
 pub mod test {
     use crate::{
-        utils::test::{load_cairo, run_program},
+        utils::{
+            sierra_gen::SierraGenerator,
+            test::{load_cairo, run_program, run_sierra_program},
+        },
         values::Value,
     };
-    use cairo_lang_sierra::program::Program;
+    use cairo_lang_sierra::{
+        extensions::{
+            felt252::{Felt252BinaryOperationWithVarLibfunc, Felt252Traits},
+            is_zero::IsZeroLibfunc,
+        },
+        program::Program,
+    };
     use lazy_static::lazy_static;
     use starknet_types_core::felt::Felt;
 
     lazy_static! {
-        static ref FELT252_ADD: (String, Program) = load_cairo! {
-            fn run_test(lhs: felt252, rhs: felt252) -> felt252 {
-                lhs + rhs
-            }
+        static ref FELT252_ADD: Program = {
+            let generator = SierraGenerator::<Felt252BinaryOperationWithVarLibfunc>::default();
+
+            generator.build_with_generic_id("felt252_add".into(), &[])
         };
 
-        static ref FELT252_SUB: (String, Program) = load_cairo! {
-            fn run_test(lhs: felt252, rhs: felt252) -> felt252 {
-                lhs - rhs
-            }
+        static ref FELT252_SUB: Program = {
+            let generator = SierraGenerator::<Felt252BinaryOperationWithVarLibfunc>::default();
+
+            generator.build_with_generic_id("felt252_sub".into(), &[])
         };
 
-        static ref FELT252_MUL: (String, Program) = load_cairo! {
-            fn run_test(lhs: felt252, rhs: felt252) -> felt252 {
-                lhs * rhs
-            }
+        static ref FELT252_MUL: Program = {
+            let generator = SierraGenerator::<Felt252BinaryOperationWithVarLibfunc>::default();
+
+            generator.build_with_generic_id("felt252_mul".into(), &[])
         };
 
-        static ref FELT252_DIV: (String, Program) = load_cairo! {
-            fn run_test(lhs: felt252, rhs: felt252) -> felt252 {
-                felt252_div(lhs, rhs.try_into().unwrap())
-            }
+        static ref FELT252_DIV: Program = {
+            let generator = SierraGenerator::<Felt252BinaryOperationWithVarLibfunc>::default();
+
+            generator.build_with_generic_id("felt252_div".into(), &[])
         };
 
         // TODO: Add test program for `felt252_add_const`.
@@ -382,12 +391,15 @@ pub mod test {
             }
         };
 
-        static ref FELT252_IS_ZERO: (String, Program) = load_cairo! {
-            fn run_test(x: felt252) -> bool {
-                match x {
-                    0 => true,
-                    _ => false,
-                }
+        static ref FELT252_IS_ZERO: Program = {
+            let generator = SierraGenerator::<IsZeroLibfunc<Felt252Traits>>::default();
+
+            generator.build(&[])
+        };
+
+        static ref FELT252_DIV_CAIRO: (String, Program) = load_cairo! {
+            fn run_test(lhs: felt252, rhs: felt252) -> felt252 {
+                felt252_div(lhs, rhs.try_into().unwrap())
             }
         };
     }
@@ -399,12 +411,8 @@ pub mod test {
     #[test]
     fn felt252_add() {
         fn r(lhs: Felt, rhs: Felt) -> Felt {
-            match run_program(
-                &FELT252_ADD,
-                "run_test",
-                &[Value::Felt252(lhs), Value::Felt252(rhs)],
-            )
-            .return_value
+            match run_sierra_program(&FELT252_ADD, &[Value::Felt252(lhs), Value::Felt252(rhs)])
+                .return_value
             {
                 Value::Felt252(x) => x,
                 _ => panic!("invalid return type"),
@@ -437,12 +445,8 @@ pub mod test {
     #[test]
     fn felt252_sub() {
         fn r(lhs: Felt, rhs: Felt) -> Felt {
-            match run_program(
-                &FELT252_SUB,
-                "run_test",
-                &[Value::Felt252(lhs), Value::Felt252(rhs)],
-            )
-            .return_value
+            match run_sierra_program(&FELT252_SUB, &[Value::Felt252(lhs), Value::Felt252(rhs)])
+                .return_value
             {
                 Value::Felt252(x) => x,
                 _ => panic!("invalid return type"),
@@ -473,12 +477,8 @@ pub mod test {
     #[test]
     fn felt252_mul() {
         fn r(lhs: Felt, rhs: Felt) -> Felt {
-            match run_program(
-                &FELT252_MUL,
-                "run_test",
-                &[Value::Felt252(lhs), Value::Felt252(rhs)],
-            )
-            .return_value
+            match run_sierra_program(&FELT252_MUL, &[Value::Felt252(lhs), Value::Felt252(rhs)])
+                .return_value
             {
                 Value::Felt252(x) => x,
                 _ => panic!("invalid return type"),
@@ -508,10 +508,47 @@ pub mod test {
 
     #[test]
     fn felt252_div() {
+        // Helper function to run the test and extract the return value.
+        fn r(lhs: Felt, rhs: Felt) -> Felt {
+            let Value::Felt252(x) =
+                run_sierra_program(&FELT252_DIV, &[Value::Felt252(lhs), Value::Felt252(rhs)])
+                    .return_value
+            else {
+                panic!("invalid result");
+            };
+
+            x
+        }
+
+        // Test cases for valid division results.
+        assert_eq!(r(f("0"), f("1")), f("0"));
+        assert_eq!(r(f("0"), f("-2")), f("0"));
+        assert_eq!(r(f("0"), f("-1")), f("0"));
+        assert_eq!(r(f("1"), f("1")), f("1"));
+        assert_eq!(
+            r(f("1"), f("-2")),
+            f("1809251394333065606848661391547535052811553607665798349986546028067936010240")
+        );
+        assert_eq!(r(f("1"), f("-1")), f("-1"));
+        assert_eq!(r(f("-2"), f("1")), f("-2"));
+        assert_eq!(r(f("-2"), f("-2")), f("1"));
+        assert_eq!(r(f("-2"), f("-1")), f("2"));
+        assert_eq!(r(f("-1"), f("1")), f("-1"));
+        assert_eq!(
+            r(f("-1"), f("-2")),
+            f("1809251394333065606848661391547535052811553607665798349986546028067936010241")
+        );
+        assert_eq!(r(f("-1"), f("-1")), f("1"));
+        assert_eq!(r(f("6"), f("2")), f("3"));
+        assert_eq!(r(f("1000"), f("2")), f("500"));
+    }
+
+    #[test]
+    fn felt252_div_panic() {
         // Helper function to run the test and extract the return value.
         fn r(lhs: Felt, rhs: Felt) -> Option<Felt> {
             match run_program(
-                &FELT252_DIV,
+                &FELT252_DIV_CAIRO,
                 "run_test",
                 &[Value::Felt252(lhs), Value::Felt252(rhs)],
             )
@@ -540,32 +577,6 @@ pub mod test {
         assert_panics(f("0"), f("0"));
         assert_panics(f("1"), f("0"));
         assert_panics(f("-2"), f("0"));
-
-        // Test cases for valid division results.
-        assert_eq!(r(f("0"), f("1")), Some(f("0")));
-        assert_eq!(r(f("0"), f("-2")), Some(f("0")));
-        assert_eq!(r(f("0"), f("-1")), Some(f("0")));
-        assert_eq!(r(f("1"), f("1")), Some(f("1")));
-        assert_eq!(
-            r(f("1"), f("-2")),
-            Some(f(
-                "1809251394333065606848661391547535052811553607665798349986546028067936010240"
-            ))
-        );
-        assert_eq!(r(f("1"), f("-1")), Some(f("-1")));
-        assert_eq!(r(f("-2"), f("1")), Some(f("-2")));
-        assert_eq!(r(f("-2"), f("-2")), Some(f("1")));
-        assert_eq!(r(f("-2"), f("-1")), Some(f("2")));
-        assert_eq!(r(f("-1"), f("1")), Some(f("-1")));
-        assert_eq!(
-            r(f("-1"), f("-2")),
-            Some(f(
-                "1809251394333065606848661391547535052811553607665798349986546028067936010241"
-            ))
-        );
-        assert_eq!(r(f("-1"), f("-1")), Some(f("1")));
-        assert_eq!(r(f("6"), f("2")), Some(f("3")));
-        assert_eq!(r(f("1000"), f("2")), Some(f("500")));
     }
 
     #[test]
@@ -584,8 +595,8 @@ pub mod test {
     #[test]
     fn felt252_is_zero() {
         fn r(x: Felt) -> bool {
-            match run_program(&FELT252_IS_ZERO, "run_test", &[Value::Felt252(x)]).return_value {
-                Value::Enum { tag, .. } => tag != 0,
+            match run_sierra_program(&FELT252_IS_ZERO, &[Value::Felt252(x)]).return_value {
+                Value::Enum { tag, .. } => tag == 0,
                 _ => panic!("invalid return type"),
             }
         }

src/libfuncs/felt252_dict.rs

@@ -143,23 +143,48 @@ pub fn build_squash<'ctx, 'this>(
 
 #[cfg(test)]
 mod test {
+    use std::collections::HashMap;
+
+    use cairo_lang_sierra::{
+        extensions::{
+            felt252_dict::{
+                Felt252DictEntryGetLibfunc, Felt252DictNewLibfunc, Felt252DictSquashLibfunc,
+            },
+            int::unsigned::{Uint32Type, Uint64Type},
+        },
+        program::GenericArg,
+    };
+    use cairo_vm::Felt252;
+
     use crate::{
-        utils::test::{jit_dict, jit_enum, jit_struct, load_cairo, run_program_assert_output},
+        utils::{
+            sierra_gen::SierraGenerator,
+            test::{
+                jit_dict, jit_enum, jit_struct, load_cairo, run_program_assert_output,
+                run_sierra_program,
+            },
+        },
         values::Value,
     };
 
     #[test]
     fn run_dict_new() {
-        let program = load_cairo!(
-            use traits::Default;
-            use dict::Felt252DictTrait;
+        let program = {
+            let mut generator = SierraGenerator::<Felt252DictNewLibfunc>::default();
 
-            fn run_test() {
-                let mut _dict: Felt252Dict<u32> = Default::default();
-            }
-        );
+            let u32_ty = generator.push_type_declaration::<Uint32Type>(&[]).clone();
+
+            generator.build(&[GenericArg::Type(u32_ty)])
+        };
 
-        run_program_assert_output(&program, "run_test", &[], jit_struct!());
+        let result = run_sierra_program(&program, &[]).return_value;
+
+        let dict = Value::Felt252Dict {
+            value: HashMap::new(),
+            debug_name: None,
+        };
+
+        assert_eq!(result, dict);
     }
 
     #[test]
@@ -177,6 +202,39 @@ mod test {
         run_program_assert_output(&program, "run_test", &[], 1u32.into());
     }
 
+    #[test]
+    fn run_dict_get() {
+        let program = {
+            let mut generator = SierraGenerator::<Felt252DictEntryGetLibfunc>::default();
+
+            let u32_ty = generator.push_type_declaration::<Uint32Type>(&[]).clone();
+
+            generator.build(&[GenericArg::Type(u32_ty)])
+        };
+
+        let dict = Value::Felt252Dict {
+            value: [
+                (Felt252::from(1), 2u32.into()),
+                (Felt252::from(2), 1u32.into()),
+            ]
+            .into(),
+            debug_name: None,
+        };
+
+        let result = run_sierra_program(&program, &[dict, Value::Felt252(2.into())]).return_value;
+
+        let dict_entry = Value::Felt252DictEntry {
+            dict: [
+                (Felt252::from(1), 2u32.into()),
+                (Felt252::from(2), 1u32.into()),
+            ]
+            .into(),
+            key: 2.into(),
+        };
+
+        assert_eq!(result, jit_struct!(dict_entry, 1u32.into()));
+    }
+
     #[test]
     fn run_dict_insert_ret_dict() {
         let program = load_cairo!(
@@ -208,6 +266,24 @@ mod test {
         );
     }
 
+    #[test]
+    fn run_dict_squash() {
+        let program = {
+            let mut generator = SierraGenerator::<Felt252DictSquashLibfunc>::default();
+
+            let u64_ty = generator.push_type_declaration::<Uint64Type>(&[]).clone();
+
+            generator.build(&[GenericArg::Type(u64_ty)])
+        };
+
+        let dict = Value::Felt252Dict {
+            value: HashMap::new(),
+            debug_name: None,
+        };
+
+        run_sierra_program(&program, &[dict]);
+    }
+
     #[test]
     fn run_dict_deserialize() {
         let program = load_cairo!(