From ec122c9b9c1c63c72158c6956d8fdb2398faf96b Mon Sep 17 00:00:00 2001 From: Jean M <132435771+jeanmon@users.noreply.github.com> Date: Wed, 10 Apr 2024 18:18:52 +0200 Subject: [PATCH] chore(avm): Add a boolean to toggle proving in AVM unit tests (#5667) Resolves #5663 --- .../vm/tests/avm_arithmetic.test.cpp | 102 +++++++++--------- .../vm/tests/avm_bitwise.test.cpp | 8 +- .../vm/tests/avm_control_flow.test.cpp | 8 +- .../vm/tests/avm_indirect_mem.test.cpp | 6 +- .../vm/tests/avm_mem_opcodes.test.cpp | 10 +- .../barretenberg/vm/tests/avm_memory.test.cpp | 4 +- .../barretenberg/vm/tests/helpers.test.cpp | 25 ++--- .../barretenberg/vm/tests/helpers.test.hpp | 8 +- 8 files changed, 89 insertions(+), 82 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 336c22da40b..3c51f5b7199 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -334,7 +334,7 @@ TEST_F(AvmArithmeticTestsFF, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over finite field type. @@ -354,7 +354,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); avm_trace::log_avm_trace(trace, 0, 10); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over finite field type. @@ -374,7 +374,7 @@ TEST_F(AvmArithmeticTestsFF, multiplication) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication by zero over finite field type. @@ -394,7 +394,7 @@ TEST_F(AvmArithmeticTestsFF, multiplicationByZero) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic division over finite field type. @@ -417,7 +417,7 @@ TEST_F(AvmArithmeticTestsFF, division) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on division with zero numerator over finite field type. @@ -440,7 +440,7 @@ TEST_F(AvmArithmeticTestsFF, divisionNumeratorZero) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on division by zero over finite field type. @@ -465,7 +465,7 @@ TEST_F(AvmArithmeticTestsFF, divisionByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on division of zero by zero over finite field type. @@ -488,7 +488,7 @@ TEST_F(AvmArithmeticTestsFF, divisionZeroByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Testing an execution of the different arithmetic opcodes over finite field @@ -513,7 +513,7 @@ TEST_F(AvmArithmeticTestsFF, mixedOperationsWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test of equality on FF elements @@ -531,7 +531,7 @@ TEST_F(AvmArithmeticTestsFF, equality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); // Expect 0 as inv of (q-1) - (q-1) - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of FF elements @@ -548,7 +548,7 @@ TEST_F(AvmArithmeticTestsFF, nonEquality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-1).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** @@ -573,7 +573,7 @@ TEST_F(AvmArithmeticTestsU8, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(91)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic addition over u8 type with carry. @@ -595,7 +595,7 @@ TEST_F(AvmArithmeticTestsU8, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(3)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u8 type. @@ -616,7 +616,7 @@ TEST_F(AvmArithmeticTestsU8, subtraction) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(133)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on subtraction over u8 type with carry. @@ -646,7 +646,7 @@ TEST_F(AvmArithmeticTestsU8, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over u8 type. @@ -669,7 +669,7 @@ TEST_F(AvmArithmeticTestsU8, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(195)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication over u8 type with overflow. @@ -693,7 +693,7 @@ TEST_F(AvmArithmeticTestsU8, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(208)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(132)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test of equality on u8 elements @@ -706,7 +706,7 @@ TEST_F(AvmArithmeticTestsU8, equality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of U8 elements @@ -719,7 +719,7 @@ TEST_F(AvmArithmeticTestsU8, nonEquality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-116).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** @@ -745,7 +745,7 @@ TEST_F(AvmArithmeticTestsU16, addition) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0xDC)); // 34780 = 0x87DC EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x87)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic addition over u16 type with carry. @@ -767,7 +767,7 @@ TEST_F(AvmArithmeticTestsU16, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(17)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u16 type. @@ -790,7 +790,7 @@ TEST_F(AvmArithmeticTestsU16, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x79)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u16 type with carry. @@ -820,7 +820,7 @@ TEST_F(AvmArithmeticTestsU16, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over u16 type. @@ -845,7 +845,7 @@ TEST_F(AvmArithmeticTestsU16, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0xBF)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication over u16 type with overflow. @@ -871,7 +871,7 @@ TEST_F(AvmArithmeticTestsU16, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(8)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test of equality on U16 elements @@ -884,7 +884,7 @@ TEST_F(AvmArithmeticTestsU16, equality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of U16 elements @@ -897,7 +897,7 @@ TEST_F(AvmArithmeticTestsU16, nonEquality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-14'300).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** @@ -924,7 +924,7 @@ TEST_F(AvmArithmeticTestsU32, addition) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF((2234567891LLU >> 8) & UINT8_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(2234567891LLU >> 16)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic addition over u32 type with carry. @@ -946,7 +946,7 @@ TEST_F(AvmArithmeticTestsU32, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(231)); // 999 = 3 * 256 + 231 EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(3)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u32 type. @@ -972,7 +972,7 @@ TEST_F(AvmArithmeticTestsU32, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0x69F)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u32 type with carry. @@ -1004,7 +1004,7 @@ TEST_F(AvmArithmeticTestsU32, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over u32 type. @@ -1033,7 +1033,7 @@ TEST_F(AvmArithmeticTestsU32, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication over u32 type with overflow. @@ -1062,7 +1062,7 @@ TEST_F(AvmArithmeticTestsU32, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(71)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test of equality on U32 elements @@ -1076,7 +1076,7 @@ TEST_F(AvmArithmeticTestsU32, equality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of U32 elements @@ -1090,7 +1090,7 @@ TEST_F(AvmArithmeticTestsU32, nonEquality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(1).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** @@ -1124,7 +1124,7 @@ TEST_F(AvmArithmeticTestsU64, addition) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0x3684)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x24)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic addition over u64 type with carry. @@ -1152,7 +1152,7 @@ TEST_F(AvmArithmeticTestsU64, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u64 type. @@ -1183,7 +1183,7 @@ TEST_F(AvmArithmeticTestsU64, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0X23)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u64 type with carry. @@ -1216,7 +1216,7 @@ TEST_F(AvmArithmeticTestsU64, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r4, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over u64 type. @@ -1245,7 +1245,7 @@ TEST_F(AvmArithmeticTestsU64, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x7B5)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication over u64 type with overflow. @@ -1280,7 +1280,7 @@ TEST_F(AvmArithmeticTestsU64, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmArithmeticTestsU64, equality) @@ -1293,7 +1293,7 @@ TEST_F(AvmArithmeticTestsU64, equality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of U64 elements @@ -1307,7 +1307,7 @@ TEST_F(AvmArithmeticTestsU64, nonEquality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0x510000).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** @@ -1350,7 +1350,7 @@ TEST_F(AvmArithmeticTestsU128, addition) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0x4444)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x8888)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic addition over u128 type with carry. @@ -1390,7 +1390,7 @@ TEST_F(AvmArithmeticTestsU128, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0xFFFF)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0xFFFF)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u128 type. @@ -1432,7 +1432,7 @@ TEST_F(AvmArithmeticTestsU128, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r7, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic subtraction over u128 type with carry. @@ -1472,7 +1472,7 @@ TEST_F(AvmArithmeticTestsU128, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x2222)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on basic multiplication over u128 type. @@ -1506,7 +1506,7 @@ TEST_F(AvmArithmeticTestsU128, multiplication) EXPECT_EQ(alu_row_second.avm_alu_u16_r1, FF(0x762C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r2, FF(0xF92C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r3, FF(0x1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test on multiplication over u128 type with overflow. @@ -1566,7 +1566,7 @@ TEST_F(AvmArithmeticTestsU128, multiplicationOverflow) EXPECT_EQ(alu_row_first.avm_alu_u64_r0, FF{ UINT64_MAX - 6 }); // 2^64 - 7 EXPECT_EQ(alu_row_first.avm_alu_cf, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmArithmeticTestsU128, equality) @@ -1586,7 +1586,7 @@ TEST_F(AvmArithmeticTestsU128, equality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Test correct non-equality of U128 elements @@ -1608,7 +1608,7 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0xdeadbeefLLU << 32).invert()); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index e250b11693e..ce4e07e8f2c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -355,7 +355,7 @@ TEST_P(AvmBitwiseTestsNot, ParamTest) FF ff_a = FF(uint256_t::from_uint128(a)); FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_op_not(trace, ff_a, ff_output, FF(0), FF(1), mem_tag); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -377,7 +377,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) FF ff_output = FF(uint256_t::from_uint128(output)); // EXPECT_EQ(1, 2) << "a ^ b " << (a ^ b) << '\n'; common_validate_bit_op(trace, 0, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, @@ -398,7 +398,7 @@ TEST_P(AvmBitwiseTestsOr, AllOrTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 1, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsOr, @@ -419,7 +419,7 @@ TEST_P(AvmBitwiseTestsXor, AllXorTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 2, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp index b721f65f5b9..5e7631bebfc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp @@ -54,7 +54,7 @@ TEST_F(AvmControlFlowTests, simpleCall) EXPECT_EQ(halt_row->avm_main_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avm_main_internal_return_ptr, FF(AvmTraceBuilder::CALLSTACK_OFFSET + 1)); } - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleJump) @@ -87,7 +87,7 @@ TEST_F(AvmControlFlowTests, simpleJump) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(JUMP_ADDRESS)); } - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleCallAndReturn) @@ -137,7 +137,7 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) EXPECT_EQ(halt_row->avm_main_pc, FF(RETURN_ADDRESS)); } - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmControlFlowTests, multipleCallsAndReturns) @@ -280,6 +280,6 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp index 0f4c3c0691e..9d2696a6dd3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp @@ -63,7 +63,7 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Testing a subtraction operation with direct input operands a, b, and an indirect @@ -109,7 +109,7 @@ TEST_F(AvmIndirectMemTests, indirectOutputSub) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Testing a multiplication operation with indirect input operand a, @@ -155,7 +155,7 @@ TEST_F(AvmIndirectMemTests, indirectInputAMul) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp index 4bf38ce132a..1e7d9a4530b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp @@ -159,7 +159,7 @@ class AvmMemOpcodeTests : public ::testing::Test { Field(&Row::avm_mem_ind_op_c, 1))); } - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } }; @@ -230,7 +230,7 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) Field(&Row::avm_mem_r_in_tag, static_cast(AvmMemoryTag::U32)), Field(&Row::avm_mem_ind_op_c, 1))); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmMemOpcodeTests, directSet) @@ -257,7 +257,7 @@ TEST_F(AvmMemOpcodeTests, directSet) Field(&Row::avm_mem_rw, 1), Field(&Row::avm_mem_ind_op_c, 0))); - validate_trace_proof(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmMemOpcodeTests, indirectSet) @@ -297,7 +297,7 @@ TEST_F(AvmMemOpcodeTests, indirectSet) Field(&Row::avm_mem_r_in_tag, static_cast(AvmMemoryTag::U32)), Field(&Row::avm_mem_tag, static_cast(AvmMemoryTag::U32)))); - validate_trace_proof(std::move(trace)); + validate_trace(std::move(trace)); } TEST_F(AvmMemOpcodeTests, indirectSetWrongTag) @@ -327,7 +327,7 @@ TEST_F(AvmMemOpcodeTests, indirectSetWrongTag) Field(&Row::avm_mem_tag, static_cast(AvmMemoryTag::U8)), Field(&Row::avm_mem_tag_err, 1))); - validate_trace_proof(std::move(trace)); + validate_trace(std::move(trace)); } /****************************************************************************** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp index e62e72b7da5..0b365104e16 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp @@ -69,7 +69,7 @@ TEST_F(AvmMemoryTests, mismatchedTagAddOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U8))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::FF))); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Testing an equality operation with a mismatched memory tag. @@ -112,7 +112,7 @@ TEST_F(AvmMemoryTests, mismatchedTagEqOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::U16))); - validate_trace_check_circuit(std::move(trace)); + validate_trace(std::move(trace)); } // Testing violation that m_lastAccess is a delimiter for two different addresses diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 05ad9ba6540..11f69780a32 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -3,36 +3,37 @@ namespace tests_avm { /** - * @brief Helper routine proving and verifying a proof based on the supplied trace + * @brief Helper routine checking the circuit constraints without proving * * @param trace The execution trace */ void validate_trace_check_circuit(std::vector&& trace) { - auto circuit_builder = AvmCircuitBuilder(); - circuit_builder.set_trace(std::move(trace)); - EXPECT_TRUE(circuit_builder.check_circuit()); + validate_trace(std::move(trace), false); }; /** - * @brief Helper routine proving and verifying a proof based on the supplied trace + * @brief Helper routine which checks the circuit constraints and depending on + * the boolean with_proof value performs a proof generation and verification. * * @param trace The execution trace */ -void validate_trace_proof(std::vector&& trace) +void validate_trace(std::vector&& trace, bool with_proof) { auto circuit_builder = AvmCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); EXPECT_TRUE(circuit_builder.check_circuit()); - auto composer = AvmComposer(); - auto prover = composer.create_prover(circuit_builder); - auto proof = prover.construct_proof(); + if (with_proof) { + auto composer = AvmComposer(); + auto prover = composer.create_prover(circuit_builder); + auto proof = prover.construct_proof(); - auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof); + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); - EXPECT_TRUE(verified); + EXPECT_TRUE(verified); + } }; /** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index 0116ccaf538..55ddd81b4b0 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -16,8 +16,14 @@ using Flavor = bb::AvmFlavor; using FF = Flavor::FF; using Row = bb::AvmFullRow; +// To toggle all relevant unit tests with proving, set the env variable "AVM_TESTS_ENABLE_PROVING". +static const bool ENABLE_PROVING = std::getenv("AVM_TESTS_ENABLE_PROVING") != nullptr; + +// If the test is expecting a relation to fail, then use validate_trace_check_circuit. +// Otherwise, use validate_trace with a single argument. If the proving needs to be +// enabled all the time in a given test, use validate_trace with setting with_proof = true. void validate_trace_check_circuit(std::vector&& trace); -void validate_trace_proof(std::vector&& trace); +void validate_trace(std::vector&& trace, bool with_proof = ENABLE_PROVING); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue,