// 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 <lib/fit/function.h>
#include <lib/zx/channel.h>
#include <lib/zx/event.h>
#include <lib/zx/fifo.h>
#include <lib/zx/object.h>
#include <lib/zx/socket.h>
#include <unistd.h>
#include <zircon/compiler.h>
#include <zircon/errors.h>
#include <zircon/rights.h>
#include <zircon/types.h>

#include <atomic>
#include <cstdio>
#include <cstdlib>
#include <limits>
#include <set>
#include <vector>

#include <zxtest/zxtest.h>

namespace {

// Data used for writing into a channel.
constexpr uint32_t kChannelData = 0xbaadcafe;

void GetBasicInfo(zx_handle_t handle, zx_info_handle_basic_t* info) {
  ASSERT_OK(zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, info, sizeof(zx_info_handle_basic_t),
                               nullptr, nullptr));
}
zx_status_t ExpectedCloseResult(zx_handle_op_t op) {
  if (op == ZX_HANDLE_OP_DUPLICATE)
    return ZX_OK;
  else
    return ZX_ERR_BAD_HANDLE;
}

const std::string test_case_str[] = {"Test case operation arg: ZX_HANDLE_OP_MOVE",
                                     "Test case operation arg: ZX_HANDLE_OP_DUPLICATE"};

TEST(ChannelWriteEtcTest, MultipleHandlesSomeInvalidResultsReportedCorrectly) {
  zx::channel channel_local, channel_remote, channel_arg_local, channel_arg_remote;
  zx::socket socket_local, socket_remote;
  zx::event event;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
  ASSERT_OK(zx::channel::create(0, &channel_arg_local, &channel_arg_remote));
  ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
  ASSERT_OK(zx::event::create(0, &event));

  zx_handle_t socket_local_handle = socket_local.release();
  zx_handle_t socket_remote_handle = socket_remote.release();
  zx_handle_t event_handle = event.release();
  zx_handle_t channel_handle = channel_arg_local.release();

  // socket_local_handle wrong type. sock_remote_handle OK. channel_handle can't be duped,
  // event_handle OK.
  zx_handle_disposition_t send_handle_list[] = {
      {ZX_HANDLE_OP_MOVE, socket_local_handle, ZX_OBJ_TYPE_PORT, ZX_RIGHT_SAME_RIGHTS, ZX_OK},
      {ZX_HANDLE_OP_MOVE, socket_remote_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK},
      {ZX_HANDLE_OP_DUPLICATE, channel_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK},
      {ZX_HANDLE_OP_MOVE, event_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

  EXPECT_EQ(ZX_ERR_WRONG_TYPE,
            channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                    std::size(send_handle_list)));

  EXPECT_EQ(ZX_ERR_WRONG_TYPE, send_handle_list[0].result);
  EXPECT_EQ(ZX_OK, send_handle_list[1].result);
  EXPECT_EQ(ZX_ERR_ACCESS_DENIED, send_handle_list[2].result);
  EXPECT_EQ(ZX_OK, send_handle_list[3].result);

  EXPECT_OK(zx_handle_close(channel_handle));
}

TEST(ChannelWriteEtcTest, ImproperlyInitalizedResultsArgReportedBackAsOriginallyInitalized) {
  zx::channel channel_local, channel_remote;
  zx::event event;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
  ASSERT_OK(zx::event::create(0, &event));

  zx_handle_t event_handle = event.release();

  zx_handle_disposition_t send_handle_list[] = {
      {ZX_HANDLE_OP_MOVE, event_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_ERR_WRONG_TYPE}};

  EXPECT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                    std::size(send_handle_list)));

  EXPECT_EQ(ZX_ERR_WRONG_TYPE, send_handle_list[0].result);
}

