zircon/system/utest/fidl/llcpp_types_tests.cc

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

#include <memory>
#include <utility>
#include <optional>

#include <lib/fidl/internal.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/sync_call.h>
#include <lib/zx/channel.h>
#include <unittest/unittest.h>
#include <zircon/fidl.h>

namespace {

// Manually define the coding table for FIDL messages used in these tests.
// These will match the llcpp codegen output.

extern const fidl_type_t NonnullableChannelMessageType;

// A message with a single non-nullable channel.
struct NonnullableChannelMessage {
  alignas(FIDL_ALIGNMENT) fidl_message_header_t header;
  zx::channel channel;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 1;

  static constexpr uint32_t PrimarySize =
      FIDL_ALIGN(sizeof(fidl_message_header_t)) + FIDL_ALIGN(sizeof(zx::channel));

  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;

  static constexpr uint32_t AltPrimarySize = PrimarySize;

  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;

  static constexpr const fidl_type_t* Type = &NonnullableChannelMessageType;

  static bool MakeDecodedMessageHelper(
      fidl::BytePart buffer, fidl::DecodedMessage<NonnullableChannelMessage>* out_decoded_message,
      zx::channel* out_channel);
};

const fidl_type_t NonnullableChannelType =
    fidl_type_t(fidl::FidlCodedHandle(ZX_OBJ_TYPE_CHANNEL, fidl::kNonnullable));
const fidl::FidlStructField NonnullableChannelMessageFields[] = {
    fidl::FidlStructField(&NonnullableChannelType, offsetof(NonnullableChannelMessage, channel), 4),
};
const fidl_type_t NonnullableChannelMessageType = fidl_type_t(
    fidl::FidlCodedStruct(NonnullableChannelMessageFields, /* field_count */ 1,
                          sizeof(NonnullableChannelMessage), "NonnullableChannelMessage"));

extern const fidl_type_t InlinePODStructType;

// A message with a uint64_t.
struct InlinePODStruct {
  uint64_t payload;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 0;

  static constexpr uint32_t PrimarySize = FIDL_ALIGN(sizeof(payload));

  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;

  static constexpr uint32_t AltPrimarySize = PrimarySize;

  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;

  static constexpr const fidl_type_t* Type = &InlinePODStructType;

  static bool MakeDecodedMessageHelper(fidl::BytePart buffer, uint64_t payload,
                                       fidl::DecodedMessage<InlinePODStruct>* out_decoded_message);
};

// Full-width primitives do not need coding tables.
const fidl::FidlStructField InlinePODStructStructFields[] = {};
const fidl_type_t InlinePODStructType = fidl_type_t(fidl::FidlCodedStruct(
    InlinePODStructStructFields, 0, sizeof(InlinePODStruct), "InlinePODStruct"));

extern const fidl_type_t OutOfLineMessageType;

// A message with an optional struct.
struct OutOfLineMessage {
  alignas(FIDL_ALIGNMENT) fidl_message_header_t header;
  InlinePODStruct* optional;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 0;

  static constexpr uint32_t PrimarySize =
      FIDL_ALIGN(sizeof(fidl_message_header_t)) + FIDL_ALIGN(sizeof(InlinePODStruct*));

  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 8;

  static constexpr uint32_t AltPrimarySize = PrimarySize;

  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;

  static constexpr const fidl_type_t* Type = &OutOfLineMessageType;

  static bool MakeDecodedMessageHelper(fidl::BytePart buffer,
                                       std::optional<uint64_t> optional_field,
                                       fidl::DecodedMessage<OutOfLineMessage>* out_decoded_message);
};

const fidl_type_t OptionalPointerType =
    fidl_type_t(fidl::FidlCodedStructPointer(&InlinePODStructType.coded_struct));
const fidl::FidlStructField OutOfLineMessageTypeFields[] = {
    fidl::FidlStructField(&OptionalPointerType, offsetof(OutOfLineMessage, optional), 0),
};
const fidl_type_t OutOfLineMessageType = fidl_type_t(fidl::FidlCodedStruct(
    OutOfLineMessageTypeFields, /* field_count */ 1, sizeof(OutOfLineMessage), "OutOfLineMessage"));

extern const fidl_type_t LargeStructType;

// A message with a large array, such that it need to be heap-allocated.
struct LargeStruct {
  // 4096 * 8 = 32 KB
  fidl::Array<uint64_t, 4096> payload;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 0;

