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 0dc7a4186f42..24c4d2648f76 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 <cstdint>
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <string>
 #include <utility>
 
 using namespace bb;
+using namespace testing;
 namespace {
 void gen_proof_and_validate(std::vector<uint8_t> const& bytecode,
                             std::vector<Row>&& trace,
@@ -65,17 +66,17 @@ TEST_F(AvmMiniExecutionTests, basicAddReturn)
     auto instructions = Deserialization::parse(bytecode);
 
     // 2 instructions
-    EXPECT_THAT(instructions, testing::SizeIs(2));
+    EXPECT_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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U8);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 7);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 9);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(3)), 1);
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U8),
+                            VariantWith<uint32_t>(7),
+                            VariantWith<uint32_t>(9),
+                            VariantWith<uint32_t>(1)));
 
     // RETURN
     EXPECT_EQ(instructions.at(1).op_code, OpCode::RETURN);
@@ -113,35 +114,34 @@ TEST_F(AvmMiniExecutionTests, setAndSubOpcodes)
     auto bytecode = hex_to_bytes(bytecode_hex);
     auto instructions = Deserialization::parse(bytecode);
 
-    EXPECT_EQ(instructions.size(), 4);
+    EXPECT_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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U16);
-    EXPECT_EQ(std::get<uint16_t>(operands.at(1)), 47123);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 170);
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U16),
+                            VariantWith<uint16_t>(47123),
+                            VariantWith<uint32_t>(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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U16);
-    EXPECT_EQ(std::get<uint16_t>(operands.at(1)), 37123);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 51);
-
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U16),
+                            VariantWith<uint16_t>(37123),
+                            VariantWith<uint32_t>(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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U16);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 170);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 51);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(3)), 1);
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U16),
+                            VariantWith<uint32_t>(170),
+                            VariantWith<uint32_t>(51),
+                            VariantWith<uint32_t>(1)));
 
     auto trace = Execution::gen_trace(instructions);
 
@@ -191,35 +191,33 @@ TEST_F(AvmMiniExecutionTests, powerWithMulOpcodes)
     auto bytecode = hex_to_bytes(bytecode_hex);
     auto instructions = Deserialization::parse(bytecode);
 
-    EXPECT_EQ(instructions.size(), 15);
+    EXPECT_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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U64);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 0);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 1);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(3)), 1);
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U64),
+                            VariantWith<uint32_t>(0),
+                            VariantWith<uint32_t>(1),
+                            VariantWith<uint32_t>(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<AvmMemoryTag>(operands.at(0)), AvmMemoryTag::U64);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 0);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 1);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(3)), 1);
+    EXPECT_THAT(operands,
+                ElementsAre(VariantWith<AvmMemoryTag>(AvmMemoryTag::U64),
+                            VariantWith<uint32_t>(0),
+                            VariantWith<uint32_t>(1),
+                            VariantWith<uint32_t>(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<uint32_t>(operands.at(0)), 0);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 0);
+    EXPECT_THAT(operands, ElementsAre(VariantWith<uint32_t>(0), VariantWith<uint32_t>(0)));
 
     auto trace = Execution::gen_trace(instructions);
 
@@ -266,14 +264,13 @@ 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<uint32_t>(instructions.at(1).operands.at(0)), 4);
+    EXPECT_THAT(instructions.at(1).operands, ElementsAre(VariantWith<uint32_t>(4)));
 
     // INTERNALRETURN
     EXPECT_EQ(instructions.at(5).op_code, OpCode::INTERNALRETURN);
@@ -343,7 +340,7 @@ TEST_F(AvmMiniExecutionTests, nestedInternalCalls)
     auto bytecode = hex_to_bytes(bytecode_hex);
     auto instructions = Deserialization::parse(bytecode);
 
-    EXPECT_EQ(instructions.size(), 12);
+    EXPECT_THAT(instructions, SizeIs(12));
 
     // Expected sequence of opcodes
     std::vector<OpCode> const opcode_sequence{ OpCode::SET,          OpCode::SET,
@@ -406,23 +403,19 @@ TEST_F(AvmMiniExecutionTests, jumpAndCalldatacopy)
     auto bytecode = hex_to_bytes(bytecode_hex);
     auto instructions = Deserialization::parse(bytecode);
 
-    EXPECT_EQ(instructions.size(), 5);
+    EXPECT_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<uint32_t>(operands.at(0)), 0);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(1)), 2);
-    EXPECT_EQ(std::get<uint32_t>(operands.at(2)), 10);
+    EXPECT_THAT(operands, ElementsAre(VariantWith<uint32_t>(0), VariantWith<uint32_t>(2), VariantWith<uint32_t>(10)));
 
     // JUMP
     EXPECT_EQ(instructions.at(1).op_code, OpCode::JUMP);
-    EXPECT_EQ(instructions.at(1).operands.size(), 1);
-    EXPECT_EQ(std::get<uint32_t>(instructions.at(1).operands.at(0)), 3);
+    EXPECT_THAT(instructions.at(1).operands, ElementsAre(VariantWith<uint32_t>(3)));
 
     auto trace = Execution::gen_trace(instructions, std::vector<FF>{ 13, 156 });