TEST(ChannelWriteEtcTest, FailureDoesNotResultInReceivedPacket) {
  zx::channel channel_local, channel_remote;
  zx::event event;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
  ASSERT_OK(zx::event::create(0, &event));

  zx_handle_t event_handle = event.release();

  zx_handle_disposition_t send_handle_list[] = {
      {ZX_HANDLE_OP_MOVE, event_handle, ZX_OBJ_TYPE_SOCKET, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

  EXPECT_EQ(ZX_ERR_WRONG_TYPE,
            channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                    std::size(send_handle_list)));
  uint32_t incoming_bytes;
  zx_handle_t incoming_handle;
  ASSERT_EQ(ZX_ERR_SHOULD_WAIT, channel_remote.read(0, &incoming_bytes, &incoming_handle,
                                                    sizeof(incoming_bytes), 1, nullptr, nullptr));
}

TEST(ChannelWriteEtcTest, SentHandleReferrsToSameObject) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::event event;

    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
    ASSERT_OK(zx::event::create(0, &event));

    zx_handle_t event_handle = event.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, event_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    zx_info_handle_basic_t event_info = {};
    GetBasicInfo(event_handle, &event_info);

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());
    ASSERT_EQ(expected_close_result, zx_handle_close(event_handle), "%s",
              test_case_str[op].c_str());

    uint32_t incoming_bytes;
    zx_handle_t incoming_handle;
    ASSERT_OK(channel_remote.read(0, &incoming_bytes, &incoming_handle, sizeof(incoming_bytes), 1,
                                  nullptr, nullptr),
              "%s", test_case_str[op].c_str());

    zx_info_handle_basic_t incoming_event_info = {};
    GetBasicInfo(incoming_handle, &incoming_event_info);

    EXPECT_EQ(event_info.koid, incoming_event_info.koid, "%s", test_case_str[op].c_str());
    EXPECT_EQ(event_info.rights, incoming_event_info.rights, "%s", test_case_str[op].c_str());
    EXPECT_EQ(event_info.type, incoming_event_info.type, "%s", test_case_str[op].c_str());
    EXPECT_OK(zx_handle_close(incoming_handle), "%s", test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, InvalidOpArgShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, std::string op_str, zx_status_t expected_close_result) {
    zx::socket socket_local, socket_remote;
    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    zx::channel channel_local, channel_remote;
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    EXPECT_EQ(ZX_ERR_INVALID_ARGS,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", op_str.c_str());

    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s", op_str.c_str());
  };

  TestHelper(0xffffffff, "op arg: 0xffffffff", ZX_ERR_BAD_HANDLE);
  TestHelper(2, "op arg: 2", ZX_ERR_BAD_HANDLE);
}

TEST(ChannelWriteEtcTest, HandleArgNotAChannelHandleShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::socket socket_local, socket_remote;
    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));

    zx_handle_t socket_local_handle = socket_local.release();
    zx_handle_t socket_remote_handle = socket_remote.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_remote_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_EQ(ZX_ERR_WRONG_TYPE,
              zx_channel_write_etc(socket_local_handle, 0, &kChannelData, sizeof(kChannelData),
                                   send_handle_list, std::size(send_handle_list)));

    ASSERT_OK(zx_handle_close(socket_local_handle));
    ASSERT_EQ(expected_close_result, zx_handle_close(socket_remote_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, ChannelHandleNotValidShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::socket socket_local, socket_remote;
    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    zx::channel channel_local, channel_remote;
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
    zx_handle_t channel_local_handle = channel_local.release();
    ASSERT_OK(zx_handle_close(channel_local_handle));

// Disable this for analyzer since this is an intentional use-after-free.
#ifndef __clang_analyzer__
    EXPECT_EQ(ZX_ERR_BAD_HANDLE,
              zx_channel_write_etc(channel_local_handle, 0, &kChannelData, sizeof(kChannelData),
                                   send_handle_list, std::size(send_handle_list)));
#endif

    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, ChannelHandleWithoutWriteRightShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote, channel_local_no_write;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_info_handle_basic_t channel_local_info = {};
    GetBasicInfo(channel_local.get(), &channel_local_info);

    zx_handle_t socket_local_handle = socket_local.release();
    zx_handle_disposition_t send_handle_list = {op, socket_local_handle, ZX_OBJ_TYPE_NONE,
                                                ZX_RIGHT_SAME_RIGHTS, ZX_OK};

    // Removing mandatory ZX_RIGHT_WRITE should fail
    ASSERT_OK(channel_local.replace(channel_local_info.rights & ~ZX_RIGHT_WRITE,
                                    &channel_local_no_write));
    ASSERT_EQ(ZX_ERR_ACCESS_DENIED,
              channel_local_no_write.write_etc(0, &kChannelData, sizeof(kChannelData),
                                               &send_handle_list, 1));
    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, HandleWithoutTransferRightShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote, socket_local_no_transfer;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_info_handle_basic_t socket_local_info = {};
    GetBasicInfo(socket_local.get(), &socket_local_info);

    ASSERT_OK(socket_local.replace(socket_local_info.rights & ~ZX_RIGHT_TRANSFER,
                                   &socket_local_no_transfer));

    zx_handle_t socket_local_no_transfer_handle = socket_local_no_transfer.release();
    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_no_transfer_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_EQ(ZX_ERR_ACCESS_DENIED,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)));
    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_no_transfer_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, InvalidHandleInTransferredHandlesShouldFail) {
  auto TestHelper = [](zx_handle_t bad_handle, std::string testcase) {
    zx::channel channel_local, channel_remote;
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
    zx_handle_disposition_t send_handle_list[] = {
        {ZX_HANDLE_OP_DUPLICATE, bad_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    EXPECT_EQ(ZX_ERR_BAD_HANDLE,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "test case: %s", testcase.c_str());
  };

  zx::socket socket_local, socket_remote;
  ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
  zx_handle_t socket_handle = socket_local.release();
  EXPECT_OK(zx_handle_close(socket_handle));

// Disable this for analyzer since this is an intentional use-after-free.
#ifndef __clang_analyzer__
  TestHelper(socket_handle, "closed socket handle");
#endif
  TestHelper(ZX_HANDLE_INVALID, "ZX_HANDLE_INVALID");
  TestHelper(0xffffffff, "0xffffffff");
}

TEST(ChannelWriteEtcTest, RepeatedHandlesWithOpMoveHandlesShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK},
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    EXPECT_EQ(ZX_ERR_BAD_HANDLE,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());

    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
}

TEST(ChannelWriteEtcTest, DuplicateHandlesInTransferredHandlesShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote, socket_local_duplicate;

    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));
    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(socket_local.duplicate(ZX_RIGHT_SAME_RIGHTS, &socket_local_duplicate));

    zx_handle_t socket_local_handle = socket_local.release();
    zx_handle_t socket_local_duplicate_handle = socket_local_duplicate.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK},
        {op, socket_local_duplicate_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    EXPECT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());
    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_duplicate_handle), "%s",
              test_case_str[op].c_str());
  };
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, HandleDoesNotMatchTypeShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_obj_type_t obj_type,
                       zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, obj_type, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    EXPECT_EQ(ZX_ERR_WRONG_TYPE,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "test case: obj_type: %u op: %d", obj_type, op);

    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_handle),
              "test case: obj_type: %u op: %d", obj_type, op);
  };

  for (zx_obj_type_t obj_type = 0; obj_type < 256; obj_type++) {
    if ((obj_type == ZX_OBJ_TYPE_SOCKET) || (obj_type == ZX_OBJ_TYPE_NONE))
      continue;
    TestHelper(ZX_HANDLE_OP_MOVE, obj_type, ZX_ERR_BAD_HANDLE);
    TestHelper(ZX_HANDLE_OP_DUPLICATE, obj_type, ZX_OK);
  }
}