  static constexpr uint32_t PrimarySize = FIDL_ALIGN(sizeof(payload));

  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;

  static constexpr uint32_t AltPrimarySize = PrimarySize;

  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;

  static constexpr const fidl_type_t* Type = &LargeStructType;

  static bool MakeDecodedMessageHelper(fidl::BytePart buffer, uint64_t fill,
                                       fidl::DecodedMessage<LargeStruct>* out_decoded_message);
};

// Full-width primitives do not need coding tables.
const fidl::FidlStructField LargeStructStructFields[] = {};
const fidl_type_t LargeStructType = fidl_type_t(
    fidl::FidlCodedStruct(LargeStructStructFields, 0, sizeof(LargeStruct), "LargeStruct"));

// These two structs are used to test the stack/heap allocation selection in
// fidl::internal::ResponseStorage

struct StructOf512Bytes {
  fidl::Array<uint8_t, 512> payload;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = FIDL_ALIGN(sizeof(payload));
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = PrimarySize;
  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;
  [[maybe_unused]] static constexpr const fidl_type_t* Type = nullptr;
};

struct StructOf513Bytes {
  fidl::Array<uint8_t, 513> payload;

  [[maybe_unused]] static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = FIDL_ALIGN(sizeof(payload));
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = PrimarySize;
  [[maybe_unused]] static constexpr uint32_t AltMaxOutOfLine = MaxOutOfLine;
  [[maybe_unused]] static constexpr const fidl_type_t* Type = nullptr;
};

}  // namespace

namespace fidl {

// Manually specialize the templates.
// These will match the llcpp codegen output.

template <>
struct IsFidlType<NonnullableChannelMessage> : public std::true_type {};
template <>
struct IsFidlMessage<NonnullableChannelMessage> : public std::true_type {};

template <>
struct IsFidlType<InlinePODStruct> : public std::true_type {};

template <>
struct IsFidlType<OutOfLineMessage> : public std::true_type {};
template <>
struct IsFidlMessage<OutOfLineMessage> : public std::true_type {};

template <>
struct IsFidlType<LargeStruct> : public std::true_type {};

template <>
struct IsFidlType<StructOf512Bytes> : public std::true_type {};

template <>
struct IsFidlType<StructOf513Bytes> : public std::true_type {};

}  // namespace fidl

