src/lib/fidl/llcpp/tests/message_container/outgoing_message_test.cc

// Copyright 2021 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 <fidl/fidl.llcpp.empty.test/cpp/wire_messaging.h>
#include <fidl/fidl.llcpp.linearized.test/cpp/wire_types.h>
#include <fidl/fidl.test.misc/cpp/wire_messaging.h>
#include <lib/fidl/cpp/wire/message.h>
#include <lib/fidl/cpp/wire/wire_messaging_declarations.h>
#include <zircon/errors.h>

#include <iterator>

#include <gtest/gtest.h>

TEST(OutgoingMessage, Create) {
  zx_channel_iovec_t iovecs[1];
  zx_handle_t handles[2];
  fidl_channel_handle_metadata_t handle_metadata[2];
  uint8_t backing_buffer[1];
  fidl::OutgoingMessage msg = fidl::OutgoingMessage::Create_InternalMayBreak({
      .transport_vtable = &fidl::internal::ChannelTransport::VTable,
      .iovecs = iovecs,
      .iovec_capacity = std::size(iovecs),
      .handles = handles,
      .handle_metadata = reinterpret_cast<fidl_handle_metadata_t*>(handle_metadata),
      .handle_capacity = std::size(handles),
      .backing_buffer = backing_buffer,
      .backing_buffer_capacity = std::size(backing_buffer),
  });
  // Capacities are stored but not exposed. Actual sizes are zero initialized.
  EXPECT_EQ(0u, msg.iovec_actual());
  EXPECT_EQ(iovecs, msg.iovecs());
  EXPECT_EQ(0u, msg.handle_actual());
  EXPECT_EQ(handles, msg.handles());
  EXPECT_EQ(fidl::internal::fidl_transport_type::kChannel, msg.transport_type());
  EXPECT_EQ(handle_metadata, msg.handle_metadata<fidl::internal::ChannelTransport>());
}

TEST(OutgoingMessage, OutgoingMessageBytesMatch) {
  uint8_t bytes_a1[]{1};
  uint8_t bytes_a2[]{2, 3, 4};
  zx_channel_iovec_t iovecs_a[] = {
      {
          .buffer = bytes_a1,
          .capacity = std::size(bytes_a1),
          .reserved = 0,
      },
      {
          .buffer = bytes_a2,
          .capacity = std::size(bytes_a2),
          .reserved = 0,
      },
  };
  auto msg_a = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_a,
      .num_iovecs = std::size(iovecs_a),
  });

  uint8_t bytes_b1[]{1, 2};
  uint8_t bytes_b2[]{3};
  uint8_t bytes_b3[]{4};
  zx_channel_iovec_t iovecs_b[] = {
      {
          .buffer = bytes_b1,
          .capacity = std::size(bytes_b1),
          .reserved = 0,
      },
      {
          .buffer = bytes_b2,
          .capacity = std::size(bytes_b2),
          .reserved = 0,
      },
      {
          .buffer = bytes_b3,
          .capacity = std::size(bytes_b3),
          .reserved = 0,
      },
  };
  auto msg_b = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_b,
      .num_iovecs = std::size(iovecs_b),
  });

  EXPECT_TRUE(msg_a.BytesMatch(msg_b));
  EXPECT_TRUE(msg_b.BytesMatch(msg_a));
}

TEST(OutgoingMessage, OutgoingMessageBytesMatchIgnoreHandles) {
  uint8_t bytes[]{1, 2, 3, 4};
  zx_channel_iovec_t iovecs[] = {
      {
          .buffer = bytes,
          .capacity = std::size(bytes),
          .reserved = 0,
      },
  };
  auto msg_without_handles = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs,
      .num_iovecs = std::size(iovecs),
  });

  // Bytes should match even if one has handles and the other doesn't.
  zx_handle_t handle;
  fidl_channel_handle_metadata_t handle_metadata;
  ASSERT_EQ(ZX_OK, zx_event_create(0, &handle));
  auto msg_with_handles = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs,
      .num_iovecs = std::size(iovecs),
      .handles = &handle,
      .handle_metadata = reinterpret_cast<fidl_handle_metadata_t*>(&handle_metadata),
      .num_handles = 1,
  });

  EXPECT_TRUE(msg_without_handles.BytesMatch(msg_with_handles));
  EXPECT_TRUE(msg_with_handles.BytesMatch(msg_without_handles));
}

TEST(OutgoingMessage, OutgoingMessageBytesMismatchByteLength) {
  uint8_t bytes[]{1, 2, 3};

  // 2 bytes.
  zx_channel_iovec_t iovecs_a[] = {
      {
          .buffer = bytes,
          .capacity = 2,
          .reserved = 0,
      },
  };
  auto msg_a = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_a,
      .num_iovecs = std::size(iovecs_a),
  });

  // 3 bytes.
  zx_channel_iovec_t iovecs_b[] = {
      {
          .buffer = bytes,
          .capacity = 3,
          .reserved = 0,
      },
  };
  auto msg_b = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_b,
      .num_iovecs = std::size(iovecs_b),
  });

  EXPECT_FALSE(msg_a.BytesMatch(msg_b));
  EXPECT_FALSE(msg_b.BytesMatch(msg_a));
}