TEST(ChannelWriteEtcTest, OptionsArgNonZeroShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_EQ(ZX_ERR_INVALID_ARGS,
              channel_local.write_etc(1, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)));

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, ChannelHandleInTransferredHandlesShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx_handle_t channel_local, channel_remote;

    ASSERT_OK(zx_channel_create(0, &channel_local, &channel_remote));

    zx_handle_disposition_t send_handle_list[] = {
        {op, channel_local, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_EQ(ZX_ERR_NOT_SUPPORTED,
              zx_channel_write_etc(channel_local, 0, &kChannelData, sizeof(kChannelData),
                                   send_handle_list, std::size(send_handle_list)));

    ASSERT_EQ(expected_close_result, zx_handle_close(channel_local), "%s",
              test_case_str[op].c_str());
    ASSERT_OK(zx_handle_close(channel_remote), "%s", test_case_str[op].c_str());
  };
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, OppositeChannelEndClosedShouldFail) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();
    channel_remote.reset();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_EQ(ZX_ERR_PEER_CLOSED,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)));

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, HandleCountBoundaryChecks) {
  auto TestHelper = [](zx_handle_op_t op, uint32_t num_handles, zx_status_t expected_write_result) {
    zx::channel channel_local, channel_remote;
    zx::event event[ZX_CHANNEL_MAX_MSG_HANDLES + 1];
    zx_handle_t event_handle[ZX_CHANNEL_MAX_MSG_HANDLES + 1];

    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_disposition_t send_handle_list[ZX_CHANNEL_MAX_MSG_HANDLES + 1];

    for (uint32_t i = 0; i < num_handles; ++i) {
      ASSERT_OK(zx::event::create(0, &event[i]));
      event_handle[i] = event[i].release();
      send_handle_list[i] = {op, event_handle[i], ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK};
    }

    ASSERT_EQ(expected_write_result,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      num_handles),
              "test case num_handles: %d op: %d", num_handles, op);

    for (uint32_t i = 0; i < num_handles; ++i) {
      EXPECT_EQ(ExpectedCloseResult(op), zx_handle_close(event_handle[i]),
                "test case num_handles: %d op: %d i: %d", num_handles, op, i);
    }
  };

  TestHelper(ZX_HANDLE_OP_MOVE, 0, ZX_OK);
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_CHANNEL_MAX_MSG_HANDLES, ZX_OK);
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_CHANNEL_MAX_MSG_HANDLES + 1, ZX_ERR_OUT_OF_RANGE);

  TestHelper(ZX_HANDLE_OP_DUPLICATE, 0, ZX_OK);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_CHANNEL_MAX_MSG_HANDLES, ZX_OK);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_CHANNEL_MAX_MSG_HANDLES + 1, ZX_ERR_OUT_OF_RANGE);
}