namespace {

// Because the EncodedMessage/DecodedMessage classes close handles using the corresponding
// Zircon system call instead of calling a destructor, we indirectly test for handle closure
// via the ZX_ERR_PEER_CLOSED error message.

bool HelperExpectPeerValid(zx::channel& channel) {
  BEGIN_HELPER;

  const char* foo = "A";
  EXPECT_EQ(channel.write(0, foo, 1, nullptr, 0), ZX_OK);

  END_HELPER;
}

bool HelperExpectPeerInvalid(zx::channel& channel) {
  BEGIN_HELPER;

  const char* foo = "A";
  EXPECT_EQ(channel.write(0, foo, 1, nullptr, 0), ZX_ERR_PEER_CLOSED);

  END_HELPER;
}

bool EncodedMessageTest() {
  BEGIN_TEST;

  // Manually construct an encoded message
  alignas(NonnullableChannelMessage) uint8_t buf[sizeof(NonnullableChannelMessage)] = {};
  auto msg = reinterpret_cast<NonnullableChannelMessage*>(&buf[0]);
  msg->channel.reset(FIDL_HANDLE_PRESENT);

  // Capture the extra handle here; it will not be cleaned by encoded_message
  zx::channel channel_1 = {};

  {
    fidl::EncodedMessage<NonnullableChannelMessage> encoded_message;
    encoded_message.Initialize(
        [&buf, &channel_1](fidl::BytePart* out_msg_bytes, fidl::HandlePart* msg_handles) {
          *out_msg_bytes = fidl::BytePart(buf, sizeof(buf), sizeof(buf));
          zx_handle_t* handle = msg_handles->data();

          // Unsafely open a channel, which should be closed automatically by encoded_message
          {
            zx::channel out0, out1;
            EXPECT_EQ(zx::channel::create(0, &out0, &out1), ZX_OK);
            *handle = out0.release();
            channel_1 = std::move(out1);
          }

          msg_handles->set_actual(1);
        });

    EXPECT_TRUE(HelperExpectPeerValid(channel_1));
  }

  EXPECT_TRUE(HelperExpectPeerInvalid(channel_1));

  END_TEST;
}

bool DecodedMessageTest() {
  BEGIN_TEST;

  // Manually construct a decoded message
  alignas(NonnullableChannelMessage) uint8_t buf[sizeof(NonnullableChannelMessage)] = {};
  auto msg = reinterpret_cast<NonnullableChannelMessage*>(&buf[0]);

  // Capture the extra handle here; it will not be cleaned by decoded_message
  zx::channel channel_1 = {};

  {
    // Unsafely open a channel, which should be closed automatically by decoded_message
    {
      zx::channel out0, out1;
      EXPECT_EQ(zx::channel::create(0, &out0, &out1), ZX_OK);
      msg->channel = std::move(out0);
      channel_1 = std::move(out1);
    }

    fidl::DecodedMessage<NonnullableChannelMessage> decoded_message(
        fidl::BytePart(buf, sizeof(buf), sizeof(buf)));

    EXPECT_TRUE(HelperExpectPeerValid(channel_1));
  }

  EXPECT_TRUE(HelperExpectPeerInvalid(channel_1));

  END_TEST;
}

// Start with an encoded message, then decode and back.
bool RoundTripTest() {
  BEGIN_TEST;

  alignas(NonnullableChannelMessage) uint8_t buf[sizeof(NonnullableChannelMessage)] = {};
  auto msg = reinterpret_cast<NonnullableChannelMessage*>(&buf[0]);
  msg->header.txid = 10;
  msg->header.ordinal = (42lu << 32);
  msg->channel.reset(FIDL_HANDLE_PRESENT);

  // Capture the extra handle here; it will not be cleaned by encoded_message
  zx::channel channel_1 = {};

  fidl::EncodedMessage<NonnullableChannelMessage>* encoded_message =
      new fidl::EncodedMessage<NonnullableChannelMessage>();
  zx_handle_t unsafe_handle_backup;

  encoded_message->Initialize([&buf, &channel_1, &unsafe_handle_backup](
                                  fidl::BytePart* out_msg_bytes, fidl::HandlePart* msg_handles) {
    *out_msg_bytes = fidl::BytePart(buf, sizeof(buf), sizeof(buf));
    zx_handle_t* handle = msg_handles->data();

    // Unsafely open a channel, which should be closed automatically by encoded_message
    {
      zx::channel out0, out1;
      EXPECT_EQ(zx::channel::create(0, &out0, &out1), ZX_OK);
      *handle = out0.release();
      unsafe_handle_backup = *handle;
      channel_1 = std::move(out1);
    }

    msg_handles->set_actual(1);
  });

  uint8_t golden_encoded[] = {10,  0,   0,   0,    // txid
                              0,   0,   0,   0,    // reserved
                              0,   0,   0,   0,    // low bytes of ordinal (was flags)
                              42,  0,   0,   0,    // high bytes of ordinal
                              255, 255, 255, 255,  // handle present
                              0,   0,   0,   0};

  // Byte-accurate comparison
  EXPECT_EQ(memcmp(golden_encoded, buf, sizeof(buf)), 0);

  EXPECT_TRUE(HelperExpectPeerValid(channel_1));

  // Decode
  auto decode_result = fidl::Decode(std::move(*encoded_message));
  auto& decoded_message = decode_result.message;
  EXPECT_EQ(decode_result.status, ZX_OK);
  EXPECT_NULL(decode_result.error, decode_result.error);
  EXPECT_EQ(decoded_message.message()->header.txid, 10);
  EXPECT_EQ(decoded_message.message()->header.ordinal, (42lu << 32));
  EXPECT_EQ(decoded_message.message()->channel.get(), unsafe_handle_backup);
  // encoded_message should be consumed
  EXPECT_EQ(encoded_message->handles().actual(), 0);
  EXPECT_EQ(encoded_message->bytes().actual(), 0);
  // If we destroy encoded_message, it should not accidentally close the channel
  delete encoded_message;
  EXPECT_TRUE(HelperExpectPeerValid(channel_1));

  // Encode
  {
    auto encode_result = fidl::Encode(std::move(decoded_message));
    auto& encoded_message = encode_result.message;
    EXPECT_EQ(encode_result.status, ZX_OK);
    EXPECT_NULL(encode_result.error, encode_result.error);
    // decoded_message should be consumed
    EXPECT_EQ(decoded_message.message(), nullptr);

    // Byte-level comparison
    EXPECT_EQ(encoded_message.bytes().actual(), sizeof(buf));
    EXPECT_EQ(encoded_message.handles().actual(), 1);
    EXPECT_EQ(encoded_message.handles().data()[0], unsafe_handle_backup);
    EXPECT_EQ(memcmp(golden_encoded, encoded_message.bytes().data(), sizeof(buf)), 0);

    EXPECT_TRUE(HelperExpectPeerValid(channel_1));
  }
  // Encoded message was destroyed, bringing down the handle with it
  EXPECT_TRUE(HelperExpectPeerInvalid(channel_1));

  END_TEST;
}

bool ArrayLayoutTest() {
  BEGIN_TEST;

  static_assert(sizeof(fidl::Array<uint8_t, 3>) == sizeof(uint8_t[3]));
  static_assert(sizeof(fidl::Array<fidl::Array<uint8_t, 7>, 3>) == sizeof(uint8_t[3][7]));

  constexpr fidl::Array<uint8_t, 3> a = {1, 2, 3};
  constexpr uint8_t b[3] = {1, 2, 3};
  EXPECT_EQ((&a[2] - &a[0]), (&b[2] - &b[0]));

  END_TEST;
}

bool UninitializedBufferStackAllocationAlignmentTest() {
  BEGIN_TEST;

  fidl::internal::AlignedBuffer<1> array_of_1;
  ASSERT_EQ(sizeof(array_of_1), 8);
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(&array_of_1) % 8 == 0);

