serialization.test.cpp

Go to the documentation of this file.

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <stdexcept>
 
#include "barretenberg/vm2/simulation/events/bytecode_events.hpp"
#include "barretenberg/vm2/simulation/lib/serialization.hpp"
 
namespace bb::avm2 {
namespace {
 
using simulation::check_tag;
using simulation::deserialize_instruction;
using simulation::InstrDeserializationError;
using simulation::InstrDeserializationEventError;
using simulation::Instruction;
using simulation::Operand;
 
// Testing serialization with some u8 variants
TEST(SerializationTest, Not8RoundTrip)
{
    const Instruction instr = { .opcode = WireOpCode::NOT_8,
                                .addressing_mode = 5,
                                .operands = { Operand::from<uint8_t>(123), Operand::from<uint8_t>(45) } };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with some u16 variants
TEST(SerializationTest, Add16RoundTrip)
{
    const Instruction instr = {
        .opcode = WireOpCode::ADD_16,
        .addressing_mode = 3,
        .operands = { Operand::from<uint16_t>(1000), Operand::from<uint16_t>(1001), Operand::from<uint16_t>(1002) }
    };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with a u32 variant
TEST(SerializationTest, Jumpi32RoundTrip)
{
    const Instruction instr = { .opcode = WireOpCode::JUMPI_32,
                                .addressing_mode = 7,
                                .operands = { Operand::from<uint16_t>(12345), Operand::from<uint32_t>(678901234) } };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with a u64 variant
TEST(SerializationTest, Set64RoundTrip)
{
    const uint64_t value_64 = 0xABCDEF0123456789LLU;
 
    const Instruction instr = { .opcode = WireOpCode::SET_64,
                                .addressing_mode = 2,
                                .operands = { Operand::from<uint16_t>(1002),
                                              Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::U64)),
                                              Operand::from<uint64_t>(value_64) } };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with a u128 variant
TEST(SerializationTest, Set128RoundTrip)
{
    const uint128_t value_128 = (uint128_t{ 0x123456789ABCDEF0LLU } << 64) + uint128_t{ 0xABCDEF0123456789LLU };
 
    const Instruction instr = { .opcode = WireOpCode::SET_128,
                                .addressing_mode = 2,
                                .operands = { Operand::from<uint16_t>(1002),
                                              Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::U128)),
                                              Operand::from<uint128_t>(value_128) } };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with ff variant
TEST(SerializationTest, SetFFRoundTrip)
{
    const FF large_ff = FF::modulus - 981723;
 
    const Instruction instr = { .opcode = WireOpCode::SET_FF,
                                .addressing_mode = 2,
                                .operands = { Operand::from<uint16_t>(1002),
                                              Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::FF)),
                                              Operand::from<FF>(large_ff) } };
    const auto decoded = deserialize_instruction(instr.serialize(), 0);
    EXPECT_EQ(instr, decoded);
}
 
// Testing serialization with ff variant which is larger than the modulus.
// Round trip would not work as multiple equivalent values over 256 bits map
// to the same FF value.
TEST(SerializationTest, DeserializeLargeFF)
{
    const uint256_t value_256 = FF::modulus + 145;
 
    // We first serialize a "dummy" instruction and then substitute the immediate value encoded as the last 32 bytes.
    const Instruction instr = { .opcode = WireOpCode::SET_FF,
                                .addressing_mode = 0,
                                .operands = { Operand::from<uint16_t>(1002),
                                              Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::U8)),
                                              Operand::from<FF>(FF::modulus - 1) } };
    auto serialized_instruction = instr.serialize();
 
    const auto buf = to_buffer(value_256);
    serialized_instruction.insert(serialized_instruction.end() - 32, buf.begin(), buf.end());
 
    const auto decoded = deserialize_instruction(serialized_instruction, 0);
    ASSERT_EQ(3, decoded.operands.size());
    EXPECT_EQ(decoded.operands[2].as<FF>(), 145);
}
 