TEST(ChannelWriteEtcTest, HandleCountAndDataCountBothZeroShouldSucceed) {
  zx::channel channel_local, channel_remote;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

  ASSERT_EQ(ZX_OK, channel_local.write_etc(0, nullptr, 0, nullptr, 0));
}

TEST(ChannelWriteEtcTest, MaximumNumberHandlesWithZeroCountArrayArgShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::event event[ZX_CHANNEL_MAX_MSG_HANDLES];
    zx_handle_t event_handle[ZX_CHANNEL_MAX_MSG_HANDLES];

    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_disposition_t send_handle_list[ZX_CHANNEL_MAX_MSG_HANDLES];

    for (uint32_t i = 0; i < std::size(send_handle_list); ++i) {
      ASSERT_OK(zx::event::create(0, &event[i]));
      event_handle[i] = event[i].release();
      send_handle_list[i] = {op, event_handle[i], ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK};
    }

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list, 0));

    for (uint32_t i = 0; i < std::size(event_handle); ++i) {
      ASSERT_EQ(expected_close_result, zx_handle_close(event_handle[i]), "%d: %s", i,
                test_case_str[op].c_str());
    }
  };

  // Since handle count set to 0, none of the handles should have been touched so even
  // the move case the handles should still be untouched and valid, and close without error.
  TestHelper(ZX_HANDLE_OP_MOVE, ZX_OK);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, ByteCountIsMaxShouldSucceed) {
  zx::channel channel_local, channel_remote;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

  uint8_t byte_array[ZX_CHANNEL_MAX_MSG_BYTES];

  ASSERT_EQ(ZX_OK, channel_local.write_etc(0, &byte_array, sizeof(byte_array), nullptr, 0));
}

TEST(ChannelWriteEtcTest, ByteCountIsMaxPlusOneShouldFail) {
  zx::channel channel_local, channel_remote;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

  uint8_t byte_array[ZX_CHANNEL_MAX_MSG_BYTES + 1];

  ASSERT_EQ(ZX_ERR_OUT_OF_RANGE,
            channel_local.write_etc(0, &byte_array, sizeof(byte_array), nullptr, 0));
}

TEST(ChannelWriteEtcTest, NullptrArgWhenSizeNonZeroShouldFail) {
  zx::channel channel_local, channel_remote;

  ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

  EXPECT_EQ(ZX_ERR_INVALID_ARGS, channel_local.write_etc(0, nullptr, 10, nullptr, 0));

  EXPECT_EQ(ZX_ERR_INVALID_ARGS, channel_local.write_etc(0, nullptr, 0, nullptr, 10));
}