  fidl::internal::AlignedBuffer<5> array_of_5;
  ASSERT_EQ(sizeof(array_of_5), 8);
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(&array_of_5) % 8 == 0);

  fidl::internal::AlignedBuffer<25> array_of_25;
  ASSERT_EQ(sizeof(array_of_25), 32);
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(&array_of_25) % 8 == 0);

  fidl::internal::AlignedBuffer<100> array_of_100;
  ASSERT_EQ(sizeof(array_of_100), 104);
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(&array_of_100) % 8 == 0);

  END_TEST;
}

bool UninitializedBufferHeapAllocationAlignmentTest() {
  BEGIN_TEST;

  std::unique_ptr array_of_1 = std::make_unique<fidl::internal::AlignedBuffer<1>>();
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(array_of_1.get()) % 8 == 0);

  std::unique_ptr array_of_5 = std::make_unique<fidl::internal::AlignedBuffer<5>>();
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(array_of_5.get()) % 8 == 0);

  std::unique_ptr array_of_25 = std::make_unique<fidl::internal::AlignedBuffer<25>>();
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(array_of_25.get()) % 8 == 0);

  std::unique_ptr array_of_100 = std::make_unique<fidl::internal::AlignedBuffer<100>>();
  ASSERT_TRUE(reinterpret_cast<uintptr_t>(array_of_100.get()) % 8 == 0);

  END_TEST;
}

template <typename TestMessage>
class MySyncCall;

// Helper to populate a OwnedSyncCallBase<NonnullableChannelMessage> with a decoded message,
// as if receiving a FIDL reply.
bool NonnullableChannelMessage::MakeDecodedMessageHelper(
    fidl::BytePart buffer, fidl::DecodedMessage<NonnullableChannelMessage>* out_decoded_message,
    zx::channel* out_channel) {
  BEGIN_HELPER;

  auto msg = reinterpret_cast<NonnullableChannelMessage*>(buffer.data());
  memset(buffer.data(), 0, buffer.capacity());

  {
    zx::channel out0, out1;
    EXPECT_EQ(zx::channel::create(0, &out0, &out1), ZX_OK);
    msg->channel = std::move(out0);
    // Capture the extra handle here; it will not be cleaned by decoded_message
    *out_channel = std::move(out1);

    fidl::BytePart full_buffer(std::move(buffer));
    full_buffer.set_actual(sizeof(NonnullableChannelMessage));
    fidl::DecodedMessage<NonnullableChannelMessage> decoded_message(std::move(full_buffer));
    *out_decoded_message = std::move(decoded_message);
  }

  EXPECT_TRUE(HelperExpectPeerValid(*out_channel));

  END_HELPER;
}

