// Copyright 2019 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 "interception_workflow_test.h"

namespace fidlcat {

// zx_object_wait_one tests.

std::unique_ptr<SystemCallTest> ZxObjectWaitOne(int64_t result, std::string_view result_name,
                                                zx_handle_t handle, zx_signals_t signals,
                                                zx_time_t deadline, zx_signals_t* observed) {
  auto value = std::make_unique<SystemCallTest>("zx_object_wait_one", result, result_name);
  value->AddInput(handle);
  value->AddInput(signals);
  value->AddInput(deadline);
  value->AddInput(reinterpret_cast<uint64_t>(observed));
  return value;
}

#define OBJECT_WAIT_ONE_DISPLAY_TEST_CONTENT(result, expected)                                  \
  zx_signals_t observed = __ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE;                          \
  auto value =                                                                                  \
      ZxObjectWaitOne(result, #result, kHandle, __ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED, \
                      ZX_TIME_INFINITE, &observed);                                             \
  PerformDisplayTest("zx_object_wait_one@plt", std::move(value), expected);

#define OBJECT_WAIT_ONE_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {               \
    OBJECT_WAIT_ONE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                         \
  TEST_F(InterceptionWorkflowTestArm, name) {               \
    OBJECT_WAIT_ONE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_WAIT_ONE_DISPLAY_TEST(ZxObjectWaitOne, ZX_OK,
                             "\n"
                             "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
                             "zx_object_wait_one("
                             "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
                             "signals:\x1B[32msignals\x1B[0m: \x1B[34m"
                             "__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m, "
                             "deadline:\x1B[32mtime\x1B[0m: \x1B[34mZX_TIME_INFINITE\x1B[0m)\n"
                             "  -> \x1B[32mZX_OK\x1B[0m ("
                             "observed:\x1B[32msignals\x1B[0m: "
                             "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE\x1B[0m)\n");

// zx_object_wait_many tests.

std::unique_ptr<SystemCallTest> ZxObjectWaitMany(int64_t result, std::string_view result_name,
                                                 zx_wait_item_t* items, size_t count,
                                                 zx_time_t deadline) {
  auto value = std::make_unique<SystemCallTest>("zx_object_wait_many", result, result_name);
  value->AddInput(reinterpret_cast<uint64_t>(items));
  value->AddInput(count);
  value->AddInput(deadline);
  return value;
}

#define OBJECT_WAIT_MANY_DISPLAY_TEST_CONTENT(result, item_count, canceled, expected)             \
  size_t count;                                                                                   \
  zx_wait_item* items;                                                                            \
  if ((item_count) == -1) {                                                                       \
    count = 0;                                                                                    \
    items = nullptr;                                                                              \
  } else {                                                                                        \
    count = (item_count);                                                                         \
    items = new zx_wait_item_t[count];                                                            \
    for (size_t i = 0; i < count; ++i) {                                                          \
      items[i].handle = kHandle + i;                                                              \
      items[i].waitfor = __ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED;                          \
      items[i].pending = 0;                                                                       \
    }                                                                                             \
  }                                                                                               \
  auto value = ZxObjectWaitMany(result, #result, items, count, ZX_TIME_INFINITE);                 \
  update_data_ = [items, count]() {                                                               \
    for (size_t i = 0; i < count; ++i) {                                                          \
      items[i].pending =                                                                          \
          (canceled) ? __ZX_OBJECT_HANDLE_CLOSED : (__ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE); \
    }                                                                                             \
  };                                                                                              \
  PerformOneThreadDisplayTest("zx_object_wait_many@plt", std::move(value), expected);             \
  delete[] items;

#define OBJECT_WAIT_MANY_DISPLAY_TEST(name, errno, item_count, canceled, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                      \
    OBJECT_WAIT_MANY_DISPLAY_TEST_CONTENT(errno, item_count, canceled, expected);  \
  }                                                                                \
  TEST_F(InterceptionWorkflowTestArm, name) {                                      \
    OBJECT_WAIT_MANY_DISPLAY_TEST_CONTENT(errno, item_count, canceled, expected);  \
  }

OBJECT_WAIT_MANY_DISPLAY_TEST(
    ZxObjectWaitManyNull, ZX_OK, -1, false,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_wait_many("
    "deadline:\x1B[32mtime\x1B[0m: \x1B[34mZX_TIME_INFINITE\x1B[0m)\n"
    "    items:\x1B[32mzx_wait_item_t\x1B[0m[]: \x1B[31mnullptr\x1B[0m\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      items:\x1B[32mzx_wait_item_t\x1B[0m[]: \x1B[31mnullptr\x1B[0m\n");

OBJECT_WAIT_MANY_DISPLAY_TEST(
    ZxObjectWaitManyZero, ZX_OK, 0, false,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_wait_many("
    "deadline:\x1B[32mtime\x1B[0m: \x1B[34mZX_TIME_INFINITE\x1B[0m)\n"
    "    items:\x1B[32mzx_wait_item_t\x1B[0m[]: \x1B[31mnullptr\x1B[0m\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      items:\x1B[32mzx_wait_item_t\x1B[0m[]: \x1B[31mnullptr\x1B[0m\n");

OBJECT_WAIT_MANY_DISPLAY_TEST(ZxObjectWaitMany, ZX_OK, 3, false,
                              "\n"
                              "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
                              "zx_object_wait_many("
                              "deadline:\x1B[32mtime\x1B[0m: \x1B[34mZX_TIME_INFINITE\x1B[0m)\n"
                              "    items:\x1B[32mzx_wait_item_t\x1B[0m[]:  {\n"
                              "      {\n"
                              "        handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m\n"
                              "        waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "        pending:\x1B[32msignals\x1B[0m: \x1B[34m0\x1B[0m\n"
                              "      },\n"
                              "      {\n"
                              "        handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db1\x1B[0m\n"
                              "        waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "        pending:\x1B[32msignals\x1B[0m: \x1B[34m0\x1B[0m\n"
                              "      },\n"
                              "      {\n"
                              "        handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db2\x1B[0m\n"
                              "        waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "        pending:\x1B[32msignals\x1B[0m: \x1B[34m0\x1B[0m\n"
                              "      }\n"
                              "    }\n"
                              "  -> \x1B[32mZX_OK\x1B[0m\n"
                              "      items:\x1B[32mzx_wait_item_t\x1B[0m[]:  {\n"
                              "        {\n"
                              "          handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m\n"
                              "          waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "          pending:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE\x1B[0m\n"
                              "        },\n"
                              "        {\n"
                              "          handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db1\x1B[0m\n"
                              "          waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "          pending:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE\x1B[0m\n"
                              "        },\n"
                              "        {\n"
                              "          handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db2\x1B[0m\n"
                              "          waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "          pending:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_WRITABLE\x1B[0m\n"
                              "        }\n"
                              "      }\n");

OBJECT_WAIT_MANY_DISPLAY_TEST(ZxObjectWaitManyCanceled, ZX_ERR_CANCELED, 1, true,
                              "\n"
                              "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
                              "zx_object_wait_many("
                              "deadline:\x1B[32mtime\x1B[0m: \x1B[34mZX_TIME_INFINITE\x1B[0m)\n"
                              "    items:\x1B[32mzx_wait_item_t\x1B[0m[]:  {\n"
                              "      {\n"
                              "        handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m\n"
                              "        waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "        pending:\x1B[32msignals\x1B[0m: \x1B[34m0\x1B[0m\n"
                              "      }\n"
                              "    }\n"
                              "  -> \x1B[31mZX_ERR_CANCELED\x1B[0m\n"
                              "      items:\x1B[32mzx_wait_item_t\x1B[0m[]:  {\n"
                              "        {\n"
                              "          handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m\n"
                              "          waitfor:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m\n"
                              "          pending:\x1B[32msignals\x1B[0m: "
                              "\x1B[34m__ZX_OBJECT_HANDLE_CLOSED\x1B[0m\n"
                              "        }\n"
                              "      }\n");

// zx_object_wait_async tests.

std::unique_ptr<SystemCallTest> ZxObjectWaitAsync(int64_t result, std::string_view result_name,
                                                  zx_handle_t handle, zx_handle_t port,
                                                  uint64_t key, zx_signals_t signals,
                                                  uint32_t options) {
  auto value = std::make_unique<SystemCallTest>("zx_object_wait_async", result, result_name);
  value->AddInput(handle);
  value->AddInput(port);
  value->AddInput(key);
  value->AddInput(signals);
  value->AddInput(options);
  return value;
}

#define OBJECT_WAIT_ASYNC_DISPLAY_TEST_CONTENT(result, expected)                     \
  auto value = ZxObjectWaitAsync(result, #result, kHandle, kPort, kKey,              \
                                 __ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED, 0); \
  PerformDisplayTest("zx_object_wait_async@plt", std::move(value), expected);

#define OBJECT_WAIT_ASYNC_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                 \
    OBJECT_WAIT_ASYNC_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                           \
  TEST_F(InterceptionWorkflowTestArm, name) {                 \
    OBJECT_WAIT_ASYNC_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_WAIT_ASYNC_DISPLAY_TEST(ZxObjectWaitAsync, ZX_OK,
                               "\n"
                               "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
                               "zx_object_wait_async("
                               "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
                               "port:\x1B[32mhandle\x1B[0m: \x1B[31mdf0b2ec1\x1B[0m, "
                               "key:\x1B[32muint64\x1B[0m: \x1B[34m1234\x1B[0m, "
                               "signals:\x1B[32msignals\x1B[0m:"
                               " \x1B[34m__ZX_OBJECT_READABLE | __ZX_OBJECT_PEER_CLOSED\x1B[0m, "
                               "options:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m)\n"
                               "  -> \x1B[32mZX_OK\x1B[0m\n");

// zx_object_signal tests.

std::unique_ptr<SystemCallTest> ZxObjectSignal(int64_t result, std::string_view result_name,
                                               zx_handle_t handle, zx_signals_t clear_mask,
                                               zx_signals_t set_mask) {
  auto value = std::make_unique<SystemCallTest>("zx_object_signal", result, result_name);
  value->AddInput(handle);
  value->AddInput(clear_mask);
  value->AddInput(set_mask);
  return value;
}

#define OBJECT_SIGNAL_DISPLAY_TEST_CONTENT(result, expected)                                 \
  auto value = ZxObjectSignal(result, #result, kHandle, ZX_USER_SIGNAL_0 | ZX_USER_SIGNAL_3, \
                              ZX_USER_SIGNAL_5 | ZX_USER_SIGNAL_7);                          \
  PerformDisplayTest("zx_object_signal@plt", std::move(value), expected);

#define OBJECT_SIGNAL_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {             \
    OBJECT_SIGNAL_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                       \
  TEST_F(InterceptionWorkflowTestArm, name) { OBJECT_SIGNAL_DISPLAY_TEST_CONTENT(errno, expected); }

OBJECT_SIGNAL_DISPLAY_TEST(
    ZxObjectSignal, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_signal("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "clear_mask:\x1B[32msignals\x1B[0m: \x1B[34mZX_USER_SIGNAL_0 | ZX_USER_SIGNAL_3\x1B[0m, "
    "set_mask:\x1B[32msignals\x1B[0m: \x1B[34mZX_USER_SIGNAL_5 | ZX_USER_SIGNAL_7\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

// zx_object_signal_peer tests.

std::unique_ptr<SystemCallTest> ZxObjectSignalPeer(int64_t result, std::string_view result_name,
                                                   zx_handle_t handle, zx_signals_t clear_mask,
                                                   zx_signals_t set_mask) {
  auto value = std::make_unique<SystemCallTest>("zx_object_signal_peer", result, result_name);
  value->AddInput(handle);
  value->AddInput(clear_mask);
  value->AddInput(set_mask);
  return value;
}

#define OBJECT_SIGNAL_PEER_DISPLAY_TEST_CONTENT(result, expected)                                \
  auto value = ZxObjectSignalPeer(result, #result, kHandle, ZX_USER_SIGNAL_0 | ZX_USER_SIGNAL_3, \
                                  ZX_USER_SIGNAL_5 | ZX_USER_SIGNAL_7);                          \
  PerformDisplayTest("zx_object_signal_peer@plt", std::move(value), expected);

#define OBJECT_SIGNAL_PEER_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                  \
    OBJECT_SIGNAL_PEER_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                            \
  TEST_F(InterceptionWorkflowTestArm, name) {                  \
    OBJECT_SIGNAL_PEER_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SIGNAL_PEER_DISPLAY_TEST(
    ZxObjectSignalPeer, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_signal_peer("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "clear_mask:\x1B[32msignals\x1B[0m: \x1B[34mZX_USER_SIGNAL_0 | ZX_USER_SIGNAL_3\x1B[0m, "
    "set_mask:\x1B[32msignals\x1B[0m: \x1B[34mZX_USER_SIGNAL_5 | ZX_USER_SIGNAL_7\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

// zx_object_get_property tests.

std::unique_ptr<SystemCallTest> ZxObjectGetProperty(int64_t result, std::string_view result_name,
                                                    zx_handle_t handle, uint32_t property,
                                                    void* value, size_t value_size) {
  auto syscall = std::make_unique<SystemCallTest>("zx_object_get_property", result, result_name);
  syscall->AddInput(handle);
  syscall->AddInput(property);
  syscall->AddInput(reinterpret_cast<uint64_t>(value));
  syscall->AddInput(value_size);
  return syscall;
}

#define OBJECT_GET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(result, expected)                          \
  std::vector<char> buffer(ZX_MAX_NAME_LEN);                                                     \
  std::string data = "My_name";                                                                  \
  memcpy(buffer.data(), data.c_str(), data.size() + 1);                                          \
  PerformDisplayTest(                                                                            \
      "zx_object_get_property@plt",                                                              \
      ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_NAME, buffer.data(), buffer.size()), \
      expected);

#define OBJECT_GET_PROPERTY_NAME_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                        \
    OBJECT_GET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                  \
  TEST_F(InterceptionWorkflowTestArm, name) {                        \
    OBJECT_GET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_NAME_DISPLAY_TEST(
    ZxObjectGetPropertyName, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_NAME\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (value:\x1B[32mstring\x1B[0m: \x1B[31m\"My_name\"\x1B[0m)\n");

#define OBJECT_GET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(result, expected)          \
  uintptr_t value = 0x45678;                                                                   \
  PerformDisplayTest("zx_object_get_property@plt",                                             \
                     ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_PROCESS_DEBUG_ADDR, \
                                         &value, sizeof(value)),                               \
                     expected);

#define OBJECT_GET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                      \
    OBJECT_GET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                \
  TEST_F(InterceptionWorkflowTestArm, name) {                                      \
    OBJECT_GET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST(
    ZxObjectGetPropertyProcessDebugAddr, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_PROCESS_DEBUG_ADDR\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (value:\x1B[32mzx_vaddr_t\x1B[0m: "
    "\x1B[34m0000000000045678\x1B[0m)\n");

#define OBJECT_GET_PROPERTY_PROCESS_VDSO_BASE_ADDRESS_DISPLAY_TEST_CONTENT(result, expected)   \
  uintptr_t value = 0x45678;                                                                   \
  PerformDisplayTest(                                                                          \
      "zx_object_get_property@plt",                                                            \
      ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_PROCESS_VDSO_BASE_ADDRESS, &value, \
                          sizeof(value)),                                                      \
      expected);

#define OBJECT_GET_PROPERTY_PROCESS_VDSO_BASE_ADDRESS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                             \
    OBJECT_GET_PROPERTY_PROCESS_VDSO_BASE_ADDRESS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                       \
  TEST_F(InterceptionWorkflowTestArm, name) {                                             \
    OBJECT_GET_PROPERTY_PROCESS_VDSO_BASE_ADDRESS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_PROCESS_VDSO_BASE_ADDRESS_DISPLAY_TEST(
    ZxObjectGetPropertyProcessVdsoBaseAddress, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_PROCESS_VDSO_BASE_ADDRESS\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (value:\x1B[32mzx_vaddr_t\x1B[0m: "
    "\x1B[34m0000000000045678\x1B[0m)\n");

#define OBJECT_GET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(result, expected)          \
  size_t value = 1000;                                                                          \
  PerformDisplayTest("zx_object_get_property@plt",                                              \
                     ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_SOCKET_RX_THRESHOLD, \
                                         &value, sizeof(value)),                                \
                     expected);

#define OBJECT_GET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                       \
    OBJECT_GET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                 \
  TEST_F(InterceptionWorkflowTestArm, name) {                                       \
    OBJECT_GET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST(
    ZxObjectGetPropertySocketRxThreshold, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_SOCKET_RX_THRESHOLD\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (value:\x1B[32msize_t\x1B[0m: \x1B[34m1000\x1B[0m)\n");

#define OBJECT_GET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(result, expected)          \
  size_t value = 1000;                                                                          \
  PerformDisplayTest("zx_object_get_property@plt",                                              \
                     ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_SOCKET_TX_THRESHOLD, \
                                         &value, sizeof(value)),                                \
                     expected);

#define OBJECT_GET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                       \
    OBJECT_GET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                 \
  TEST_F(InterceptionWorkflowTestArm, name) {                                       \
    OBJECT_GET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST(
    ZxObjectGetPropertySocketTxThreshold, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_SOCKET_TX_THRESHOLD\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (value:\x1B[32msize_t\x1B[0m: \x1B[34m1000\x1B[0m)\n");

#define OBJECT_GET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(result, expected)          \
  uint32_t value = ZX_EXCEPTION_STATE_HANDLED;                                              \
  PerformDisplayTest("zx_object_get_property@plt",                                          \
                     ZxObjectGetProperty(result, #result, kHandle, ZX_PROP_EXCEPTION_STATE, \
                                         &value, sizeof(value)),                            \
                     expected);

#define OBJECT_GET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                   \
    OBJECT_GET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                                   \
    OBJECT_GET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST(
    ZxObjectGetPropertyExceptionState, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_EXCEPTION_STATE\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m ("
    "value:\x1B[32mzx_exception_state_t\x1B[0m: \x1B[34mZX_EXCEPTION_STATE_HANDLED\x1B[0m)\n");

// zx_object_set_property tests.

std::unique_ptr<SystemCallTest> ZxObjectSetProperty(int64_t result, std::string_view result_name,
                                                    zx_handle_t handle, uint32_t property,
                                                    const void* value, size_t value_size) {
  auto syscall = std::make_unique<SystemCallTest>("zx_object_set_property", result, result_name);
  syscall->AddInput(handle);
  syscall->AddInput(property);
  syscall->AddInput(reinterpret_cast<uint64_t>(value));
  syscall->AddInput(value_size);
  return syscall;
}

#define OBJECT_SET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(result, expected)                          \
  std::vector<char> buffer(ZX_MAX_NAME_LEN);                                                     \
  std::string data = "My_name";                                                                  \
  memcpy(buffer.data(), data.c_str(), data.size() + 1);                                          \
  PerformDisplayTest(                                                                            \
      "zx_object_set_property@plt",                                                              \
      ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_NAME, buffer.data(), buffer.size()), \
      expected);

#define OBJECT_SET_PROPERTY_NAME_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                        \
    OBJECT_SET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                  \
  TEST_F(InterceptionWorkflowTestArm, name) {                        \
    OBJECT_SET_PROPERTY_NAME_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_NAME_DISPLAY_TEST(
    ZxObjectSetPropertyName, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_NAME\x1B[0m, "
    "value:\x1B[32mstring\x1B[0m: \x1B[31m\"My_name\"\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_REGISTER_FS_DISPLAY_TEST_CONTENT(result, expected)                   \
  uintptr_t value = 0x45678;                                                                     \
  PerformDisplayTest(                                                                            \
      "zx_object_set_property@plt",                                                              \
      ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_REGISTER_FS, &value, sizeof(value)), \
      expected);

#define OBJECT_SET_PROPERTY_REGISTER_FS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                               \
    OBJECT_SET_PROPERTY_REGISTER_FS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                         \
  TEST_F(InterceptionWorkflowTestArm, name) {                               \
    OBJECT_SET_PROPERTY_REGISTER_FS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_REGISTER_FS_DISPLAY_TEST(
    ZxObjectSetPropertyRegisterFs, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_REGISTER_FS\x1B[0m, "
    "value:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000045678\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_REGISTER_GS_DISPLAY_TEST_CONTENT(result, expected)                   \
  uintptr_t value = 0x45678;                                                                     \
  PerformDisplayTest(                                                                            \
      "zx_object_set_property@plt",                                                              \
      ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_REGISTER_GS, &value, sizeof(value)), \
      expected);

#define OBJECT_SET_PROPERTY_REGISTER_GS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                               \
    OBJECT_SET_PROPERTY_REGISTER_GS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                         \
  TEST_F(InterceptionWorkflowTestArm, name) {                               \
    OBJECT_SET_PROPERTY_REGISTER_GS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_REGISTER_GS_DISPLAY_TEST(
    ZxObjectSetPropertyRegisterGs, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_REGISTER_GS\x1B[0m, "
    "value:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000045678\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(result, expected)          \
  uintptr_t value = 0x45678;                                                                   \
  PerformDisplayTest("zx_object_set_property@plt",                                             \
                     ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_PROCESS_DEBUG_ADDR, \
                                         &value, sizeof(value)),                               \
                     expected);

#define OBJECT_SET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                      \
    OBJECT_SET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                \
  TEST_F(InterceptionWorkflowTestArm, name) {                                      \
    OBJECT_SET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_PROCESS_DEBUG_ADDR_DISPLAY_TEST(
    ZxObjectSetPropertyProcessDebugAddr, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_PROCESS_DEBUG_ADDR\x1B[0m, "
    "value:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000045678\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(result, expected)          \
  size_t value = 1000;                                                                          \
  PerformDisplayTest("zx_object_set_property@plt",                                              \
                     ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_SOCKET_RX_THRESHOLD, \
                                         &value, sizeof(value)),                                \
                     expected);

#define OBJECT_SET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                       \
    OBJECT_SET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                 \
  TEST_F(InterceptionWorkflowTestArm, name) {                                       \
    OBJECT_SET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_SOCKET_RX_THRESHOLD_DISPLAY_TEST(
    ZxObjectSetPropertySocketRxThreshold, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_SOCKET_RX_THRESHOLD\x1B[0m, "
    "value:\x1B[32msize_t\x1B[0m: \x1B[34m1000\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(result, expected)          \
  size_t value = 1000;                                                                          \
  PerformDisplayTest("zx_object_set_property@plt",                                              \
                     ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_SOCKET_TX_THRESHOLD, \
                                         &value, sizeof(value)),                                \
                     expected);

#define OBJECT_SET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                       \
    OBJECT_SET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                                 \
  TEST_F(InterceptionWorkflowTestArm, name) {                                       \
    OBJECT_SET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_SOCKET_TX_THRESHOLD_DISPLAY_TEST(
    ZxObjectSetPropertySocketTxThreshold, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_SOCKET_TX_THRESHOLD\x1B[0m, "
    "value:\x1B[32msize_t\x1B[0m: \x1B[34m1000\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_JOB_KILL_ON_OOM_DISPLAY_TEST_CONTENT(result, expected)          \
  size_t value = 1;                                                                         \
  PerformDisplayTest("zx_object_set_property@plt",                                          \
                     ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_JOB_KILL_ON_OOM, \
                                         &value, sizeof(value)),                            \
                     expected);

#define OBJECT_SET_PROPERTY_JOB_KILL_ON_OOM_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                   \
    OBJECT_SET_PROPERTY_JOB_KILL_ON_OOM_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                                   \
    OBJECT_SET_PROPERTY_JOB_KILL_ON_OOM_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_JOB_KILL_ON_OOM_DISPLAY_TEST(
    ZxObjectSetPropertyJobKillOnOom, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_JOB_KILL_ON_OOM\x1B[0m, "
    "value:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

#define OBJECT_SET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(result, expected)          \
  uint32_t value = ZX_EXCEPTION_STATE_HANDLED;                                              \
  PerformDisplayTest("zx_object_set_property@plt",                                          \
                     ZxObjectSetProperty(result, #result, kHandle, ZX_PROP_EXCEPTION_STATE, \
                                         &value, sizeof(value)),                            \
                     expected);

#define OBJECT_SET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                   \
    OBJECT_SET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                                   \
    OBJECT_SET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROPERTY_EXCEPTION_STATE_DISPLAY_TEST(
    ZxObjectSetPropertyExceptionState, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_property("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "property:\x1B[32mzx_prop_type_t\x1B[0m: \x1B[34mZX_PROP_EXCEPTION_STATE\x1B[0m, "
    "value:\x1B[32mzx_exception_state_t\x1B[0m: \x1B[34mZX_EXCEPTION_STATE_HANDLED\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

// zx_object_get_info tests.

std::unique_ptr<SystemCallTest> ZxObjectGetInfo(int64_t result, std::string_view result_name,
                                                zx_handle_t handle, uint32_t topic, void* buffer,
                                                size_t buffer_size, size_t* actual, size_t* avail) {
  auto value = std::make_unique<SystemCallTest>("zx_object_get_info", result, result_name);
  value->AddInput(handle);
  value->AddInput(topic);
  value->AddInput(reinterpret_cast<uint64_t>(buffer));
  value->AddInput(buffer_size);
  value->AddInput(reinterpret_cast<uint64_t>(actual));
  value->AddInput(reinterpret_cast<uint64_t>(avail));
  return value;
}

#define OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST_CONTENT(result, expected)                \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_HANDLE_VALID, nullptr, 0, \
                               nullptr, nullptr);                                          \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST(
    ZxObjectGetInfoHandleValidOk, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_HANDLE_VALID\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m0\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

OBJECT_GET_INFO_HANDLE_VALID_DISPLAY_TEST(
    ZxObjectGetInfoHandleValidBad, ZX_ERR_BAD_HANDLE,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_HANDLE_VALID\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m0\x1B[0m)\n"
    "  -> \x1B[31mZX_ERR_BAD_HANDLE\x1B[0m\n");

#define OBJECT_GET_INFO_HANDLE_BASIC_DISPLAY_TEST_CONTENT(result, expected)                   \
  zx_info_handle_basic_t buffer;                                                              \
  buffer.koid = kKoid;                                                                        \
  buffer.rights = ZX_RIGHT_DUPLICATE | ZX_RIGHT_TRANSFER | ZX_RIGHT_WRITE | ZX_RIGHT_SIGNAL | \
                  ZX_RIGHT_WAIT | ZX_RIGHT_INSPECT;                                           \
  buffer.type = ZX_OBJ_TYPE_LOG;                                                              \
  buffer.related_koid = 0;                                                                    \
  buffer.props = ZX_OBJ_PROP_WAITABLE;                                                        \
  auto value =                                                                                \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_HANDLE_BASIC,                         \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr);    \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_HANDLE_BASIC_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_HANDLE_BASIC_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_HANDLE_BASIC_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_HANDLE_BASIC_DISPLAY_TEST(
    ZxObjectGetInfoHandleBasic, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_HANDLE_BASIC\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m32\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_handle_basic_t\x1B[0m: {\n"
    "        koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m4252\x1B[0m\n"
    "        rights:\x1B[32mzx_rights_t\x1B[0m: \x1B[34mZX_RIGHT_DUPLICATE | ZX_RIGHT_TRANSFER | "
    "ZX_RIGHT_WRITE | ZX_RIGHT_SIGNAL | ZX_RIGHT_WAIT | ZX_RIGHT_INSPECT\x1B[0m\n"
    "        type:\x1B[32mzx_obj_type_t\x1B[0m: \x1B[34mZX_OBJ_TYPE_LOG\x1B[0m\n"
    "        related_koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m0\x1B[0m\n"
    "        props:\x1B[32mzx_obj_props_t\x1B[0m: \x1B[34mZX_OBJ_PROP_WAITABLE\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_HANDLE_COUNT_DISPLAY_TEST_CONTENT(result, expected)                \
  zx_info_handle_count_t buffer;                                                           \
  buffer.handle_count = 2;                                                                 \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_HANDLE_COUNT,                      \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_HANDLE_COUNT_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_HANDLE_COUNT_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_HANDLE_COUNT_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_HANDLE_COUNT_DISPLAY_TEST(
    ZxObjectGetInfoHandleCount, ZX_OK,
    "\ntest_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_HANDLE_COUNT\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m4\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_handle_count_t\x1B[0m: {\n"
    "        handle_count:\x1B[32muint32\x1B[0m: \x1B[34m2\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_PROCESS_HANDLE_STATS_DISPLAY_TEST_CONTENT(result, expected)        \
  zx_info_process_handle_stats_t buffer;                                                   \
  memset(&buffer, 0, sizeof(buffer));                                                      \
  buffer.handle_count[ZX_OBJ_TYPE_THREAD] = 3;                                             \
  buffer.handle_count[ZX_OBJ_TYPE_SOCKET] = 2;                                             \
  buffer.handle_count[ZX_OBJ_TYPE_TIMER] = 1;                                              \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_PROCESS_HANDLE_STATS,              \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_PROCESS_HANDLE_STATS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                                    \
    OBJECT_GET_INFO_PROCESS_HANDLE_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                              \
  TEST_F(InterceptionWorkflowTestArm, name) {                                    \
    OBJECT_GET_INFO_PROCESS_HANDLE_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_PROCESS_HANDLE_STATS_DISPLAY_TEST(
    ZxObjectGetInfoProcessHandleStats, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_PROCESS_HANDLE_STATS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m256\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_process_handle_stats_t\x1B[0m: {\n"
    "        handle_count:\x1B[32muint32[]\x1B[0m: "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m3\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m2\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m1\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, "
    "\x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m, \x1B[34m0\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_JOB_DISPLAY_TEST_CONTENT(result, expected)                             \
  zx_info_job_t buffer;                                                                        \
  buffer.return_code = -1;                                                                     \
  buffer.exited = true;                                                                        \
  buffer.kill_on_oom = false;                                                                  \
  buffer.debugger_attached = false;                                                            \
  auto value =                                                                                 \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_JOB, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                       \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_JOB_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                   \
    OBJECT_GET_INFO_JOB_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                   \
    OBJECT_GET_INFO_JOB_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_JOB_DISPLAY_TEST(
    ZxObjectGetInfoJob, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_JOB\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m16\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_job_t\x1B[0m: {\n"
    "        return_code:\x1B[32mint64\x1B[0m: \x1B[34m-1\x1B[0m\n"
    "        exited:\x1B[32mbool\x1B[0m: \x1B[34mtrue\x1B[0m\n"
    "        kill_on_oom:\x1B[32mbool\x1B[0m: \x1B[34mfalse\x1B[0m\n"
    "        debugger_attached:\x1B[32mbool\x1B[0m: \x1B[34mfalse\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_PROCESS_DISPLAY_TEST_CONTENT(result, expected)                             \
  zx_info_process_t buffer;                                                                        \
  buffer.return_code = -1;                                                                         \
  buffer.started = true;                                                                           \
  buffer.exited = true;                                                                            \
  buffer.debugger_attached = false;                                                                \
  auto value =                                                                                     \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_PROCESS, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                           \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_PROCESS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                       \
    OBJECT_GET_INFO_PROCESS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                 \
  TEST_F(InterceptionWorkflowTestArm, name) {                       \
    OBJECT_GET_INFO_PROCESS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_PROCESS_DISPLAY_TEST(
    ZxObjectGetInfoProcess, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_PROCESS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m16\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_process_t\x1B[0m: {\n"
    "        return_code:\x1B[32mint64\x1B[0m: \x1B[34m-1\x1B[0m\n"
    "        started:\x1B[32mbool\x1B[0m: \x1B[34mtrue\x1B[0m\n"
    "        exited:\x1B[32mbool\x1B[0m: \x1B[34mtrue\x1B[0m\n"
    "        debugger_attached:\x1B[32mbool\x1B[0m: \x1B[34mfalse\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_PROCESS_THREADS_DISPLAY_TEST_CONTENT(result, expected)      \
  constexpr zx_koid_t kThread1 = 1111;                                              \
  constexpr zx_koid_t kThread2 = 2222;                                              \
  constexpr zx_koid_t kThread3 = 3333;                                              \
  std::vector<zx_koid_t> buffer = {kThread1, kThread2, kThread3};                   \
  size_t actual = buffer.size();                                                    \
  size_t avail = buffer.size() + 2;                                                 \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_PROCESS_THREADS,   \
                               reinterpret_cast<void*>(buffer.data()),              \
                               buffer.size() * sizeof(zx_koid_t), &actual, &avail); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_PROCESS_THREADS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                               \
    OBJECT_GET_INFO_PROCESS_THREADS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                         \
  TEST_F(InterceptionWorkflowTestArm, name) {                               \
    OBJECT_GET_INFO_PROCESS_THREADS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_PROCESS_THREADS_DISPLAY_TEST(
    ZxObjectGetInfoProcessThreads, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_PROCESS_THREADS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m24\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (actual:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m/\x1B[34m5\x1B[0m)\n"
    "      info:\x1B[32mzx_koid_t\x1B[0m: "
    "\x1B[31m1111\x1B[0m, \x1B[31m2222\x1B[0m, \x1B[31m3333\x1B[0m\n");

#define OBJECT_GET_INFO_THREAD_DISPLAY_TEST_CONTENT(result, expected)                             \
  zx_info_thread_t buffer;                                                                        \
  buffer.state = ZX_THREAD_STATE_BLOCKED_EXCEPTION;                                               \
  buffer.wait_exception_channel_type = ZX_EXCEPTION_CHANNEL_TYPE_THREAD;                          \
  memset(&buffer.cpu_affinity_mask, 0, sizeof(buffer.cpu_affinity_mask));                         \
  buffer.cpu_affinity_mask.mask[0] = 0xe;                                                         \
  auto value =                                                                                    \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_THREAD, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                          \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_THREAD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                      \
    OBJECT_GET_INFO_THREAD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                \
  TEST_F(InterceptionWorkflowTestArm, name) {                      \
    OBJECT_GET_INFO_THREAD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_THREAD_DISPLAY_TEST(
    ZxObjectGetInfoThread, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_THREAD\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m72\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_thread_t\x1B[0m: {\n"
    "        state:\x1B[32mzx_info_thread_t::state\x1B[0m: "
    "\x1B[34mZX_THREAD_STATE_BLOCKED_EXCEPTION\x1B[0m\n"
    "        "
    "wait_exception_channel_type:\x1B[32mzx_info_thread_t::wait_exception_port_type\x1B[0m: "
    "\x1B[34mZX_EXCEPTION_CHANNEL_TYPE_THREAD\x1B[0m\n"
    "        cpu_affinity_mask:\x1B[32mzx_cpu_set_t\x1B[0m: {\n"
    "          mask:\x1B[32muint64[]\x1B[0m: "
    "\x1B[34m000000000000000e\x1B[0m, \x1B[34m0000000000000000\x1B[0m, "
    "\x1B[34m0000000000000000\x1B[0m, \x1B[34m0000000000000000\x1B[0m, "
    "\x1B[34m0000000000000000\x1B[0m, \x1B[34m0000000000000000\x1B[0m, "
    "\x1B[34m0000000000000000\x1B[0m, \x1B[34m0000000000000000\x1B[0m\n"
    "        }\n"
    "      }\n");

#define OBJECT_GET_INFO_THREAD_STATS_DISPLAY_TEST_CONTENT(result, expected)                \
  zx_info_thread_stats_t buffer;                                                           \
  buffer.total_runtime = ZX_SEC(3664) + 1234;                                              \
  buffer.last_scheduled_cpu = 1;                                                           \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_THREAD_STATS,                      \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_THREAD_STATS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_THREAD_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_THREAD_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_THREAD_STATS_DISPLAY_TEST(
    ZxObjectGetInfoThreadStats, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_THREAD_STATS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m16\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_thread_stats_t\x1B[0m: {\n"
    "        total_runtime:\x1B[32mduration\x1B[0m: "
    "\x1B[34m1 hours, 1 minutes, 4 seconds and 1234 nano seconds\x1B[0m\n"
    "        last_scheduled_cpu:\x1B[32muint32\x1B[0m: \x1B[34m1\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_CPU_STATS_DISPLAY_TEST_CONTENT(result, expected)                   \
  constexpr zx_duration_t kIdleTime = ZX_SEC(50) + 567;                                    \
  constexpr uint64_t kReschedules = 321;                                                   \
  constexpr uint64_t kContextSwitches = 130;                                               \
  constexpr uint64_t kIrqPreempts = 10;                                                    \
  constexpr uint64_t kPreempts = 20;                                                       \
  constexpr uint64_t kYields = 5;                                                          \
  constexpr uint64_t kInts = 3;                                                            \
  constexpr uint64_t kTimerInts = 1;                                                       \
  constexpr uint64_t kTimers = 1;                                                          \
  constexpr uint64_t kSyscalls = 15;                                                       \
  constexpr uint64_t kRecheduleIpis = 2;                                                   \
  constexpr uint64_t kGenericIpis = 1;                                                     \
  zx_info_cpu_stats_t buffer;                                                              \
  buffer.cpu_number = 1;                                                                   \
  buffer.flags = 0;                                                                        \
  buffer.idle_time = kIdleTime;                                                            \
  buffer.reschedules = kReschedules;                                                       \
  buffer.context_switches = kContextSwitches;                                              \
  buffer.irq_preempts = kIrqPreempts;                                                      \
  buffer.preempts = kPreempts;                                                             \
  buffer.yields = kYields;                                                                 \
  buffer.ints = kInts;                                                                     \
  buffer.timer_ints = kTimerInts;                                                          \
  buffer.timers = kTimers;                                                                 \
  buffer.syscalls = kSyscalls;                                                             \
  buffer.reschedule_ipis = kRecheduleIpis;                                                 \
  buffer.generic_ipis = kGenericIpis;                                                      \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_CPU_STATS,                         \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_CPU_STATS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                         \
    OBJECT_GET_INFO_CPU_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                   \
  TEST_F(InterceptionWorkflowTestArm, name) {                         \
    OBJECT_GET_INFO_CPU_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_CPU_STATS_DISPLAY_TEST(
    ZxObjectGetInfoCpuStats, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_CPU_STATS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m120\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_cpu_stats_t\x1B[0m: {\n"
    "        cpu_number:\x1B[32muint32\x1B[0m: \x1B[34m1\x1B[0m\n"
    "        flags:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m\n"
    "        idle_time:\x1B[32mduration\x1B[0m: \x1B[34m50 seconds and 567 nano seconds\x1B[0m\n"
    "        reschedules:\x1B[32muint64\x1B[0m: \x1B[34m321\x1B[0m\n"
    "        context_switches:\x1B[32muint64\x1B[0m: \x1B[34m130\x1B[0m\n"
    "        irq_preempts:\x1B[32muint64\x1B[0m: \x1B[34m10\x1B[0m\n"
    "        preempts:\x1B[32muint64\x1B[0m: \x1B[34m20\x1B[0m\n"
    "        yields:\x1B[32muint64\x1B[0m: \x1B[34m5\x1B[0m\n"
    "        ints:\x1B[32muint64\x1B[0m: \x1B[34m3\x1B[0m\n"
    "        timer_ints:\x1B[32muint64\x1B[0m: \x1B[34m1\x1B[0m\n"
    "        timers:\x1B[32muint64\x1B[0m: \x1B[34m1\x1B[0m\n"
    "        syscalls:\x1B[32muint64\x1B[0m: \x1B[34m15\x1B[0m\n"
    "        reschedule_ipis:\x1B[32muint64\x1B[0m: \x1B[34m2\x1B[0m\n"
    "        generic_ipis:\x1B[32muint64\x1B[0m: \x1B[34m1\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_VMAR_DISPLAY_TEST_CONTENT(result, expected)                             \
  constexpr uintptr_t kBase = 0x124680aceUL;                                                    \
  constexpr size_t kLen = 4096;                                                                 \
  zx_info_vmar_t buffer;                                                                        \
  buffer.base = kBase;                                                                          \
  buffer.len = kLen;                                                                            \
  auto value =                                                                                  \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_VMAR, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                        \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_VMAR_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                    \
    OBJECT_GET_INFO_VMAR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                              \
  TEST_F(InterceptionWorkflowTestArm, name) {                    \
    OBJECT_GET_INFO_VMAR_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_VMAR_DISPLAY_TEST(
    ZxObjectGetInfoVmar, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_VMAR\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m16\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_vmar_t\x1B[0m: {\n"
    "        base:\x1B[32muintptr_t\x1B[0m: \x1B[34m0000000124680ace\x1B[0m\n"
    "        len:\x1B[32msize_t\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_VMO_DISPLAY_TEST_CONTENT(result, expected)                             \
  constexpr size_t kSizeBytes = 4000;                                                          \
  constexpr size_t kCommittedBytes = 4096;                                                     \
  zx_info_vmo_t buffer{                                                                        \
      .koid = kKoid,                                                                           \
      .name = "my_vmo",                                                                        \
      .size_bytes = kSizeBytes,                                                                \
      .parent_koid = 0,                                                                        \
      .num_children = 2,                                                                       \
      .num_mappings = 1,                                                                       \
      .share_count = 3,                                                                        \
      .flags = ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE | ZX_INFO_VMO_CONTIGUOUS,        \
      .committed_bytes = kCommittedBytes,                                                      \
      .handle_rights = 0,                                                                      \
      .cache_policy = ZX_CACHE_POLICY_CACHED};                                                 \
  auto value =                                                                                 \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_VMO, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                       \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_VMO_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                   \
    OBJECT_GET_INFO_VMO_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                   \
    OBJECT_GET_INFO_VMO_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_VMO_DISPLAY_TEST(
    ZxObjectGetInfoVmo, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_VMO\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m104\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_vmo_t\x1B[0m: {\n"
    "        koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m4252\x1B[0m\n"
    "        name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"my_vmo\"\x1B[0m\n"
    "        size_bytes:\x1B[32muint64\x1B[0m: \x1B[34m4000\x1B[0m\n"
    "        parent_koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m0\x1B[0m\n"
    "        num_children:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m\n"
    "        num_mappings:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m\n"
    "        share_count:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m\n"
    "        flags:\x1B[32mzx_info_vmo_type_t\x1B[0m: "
    "\x1B[34mZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE | ZX_INFO_VMO_CONTIGUOUS\x1B[0m\n"
    "        committed_bytes:\x1B[32muint64\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "        handle_rights:\x1B[32mzx_rights_t\x1B[0m: \x1B[34mZX_RIGHT_NONE\x1B[0m\n"
    "        cache_policy:\x1B[32mzx_cache_policy_t\x1B[0m: \x1B[31mZX_CACHE_POLICY_CACHED\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_SOCKET_DISPLAY_TEST_CONTENT(result, expected)                             \
  constexpr size_t kRxBufMax = 8192;                                                              \
  constexpr size_t kRxBufSize = 4096;                                                             \
  constexpr size_t kRxBufAvailable = 4002;                                                        \
  constexpr size_t kTxBufMax = 8192;                                                              \
  constexpr size_t kTxBufSize = 4096;                                                             \
  zx_info_socket_t buffer;                                                                        \
  buffer.options = 0;                                                                             \
  buffer.rx_buf_max = kRxBufMax;                                                                  \
  buffer.rx_buf_size = kRxBufSize;                                                                \
  buffer.rx_buf_available = kRxBufAvailable;                                                      \
  buffer.tx_buf_max = kTxBufMax;                                                                  \
  buffer.tx_buf_size = kTxBufSize;                                                                \
  auto value =                                                                                    \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_SOCKET, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                          \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_SOCKET_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                      \
    OBJECT_GET_INFO_SOCKET_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                \
  TEST_F(InterceptionWorkflowTestArm, name) {                      \
    OBJECT_GET_INFO_SOCKET_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_SOCKET_DISPLAY_TEST(
    ZxObjectGetInfoSocket, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_SOCKET\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m48\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_socket_t\x1B[0m: {\n"
    "        options:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m\n"
    "        rx_buf_max:\x1B[32msize_t\x1B[0m: \x1B[34m8192\x1B[0m\n"
    "        rx_buf_size:\x1B[32msize_t\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "        rx_buf_available:\x1B[32msize_t\x1B[0m: \x1B[34m4002\x1B[0m\n"
    "        tx_buf_max:\x1B[32msize_t\x1B[0m: \x1B[34m8192\x1B[0m\n"
    "        tx_buf_size:\x1B[32msize_t\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_TIMER_DISPLAY_TEST_CONTENT(result, expected)                             \
  constexpr int kDeadline = 1000;                                                                \
  constexpr zx_duration_t kSlack = 100;                                                          \
  zx_info_timer_t buffer;                                                                        \
  buffer.options = 0;                                                                            \
  buffer.deadline = ZX_SEC(kDeadline);                                                           \
  buffer.slack = kSlack;                                                                         \
  auto value =                                                                                   \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_TIMER, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                         \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_TIMER_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                     \
    OBJECT_GET_INFO_TIMER_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                               \
  TEST_F(InterceptionWorkflowTestArm, name) {                     \
    OBJECT_GET_INFO_TIMER_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_TIMER_DISPLAY_TEST(
    ZxObjectGetInfoTimer, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mtopic=25\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m24\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_timer_t\x1B[0m: {\n"
    "        options:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m\n"
    "        deadline:\x1B[32mzx_time_t\x1B[0m: \x1B[34m16 minutes, 40 seconds\x1B[0m\n"
    "        slack:\x1B[32mduration\x1B[0m: \x1B[34m100 nano seconds\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_JOB_CHILDREN_DISPLAY_TEST_CONTENT(result, expected)         \
  constexpr zx_koid_t kThread1 = 1111;                                              \
  constexpr zx_koid_t kThread2 = 2222;                                              \
  constexpr zx_koid_t kThread3 = 3333;                                              \
  std::vector<zx_koid_t> buffer = {kThread1, kThread2, kThread3};                   \
  size_t actual = buffer.size();                                                    \
  size_t avail = buffer.size() + 2;                                                 \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_JOB_CHILDREN,      \
                               reinterpret_cast<void*>(buffer.data()),              \
                               buffer.size() * sizeof(zx_koid_t), &actual, &avail); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_JOB_CHILDREN_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_JOB_CHILDREN_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_JOB_CHILDREN_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_JOB_CHILDREN_DISPLAY_TEST(
    ZxObjectGetInfoJobChildren, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_JOB_CHILDREN\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m24\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (actual:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m/\x1B[34m5\x1B[0m)\n"
    "      info:\x1B[32mzx_koid_t\x1B[0m: "
    "\x1B[31m1111\x1B[0m, \x1B[31m2222\x1B[0m, \x1B[31m3333\x1B[0m\n");

#define OBJECT_GET_INFO_JOB_PROCESSES_DISPLAY_TEST_CONTENT(result, expected)        \
  constexpr zx_koid_t kThread1 = 1111;                                              \
  constexpr zx_koid_t kThread2 = 2222;                                              \
  constexpr zx_koid_t kThread3 = 3333;                                              \
  std::vector<zx_koid_t> buffer = {kThread1, kThread2, kThread3};                   \
  size_t actual = buffer.size();                                                    \
  size_t avail = buffer.size() + 2;                                                 \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_JOB_PROCESSES,     \
                               reinterpret_cast<void*>(buffer.data()),              \
                               buffer.size() * sizeof(zx_koid_t), &actual, &avail); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_JOB_PROCESSES_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                             \
    OBJECT_GET_INFO_JOB_PROCESSES_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                       \
  TEST_F(InterceptionWorkflowTestArm, name) {                             \
    OBJECT_GET_INFO_JOB_PROCESSES_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_JOB_PROCESSES_DISPLAY_TEST(
    ZxObjectGetInfoJobProcesses, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_JOB_PROCESSES\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m24\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (actual:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m/\x1B[34m5\x1B[0m)\n"
    "      info:\x1B[32mzx_koid_t\x1B[0m: "
    "\x1B[31m1111\x1B[0m, \x1B[31m2222\x1B[0m, \x1B[31m3333\x1B[0m\n");

#define OBJECT_GET_INFO_TASK_STATS_DISPLAY_TEST_CONTENT(result, expected)                  \
  constexpr size_t kMemMappedBytes = 65536;                                                \
  constexpr size_t kMemPrivateBytes = 16000;                                               \
  constexpr size_t kMemSharedBytes = 20000;                                                \
  constexpr size_t kMemScaledSharedBytes = 5000;                                           \
  zx_info_task_stats_t buffer;                                                             \
  buffer.mem_mapped_bytes = kMemMappedBytes;                                               \
  buffer.mem_private_bytes = kMemPrivateBytes;                                             \
  buffer.mem_shared_bytes = kMemSharedBytes;                                               \
  buffer.mem_scaled_shared_bytes = kMemScaledSharedBytes;                                  \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_TASK_STATS,                        \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_TASK_STATS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                          \
    OBJECT_GET_INFO_TASK_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                    \
  TEST_F(InterceptionWorkflowTestArm, name) {                          \
    OBJECT_GET_INFO_TASK_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_TASK_STATS_DISPLAY_TEST(
    ZxObjectGetInfoTaskStats, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_TASK_STATS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m32\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_task_stats_t\x1B[0m: {\n"
    "        mem_mapped_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m65536\x1B[0m\n"
    "        mem_private_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m16000\x1B[0m\n"
    "        mem_shared_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m20000\x1B[0m\n"
    "        mem_scaled_shared_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m5000\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_PROCESS_MAPS_DISPLAY_TEST_CONTENT(result, expected)                       \
  std::vector<zx_info_maps_t> buffer(3);                                                          \
  buffer[0] = {                                                                                   \
      .name = "map1", .base = 0x10000, .size = 4096, .depth = 1, .type = ZX_INFO_MAPS_TYPE_NONE}; \
  buffer[1] = {                                                                                   \
      .name = "map2",                                                                             \
      .base = 0x20000,                                                                            \
      .size = 2048,                                                                               \
      .depth = 2,                                                                                 \
      .type = ZX_INFO_MAPS_TYPE_MAPPING,                                                          \
      .u = {.mapping = {.mmu_flags = ZX_VM_ALIGN_2KB | ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE,      \
                        .vmo_koid = 5555,                                                         \
                        .vmo_offset = 2048,                                                       \
                        .committed_pages = 1}}};                                                  \
  buffer[2] = {                                                                                   \
      .name = "map3", .base = 0x40000, .size = 2048, .depth = 2, .type = ZX_INFO_MAPS_TYPE_VMAR}; \
  size_t actual = buffer.size();                                                                  \
  size_t avail = 10;                                                                              \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_PROCESS_MAPS,                    \
                               reinterpret_cast<void*>(buffer.data()),                            \
                               buffer.size() * sizeof(zx_info_maps_t), &actual, &avail);          \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_PROCESS_MAPS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_PROCESS_MAPS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_PROCESS_MAPS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_PROCESS_MAPS_DISPLAY_TEST(
    ZxObjectGetInfoProcessMaps, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_PROCESS_MAPS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m288\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m ("
    "actual:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m/\x1B[34m10\x1B[0m)\n"
    "      info:\x1B[32mzx_info_maps_t\x1B[0m[]:  {\n"
    "        {\n"
    "          name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"map1\"\x1B[0m\n"
    "          base:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000010000\x1B[0m\n"
    "          size:\x1B[32msize_t\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "          depth:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m\n"
    "          type:\x1B[32mzx_info_maps_type_t\x1B[0m: \x1B[31mZX_INFO_MAPS_TYPE_NONE\x1B[0m\n"
    "        },\n"
    "        {\n"
    "          name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"map2\"\x1B[0m\n"
    "          base:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000020000\x1B[0m\n"
    "          size:\x1B[32msize_t\x1B[0m: \x1B[34m2048\x1B[0m\n"
    "          depth:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m\n"
    "          type:\x1B[32mzx_info_maps_type_t\x1B[0m: \x1B[31mZX_INFO_MAPS_TYPE_MAPPING\x1B[0m\n"
    "          mapping:\x1B[32mzx_info_maps_mapping_t\x1B[0m: {\n"
    "            mmu_flags:\x1B[32mzx_vm_option_t\x1B[0m: "
    "\x1B[31mZX_VM_ALIGN_2KB | ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE\x1B[0m\n"
    "            vmo_koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m5555\x1B[0m\n"
    "            vmo_offset:\x1B[32muint64\x1B[0m: \x1B[34m2048\x1B[0m\n"
    "            committed_pages:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m\n"
    "          }\n"
    "        },\n"
    "        {\n"
    "          name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"map3\"\x1B[0m\n"
    "          base:\x1B[32mzx_vaddr_t\x1B[0m: \x1B[34m0000000000040000\x1B[0m\n"
    "          size:\x1B[32msize_t\x1B[0m: \x1B[34m2048\x1B[0m\n"
    "          depth:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m\n"
    "          type:\x1B[32mzx_info_maps_type_t\x1B[0m: \x1B[31mZX_INFO_MAPS_TYPE_VMAR\x1B[0m\n"
    "        }\n"
    "      }\n");

#define OBJECT_GET_INFO_PROCESS_VMOS_DISPLAY_TEST_CONTENT(result, expected)                      \
  std::vector<zx_info_vmo_t> buffer(2);                                                          \
  buffer[0] = {.koid = kKoid,                                                                    \
               .name = "my_vmo1",                                                                \
               .size_bytes = 4000,                                                               \
               .parent_koid = 0,                                                                 \
               .num_children = 2,                                                                \
               .num_mappings = 1,                                                                \
               .share_count = 3,                                                                 \
               .flags = ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE | ZX_INFO_VMO_CONTIGUOUS, \
               .committed_bytes = 4096,                                                          \
               .handle_rights = 0,                                                               \
               .cache_policy = ZX_CACHE_POLICY_CACHED};                                          \
  buffer[1] = {.koid = kKoid2,                                                                   \
               .name = "my_vmo2",                                                                \
               .size_bytes = 8000,                                                               \
               .parent_koid = 0,                                                                 \
               .num_children = 2,                                                                \
               .num_mappings = 1,                                                                \
               .share_count = 3,                                                                 \
               .flags = ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE,                          \
               .committed_bytes = 4096,                                                          \
               .handle_rights = 0,                                                               \
               .cache_policy = ZX_CACHE_POLICY_CACHED};                                          \
  size_t actual = buffer.size();                                                                 \
  size_t avail = 2;                                                                              \
  auto value = ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_PROCESS_VMOS,                   \
                               reinterpret_cast<void*>(buffer.data()),                           \
                               buffer.size() * sizeof(zx_info_vmo_t), &actual, &avail);          \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_PROCESS_VMOS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                            \
    OBJECT_GET_INFO_PROCESS_VMOS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                      \
  TEST_F(InterceptionWorkflowTestArm, name) {                            \
    OBJECT_GET_INFO_PROCESS_VMOS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_PROCESS_VMOS_DISPLAY_TEST(
    ZxObjectGetInfoProcessVmos, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_PROCESS_VMOS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m208\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m ("
    "actual:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m/\x1B[34m2\x1B[0m)\n"
    "      info:\x1B[32mzx_info_vmo_t\x1B[0m[]:  {\n"
    "        {\n"
    "          koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m4252\x1B[0m\n"
    "          name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"my_vmo1\"\x1B[0m\n"
    "          size_bytes:\x1B[32muint64\x1B[0m: \x1B[34m4000\x1B[0m\n"
    "          parent_koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m0\x1B[0m\n"
    "          num_children:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m\n"
    "          num_mappings:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m\n"
    "          share_count:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m\n"
    "          flags:\x1B[32mzx_info_vmo_type_t\x1B[0m: "
    "\x1B[34mZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE | ZX_INFO_VMO_CONTIGUOUS\x1B[0m\n"
    "          committed_bytes:\x1B[32muint64\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "          handle_rights:\x1B[32mzx_rights_t\x1B[0m: \x1B[34mZX_RIGHT_NONE\x1B[0m\n"
    "          cache_policy:\x1B[32mzx_cache_policy_t\x1B[0m: "
    "\x1B[31mZX_CACHE_POLICY_CACHED\x1B[0m\n"
    "        },\n"
    "        {\n"
    "          koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m5242\x1B[0m\n"
    "          name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"my_vmo2\"\x1B[0m\n"
    "          size_bytes:\x1B[32muint64\x1B[0m: \x1B[34m8000\x1B[0m\n"
    "          parent_koid:\x1B[32mzx_koid_t\x1B[0m: \x1B[31m0\x1B[0m\n"
    "          num_children:\x1B[32msize_t\x1B[0m: \x1B[34m2\x1B[0m\n"
    "          num_mappings:\x1B[32msize_t\x1B[0m: \x1B[34m1\x1B[0m\n"
    "          share_count:\x1B[32msize_t\x1B[0m: \x1B[34m3\x1B[0m\n"
    "          flags:\x1B[32mzx_info_vmo_type_t\x1B[0m: "
    "\x1B[34mZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_RESIZABLE\x1B[0m\n"
    "          committed_bytes:\x1B[32muint64\x1B[0m: \x1B[34m4096\x1B[0m\n"
    "          handle_rights:\x1B[32mzx_rights_t\x1B[0m: \x1B[34mZX_RIGHT_NONE\x1B[0m\n"
    "          cache_policy:\x1B[32mzx_cache_policy_t\x1B[0m: "
    "\x1B[31mZX_CACHE_POLICY_CACHED\x1B[0m\n"
    "        }\n"
    "      }\n");

#define OBJECT_GET_INFO_KMEM_STATS_DISPLAY_TEST_CONTENT(result, expected)                  \
  constexpr size_t kTotalBytes = 16384;                                                    \
  constexpr size_t kFreeBytes = 6334;                                                      \
  constexpr size_t kWiredBytes = 1000;                                                     \
  constexpr size_t kTotalHeapBytes = 800;                                                  \
  constexpr size_t kFreeHeapBytes = 100;                                                   \
  constexpr size_t kVmoBytes = 8000;                                                       \
  constexpr size_t kMmuOverheadBytes = 200;                                                \
  constexpr size_t kOtherBytes = 50;                                                       \
  zx_info_kmem_stats_t buffer;                                                             \
  buffer.total_bytes = kTotalBytes;                                                        \
  buffer.free_bytes = kFreeBytes;                                                          \
  buffer.wired_bytes = kWiredBytes;                                                        \
  buffer.total_heap_bytes = kTotalHeapBytes;                                               \
  buffer.free_heap_bytes = kFreeHeapBytes;                                                 \
  buffer.vmo_bytes = kVmoBytes;                                                            \
  buffer.mmu_overhead_bytes = kMmuOverheadBytes;                                           \
  buffer.other_bytes = kOtherBytes;                                                        \
  auto value =                                                                             \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_KMEM_STATS,                        \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr); \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_KMEM_STATS_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                          \
    OBJECT_GET_INFO_KMEM_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                    \
  TEST_F(InterceptionWorkflowTestArm, name) {                          \
    OBJECT_GET_INFO_KMEM_STATS_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_KMEM_STATS_DISPLAY_TEST(
    ZxObjectGetInfoKmemStats, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_KMEM_STATS\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m72\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_kmem_stats_t\x1B[0m: {\n"
    "        total_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m16384\x1B[0m\n"
    "        free_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m6334\x1B[0m\n"
    "        wired_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m1000\x1B[0m\n"
    "        total_heap_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m800\x1B[0m\n"
    "        free_heap_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m100\x1B[0m\n"
    "        vmo_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m8000\x1B[0m\n"
    "        mmu_overhead_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m200\x1B[0m\n"
    "        other_bytes:\x1B[32msize_t\x1B[0m: \x1B[34m50\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_RESOURCE_DISPLAY_TEST_CONTENT(result, expected)                       \
  constexpr uint64_t kBase = 1000;                                                            \
  constexpr uint64_t kSize = 100;                                                             \
  zx_info_resource_t buffer{                                                                  \
      .kind = ZX_RSRC_KIND_ROOT, .flags = 0, .base = kBase, .size = kSize, .name = "my_res"}; \
  auto value =                                                                                \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_RESOURCE,                             \
                      reinterpret_cast<void*>(&buffer), sizeof(buffer), nullptr, nullptr);    \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_RESOURCE_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                        \
    OBJECT_GET_INFO_RESOURCE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                                  \
  TEST_F(InterceptionWorkflowTestArm, name) {                        \
    OBJECT_GET_INFO_RESOURCE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_RESOURCE_DISPLAY_TEST(
    ZxObjectGetInfoResource, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_RESOURCE\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m56\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_resource_t\x1B[0m: {\n"
    "        kind:\x1B[32mzx_rsrc_kind_t\x1B[0m: \x1B[34mZX_RSRC_KIND_ROOT\x1B[0m\n"
    "        flags:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m\n"
    "        base:\x1B[32muint64\x1B[0m: \x1B[34m1000\x1B[0m\n"
    "        size:\x1B[32msize_t\x1B[0m: \x1B[34m100\x1B[0m\n"
    "        name:\x1B[32mchar[]\x1B[0m: \x1B[31m\"my_res\"\x1B[0m\n"
    "      }\n");

#define OBJECT_GET_INFO_BTI_DISPLAY_TEST_CONTENT(result, expected)                             \
  constexpr uint64_t kMinimumContiguity = 1024 * 1024;                                         \
  constexpr uint64_t kAspaceSize = 512 * 1024 * 1024;                                          \
  zx_info_bti_t buffer;                                                                        \
  buffer.minimum_contiguity = kMinimumContiguity;                                              \
  buffer.aspace_size = kAspaceSize;                                                            \
  auto value =                                                                                 \
      ZxObjectGetInfo(result, #result, kHandle, ZX_INFO_BTI, reinterpret_cast<void*>(&buffer), \
                      sizeof(buffer), nullptr, nullptr);                                       \
  PerformDisplayTest("zx_object_get_info@plt", std::move(value), expected);

#define OBJECT_GET_INFO_BTI_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                   \
    OBJECT_GET_INFO_BTI_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                             \
  TEST_F(InterceptionWorkflowTestArm, name) {                   \
    OBJECT_GET_INFO_BTI_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_INFO_BTI_DISPLAY_TEST(
    ZxObjectGetInfoBti, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_info("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "topic:\x1B[32mzx_object_info_topic_t\x1B[0m: \x1B[34mZX_INFO_BTI\x1B[0m, "
    "buffer_size:\x1B[32msize_t\x1B[0m: \x1B[34m16\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n"
    "      info:\x1B[32mzx_info_bti_t\x1B[0m: {\n"
    "        minimum_contiguity:\x1B[32muint64\x1B[0m: \x1B[34m1048576\x1B[0m\n"
    "        aspace_size:\x1B[32muint64\x1B[0m: \x1B[34m536870912\x1B[0m\n"
    "      }\n");

// zx_object_get_child tests.

std::unique_ptr<SystemCallTest> ZxObjectGetChild(int64_t result, std::string_view result_name,
                                                 zx_handle_t handle, uint64_t koid,
                                                 zx_rights_t rights, zx_handle_t* out) {
  auto value = std::make_unique<SystemCallTest>("zx_object_get_child", result, result_name);
  value->AddInput(handle);
  value->AddInput(koid);
  value->AddInput(rights);
  value->AddInput(reinterpret_cast<uint64_t>(out));
  return value;
}

#define OBJECT_GET_CHILD_DISPLAY_TEST_CONTENT(result, expected)                               \
  zx_handle_t out = kHandleOut;                                                               \
  auto value = ZxObjectGetChild(result, #result, kHandle, kKoid, ZX_RIGHT_SAME_RIGHTS, &out); \
  PerformDisplayTest("zx_object_get_child@plt", std::move(value), expected);

#define OBJECT_GET_CHILD_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                \
    OBJECT_GET_CHILD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                          \
  TEST_F(InterceptionWorkflowTestArm, name) {                \
    OBJECT_GET_CHILD_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_GET_CHILD_DISPLAY_TEST(
    ZxObjectGetChild, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_get_child("
    "handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "koid:\x1B[32muint64\x1B[0m: \x1B[34m4252\x1B[0m, "
    "rights:\x1B[32mzx_rights_t\x1B[0m: \x1B[34mZX_RIGHT_SAME_RIGHTS\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m (out:\x1B[32mhandle\x1B[0m: \x1B[31mbde90caf\x1B[0m)\n");

// zx_object_set_profile tests.

std::unique_ptr<SystemCallTest> ZxObjectSetProfile(int64_t result, std::string_view result_name,
                                                   zx_handle_t handle, zx_handle_t profile,
                                                   uint32_t options) {
  auto value = std::make_unique<SystemCallTest>("zx_object_set_profile", result, result_name);
  value->AddInput(handle);
  value->AddInput(profile);
  value->AddInput(options);
  return value;
}

#define OBJECT_SET_PROFILE_DISPLAY_TEST_CONTENT(result, expected) \
  PerformDisplayTest("zx_object_set_profile@plt",                 \
                     ZxObjectSetProfile(result, #result, kHandle, kHandle2, 0), expected);

#define OBJECT_SET_PROFILE_DISPLAY_TEST(name, errno, expected) \
  TEST_F(InterceptionWorkflowTestX64, name) {                  \
    OBJECT_SET_PROFILE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }                                                            \
  TEST_F(InterceptionWorkflowTestArm, name) {                  \
    OBJECT_SET_PROFILE_DISPLAY_TEST_CONTENT(errno, expected);  \
  }

OBJECT_SET_PROFILE_DISPLAY_TEST(
    ZxObjectSetProfile, ZX_OK,
    "\n"
    "test_3141 \x1B[31m3141\x1B[0m:\x1B[31m8764\x1B[0m "
    "zx_object_set_profile(handle:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1db0\x1B[0m, "
    "profile:\x1B[32mhandle\x1B[0m: \x1B[31mcefa1222\x1B[0m, "
    "options:\x1B[32muint32\x1B[0m: \x1B[34m0\x1B[0m)\n"
    "  -> \x1B[32mZX_OK\x1B[0m\n");

}  // namespace fidlcat