// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <gtest/gtest.h>

#include "garnet/lib/debug_ipc/agent_protocol.h"
#include "garnet/lib/debug_ipc/client_protocol.h"
#include "garnet/lib/debug_ipc/message_reader.h"
#include "garnet/lib/debug_ipc/message_writer.h"
#include "garnet/lib/debug_ipc/protocol_helpers.h"
#include "garnet/lib/debug_ipc/register_test_support.h"

namespace debug_ipc {

namespace {

template <typename RequestType>
bool SerializeDeserializeRequest(const RequestType& in, RequestType* out) {
  MessageWriter writer;
  uint32_t in_transaction_id = 32;
  WriteRequest(in, in_transaction_id, &writer);

  std::vector<char> serialized = writer.MessageComplete();

  MessageReader reader(std::move(serialized));
  uint32_t out_transaction_id = 0;
  if (!ReadRequest(&reader, out, &out_transaction_id))
    return false;
  EXPECT_EQ(in_transaction_id, out_transaction_id);
  return true;
}

template <typename ReplyType>
bool SerializeDeserializeReply(const ReplyType& in, ReplyType* out) {
  MessageWriter writer;
  uint32_t in_transaction_id = 32;
  WriteReply(in, in_transaction_id, &writer);

  std::vector<char> serialized = writer.MessageComplete();

  MessageReader reader(std::move(serialized));
  uint32_t out_transaction_id = 0;
  if (!ReadReply(&reader, out, &out_transaction_id))
    return false;
  EXPECT_EQ(in_transaction_id, out_transaction_id);
  return true;
}

template <typename NotificationType>
bool SerializeDeserializeNotification(
    const NotificationType& in, NotificationType* out,
    void (*write_fn)(const NotificationType&, MessageWriter*),
    bool (*read_fn)(MessageReader*, NotificationType*)) {
  MessageWriter writer;
  write_fn(in, &writer);

  MessageReader reader(writer.MessageComplete());
  return read_fn(&reader, out);
}

}  // namespace

// Hello -----------------------------------------------------------------------

TEST(Protocol, HelloRequest) {
  HelloRequest initial;
  HelloRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
}

TEST(Protocol, HelloReply) {
  HelloReply initial;
  initial.version = 12345678;
  HelloReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.version, second.version);
}

// Launch ----------------------------------------------------------------------

TEST(Protocol, LaunchRequest) {
  LaunchRequest initial;
  initial.argv.push_back("/usr/bin/WINWORD.EXE");
  initial.argv.push_back("--dosmode");

  LaunchRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  ASSERT_EQ(initial.argv.size(), second.argv.size());
  for (size_t i = 0; i < initial.argv.size(); i++)
    EXPECT_EQ(initial.argv[i], second.argv[i]);
}

TEST(Protocol, LaunchReply) {
  LaunchReply initial;
  initial.status = 67;
  initial.process_koid = 0x1234;
  initial.process_name = "winword.exe";

  LaunchReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.status, second.status);
  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.process_name, second.process_name);
}

// Kill ----------------------------------------------------------------------

TEST(Protocol, KillRequest) {
  KillRequest initial;
  initial.process_koid = 5678;

  KillRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
}

TEST(Protocol, KillReply) {
  KillReply initial;
  initial.status = 67;

  KillReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.status, second.status);
}

// Attach ----------------------------------------------------------------------

TEST(Protocol, AttachRequest) {
  AttachRequest initial;
  initial.koid = 5678;

  AttachRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.koid, second.koid);
}

TEST(Protocol, AttachReply) {
  AttachReply initial;
  initial.koid = 2312;
  initial.status = 67;
  initial.name = "virtual console";

  AttachReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.status, second.status);
  EXPECT_EQ(initial.name, second.name);
}

// Detach ----------------------------------------------------------------------