// Manually define the OwnedSyncCallBase type for NonnullableChannelMessage for the
// OwningSyncCallWithHandlesTest below.
// This is similar to the llcpp codegen output.
template <>
class MySyncCall<NonnullableChannelMessage>
    : private fidl::internal::OwnedSyncCallBase<NonnullableChannelMessage> {
  using Super = fidl::internal::OwnedSyncCallBase<NonnullableChannelMessage>;

 public:
  explicit MySyncCall(zx::channel* out_channel) {
    fidl::DecodedMessage<NonnullableChannelMessage> decoded_message;
    EXPECT_TRUE(NonnullableChannelMessage::MakeDecodedMessageHelper(Super::response_buffer(),
                                                                    &decoded_message, out_channel));
    Super::SetResult(fidl::DecodeResult(ZX_OK, nullptr, std::move(decoded_message)));
  }
  ~MySyncCall() = default;
  MySyncCall(MySyncCall&& other) = default;
  MySyncCall& operator=(MySyncCall&& other) = default;
  using Super::error;
  using Super::status;
  using Super::Unwrap;
};

// Helper to populate a OwnedSyncCallBase<InlinePODStruct> with a decoded message,
// as if receiving a FIDL reply.
bool InlinePODStruct::MakeDecodedMessageHelper(
    fidl::BytePart buffer, uint64_t payload,
    fidl::DecodedMessage<InlinePODStruct>* out_decoded_message) {
  BEGIN_HELPER;

  auto msg = reinterpret_cast<InlinePODStruct*>(buffer.data());
  memset(buffer.data(), 0, buffer.capacity());
  msg->payload = payload;

  {
    fidl::BytePart full_buffer(std::move(buffer));
    full_buffer.set_actual(sizeof(InlinePODStruct));
    fidl::DecodedMessage<InlinePODStruct> decoded_message(std::move(full_buffer));
    *out_decoded_message = std::move(decoded_message);
  }

  EXPECT_EQ(out_decoded_message->message()->payload, payload);

  END_HELPER;
}

// Manually define the OwnedSyncCallBase type for InlinePODStruct for the
// OwningSyncCallWithPODTest below.
// This is similar to the llcpp codegen output.
template <>
class MySyncCall<InlinePODStruct> : private fidl::internal::OwnedSyncCallBase<InlinePODStruct> {
  using Super = fidl::internal::OwnedSyncCallBase<InlinePODStruct>;

 public:
  explicit MySyncCall(uint64_t payload) {
    fidl::DecodedMessage<InlinePODStruct> decoded_message;
    EXPECT_TRUE(InlinePODStruct::MakeDecodedMessageHelper(Super::response_buffer(), payload,
                                                          &decoded_message));
    Super::SetResult(fidl::DecodeResult(ZX_OK, nullptr, std::move(decoded_message)));
  }

  // Constructs a failed OwnedSyncCallBase.
  MySyncCall(zx_status_t status, const char* error) {
    Super::SetFailure(fidl::EncodeResult<InlinePODStruct>(status, error));
  }

  ~MySyncCall() = default;
  MySyncCall(MySyncCall&& other) = default;
  MySyncCall& operator=(MySyncCall&& other) = default;
  using Super::error;
  using Super::status;
  using Super::Unwrap;
};

// Helper to populate a OwnedSyncCallBase<OutOfLineMessage> with a decoded message,
// as if receiving a FIDL reply.
bool OutOfLineMessage::MakeDecodedMessageHelper(
    fidl::BytePart buffer, std::optional<uint64_t> optional_field,
    fidl::DecodedMessage<OutOfLineMessage>* out_decoded_message) {
  BEGIN_HELPER;

  auto msg = reinterpret_cast<OutOfLineMessage*>(buffer.data());
  memset(buffer.data(), 0, buffer.capacity());

  if (optional_field) {
    ASSERT_EQ(buffer.capacity(), FIDL_ALIGN(OutOfLineMessage::PrimarySize) +
                                     FIDL_ALIGN(OutOfLineMessage::MaxOutOfLine));
    auto out_of_line = reinterpret_cast<InlinePODStruct*>(
        reinterpret_cast<uint8_t*>(msg) + FIDL_ALIGN(OutOfLineMessage::PrimarySize));
    out_of_line->payload = optional_field.value();
    msg->optional = out_of_line;
  } else {
    ASSERT_GE(buffer.capacity(), FIDL_ALIGN(OutOfLineMessage::PrimarySize));
    msg->optional = nullptr;
  }

  {
    fidl::BytePart full_buffer(std::move(buffer));
    full_buffer.set_actual(sizeof(OutOfLineMessage));
    fidl::DecodedMessage<OutOfLineMessage> decoded_message(std::move(full_buffer));
    *out_decoded_message = std::move(decoded_message);
  }

  END_HELPER;
}

