chore: unit test for brillig solver (greenlight ACVM execution)

acvm-repo/acvm/src/pwg/brillig.rs

@@ -349,3 +349,94 @@ pub struct ForeignCallWaitInfo<F> {
     /// Resolved inputs to a foreign call computed in the previous steps of a Brillig VM process
     pub inputs: Vec<ForeignCallParam<F>>,
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::pwg::BrilligSolver;
+    use acir::{
+        FieldElement,
+        brillig::{BinaryFieldOp, BitSize, HeapVector, IntegerBitSize, MemoryAddress, Opcode},
+        circuit::brillig::{BrilligFunctionId, BrilligInputs, BrilligOutputs},
+        native_types::{Expression, Witness, WitnessMap},
+    };
+    use std::collections::{BTreeMap, HashMap};
+
+    #[test]
+    fn test_solver() {
+        let mut initial_witness = WitnessMap::from(BTreeMap::from_iter([
+            (Witness(1), FieldElement::from(1u128)),
+            (Witness(2), FieldElement::from(1u128)),
+            (Witness(3), FieldElement::from(2u128)),
+        ]));
+        let w1 = Expression::from(Witness(1));
+        let w2 = Expression::from(Witness(2));
+        let w3 = Expression::from(Witness(3));
+        let inputs =
+            vec![BrilligInputs::Single(w1), BrilligInputs::Single(w2), BrilligInputs::Single(w3)];
+
+        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver(false);
+        let bytecode = vec![
+            Opcode::Const {
+                destination: MemoryAddress::Direct(21),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(1_u128),
+            },
+            Opcode::Const {
+                destination: MemoryAddress::Direct(20),
+                bit_size: BitSize::Integer(IntegerBitSize::U32),
+                value: FieldElement::from(0_u128),
+            },
+            Opcode::CalldataCopy {
+                destination_address: MemoryAddress::Direct(0),
+                size_address: MemoryAddress::Direct(21),
+                offset_address: MemoryAddress::Direct(20),
+            },
+            Opcode::Const {
+                destination: MemoryAddress::Direct(2),
+                bit_size: BitSize::Field,
+                value: FieldElement::from(0_u128),
+            },
+            Opcode::BinaryFieldOp {
+                destination: MemoryAddress::Direct(3),
+                op: BinaryFieldOp::Equals,
+                lhs: MemoryAddress::Direct(0),
+                rhs: MemoryAddress::Direct(2),
+            },
+            Opcode::JumpIf { condition: MemoryAddress::Direct(3), location: 8 },
+            Opcode::Const {
+                destination: MemoryAddress::Direct(1),
+                bit_size: BitSize::Field,
+                value: FieldElement::from(1_u128),
+            },
+            Opcode::BinaryFieldOp {
+                destination: MemoryAddress::Direct(0),
+                op: BinaryFieldOp::Add,
+                lhs: MemoryAddress::Direct(1),
+                rhs: MemoryAddress::Direct(0),
+            },
+            Opcode::Stop {
+                return_data: HeapVector {
+                    pointer: MemoryAddress::Direct(20),
+                    size: MemoryAddress::Direct(21),
+                },
+            },
+        ];
+        let mut solver = BrilligSolver::new_call(
+            &initial_witness,
+            &HashMap::new(),
+            &inputs,
+            &bytecode,
+            &backend,
+            0,
+            BrilligFunctionId::default(),
+            false,
+            None,
+        )
+        .unwrap();
+        solver.solve().unwrap();
+        let outputs = vec![BrilligOutputs::Simple(Witness(4))];
+        solver.finalize(&mut initial_witness, &outputs).unwrap();
+
+        assert_eq!(initial_witness[&Witness(4)], FieldElement::from(2u128));
+    }
+}