TEST(Protocol, DetachRequest) {
  DetachRequest initial;
  initial.koid = 5678;
  initial.type = DetachRequest::Type::kJob;

  DetachRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.koid, second.koid);
  EXPECT_EQ(initial.type, second.type);
}

TEST(Protocol, DetachReply) {
  DetachReply initial;
  initial.status = 67;

  DetachReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.status, second.status);
}

// Pause ---------------------------------------------------------------------

TEST(Protocol, PauseRequest) {
  PauseRequest initial;
  initial.process_koid = 3746234;
  initial.thread_koid = 123523;

  PauseRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread_koid, second.thread_koid);
}

// Resume --------------------------------------------------------------------

TEST(Protocol, ResumeRequest) {
  ResumeRequest initial;
  initial.process_koid = 3746234;
  initial.thread_koids.push_back(123523);
  initial.how = ResumeRequest::How::kStepInRange;
  initial.range_begin = 0x12345;
  initial.range_end = 0x123456;

  ResumeRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread_koids, second.thread_koids);
  EXPECT_EQ(initial.how, second.how);
  EXPECT_EQ(initial.range_begin, second.range_begin);
  EXPECT_EQ(initial.range_end, second.range_end);
}

// ProcessTree -----------------------------------------------------------------

TEST(Protocol, ProcessTreeRequest) {
  ProcessTreeRequest initial;
  ProcessTreeRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
}

TEST(Protocol, ProcessTreeReply) {
  ProcessTreeReply initial;
  initial.root.type = ProcessTreeRecord::Type::kJob;
  initial.root.koid = 1234;
  initial.root.name = "root";

  initial.root.children.resize(1);
  initial.root.children[0].type = ProcessTreeRecord::Type::kProcess;
  initial.root.children[0].koid = 3456;
  initial.root.children[0].name = "hello";

  ProcessTreeReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(initial.root.type, second.root.type);
  EXPECT_EQ(initial.root.koid, second.root.koid);
  EXPECT_EQ(initial.root.name, second.root.name);
  ASSERT_EQ(initial.root.children.size(), second.root.children.size());
  EXPECT_EQ(initial.root.children[0].type, second.root.children[0].type);
  EXPECT_EQ(initial.root.children[0].koid, second.root.children[0].koid);
  EXPECT_EQ(initial.root.children[0].name, second.root.children[0].name);
}

// Threads ---------------------------------------------------------------------

TEST(Protocol, ThreadsRequest) {
  ThreadsRequest initial;
  initial.process_koid = 36473476;

  ThreadsRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
}

TEST(Protocol, ThreadsReply) {
  ThreadsReply initial;
  initial.threads.resize(2);
  initial.threads[0].koid = 1234;
  initial.threads[0].name = "one";
  initial.threads[1].koid = 7634;
  initial.threads[1].name = "two";

  ThreadsReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  ASSERT_EQ(initial.threads.size(), second.threads.size());
  EXPECT_EQ(initial.threads[0].koid, second.threads[0].koid);
  EXPECT_EQ(initial.threads[0].name, second.threads[0].name);
  EXPECT_EQ(initial.threads[1].koid, second.threads[1].koid);
  EXPECT_EQ(initial.threads[1].name, second.threads[1].name);
}

// ReadMemory ------------------------------------------------------------------

TEST(Protocol, ReadMemoryRequest) {
  ReadMemoryRequest initial;
  initial.process_koid = 91823765;
  initial.address = 983462384;
  initial.size = 93453926;

  ReadMemoryRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.address, second.address);
  EXPECT_EQ(initial.size, second.size);
}