// Manually define the OwnedSyncCallBase type for OutOfLineMessage for the
// OwningSyncCallWithOutOfLineTest below.
// This is similar to the llcpp codegen output.
template <>
class MySyncCall<OutOfLineMessage> : private fidl::internal::OwnedSyncCallBase<OutOfLineMessage> {
  using Super = fidl::internal::OwnedSyncCallBase<OutOfLineMessage>;

 public:
  explicit MySyncCall(std::optional<uint64_t> optional_field) {
    fidl::DecodedMessage<OutOfLineMessage> decoded_message;
    EXPECT_TRUE(OutOfLineMessage::MakeDecodedMessageHelper(Super::response_buffer(), optional_field,
                                                           &decoded_message));
    Super::SetResult(fidl::DecodeResult(ZX_OK, nullptr, std::move(decoded_message)));
  }
  ~MySyncCall() = default;
  MySyncCall(MySyncCall&& other) = default;
  MySyncCall& operator=(MySyncCall&& other) = default;
  using Super::error;
  using Super::status;
  using Super::Unwrap;
};

// Helper to populate a OwnedSyncCallBase<LargeStruct> with a decoded message,
// as if receiving a FIDL reply.
bool LargeStruct::MakeDecodedMessageHelper(fidl::BytePart buffer, uint64_t fill,
                                           fidl::DecodedMessage<LargeStruct>* out_decoded_message) {
  BEGIN_HELPER;

  auto msg = reinterpret_cast<LargeStruct*>(buffer.data());
  memset(buffer.data(), 0, buffer.capacity());
  for (auto& x : msg->payload) {
    x = fill;
  }

  {
    fidl::BytePart full_buffer(std::move(buffer));
    full_buffer.set_actual(sizeof(LargeStruct));
    fidl::DecodedMessage<LargeStruct> decoded_message(std::move(full_buffer));
    *out_decoded_message = std::move(decoded_message);
  }

  for (const auto& x : out_decoded_message->message()->payload) {
    EXPECT_EQ(x, fill);
  }

  END_HELPER;
}

// Manually define the OwnedSyncCallBase type for LargeStruct, for the OwningSyncCallHeapTest below.
// This is similar to the llcpp codegen output.
template <>
class MySyncCall<LargeStruct> : private fidl::internal::OwnedSyncCallBase<LargeStruct> {
  using Super = fidl::internal::OwnedSyncCallBase<LargeStruct>;

 public:
  explicit MySyncCall(uint64_t fill) {
    fidl::DecodedMessage<LargeStruct> decoded_message;
    EXPECT_TRUE(
        LargeStruct::MakeDecodedMessageHelper(Super::response_buffer(), fill, &decoded_message));
    Super::SetResult(fidl::DecodeResult(ZX_OK, nullptr, std::move(decoded_message)));
  }

  ~MySyncCall() = default;
  MySyncCall(MySyncCall&& other) = default;
  MySyncCall& operator=(MySyncCall&& other) = default;
  using Super::error;
  using Super::status;
  using Super::Unwrap;
};

// Test that in the case of stack-allocated response, handles are transferred correctly
// when the message is moved.
bool OwningSyncCallWithHandlesTest() {
  BEGIN_TEST;

  zx::channel peer_1;
  zx::channel peer_2;

  {
    MySyncCall<NonnullableChannelMessage> sync_call_1(&peer_1);
    ASSERT_TRUE(HelperExpectPeerValid(peer_1));
    ASSERT_EQ(sync_call_1.status(), ZX_OK);
    ASSERT_EQ(sync_call_1.error(), nullptr);

    MySyncCall<NonnullableChannelMessage> sync_call_2(&peer_2);
    ASSERT_TRUE(HelperExpectPeerValid(peer_2));
    ASSERT_EQ(sync_call_2.status(), ZX_OK);
    ASSERT_EQ(sync_call_2.error(), nullptr);

    // Moving |sync_call_2| into |sync_call_1| will destroy the message originally in |sync_call_1|.
    sync_call_1 = std::move(sync_call_2);
    ASSERT_TRUE(HelperExpectPeerInvalid(peer_1));
    ASSERT_TRUE(HelperExpectPeerValid(peer_2));
  }

  ASSERT_TRUE(HelperExpectPeerInvalid(peer_1));
  ASSERT_TRUE(HelperExpectPeerInvalid(peer_2));

  END_TEST;
}

