Add tests for bounded_int_mul libfunc (#1470)

* add some tests on bounded_int_mul

* add more tests on bounded_int_mul

* add test removed

* Begin new implementation of mul

* Add comments and docu

* Add test case

* Revert "Add comments and docu"

This reverts commit c0194df.

* Revert "Begin new implementation of mul"

This reverts commit 3875f52.

* Refactor of res_offset calculation

* Refactor of tests

* Refactor of tests

* Refactor of tests names

* Update src/libfuncs/bounded_int.rs

Co-authored-by: Julian Gonzalez Calderon <gonzalezcalderonjulian@gmail.com>

---------

Co-authored-by: Diego Civini <diego.civini@lambdaclass.com>
Co-authored-by: DiegoC <90105443+DiegoCivi@users.noreply.github.com>
Co-authored-by: Julian Gonzalez Calderon <gonzalezcalderonjulian@gmail.com>
Co-authored-by: Gabriel Bosio <38794644+gabrielbosio@users.noreply.github.com>

Author: 4 people

src/libfuncs/bounded_int.rs

@@ -372,7 +372,7 @@ fn build_mul<'ctx, 'this>(
     let res_value = entry.muli(lhs_value, rhs_value, location)?;
 
     // Offset and truncate the result to the output type.
-    let res_offset = (&dst_range.lower).max(&compute_range.lower).clone();
+    let res_offset = dst_range.lower.clone();
     let res_value = if res_offset != BigInt::ZERO {
         let res_offset = entry.const_int_from_type(context, location, res_offset, compute_ty)?;
         entry.append_op_result(arith::subi(res_value, res_offset, location))?
@@ -838,6 +838,132 @@ mod test {
         Value,
     };
 
+    lazy_static! {
+        static ref TEST_MUL_PROGRAM: (String, Program) = load_cairo! {
+                        #[feature("bounded-int-utils")]
+            use core::internal::bounded_int::{self, BoundedInt, MulHelper, mul, UnitInt};
+
+            impl MulHelperBI_m128x127_BI_m128x127 of MulHelper<BoundedInt<-128, 127>, BoundedInt<-128, 127>> {
+                type Result = BoundedInt<-16256, 16384>;
+            }
+
+            impl MulHelperBI_0x128_BI_0x128 of MulHelper<BoundedInt<0, 128>, BoundedInt<0, 128>> {
+                type Result = BoundedInt<0, 16384>;
+            }
+
+            impl MulHelperBI_1x31_BI_1x1 of MulHelper<BoundedInt<1, 31>, BoundedInt<1, 1>> {
+                type Result = BoundedInt<1, 31>;
+            }
+
+            impl MulHelperBI_m1x31_BI_m1xm1 of MulHelper<BoundedInt<-1, 31>, BoundedInt<-1, -1>> {
+                type Result = BoundedInt<-31, 1>;
+            }
+
+            impl MulHelperBI_31x31_BI_1x1 of MulHelper<BoundedInt<31, 31>, BoundedInt<1, 1>> {
+                type Result = BoundedInt<31, 31>;
+            }
+
+            impl MulHelperBI_m10x0_BI_0x100 of MulHelper<BoundedInt<-100, 0>, BoundedInt<0, 100>> {
+                type Result = BoundedInt<-10000, 0>;
+            }
+
+            impl MulHelperBI_1x1_BI_1x1 of MulHelper<BoundedInt<1, 1>, BoundedInt<1, 1>> {
+                type Result = BoundedInt<1, 1>;
+            }
+
+            impl MulHelperBI_m5x5_UI_2 of MulHelper<BoundedInt<-5, 5>, UnitInt<2>> {
+                type Result = BoundedInt<-10, 10>;
+            }
+
+            fn bi_m128x127_times_bi_m128x127(a: felt252, b: felt252) -> BoundedInt<-16256, 16384> {
+                let a: BoundedInt<-128, 127> = a.try_into().unwrap();
+                let b: BoundedInt<-128, 127> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_0x128_times_bi_0x128(a: felt252, b: felt252) -> BoundedInt<0, 16384> {
+                let a: BoundedInt<0, 128> = a.try_into().unwrap();
+                let b: BoundedInt<0, 128> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_1x31_times_bi_1x1(a: felt252, b: felt252) -> BoundedInt<1, 31> {
+                let a: BoundedInt<1, 31> = a.try_into().unwrap();
+                let b: BoundedInt<1, 1> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_m1x31_times_bi_m1xm1(a: felt252, b: felt252) -> BoundedInt<-31, 1> {
+                let a: BoundedInt<-1, 31> = a.try_into().unwrap();
+                let b: BoundedInt<-1, -1> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_31x31_times_bi_1x1(a: felt252, b: felt252) -> BoundedInt<31, 31> {
+                let a: BoundedInt<31, 31> = a.try_into().unwrap();
+                let b: BoundedInt<1, 1> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_m100x0_times_bi_0x100(a: felt252, b: felt252) -> BoundedInt<-10000, 0> {
+                let a: BoundedInt<-100, 0> = a.try_into().unwrap();
+                let b: BoundedInt<0, 100> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_1x1_times_bi_1x1(a: felt252, b: felt252) -> BoundedInt<1, 1> {
+                let a: BoundedInt<1, 1> = a.try_into().unwrap();
+                let b: BoundedInt<1, 1> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+
+            fn bi_m5x5_times_ui_2(a: felt252, b: felt252) -> BoundedInt<-10, 10> {
+                let a: BoundedInt<-5, 5> = a.try_into().unwrap();
+                let b: UnitInt<2> = b.try_into().unwrap();
+
+                mul(a,b)
+            }
+        };
+    }
+
+    #[test_case("bi_m128x127_times_bi_m128x127", -128, -128, 16384)]
+    #[test_case("bi_0x128_times_bi_0x128", 126, 128, 16128)]
+    #[test_case("bi_1x31_times_bi_1x1", 31, 1, 31)]
+    #[test_case("bi_m1x31_times_bi_m1xm1", 31, -1, -31)]
+    #[test_case("bi_31x31_times_bi_1x1", 31, 1, 31)]
+    #[test_case("bi_m100x0_times_bi_0x100", -100, 100, -10000)]
+    #[test_case("bi_1x1_times_bi_1x1", 1, 1, 1)]
+    #[test_case("bi_m5x5_times_ui_2", -3, 2, -6)]
+    fn test_mul(entry_point: &str, lhs: i32, rhs: i32, expected_result: i32) {
+        let result = run_program(
+            &TEST_MUL_PROGRAM,
+            entry_point,
+            &[
+                Value::Felt252(Felt252::from(lhs)),
+                Value::Felt252(Felt252::from(rhs)),
+            ],
+        )
+        .return_value;
+        if let Value::Enum { value, .. } = result {
+            if let Value::Struct { fields, .. } = *value {
+                assert!(
+                    matches!(fields[0], Value::BoundedInt { value, .. } if value == Felt252::from(expected_result))
+                )
+            } else {
+                panic!("Test returned an unexpected value");
+            }
+        } else {
+            panic!("Test didn't return an enum as expected");
+        }
+    }
+
     lazy_static! {
         static ref TEST_TRIM_PROGRAM: (String, Program) = load_cairo! {
             #[feature("bounded-int-utils")]