// Testing deserialization pc out of range error
TEST(SerializationTest, PCOutOfRange)
{
    std::vector<uint8_t> bytecode;
    bytecode.resize(35, 0);
 
    try {
        deserialize_instruction(bytecode, bytecode.size() + 1);
    } catch (const InstrDeserializationError& error) {
        EXPECT_EQ(error.type, InstrDeserializationEventError::PC_OUT_OF_RANGE);
        EXPECT_TRUE(error.message.has_value());
    }
}
 
// Testing deserialization wire opcode out of range error
TEST(SerializationTest, OpcodeOutOfRange)
{
    std::vector<uint8_t> bytecode;
    bytecode.push_back(static_cast<uint8_t>(WireOpCode::LAST_OPCODE_SENTINEL) + 1); // Invalid opcode
 
    try {
        deserialize_instruction(bytecode, 0);
    } catch (const InstrDeserializationError& error) {
        EXPECT_EQ(error.type, InstrDeserializationEventError::OPCODE_OUT_OF_RANGE);
        EXPECT_TRUE(error.message.has_value());
    }
}
 
// Testing deserialization instruction out of range error
TEST(SerializationTest, InstructionOutOfRange)
{
    // Create a valid SET_16 instruction
    Instruction instr = { .opcode = WireOpCode::SET_16,
                          .addressing_mode = 2,
                          .operands = { Operand::from<uint16_t>(1002),
                                        Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::U16)),
                                        Operand::from<uint16_t>(12345) } };
 
    auto bytecode = instr.serialize();
 
    // Truncate the bytecode
    bytecode.resize(bytecode.size() - 1);
 
    try {
        deserialize_instruction(bytecode, 0);
    } catch (const InstrDeserializationError& error) {
        EXPECT_EQ(error.type, InstrDeserializationEventError::INSTRUCTION_OUT_OF_RANGE);
        EXPECT_TRUE(error.message.has_value());
    }
}
 
// Testing check_tag with a valid instruction for wire opcode SET_128
TEST(SerializationTest, CheckTagValid)
{
    Instruction instr = { .opcode = WireOpCode::SET_128,
                          .addressing_mode = 2,
                          .operands = { Operand::from<uint16_t>(1002),
                                        Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::U128)),
                                        Operand::from<uint128_t>(12345) } };
    EXPECT_TRUE(check_tag(instr));
}
 
// Testing check_tag with an invalid tag for wire opcode SET_128
TEST(SerializationTest, CheckTagInvalid)
{
    Instruction instr = { .opcode = WireOpCode::SET_128,
                          .addressing_mode = 2,
                          .operands = { Operand::from<uint16_t>(1002),
                                        Operand::from<uint8_t>(static_cast<uint8_t>(MemoryTag::MAX) + 1),
                                        Operand::from<uint128_t>(12345) } };
    EXPECT_FALSE(check_tag(instr));
}
 
// Testing check_tag with an invalid instruction for wire opcode SET_128, not enough operands
TEST(SerializationTest, CheckTagInvalidNotEnoughOperands)
{
    Instruction instr = { .opcode = WireOpCode::SET_128,
                          .addressing_mode = 2,
                          .operands = { Operand::from<uint16_t>(1002) } };
    // check_tag() throws as 'not enough operands' should have been caught by previous INSTRUCTION_OUT_OF_RANGE checks,
    // where the correct wire format was used.
    EXPECT_THROW(check_tag(instr), std::runtime_error);
}
 
// Testing check_tag with an invalid instruction for wire opcode SET_128, tag is not a byte
TEST(SerializationTest, CheckTagInvalidTagNotByte)
{
    Instruction instr = { .opcode = WireOpCode::SET_128,
                          .addressing_mode = 2,
                          .operands = { Operand::from<uint16_t>(1002),
                                        Operand::from<uint16_t>(static_cast<uint8_t>(MemoryTag::U128)),
                                        Operand::from<uint128_t>(12345) } };
    EXPECT_FALSE(check_tag(instr));
}
 
} // namespace
} // namespace bb::avm2