// Test that in the case of stack-allocated response, pointers to out-of-line are correctly
// updated when the message is moved.
bool OwningSyncCallWithOutOfLineTest() {
  BEGIN_TEST;

  MySyncCall<OutOfLineMessage> sync_call_1(std::nullopt);
  ASSERT_EQ(sync_call_1.status(), ZX_OK);
  ASSERT_EQ(sync_call_1.error(), nullptr);
  ASSERT_NULL(sync_call_1.Unwrap()->optional);

  MySyncCall<OutOfLineMessage> sync_call_2(0xABCDABCD);
  ASSERT_EQ(sync_call_2.status(), ZX_OK);
  ASSERT_EQ(sync_call_2.error(), nullptr);
  ASSERT_NONNULL(sync_call_2.Unwrap()->optional);
  ASSERT_EQ(sync_call_2.Unwrap()->optional->payload, 0xABCDABCD);

  sync_call_1 = std::move(sync_call_2);
  ASSERT_NONNULL(sync_call_1.Unwrap());
  ASSERT_NULL(sync_call_2.Unwrap());
  ASSERT_EQ(sync_call_1.Unwrap()->optional->payload, 0xABCDABCD);

  auto pointer_to_optional = reinterpret_cast<InlinePODStruct*>(
      reinterpret_cast<uint8_t*>(sync_call_1.Unwrap()) + FIDL_ALIGN(OutOfLineMessage::PrimarySize));
  ASSERT_EQ(sync_call_1.Unwrap()->optional, pointer_to_optional);

  END_TEST;
}

// Test that std::move on a stack-allocated POD response works correctly.
// Internally, it should be implemented as a memcpy.
bool OwningSyncCallWithPODTest() {
  BEGIN_TEST;

  MySyncCall<InlinePODStruct> sync_call_1(0x12345678);
  ASSERT_EQ(sync_call_1.status(), ZX_OK);
  ASSERT_EQ(sync_call_1.error(), nullptr);
  ASSERT_EQ(sync_call_1.Unwrap()->payload, 0x12345678);

  MySyncCall<InlinePODStruct> sync_call_2(0xABABABAB);
  ASSERT_EQ(sync_call_2.status(), ZX_OK);
  ASSERT_EQ(sync_call_2.error(), nullptr);
  ASSERT_EQ(sync_call_2.Unwrap()->payload, 0xABABABAB);

  ASSERT_NE(&sync_call_1.Unwrap()->payload, &sync_call_2.Unwrap()->payload);

  sync_call_1 = std::move(sync_call_2);
  ASSERT_NONNULL(sync_call_1.Unwrap());
  ASSERT_NULL(sync_call_2.Unwrap());
  ASSERT_EQ(sync_call_1.Unwrap()->payload, 0xABABABAB);

  END_TEST;
}

// Test that in the case of heap-allocated response, moving the message moves the pointer
// to response buffer.
bool OwningSyncCallHeapTest() {
  BEGIN_TEST;

  MySyncCall<LargeStruct> sync_call_1(0x12345678);
  ASSERT_EQ(sync_call_1.status(), ZX_OK);
  ASSERT_EQ(sync_call_1.error(), nullptr);
  ASSERT_EQ(sync_call_1.Unwrap()->payload[0], 0x12345678);

  uint64_t* array_address = &sync_call_1.Unwrap()->payload[0];
  MySyncCall<LargeStruct> sync_call_2(std::move(sync_call_1));
  ASSERT_NE(&sync_call_1, &sync_call_2);
  ASSERT_EQ(array_address, &sync_call_2.Unwrap()->payload[0]);
  ASSERT_EQ(sync_call_2.Unwrap()->payload[0], 0x12345678);

  END_TEST;
}

// Test the |OwnedSyncCallBase| holds failure during encode/decode etc correctly.
bool OwningSyncCallFailureTest() {
  BEGIN_TEST;

  MySyncCall<InlinePODStruct> failed_call(ZX_ERR_INVALID_ARGS, "err");
  ASSERT_EQ(failed_call.status(), ZX_ERR_INVALID_ARGS);
  ASSERT_STR_EQ(failed_call.error(), "err");

  END_TEST;
}