TEST(Protocol, ReadMemoryReply) {
  ReadMemoryReply initial;
  initial.blocks.resize(2);
  initial.blocks[0].address = 876234;
  initial.blocks[0].valid = true;
  initial.blocks[0].size = 12;
  for (uint64_t i = 0; i < initial.blocks[0].size; i++)
    initial.blocks[0].data.push_back(static_cast<uint8_t>(i));

  initial.blocks[1].address = 89362454;
  initial.blocks[1].valid = false;
  initial.blocks[1].size = 0;

  ReadMemoryReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  ASSERT_EQ(initial.blocks.size(), second.blocks.size());

  EXPECT_EQ(initial.blocks[0].address, second.blocks[0].address);
  EXPECT_EQ(initial.blocks[0].valid, second.blocks[0].valid);
  EXPECT_EQ(initial.blocks[0].size, second.blocks[0].size);
  EXPECT_EQ(second.blocks[0].size, second.blocks[0].data.size());
  for (uint64_t i = 0; i < second.blocks[0].size; i++)
    EXPECT_EQ(static_cast<uint8_t>(i), second.blocks[0].data[i]);

  EXPECT_EQ(initial.blocks[1].address, second.blocks[1].address);
  EXPECT_EQ(initial.blocks[1].valid, second.blocks[1].valid);
  EXPECT_EQ(initial.blocks[1].size, second.blocks[1].size);
  EXPECT_TRUE(second.blocks[1].data.empty());
}

// AddOrChangeBreakpoint -------------------------------------------------------

TEST(Protocol, AddOrChangeBreakpointRequest) {
  AddOrChangeBreakpointRequest initial;
  initial.breakpoint.breakpoint_id = 8976;
  initial.breakpoint.stop = debug_ipc::Stop::kProcess;
  initial.breakpoint.locations.resize(1);

  ProcessBreakpointSettings& pr_settings = initial.breakpoint.locations.back();
  pr_settings.process_koid = 1234;
  pr_settings.thread_koid = 14612;
  pr_settings.address = 0x723456234;

  AddOrChangeBreakpointRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.breakpoint.breakpoint_id, second.breakpoint.breakpoint_id);
  EXPECT_EQ(initial.breakpoint.stop, second.breakpoint.stop);
  ASSERT_EQ(initial.breakpoint.locations.size(),
            second.breakpoint.locations.size());

  EXPECT_EQ(initial.breakpoint.locations[0].process_koid,
            second.breakpoint.locations[0].process_koid);
  EXPECT_EQ(initial.breakpoint.locations[0].thread_koid,
            second.breakpoint.locations[0].thread_koid);
  EXPECT_EQ(initial.breakpoint.locations[0].address,
            second.breakpoint.locations[0].address);
}

TEST(Protocol, AddOrChangeBreakpointReply) {
  AddOrChangeBreakpointReply initial;
  initial.status = 78;

  AddOrChangeBreakpointReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(initial.status, second.status);
}

// RemoveBreakpoint ------------------------------------------------------------

TEST(Protocol, RemoveBreakpointRequest) {
  RemoveBreakpointRequest initial;
  initial.breakpoint_id = 8976;

  RemoveBreakpointRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.breakpoint_id, second.breakpoint_id);
}

TEST(Protocol, RemoveBreakpointReply) {
  RemoveBreakpointReply initial;
  RemoveBreakpointReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
}

// ThreadStatus ----------------------------------------------------------------

TEST(Protocol, ThreadStatusRequest) {
  ThreadStatusRequest initial;
  initial.process_koid = 1234;
  initial.thread_koid = 8976;

  ThreadStatusRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread_koid, second.thread_koid);
}