TEST(OutgoingMessage, OutgoingMessageBytesMismatchIovecLength) {
  uint8_t bytes1[]{1, 2};
  uint8_t bytes2[]{3};

  // 1 iovec.
  zx_channel_iovec_t iovecs_a[] = {
      {
          .buffer = bytes1,
          .capacity = sizeof(bytes1),
          .reserved = 0,
      },
  };
  auto msg_a = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_a,
      .num_iovecs = std::size(iovecs_a),
  });

  // 2 iovecs.
  zx_channel_iovec_t iovecs_b[] = {
      {
          .buffer = bytes1,
          .capacity = std::size(bytes1),
          .reserved = 0,
      },
      {
          .buffer = bytes2,
          .capacity = std::size(bytes2),
          .reserved = 0,
      },
  };
  auto msg_b = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_b,
      .num_iovecs = std::size(iovecs_b),
  });

  EXPECT_FALSE(msg_a.BytesMatch(msg_b));
  EXPECT_FALSE(msg_b.BytesMatch(msg_a));
}

TEST(OutgoingMessage, OutgoingMessageBytesMismatch) {
  uint8_t bytes_a1[]{1};
  uint8_t bytes_a2[]{2, 3, 4};
  zx_channel_iovec_t iovecs_a[] = {
      {
          .buffer = bytes_a1,
          .capacity = std::size(bytes_a1),
          .reserved = 0,
      },
      {
          .buffer = bytes_a2,
          .capacity = std::size(bytes_a2),
          .reserved = 0,
      },
  };
  auto msg_a = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_a,
      .num_iovecs = std::size(iovecs_a),
  });

  uint8_t bytes_b1[]{1, 2};
  uint8_t bytes_b2[]{5};
  uint8_t bytes_b3[]{4};
  zx_channel_iovec_t iovecs_b[] = {
      {
          .buffer = bytes_b1,
          .capacity = std::size(bytes_b1),
          .reserved = 0,
      },
      {
          .buffer = bytes_b2,
          .capacity = std::size(bytes_b2),
          .reserved = 0,
      },
      {
          .buffer = bytes_b3,
          .capacity = std::size(bytes_b3),
          .reserved = 0,
      },
  };
  auto msg_b = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs_b,
      .num_iovecs = std::size(iovecs_b),
  });

  EXPECT_FALSE(msg_a.BytesMatch(msg_b));
  EXPECT_FALSE(msg_b.BytesMatch(msg_a));
}

TEST(OutgoingMessage, OutgoingMessageCopiedBytes) {
  uint8_t bytes1[]{1, 2};
  uint8_t bytes2[]{3};
  uint8_t bytes3[]{4};
  zx_channel_iovec_t iovecs[] = {
      {
          .buffer = bytes1,
          .capacity = std::size(bytes1),
          .reserved = 0,
      },
      {
          .buffer = bytes2,
          .capacity = std::size(bytes2),
          .reserved = 0,
      },
      {
          .buffer = bytes3,
          .capacity = std::size(bytes3),
          .reserved = 0,
      },
  };
  auto msg = fidl::OutgoingMessage::Create_InternalMayBreak({
      .iovecs = iovecs,
      .num_iovecs = std::size(iovecs),
  });

  uint8_t expected_bytes[] = {1, 2, 3, 4};
  EXPECT_EQ(4u, msg.CountBytes());
  fidl::OutgoingMessage::CopiedBytes msg_bytes = msg.CopyBytes();
  EXPECT_EQ(std::size(expected_bytes), msg_bytes.size());
  EXPECT_EQ(0, memcmp(expected_bytes, msg_bytes.data(), std::size(expected_bytes)));
}

TEST(OutgoingMessage, SettingTxIdRequiresTransactionalMessageNegative) {
  fidl_llcpp_linearized_test::wire::NoOpLinearizedStruct value{.x = 42};
  fidl::internal::OwnedEncodedMessage<fidl_llcpp_linearized_test::wire::NoOpLinearizedStruct>
      encoded(fidl::internal::WireFormatVersion::kV2, &value);
  ASSERT_EQ(ZX_OK, encoded.status());
  ASSERT_DEATH({ encoded.GetOutgoingMessage().set_txid(1); }, "transactional");
}

TEST(OutgoingMessage, SettingTxIdRequiresTransactionalMessagePositive) {
  using Request = fidl::internal::TransactionalRequest<fidl_test_misc::Echo::EchoString>;
  Request request{fidl::StringView("")};
  fidl::internal::OwnedEncodedMessage<Request> encoded(fidl::internal::WireFormatVersion::kV2,
                                                       &request);
  ASSERT_EQ(ZX_OK, encoded.status());
  encoded.GetOutgoingMessage().set_txid(1);
}