From bf4fc6c7d50957236d56b311dd0272b1dceca92f Mon Sep 17 00:00:00 2001 From: Jean M <132435771+jeanmon@users.noreply.github.com> Date: Thu, 8 Feb 2024 16:21:41 +0100 Subject: [PATCH] test(avm): use some matchers gtest functionalities to improve unit tests (#4502) Resolves #4495 --- .../vm/tests/AvmMini_execution.test.cpp | 147 ++++++++---------- 1 file changed, 66 insertions(+), 81 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_execution.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_execution.test.cpp index 0dc7a4186f4..c6680631aec 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_execution.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_execution.test.cpp @@ -6,13 +6,14 @@ #include "barretenberg/vm/avm_trace/AvmMini_helper.hpp" #include "barretenberg/vm/avm_trace/AvmMini_opcode.hpp" #include "barretenberg/vm/tests/helpers.test.hpp" +#include "gmock/gmock.h" #include -#include #include #include #include using namespace bb; +using namespace testing; namespace { void gen_proof_and_validate(std::vector const& bytecode, std::vector&& trace, @@ -65,28 +66,23 @@ TEST_F(AvmMiniExecutionTests, basicAddReturn) auto instructions = Deserialization::parse(bytecode); // 2 instructions - EXPECT_THAT(instructions, testing::SizeIs(2)); + ASSERT_THAT(instructions, SizeIs(2)); // ADD - EXPECT_EQ(instructions.at(0).op_code, OpCode::ADD); - - auto operands = instructions.at(0).operands; - EXPECT_EQ(operands.size(), 4); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U8); - EXPECT_EQ(std::get(operands.at(1)), 7); - EXPECT_EQ(std::get(operands.at(2)), 9); - EXPECT_EQ(std::get(operands.at(3)), 1); + EXPECT_THAT(instructions.at(0), + AllOf(Field(&Instruction::op_code, OpCode::ADD), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U8), + VariantWith(7), + VariantWith(9), + VariantWith(1))))); // RETURN - EXPECT_EQ(instructions.at(1).op_code, OpCode::RETURN); - - operands = instructions.at(1).operands; - EXPECT_EQ(operands.size(), 2); - EXPECT_EQ(std::get(operands.at(0)), 0); - EXPECT_EQ(std::get(operands.at(1)), 0); + EXPECT_THAT(instructions.at(1), + AllOf(Field(&Instruction::op_code, OpCode::RETURN), + Field(&Instruction::operands, ElementsAre(VariantWith(0), VariantWith(0))))); auto trace = Execution::gen_trace(instructions); - gen_proof_and_validate(bytecode, std::move(trace), {}); } @@ -113,35 +109,32 @@ TEST_F(AvmMiniExecutionTests, setAndSubOpcodes) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_EQ(instructions.size(), 4); + ASSERT_THAT(instructions, SizeIs(4)); // SET - EXPECT_EQ(instructions.at(0).op_code, OpCode::SET); - - auto operands = instructions.at(0).operands; - EXPECT_EQ(operands.size(), 3); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U16); - EXPECT_EQ(std::get(operands.at(1)), 47123); - EXPECT_EQ(std::get(operands.at(2)), 170); + EXPECT_THAT(instructions.at(0), + AllOf(Field(&Instruction::op_code, OpCode::SET), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U16), + VariantWith(47123), + VariantWith(170))))); // SET - EXPECT_EQ(instructions.at(1).op_code, OpCode::SET); - - operands = instructions.at(1).operands; - EXPECT_EQ(operands.size(), 3); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U16); - EXPECT_EQ(std::get(operands.at(1)), 37123); - EXPECT_EQ(std::get(operands.at(2)), 51); + EXPECT_THAT(instructions.at(1), + AllOf(Field(&Instruction::op_code, OpCode::SET), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U16), + VariantWith(37123), + VariantWith(51))))); // SUB - EXPECT_EQ(instructions.at(2).op_code, OpCode::SUB); - - operands = instructions.at(2).operands; - EXPECT_EQ(operands.size(), 4); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U16); - EXPECT_EQ(std::get(operands.at(1)), 170); - EXPECT_EQ(std::get(operands.at(2)), 51); - EXPECT_EQ(std::get(operands.at(3)), 1); + EXPECT_THAT(instructions.at(2), + AllOf(Field(&Instruction::op_code, OpCode::SUB), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U16), + VariantWith(170), + VariantWith(51), + VariantWith(1))))); auto trace = Execution::gen_trace(instructions); @@ -181,8 +174,7 @@ TEST_F(AvmMiniExecutionTests, powerWithMulOpcodes) "00000000" // ret offset 0 "00000000"; // ret size 0 - uint8_t num = 12; - while (num-- > 0) { + for (int i = 0; i < 12; i++) { bytecode_hex.append(mul_hex); } @@ -191,35 +183,30 @@ TEST_F(AvmMiniExecutionTests, powerWithMulOpcodes) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_EQ(instructions.size(), 15); + ASSERT_THAT(instructions, SizeIs(15)); // MUL first pos - EXPECT_EQ(instructions.at(2).op_code, OpCode::MUL); - - auto operands = instructions.at(2).operands; - EXPECT_EQ(operands.size(), 4); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U64); - EXPECT_EQ(std::get(operands.at(1)), 0); - EXPECT_EQ(std::get(operands.at(2)), 1); - EXPECT_EQ(std::get(operands.at(3)), 1); + EXPECT_THAT(instructions.at(2), + AllOf(Field(&Instruction::op_code, OpCode::MUL), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U64), + VariantWith(0), + VariantWith(1), + VariantWith(1))))); // MUL last pos - EXPECT_EQ(instructions.at(13).op_code, OpCode::MUL); - - operands = instructions.at(13).operands; - EXPECT_EQ(operands.size(), 4); - EXPECT_EQ(std::get(operands.at(0)), AvmMemoryTag::U64); - EXPECT_EQ(std::get(operands.at(1)), 0); - EXPECT_EQ(std::get(operands.at(2)), 1); - EXPECT_EQ(std::get(operands.at(3)), 1); + EXPECT_THAT(instructions.at(13), + AllOf(Field(&Instruction::op_code, OpCode::MUL), + Field(&Instruction::operands, + ElementsAre(VariantWith(AvmMemoryTag::U64), + VariantWith(0), + VariantWith(1), + VariantWith(1))))); // RETURN - EXPECT_EQ(instructions.at(14).op_code, OpCode::RETURN); - operands = instructions.at(14).operands; - - EXPECT_EQ(operands.size(), 2); - EXPECT_EQ(std::get(operands.at(0)), 0); - EXPECT_EQ(std::get(operands.at(1)), 0); + EXPECT_THAT(instructions.at(14), + AllOf(Field(&Instruction::op_code, OpCode::RETURN), + Field(&Instruction::operands, ElementsAre(VariantWith(0), VariantWith(0))))); auto trace = Execution::gen_trace(instructions); @@ -266,14 +253,14 @@ TEST_F(AvmMiniExecutionTests, simpleInternalCall) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_EQ(instructions.size(), 6); + EXPECT_THAT(instructions, SizeIs(6)); // We test parsing step for INTERNALCALL and INTERNALRETURN. // INTERNALCALL - EXPECT_EQ(instructions.at(1).op_code, OpCode::INTERNALCALL); - EXPECT_EQ(instructions.at(1).operands.size(), 1); - EXPECT_EQ(std::get(instructions.at(1).operands.at(0)), 4); + EXPECT_THAT(instructions.at(1), + AllOf(Field(&Instruction::op_code, OpCode::INTERNALCALL), + Field(&Instruction::operands, ElementsAre(VariantWith(4))))); // INTERNALRETURN EXPECT_EQ(instructions.at(5).op_code, OpCode::INTERNALRETURN); @@ -343,7 +330,7 @@ TEST_F(AvmMiniExecutionTests, nestedInternalCalls) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_EQ(instructions.size(), 12); + ASSERT_THAT(instructions, SizeIs(12)); // Expected sequence of opcodes std::vector const opcode_sequence{ OpCode::SET, OpCode::SET, @@ -406,23 +393,21 @@ TEST_F(AvmMiniExecutionTests, jumpAndCalldatacopy) auto bytecode = hex_to_bytes(bytecode_hex); auto instructions = Deserialization::parse(bytecode); - EXPECT_EQ(instructions.size(), 5); + ASSERT_THAT(instructions, SizeIs(5)); // We test parsing steps for CALLDATACOPY and JUMP. // CALLDATACOPY - EXPECT_EQ(instructions.at(0).op_code, OpCode::CALLDATACOPY); - EXPECT_EQ(instructions.at(0).operands.size(), 3); - - auto operands = instructions.at(0).operands; - EXPECT_EQ(std::get(operands.at(0)), 0); - EXPECT_EQ(std::get(operands.at(1)), 2); - EXPECT_EQ(std::get(operands.at(2)), 10); + EXPECT_THAT( + instructions.at(0), + AllOf(Field(&Instruction::op_code, OpCode::CALLDATACOPY), + Field(&Instruction::operands, + ElementsAre(VariantWith(0), VariantWith(2), VariantWith(10))))); // JUMP - EXPECT_EQ(instructions.at(1).op_code, OpCode::JUMP); - EXPECT_EQ(instructions.at(1).operands.size(), 1); - EXPECT_EQ(std::get(instructions.at(1).operands.at(0)), 3); + EXPECT_THAT(instructions.at(1), + AllOf(Field(&Instruction::op_code, OpCode::JUMP), + Field(&Instruction::operands, ElementsAre(VariantWith(3))))); auto trace = Execution::gen_trace(instructions, std::vector{ 13, 156 });