TEST(Protocol, ThreadStatusReply) {
  ThreadStatusReply initial;
  initial.record.koid = 1234;
  initial.record.name = "Spartacus";
  initial.record.state = ThreadRecord::State::kRunning;
  initial.record.stack_amount = ThreadRecord::StackAmount::kFull;
  initial.record.frames.resize(2);
  initial.record.frames[0].ip = 1234;
  initial.record.frames[0].sp = 9875;
  initial.record.frames[0].bp = 6666;
  initial.record.frames[1].ip = 71562341;
  initial.record.frames[1].sp = 89236413;
  initial.record.frames[1].bp = 777;

  ThreadStatusReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(2u, second.record.frames.size());
  EXPECT_EQ(initial.record.koid, second.record.koid);
  EXPECT_EQ(initial.record.name, second.record.name);
  EXPECT_EQ(initial.record.state, second.record.state);
  EXPECT_EQ(initial.record.stack_amount, second.record.stack_amount);
  EXPECT_EQ(initial.record.frames[0].ip, second.record.frames[0].ip);
  EXPECT_EQ(initial.record.frames[0].sp, second.record.frames[0].sp);
  EXPECT_EQ(initial.record.frames[0].bp, second.record.frames[0].bp);
  EXPECT_EQ(initial.record.frames[1].ip, second.record.frames[1].ip);
  EXPECT_EQ(initial.record.frames[1].sp, second.record.frames[1].sp);
  EXPECT_EQ(initial.record.frames[1].bp, second.record.frames[1].bp);
}

// Modules ---------------------------------------------------------------------

TEST(Protocol, ModulesRequest) {
  ModulesRequest initial;
  initial.process_koid = 1234;

  ModulesRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
}

TEST(Protocol, ModulesReply) {
  ModulesReply initial;
  initial.modules.resize(2);
  initial.modules[0].name = "winnt.dll";
  initial.modules[0].base = 0x1234567890;
  initial.modules[1].name = "libncurses.so.1.0.0";
  initial.modules[1].base = 0x1000;

  ModulesReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(2u, second.modules.size());
  EXPECT_EQ(initial.modules[0].name, second.modules[0].name);
  EXPECT_EQ(initial.modules[0].base, second.modules[0].base);
  EXPECT_EQ(initial.modules[1].name, second.modules[1].name);
  EXPECT_EQ(initial.modules[1].base, second.modules[1].base);
}

// Symbol tables ---------------------------------------------------------------

TEST(Protocol, SymbolTablesRequest) {
  SymbolTablesRequest initial;
  initial.process_koid = 1234;

  SymbolTablesRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
}

TEST(Protocol, SymbolTablesReply) {
  SymbolTablesReply initial;
  initial.symbols.resize(2);
  initial.symbols[0].name = "somefunc";
  initial.symbols[0].value = 0xbeefUL;
  initial.symbols[1].name = "wompwomp";
  initial.symbols[1].value = 0xb0efUL;

  SymbolTablesReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(2u, second.symbols.size());
  EXPECT_EQ(initial.symbols[0].name, second.symbols[0].name);
  EXPECT_EQ(initial.symbols[0].value, second.symbols[0].value);
  EXPECT_EQ(initial.symbols[1].name, second.symbols[1].name);
  EXPECT_EQ(initial.symbols[1].value, second.symbols[1].value);
}

// ASpace ----------------------------------------------------------------------

TEST(Protocol, AspaceRequest) {
  AddressSpaceRequest initial;
  initial.process_koid = 1234;
  initial.address = 0x717171;

  AddressSpaceRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.address, second.address);
}