bool UnownedSyncCallTest() {
  BEGIN_TEST;

  // Manually define the unowned OwnedSyncCallBase type for InlinePODStruct.
  // This is similar to the llcpp codegen output.
  class MyUnownedSyncCall : private fidl::internal::UnownedSyncCallBase<InlinePODStruct> {
    using Super = fidl::internal::UnownedSyncCallBase<InlinePODStruct>;

   public:
    explicit MyUnownedSyncCall(fidl::BytePart buffer, uint64_t payload) {
      fidl::DecodedMessage<InlinePODStruct> decoded_message;
      EXPECT_TRUE(
          InlinePODStruct::MakeDecodedMessageHelper(std::move(buffer), payload, &decoded_message));
      Super::SetResult(fidl::DecodeResult(ZX_OK, nullptr, std::move(decoded_message)));
    }

    ~MyUnownedSyncCall() = default;
    MyUnownedSyncCall(MyUnownedSyncCall&& other) = default;
    MyUnownedSyncCall& operator=(MyUnownedSyncCall&& other) = default;
    using Super::error;
    using Super::status;
    using Super::Unwrap;
  };

  // When using caller-allocated buffer, it has to be FIDL-aligned.
  FIDL_ALIGNDECL uint8_t response_buffer[64];
  MyUnownedSyncCall call_1(fidl::BytePart::WrapEmpty(response_buffer), 0xABCDABCD);
  ASSERT_EQ(call_1.status(), ZX_OK);
  ASSERT_EQ(call_1.error(), nullptr);
  ASSERT_EQ(call_1.Unwrap()->payload, 0xABCDABCD);
  ASSERT_EQ(reinterpret_cast<uint8_t*>(call_1.Unwrap()), &response_buffer[0]);

  MyUnownedSyncCall call_2(std::move(call_1));
  ASSERT_EQ(call_2.status(), ZX_OK);
  ASSERT_EQ(call_2.error(), nullptr);
  ASSERT_EQ(call_2.Unwrap()->payload, 0xABCDABCD);
  ASSERT_EQ(reinterpret_cast<uint8_t*>(call_2.Unwrap()), &response_buffer[0]);

  END_TEST;
}

bool ResponseStorageAllocationStrategyTest() {
  BEGIN_TEST;

  // The stack allocation limit of 512 bytes is defined in
  // zircon/system/ulib/fidl/include/lib/fidl/llcpp/sync_call.h
  ASSERT_EQ(sizeof(fidl::internal::ResponseStorage<StructOf512Bytes>), 512);

  // Since the buffer is on heap, |ResponseStorage| becomes a pointer.
  ASSERT_EQ(sizeof(fidl::internal::ResponseStorage<StructOf513Bytes>), sizeof(std::uintptr_t));

  END_TEST;
}

}  // namespace

BEGIN_TEST_CASE(llcpp_types_tests)
RUN_NAMED_TEST("EncodedMessage test", EncodedMessageTest)
RUN_NAMED_TEST("DecodedMessage test", DecodedMessageTest)
RUN_NAMED_TEST("Round trip test", RoundTripTest)
RUN_NAMED_TEST("Array layout test", ArrayLayoutTest)
RUN_NAMED_TEST("fidl::internal::AlignedBuffer alignment on stack",
               UninitializedBufferStackAllocationAlignmentTest)
RUN_NAMED_TEST("fidl::internal::AlignedBuffer alignment on heap",
               UninitializedBufferHeapAllocationAlignmentTest)
RUN_NAMED_TEST("OwnedSyncCallBase std::move [inlined response, message has handles]",
               OwningSyncCallWithHandlesTest)
RUN_NAMED_TEST("OwnedSyncCallBase std::move [inlined response, message has out-of-line]",
               OwningSyncCallWithOutOfLineTest)
RUN_NAMED_TEST("OwnedSyncCallBase std::move [inlined response, message is POD]",
               OwningSyncCallWithPODTest)
RUN_NAMED_TEST("OwnedSyncCallBase std::move [response on heap]", OwningSyncCallHeapTest)
RUN_NAMED_TEST("OwnedSyncCallBase when call failed", OwningSyncCallFailureTest)
RUN_NAMED_TEST("Unowned OwnedSyncCallBase std::move", UnownedSyncCallTest)
RUN_NAMED_TEST("ResponseStorage allocation strategy", ResponseStorageAllocationStrategyTest)
END_TEST_CASE(llcpp_types_tests)