Add proof mode cairo run integration tests (lambdaclass#280)

* Save work in progresx

* Add proof mode cairo run integration tests and copy cairo programs to proof_programs folder

* Add deleted test

* Replace proof programs by symlinks

---------

Co-authored-by: Javier Chatruc <jrchatruc@gmail.com>

Makefile

@@ -104,6 +104,7 @@ clean:
 
 clean_files:
 	rm -f $(TEST_DIR)/*.json
+	rm -f $(TEST_DIR)/proof_programs/*.json
 	rm -f $(TEST_DIR)/*.memory
 	rm -f $(TEST_DIR)/*.trace
 

cairo_programs/proof_programs/assert_250_bit_element_array.cairo

@@ -0,0 +1 @@
+../assert_250_bit_element_array.cairo

cairo_programs/proof_programs/assert_le_felt.cairo

@@ -0,0 +1 @@
+../assert_le_felt.cairo

cairo_programs/proof_programs/assert_lt_felt.cairo

@@ -0,0 +1 @@
+../assert_lt_felt.cairo

cairo_programs/proof_programs/common_signature.cairo

@@ -0,0 +1 @@
+../common_signature.cairo

cairo_programs/proof_programs/dict_squash.cairo

@@ -0,0 +1 @@
+../dict_squash.cairo

cairo_programs/proof_programs/dict_update.cairo

@@ -0,0 +1 @@
+../dict_update.cairo

cairo_programs/proof_programs/is_quad_residue.cairo

@@ -0,0 +1 @@
+../is_quad_residue.cairo

cairo_programs/proof_programs/math_cmp.cairo

@@ -0,0 +1 @@
+../math_cmp.cairo

cairo_programs/proof_programs/memcpy_test.cairo

@@ -0,0 +1 @@
+../memcpy_test.cairo

cairo_programs/proof_programs/memset.cairo

@@ -0,0 +1 @@
+../memset.cairo

cairo_programs/proof_programs/pow.cairo

@@ -0,0 +1 @@
+../pow.cairo

cairo_programs/proof_programs/signed_div_rem.cairo

@@ -0,0 +1 @@
+../signed_div_rem.cairo

cairo_programs/proof_programs/split_felt.cairo

@@ -0,0 +1 @@
+../split_felt.cairo

cairo_programs/proof_programs/split_int.cairo

@@ -0,0 +1 @@
+../split_int.cairo

cairo_programs/proof_programs/sqrt.cairo

@@ -0,0 +1 @@
+../sqrt.cairo

cairo_programs/proof_programs/squash_dict.cairo

@@ -0,0 +1 @@
+../squash_dict.cairo

cairo_programs/proof_programs/unsafe_keccak.cairo

@@ -0,0 +1 @@
+../unsafe_keccak.cairo

cairo_programs/proof_programs/unsafe_keccak_finalize.cairo

@@ -0,0 +1 @@
+../unsafe_keccak_finalize.cairo

cairo_programs/proof_programs/unsigned_div_rem.cairo

@@ -0,0 +1 @@
+../unsigned_div_rem.cairo

pkg/vm/cairo_run/cairo_run_test.go

@@ -39,14 +39,26 @@ func TestPoseidonBuiltin(t *testing.T) {
 	testProgram("poseidon_builtin", t)
 }
 
+func TestPoseidonBuiltinProofMode(t *testing.T) {
+	testProgramProof("poseidon_builtin", t)
+}
+
 func TestPoseidonHash(t *testing.T) {
 	testProgram("poseidon_hash", t)
 }
 
+func TestPoseidonHashProofMode(t *testing.T) {
+	testProgramProof("poseidon_hash", t)
+}
+
 func TestSimplePrint(t *testing.T) {
 	testProgram("simple_print", t)
 }
 
+func TestSimplePrintProofMode(t *testing.T) {
+	testProgramProof("simple_print", t)
+}
+
 func TestWriteOutputProgram(t *testing.T) {
 	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
 	runner, err := cairo_run.CairoRun("../../../cairo_programs/bitwise_output.json", cairoRunConfig)
@@ -69,32 +81,66 @@ func TestPedersenBuiltin(t *testing.T) {
 	testProgram("pedersen_test", t)
 }
 
+func TestPedersenBuiltinProofMode(t *testing.T) {
+	testProgramProof("pedersen_test", t)
+}
+
 func TestPedersenAndBitwiseBuiltins(t *testing.T) {
 	testProgram("pedersen_and_bitwise_builtins", t)
 }
 
+func TestPedersenAndBitwiseBuiltinsProofMode(t *testing.T) {
+	testProgramProof("pedersen_and_bitwise_builtins", t)
+}
+
 func TestPedersenAndBitwiseBuiltinsWithAllocLocals(t *testing.T) {
 	testProgram("pedersen_and_bitwise_builtins_with_alloc_locals", t)
 }
 
+func TestPedersenAndBitwiseBuiltinsWithAllocLocalsProofMode(t *testing.T) {
+	testProgramProof("pedersen_and_bitwise_builtins_with_alloc_locals", t)
+}
+
 func TestAllocAddSegmentHint(t *testing.T) {
 	testProgram("if_reloc_equal", t)
 }
 
+func TestAllocAddSegmentHintProofMode(t *testing.T) {
+	testProgramProof("if_reloc_equal", t)
+}
+
 func TestAssertNNHint(t *testing.T) {
 	testProgram("assert_nn", t)
 }
 
+func TestAssertNNHintProofMode(t *testing.T) {
+	testProgramProof("assert_nn", t)
+}
+
 func TestAbsValue(t *testing.T) {
 	testProgram("abs_value", t)
 }
+
+func TestAbsValueProofMode(t *testing.T) {
+	testProgramProof("abs_value", t)
+}
+
 func TestCommonSignature(t *testing.T) {
 	testProgram("common_signature", t)
 }
+
+func TestCommonSignatureProofMode(t *testing.T) {
+	testProgramProof("common_signature", t)
+}
+
 func TestAssertNotZeroHint(t *testing.T) {
 	testProgram("assert_not_zero", t)
 }
 
+func TestAssertNotZeroHintProofMode(t *testing.T) {
+	testProgramProof("assert_not_zero", t)
+}
+
 func TestBitwiseRecursion(t *testing.T) {
 	testProgram("bitwise_recursion", t)
 }
@@ -115,36 +161,72 @@ func TestDict(t *testing.T) {
 	testProgram("dict", t)
 }
 
+func TestDictProofMode(t *testing.T) {
+	testProgramProof("dict", t)
+}
+
 func TestDictUpdate(t *testing.T) {
 	testProgram("dict_update", t)
 }
 
+func TestDictUpdateProofMode(t *testing.T) {
+	testProgramProof("dict_update", t)
+}
+
 func TestAssertNotEqualHint(t *testing.T) {
 	testProgram("assert_not_equal", t)
 }
 
+func TestAssertNotEqualHintProofMode(t *testing.T) {
+	testProgramProof("assert_not_equal", t)
+}
+
 func TestPowHint(t *testing.T) {
 	testProgram("pow", t)
 }
 
+func TestPowHintProofMode(t *testing.T) {
+	testProgramProof("pow", t)
+}
+
 func TestSqrtHint(t *testing.T) {
 	testProgram("sqrt", t)
 }
 
+func TestSqrtHintProofMode(t *testing.T) {
+	testProgramProof("sqrt", t)
+}
+
 func TestUnsafeKeccak(t *testing.T) {
 	testProgram("unsafe_keccak", t)
 }
 
+func TestUnsafeKeccakProofMode(t *testing.T) {
+	testProgramProof("unsafe_keccak", t)
+}
+
 func TestUnsafeKeccakFinalize(t *testing.T) {
 	testProgram("unsafe_keccak_finalize", t)
 }
 
+func TestUnsafeKeccakFinalizeProofMode(t *testing.T) {
+	testProgramProof("unsafe_keccak_finalize", t)
+}
+
 func TestUnsignedDivRemHint(t *testing.T) {
-	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
-	_, err := cairo_run.CairoRun("../../../cairo_programs/unsigned_div_rem.json", cairoRunConfig)
-	if err != nil {
-		t.Errorf("Program execution failed with error: %s", err)
-	}
+	testProgram("unsigned_div_rem", t)
+}
+
+func TestUnsignedDivRemHintProofMode(t *testing.T) {
+	testProgramProof("unsigned_div_rem", t)
+}
+
+func TestSignedDivRemHint(t *testing.T) {
+	testProgram("signed_div_rem", t)
+}
+
+func TestSignedDivRemHintProofMode(t *testing.T) {
+	testProgramProof("signed_div_rem", t)
 }
 
 func TestSetAddHint(t *testing.T) {
@@ -155,27 +237,48 @@ func TestMemcpyHint(t *testing.T) {
 	testProgram("memcpy_test", t)
 }
 
+func TestMemcpyHintProofMode(t *testing.T) {
+	testProgramProof("memcpy_test", t)
+}
+
 func TestAssertLeFelt(t *testing.T) {
 	testProgram("assert_le_felt", t)
 }
 
+func TestAssertLeFeltProofMode(t *testing.T) {
+	testProgramProof("assert_le_felt", t)
+}
+
 func TestAssertLtFelt(t *testing.T) {
 	testProgram("assert_lt_felt", t)
 }
 
+func TestAssertLtFeltProofMode(t *testing.T) {
+	testProgramProof("assert_lt_felt", t)
+}
+
 func TestMemsetHint(t *testing.T) {
 	testProgram("memset", t)
 }
 
+func TestMemsetHintProofMode(t *testing.T) {
+	testProgramProof("memset", t)
+}
+
 func TestMathCmp(t *testing.T) {
 	testProgram("math_cmp", t)
 }
+
+func TestMathCmpProofMode(t *testing.T) {
+	testProgramProof("math_cmp", t)
+}
+
 func TestSquashDict(t *testing.T) {
 	testProgram("squash_dict", t)
 }
 
-func TestSignedDivRemHint(t *testing.T) {
-	testProgram("signed_div_rem", t)
+func TestSquashDictProofMode(t *testing.T) {
+	testProgramProof("squash_dict", t)
 }
 
 func TestFindElementHint(t *testing.T) {
@@ -190,18 +293,30 @@ func TestAssert250BitHint(t *testing.T) {
 	testProgram("assert_250_bit_element_array", t)
 }
 
+func TestAssert250BitHintProofMode(t *testing.T) {
+	testProgramProof("assert_250_bit_element_array", t)
+}
+
 func TestDictSquash(t *testing.T) {
 	testProgram("dict_squash", t)
 }
 
+func TestDictSquashProofMode(t *testing.T) {
+	testProgramProof("dict_squash", t)
+}
+
 func TestSplitFeltHint(t *testing.T) {
 	testProgram("split_felt", t)
 }
 
+func TestSplitFeltHintProofMode(t *testing.T) {
+	testProgramProof("split_felt", t)
+}
+
 func TestSplitIntHint(t *testing.T) {
-	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
-	_, err := cairo_run.CairoRun("../../../cairo_programs/split_int.json", cairoRunConfig)
-	if err != nil {
-		t.Errorf("Program execution failed with error: %s", err)
-	}
+	testProgram("split_int", t)
+}
+
+func TestSplitIntHintProofMode(t *testing.T) {
+	testProgramProof("split_int", t)
 }