adding a test for divide_queries_ind_by_coset_size_to_fp_offset (#213)

Author: Idanh-starkware

crates/cairo-program-runner-lib/src/hints/bootloader_hints.rs

@@ -492,7 +492,7 @@ mod tests {
     use crate::hints::codes::*;
     use crate::hints::hint_processors::MinimalBootloaderHintProcessor;
     use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput};
-    use crate::test_utils::prepare_ids_data_for_test;
+    use crate::test_utils::fill_ids_data_for_test;
     use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
     use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name;
     use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic;
@@ -547,7 +547,7 @@ mod tests {
             .push(BuiltinRunner::Output(output_builtin.clone()));
 
         let mut exec_scopes = ExecutionScopes::new();
-        let ids_data = prepare_ids_data_for_test(&["simple_bootloader_output_start"]);
+        let ids_data = fill_ids_data_for_test(&["simple_bootloader_output_start"]);
         let ap_tracking = ApTracking::new();
 
         exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input);
@@ -685,7 +685,7 @@ mod tests {
         vm.set_fp(2);
 
         let mut exec_scopes = ExecutionScopes::new();
-        let ids_data = prepare_ids_data_for_test(&["bootloader_config"]);
+        let ids_data = fill_ids_data_for_test(&["bootloader_config"]);
         let ap_tracking = ApTracking::new();
 
         exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input);
@@ -833,7 +833,7 @@ mod tests {
             &[MaybeRelocatable::Int(Felt252::from(2))],
         );
 
-        let ids_data = prepare_ids_data_for_test(&["n_subtasks"]);
+        let ids_data = fill_ids_data_for_test(&["n_subtasks"]);
 
         let ap_tracking = ApTracking::default();
 
@@ -1097,7 +1097,7 @@ mod tests {
         vm.set_fp(2);
 
         let ids_data =
-            prepare_ids_data_for_test(&["nested_subtasks_output_len", "nested_subtasks_output"]);
+            fill_ids_data_for_test(&["nested_subtasks_output_len", "nested_subtasks_output"]);
 
         let mut exec_scopes = ExecutionScopes::new();
 
@@ -1169,7 +1169,7 @@ mod tests {
         vm.segments.add();
         vm.set_fp(2);
 
-        let ids_data = prepare_ids_data_for_test(&["program_address"]);
+        let ids_data = fill_ids_data_for_test(&["program_address"]);
         let ap_tracking = ApTracking::new();
 
         let mut ptr = Relocatable {

crates/cairo-program-runner-lib/src/hints/builtin_usage_hints.rs

@@ -214,7 +214,7 @@ pub fn flexible_builtin_usage_from_input(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::prepare_ids_data_for_test;
+    use crate::test_utils::fill_ids_data_for_test;
     use cairo_vm::serde::deserialize_program::OffsetValue;
     use cairo_vm::types::relocatable::MaybeRelocatable;
     use cairo_vm::types::relocatable::Relocatable;
@@ -252,7 +252,7 @@ mod tests {
         // local n_memory_holes;
         // local n_blake2s;
         let mut vm = VirtualMachine::new(false, false);
-        let ids_data = prepare_ids_data_for_test(&[
+        let ids_data = fill_ids_data_for_test(&[
             "n_output",
             "n_pedersen",
             "n_range_check",
@@ -282,7 +282,7 @@ mod tests {
     #[rstest(finalize, case(true), case(false))]
     fn test_builtin_usage_add_other_segment(finalize: bool) {
         let mut vm = VirtualMachine::new(false, false);
-        let ids_data = prepare_ids_data_for_test(&["other_segment"]);
+        let ids_data = fill_ids_data_for_test(&["other_segment"]);
         vm.segments.add();
         vm.segments.add();
         vm.set_fp(1);
@@ -311,7 +311,7 @@ mod tests {
     #[test]
     fn test_builtin_usage_add_signature() {
         let mut vm = VirtualMachine::new(false, false);
-        let ids_data = prepare_ids_data_for_test(&["ecdsa_ptr"]);
+        let ids_data = fill_ids_data_for_test(&["ecdsa_ptr"]);
         let ap_tracking = ApTracking::default();
         vm.segments.add();
         vm.segments.add();
@@ -395,7 +395,7 @@ mod tests {
     )]
     fn test_builtin_usage_set_pages_and_fact_topology(left_pedersen_hash: usize) {
         let mut vm = VirtualMachine::new(false, false);
-        let ids_data = prepare_ids_data_for_test(&["output_ptr"]);
+        let ids_data = fill_ids_data_for_test(&["output_ptr"]);
         let ap_tracking = ApTracking::default();
         vm.segments.add();
         vm.segments.add();

crates/cairo-program-runner-lib/src/hints/execute_task_hints.rs

@@ -588,8 +588,8 @@ mod tests {
     use super::*;
     use crate::hints::codes::*;
     use crate::hints::types::{Cairo0Executable, Task};
+    use crate::test_utils::{fill_ids_data_for_test, prepare_vm_for_load_program_loading_test};
     use crate::test_utils::{get_hint_codes_at_pc, prepare_non_continuous_ids_data_for_test};
-    use crate::test_utils::{prepare_ids_data_for_test, prepare_vm_for_load_program_loading_test};
     use cairo_vm::any_box;
     use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
     use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic;
@@ -1124,7 +1124,7 @@ mod tests {
         vm.set_ap(1);
         let mut exec_scopes = ExecutionScopes::new();
         exec_scopes.insert_value(vars::USE_PREV_HASH, use_prev_hash);
-        let ids_data = prepare_ids_data_for_test(&["use_prev_hash"]);
+        let ids_data = fill_ids_data_for_test(&["use_prev_hash"]);
         let ap_tracking = ApTracking::new();
         determine_use_prev_hash(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking)
             .expect("Hint failed unexpectedly");

crates/cairo-program-runner-lib/src/hints/fri_layer.rs

@@ -63,3 +63,73 @@ pub fn divide_queries_ind_by_coset_size_to_fp_offset(
     let dest = (vm.get_fp() + 1)?;
     Ok(vm.insert_value(dest, result)?)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test_utils::fill_ids_data_for_test;
+    use cairo_vm::types::relocatable::Relocatable;
+    use cairo_vm::Felt252;
+    use rstest::rstest;
+
+    /// This test checks the hint implementation of `divide_queries_ind_by_coset_size_to_fp_offset`.
+    /// It tests that the hint correctly divides the query index by the coset size and stores the
+    /// result in fp + 1.
+    #[rstest]
+    #[case(42, 7, 6)]
+    #[case(100, 25, 4)]
+    #[case(0, 5, 0)]
+    fn test_divide_queries_ind_by_coset_size_to_fp_offset(
+        #[case] index: u64,
+        #[case] coset_size: u64,
+        #[case] expected: u64,
+    ) {
+        let mut vm = VirtualMachine::new(false, false);
+        let mut ids_data = fill_ids_data_for_test(&["queries", "params"]);
+        let ap_tracking = ApTracking::default();
+        vm.add_memory_segment();
+        vm.add_memory_segment();
+        vm.add_memory_segment();
+        vm.set_ap(2);
+        vm.set_fp(2);
+
+        let queries_addr = Relocatable::from((2, 0));
+        let params_addr = Relocatable::from((2, 3));
+        let fp = vm.get_fp();
+        vm.insert_value(
+            Relocatable::from((fp.segment_index, fp.offset - 2)),
+            MaybeRelocatable::from(queries_addr),
+        )
+        .expect("Failed to insert queries pointer");
+        vm.insert_value(
+            Relocatable::from((fp.segment_index, fp.offset - 1)),
+            MaybeRelocatable::from(params_addr),
+        )
+        .expect("Failed to insert params pointer");
+
+        let _ = vm.segments.load_data(
+            queries_addr,
+            &[
+                MaybeRelocatable::from(Felt252::from(index)), // index
+                MaybeRelocatable::from(100),                  // y_value
+                MaybeRelocatable::from(200),                  // x_inv_value
+            ],
+        );
+        let _ = vm.segments.load_data(
+            params_addr,
+            &[
+                MaybeRelocatable::from(Felt252::from(coset_size)), // coset_size
+                MaybeRelocatable::from(300),                       /* fri_group (pointer, not
+                                                                    * used here) */
+                MaybeRelocatable::from(400), // eval_point
+            ],
+        );
+        divide_queries_ind_by_coset_size_to_fp_offset(&mut vm, &mut ids_data, &ap_tracking)
+            .expect("Failed to run hint");
+        // Assert result at fp+1 is 42/7 = 6
+        let fp = vm.get_fp();
+        let result_addr = Relocatable::from((fp.segment_index, fp.offset + 1));
+        let result = vm.get_integer(result_addr).expect("Failed to get result");
+        assert_eq!(*result.as_ref(), Felt252::from(expected));
+    }
+}

crates/cairo-program-runner-lib/src/test_utils.rs

@@ -35,9 +35,7 @@ pub fn prepare_refrences_for_test(num: i32) -> std::collections::HashMap<usize,
 ///     "nameN": HintReference::new_simple(-1),
 /// }
 /// where num is the length of names.
-pub fn prepare_ids_data_for_test(
-    names: &[&str],
-) -> std::collections::HashMap<String, HintReference> {
+pub fn fill_ids_data_for_test(names: &[&str]) -> std::collections::HashMap<String, HintReference> {
     let references = prepare_refrences_for_test(names.len() as i32);
     let mut ids_data = std::collections::HashMap::<String, HintReference>::new();
     for (i, name) in names.iter().enumerate() {
@@ -109,7 +107,7 @@ pub fn prepare_vm_for_load_program_loading_test(
     );
 
     let ids_data =
-        prepare_ids_data_for_test(&["program_segment_ptr", "program_header", "program_data_ptr"]);
+        fill_ids_data_for_test(&["program_segment_ptr", "program_header", "program_data_ptr"]);
     let expected_program_data_segment_index = vm.segments.num_segments();
     let program_header_ptr = Relocatable::from((2, 0));
     let mut exec_scopes = ExecutionScopes::new();