TEST(Protocol, AspaceReply) {
  const uint64_t kOneT = 1024 * 1024u * 1024u * 1024ull;
  AddressSpaceReply initial;

  initial.map.resize(4u);
  initial.map[0] = AddressRegion{"proc:5616", 0x1000000, 127 * kOneT, 0};
  initial.map[1] = AddressRegion{"root", 0x1000000, 127 * kOneT, 0};
  initial.map[2] = AddressRegion{"useralloc", 0x371f1276000, 12 * 1024, 1};
  initial.map[3] = AddressRegion{"initial-thread", 0x371f1277000, 4 * 1024, 2};

  AddressSpaceReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  ASSERT_EQ(4u, second.map.size());
  EXPECT_EQ(initial.map[0].name, second.map[0].name);
  EXPECT_EQ(initial.map[0].base, second.map[0].base);
  EXPECT_EQ(initial.map[0].size, second.map[0].size);
  EXPECT_EQ(initial.map[0].depth, second.map[0].depth);
  EXPECT_EQ(initial.map[1].name, second.map[1].name);
  EXPECT_EQ(initial.map[1].base, second.map[1].base);
  EXPECT_EQ(initial.map[1].size, second.map[1].size);
  EXPECT_EQ(initial.map[1].depth, second.map[1].depth);
  EXPECT_EQ(initial.map[2].name, second.map[2].name);
  EXPECT_EQ(initial.map[2].base, second.map[2].base);
  EXPECT_EQ(initial.map[2].size, second.map[2].size);
  EXPECT_EQ(initial.map[2].depth, second.map[2].depth);
  EXPECT_EQ(initial.map[3].name, second.map[3].name);
  EXPECT_EQ(initial.map[3].base, second.map[3].base);
  EXPECT_EQ(initial.map[3].size, second.map[3].size);
  EXPECT_EQ(initial.map[3].depth, second.map[3].depth);
}

// JobFilter ------------------------------------------------------------------

TEST(Protocol, JobFilterRequest) {
  JobFilterRequest initial;
  initial.job_koid = 5678;
  initial.filters.push_back("Clock");
  initial.filters.push_back("Time");
  initial.filters.push_back("Network");

  JobFilterRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.job_koid, second.job_koid);
  EXPECT_EQ(initial.filters, second.filters);
}

TEST(Protocol, JobFilterReply) {
  JobFilterReply initial;
  initial.status = 67;

  JobFilterReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));
  EXPECT_EQ(initial.status, second.status);
}

// WriteMemory -----------------------------------------------------------------

TEST(Protocol, WriteMemoryRequest) {
  WriteMemoryRequest initial;
  initial.process_koid = 91823765;
  initial.address = 0x3468234;
  initial.data = {0, 1, 2, 3, 4, 5};

  WriteMemoryRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));
  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.address, second.address);
  ASSERT_EQ(initial.data.size(), second.data.size());
  for (size_t i = 0; i < initial.data.size(); i++)
    EXPECT_EQ(initial.data[i], second.data[i]);
}

TEST(Protocol, WriteMemoryReply) {
  WriteMemoryReply initial;
  initial.status = 7645;

  WriteMemoryReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  ASSERT_EQ(initial.status, second.status);
}

// Registers -------------------------------------------------------------------

using debug_ipc::RegisterID;

TEST(Protocol, ReadRegistersRequest) {
  ReadRegistersRequest initial;
  initial.process_koid = 0x1234;
  initial.thread_koid = 0x5678;

  ReadRegistersRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread_koid, second.thread_koid);
}