TEST(ChannelWriteEtcTest, RemoveAllHandleRightsShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_NONE, ZX_OK}};

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());

    uint32_t incoming_bytes;
    zx_handle_t incoming_handle;
    zx_info_handle_basic_t info;
    ASSERT_OK(channel_remote.read(0, &incoming_bytes, &incoming_handle, sizeof(incoming_bytes), 1,
                                  nullptr, nullptr));
    GetBasicInfo(incoming_handle, &info);

    ASSERT_EQ(ZX_RIGHT_NONE, info.rights);
    ASSERT_OK(zx_handle_close(incoming_handle));
    ASSERT_EQ(ZX_OBJ_TYPE_SOCKET, info.type);
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, RemovingSomeHandleRightsShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_info_handle_basic_t info_before;
    GetBasicInfo(socket_local_handle, &info_before);

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, info_before.rights & ~ZX_RIGHT_WRITE, ZX_OK}};

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());

    uint32_t incoming_bytes;
    zx_handle_t incoming_handle;
    zx_info_handle_basic_t info_after;
    ASSERT_OK(channel_remote.read(0, &incoming_bytes, &incoming_handle, sizeof(incoming_bytes), 1,
                                  nullptr, nullptr));
    GetBasicInfo(incoming_handle, &info_after);

    EXPECT_EQ(info_before.rights & ~ZX_RIGHT_WRITE, info_after.rights, "%s",
              test_case_str[op].c_str());
    EXPECT_OK(zx_handle_close(incoming_handle), "%s", test_case_str[op].c_str());
    EXPECT_EQ(ZX_OBJ_TYPE_SOCKET, info_after.type, "%s", test_case_str[op].c_str());

    // In ZX_HANDLE_OP_DUPLICATE case, original right should not have been affected
    if (op == ZX_HANDLE_OP_DUPLICATE) {
      zx_info_handle_basic_t info_original_after;
      GetBasicInfo(socket_local_handle, &info_original_after);
      EXPECT_EQ(info_before.rights, info_original_after.rights, "%s", test_case_str[op].c_str());
    }

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, SameHandleRightsBitsShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_info_handle_basic_t info_before;
    GetBasicInfo(socket_local_handle, &info_before);

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, info_before.rights, ZX_OK}};

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());

    uint32_t incoming_bytes;
    zx_handle_t incoming_handle;
    zx_info_handle_basic_t info_after;
    ASSERT_OK(channel_remote.read(0, &incoming_bytes, &incoming_handle, sizeof(incoming_bytes), 1,
                                  nullptr, nullptr));
    GetBasicInfo(incoming_handle, &info_after);

    EXPECT_EQ(info_before.rights, info_after.rights, "%s", test_case_str[op].c_str());
    EXPECT_OK(zx_handle_close(incoming_handle), "%s", test_case_str[op].c_str());
    EXPECT_EQ(ZX_OBJ_TYPE_SOCKET, info_after.type, "%s", test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, SameHandleRightsFlagShouldSucceed) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();

    zx_info_handle_basic_t info_before;
    GetBasicInfo(socket_local_handle, &info_before);

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    ASSERT_OK(channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s", test_case_str[op].c_str());

    ASSERT_EQ(expected_close_result, zx_handle_close(socket_local_handle), "%s",
              test_case_str[op].c_str());

    uint32_t incoming_bytes;
    zx_handle_t incoming_handle;
    zx_info_handle_basic_t info_after;
    ASSERT_OK(channel_remote.read(0, &incoming_bytes, &incoming_handle, sizeof(incoming_bytes), 1,
                                  nullptr, nullptr));
    GetBasicInfo(incoming_handle, &info_after);

    EXPECT_EQ(info_before.rights, info_after.rights, "%s", test_case_str[op].c_str());
    EXPECT_OK(zx_handle_close(incoming_handle), "%s", test_case_str[op].c_str());
    EXPECT_EQ(ZX_OBJ_TYPE_SOCKET, info_after.type, "%s", test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK);
}

TEST(ChannelWriteEtcTest, HandleWithoutDuplicateRightsMoveOpSucceedsDuplicateOpFails) {
  auto TestHelper = [](zx_handle_op_t op, zx_status_t expected_close_result,
                       zx_status_t expected_write_result) {
    zx::channel channel_local, channel_remote;
    zx::socket socket_local, socket_remote;

    ASSERT_OK(zx::socket::create(ZX_SOCKET_STREAM, &socket_local, &socket_remote));
    ASSERT_OK(zx::channel::create(0, &channel_local, &channel_remote));

    zx_handle_t socket_local_handle = socket_local.release();
    zx_info_handle_basic_t info;
    GetBasicInfo(socket_local_handle, &info);

    zx_handle_t socket_local_no_duplicate_handle;
    ASSERT_OK(zx_handle_duplicate(socket_local_handle, info.rights & ~ZX_RIGHT_DUPLICATE,
                                  &socket_local_no_duplicate_handle));

    zx_handle_disposition_t send_handle_list[] = {
        {op, socket_local_no_duplicate_handle, ZX_OBJ_TYPE_NONE, ZX_RIGHT_SAME_RIGHTS, ZX_OK}};

    EXPECT_EQ(expected_write_result,
              channel_local.write_etc(0, &kChannelData, sizeof(kChannelData), send_handle_list,
                                      std::size(send_handle_list)),
              "%s rights: 0x%x", test_case_str[op].c_str(), info.rights & ~ZX_RIGHT_DUPLICATE);

    EXPECT_EQ(expected_close_result, zx_handle_close(socket_local_no_duplicate_handle), "%s",
              test_case_str[op].c_str());
  };

  TestHelper(ZX_HANDLE_OP_MOVE, ZX_ERR_BAD_HANDLE, ZX_OK);
  TestHelper(ZX_HANDLE_OP_DUPLICATE, ZX_OK, ZX_ERR_ACCESS_DENIED);
}

}  // namespace