TEST(Protocol, ReadRegistersReply) {
  ReadRegistersReply initial;

  RegisterCategory cat1;
  cat1.type = RegisterCategory::Type::kGeneral;
  cat1.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_lr, 1));
  cat1.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_pc, 2));
  cat1.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_sp, 4));
  cat1.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_cpsr, 8));
  initial.categories.push_back(cat1);

  // Sanity check
  ASSERT_EQ(*(uint8_t*)&(cat1.registers[0].data[0]), 0x01u);
  ASSERT_EQ(*(uint16_t*)&(cat1.registers[1].data[0]), 0x0102u);
  ASSERT_EQ(*(uint32_t*)&(cat1.registers[2].data[0]), 0x01020304u);
  ASSERT_EQ(*(uint64_t*)&(cat1.registers[3].data[0]), 0x0102030405060708u);

  RegisterCategory cat2;
  cat2.type = RegisterCategory::Type::kVector;
  cat2.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x0, 1));
  cat2.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x1, 2));
  cat2.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x2, 4));
  cat2.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x3, 8));
  cat2.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x4, 16));
  initial.categories.push_back(cat2);

  ReadRegistersReply second;
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  ASSERT_EQ(second.categories.size(), 2u);

  // Check cat1
  auto& out_cat1 = second.categories[0];
  EXPECT_EQ(out_cat1.type, cat1.type);
  ASSERT_EQ(out_cat1.registers.size(), 4u);
  EXPECT_EQ(out_cat1.registers[0].id, cat1.registers[0].id);
  EXPECT_EQ(out_cat1.registers[0].data, cat1.registers[0].data);
  EXPECT_EQ(out_cat1.registers[1].id, cat1.registers[1].id);
  EXPECT_EQ(out_cat1.registers[1].data, cat1.registers[1].data);
  EXPECT_EQ(out_cat1.registers[2].id, cat1.registers[2].id);
  EXPECT_EQ(out_cat1.registers[2].data, cat1.registers[2].data);

  // Check cat2
  auto& out_cat2 = second.categories[1];
  EXPECT_EQ(out_cat2.type, cat2.type);
  ASSERT_EQ(out_cat2.registers.size(), 5u);
  EXPECT_EQ(out_cat2.registers[0].id, cat2.registers[0].id);
  EXPECT_EQ(out_cat2.registers[0].data, cat2.registers[0].data);
  EXPECT_EQ(out_cat2.registers[1].id, cat2.registers[1].id);
  EXPECT_EQ(out_cat2.registers[1].data, cat2.registers[1].data);
  EXPECT_EQ(out_cat2.registers[2].id, cat2.registers[2].id);
  EXPECT_EQ(out_cat2.registers[2].data, cat2.registers[2].data);
  EXPECT_EQ(out_cat2.registers[3].id, cat2.registers[3].id);
  EXPECT_EQ(out_cat2.registers[3].data, cat2.registers[3].data);
}

TEST(Protocol, WriteRegistersRequest) {
  WriteRegistersRequest initial;
  initial.process_koid = 0x1234;
  initial.thread_koid = 0x5678;
  initial.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x0, 1));
  initial.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x1, 2));
  initial.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x2, 4));
  initial.registers.push_back(CreateRegisterWithData(RegisterID::kARMv8_x3, 8));
  initial.registers.push_back(
      CreateRegisterWithData(RegisterID::kARMv8_x4, 16));

  WriteRegistersRequest second;
  ASSERT_TRUE(SerializeDeserializeRequest(initial, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread_koid, second.thread_koid);
  ASSERT_EQ(second.registers.size(), 5u);
  EXPECT_EQ(second.registers[0].id, initial.registers[0].id);
  EXPECT_EQ(second.registers[0].data, initial.registers[0].data);
  EXPECT_EQ(second.registers[1].id, initial.registers[1].id);
  EXPECT_EQ(second.registers[1].data, initial.registers[1].data);
  EXPECT_EQ(second.registers[2].id, initial.registers[2].id);
  EXPECT_EQ(second.registers[2].data, initial.registers[2].data);
  EXPECT_EQ(second.registers[3].id, initial.registers[3].id);
  EXPECT_EQ(second.registers[3].data, initial.registers[3].data);
}

TEST(Protocol, WriteRegistersReply) {
  WriteRegistersReply initial = {};
  initial.status = 0x1234u;

  WriteRegistersReply second = {};
  ASSERT_TRUE(SerializeDeserializeReply(initial, &second));

  EXPECT_EQ(second.status, initial.status);
}

// Notifications ---------------------------------------------------------------

TEST(Protocol, NotifyThread) {
  NotifyThread initial;
  initial.process_koid = 9887;
  initial.record.koid = 1234;
  initial.record.name = "Wolfgang";
  initial.record.state = ThreadRecord::State::kDying;
  initial.record.stack_amount = ThreadRecord::StackAmount::kNone;

  MessageWriter writer;
  WriteNotifyThread(MsgHeader::Type::kNotifyThreadStarting, initial, &writer);

  MessageReader reader(writer.MessageComplete());
  NotifyThread second;
  ASSERT_TRUE(ReadNotifyThread(&reader, &second));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.record.koid, second.record.koid);
  EXPECT_EQ(initial.record.name, second.record.name);
  EXPECT_EQ(initial.record.state, second.record.state);
  EXPECT_EQ(initial.record.stack_amount, second.record.stack_amount);
}

TEST(Protocol, NotifyException) {
  NotifyException initial;
  initial.process_koid = 23;
  initial.thread.name = "foo";
  initial.thread.stack_amount = ThreadRecord::StackAmount::kMinimal;
  initial.thread.frames.resize(1);
  initial.thread.frames[0].ip = 0x7647342634;
  initial.thread.frames[0].sp = 0x9861238251;
  initial.type = NotifyException::Type::kHardware;

  initial.hit_breakpoints.emplace_back();
  initial.hit_breakpoints[0].breakpoint_id = 45;
  initial.hit_breakpoints[0].hit_count = 15;
  initial.hit_breakpoints[0].should_delete = true;

  initial.hit_breakpoints.emplace_back();
  initial.hit_breakpoints[1].breakpoint_id = 46;
  initial.hit_breakpoints[1].hit_count = 16;
  initial.hit_breakpoints[1].should_delete = false;

  NotifyException second;
  ASSERT_TRUE(SerializeDeserializeNotification(
      initial, &second, &WriteNotifyException, &ReadNotifyException));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  EXPECT_EQ(initial.thread.name, second.thread.name);
  EXPECT_EQ(initial.thread.stack_amount, second.thread.stack_amount);
  EXPECT_EQ(initial.thread.frames[0].ip, second.thread.frames[0].ip);
  EXPECT_EQ(initial.thread.frames[0].sp, second.thread.frames[0].sp);
  EXPECT_EQ(initial.type, second.type);
  ASSERT_EQ(initial.hit_breakpoints.size(), second.hit_breakpoints.size());

  EXPECT_EQ(initial.hit_breakpoints[0].breakpoint_id,
            second.hit_breakpoints[0].breakpoint_id);
  EXPECT_EQ(initial.hit_breakpoints[0].hit_count,
            second.hit_breakpoints[0].hit_count);
  EXPECT_EQ(initial.hit_breakpoints[0].should_delete,
            second.hit_breakpoints[0].should_delete);

  EXPECT_EQ(initial.hit_breakpoints[1].breakpoint_id,
            second.hit_breakpoints[1].breakpoint_id);
  EXPECT_EQ(initial.hit_breakpoints[1].hit_count,
            second.hit_breakpoints[1].hit_count);
  EXPECT_EQ(initial.hit_breakpoints[1].should_delete,
            second.hit_breakpoints[1].should_delete);
}

TEST(Protocol, NotifyModules) {
  NotifyModules initial;
  initial.process_koid = 23;
  initial.modules.resize(2);
  initial.modules[0].name = "foo";
  initial.modules[0].base = 0x12345;
  initial.modules[1].name = "bar";
  initial.modules[1].base = 0x43567;
  initial.stopped_thread_koids.push_back(34);
  initial.stopped_thread_koids.push_back(96);

  NotifyModules second;
  ASSERT_TRUE(SerializeDeserializeNotification(
      initial, &second, &WriteNotifyModules, &ReadNotifyModules));

  EXPECT_EQ(initial.process_koid, second.process_koid);
  ASSERT_EQ(initial.modules.size(), second.modules.size());
  EXPECT_EQ(initial.modules[0].name, second.modules[0].name);
  EXPECT_EQ(initial.modules[0].base, second.modules[0].base);
  EXPECT_EQ(initial.modules[1].name, second.modules[1].name);
  EXPECT_EQ(initial.modules[1].base, second.modules[1].base);
  EXPECT_EQ(initial.stopped_thread_koids, second.stopped_thread_koids);
}

}  // namespace debug_ipc