// Copyright 2017 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/fidl/coding.h>
#include <stddef.h>

#include <cstdio>
#include <limits>
#include <memory>

#include <zxtest/zxtest.h>

#include "array_util.h"
#include "extra_messages.h"
#include "fidl_coded_types.h"
#include "fidl_structs.h"

namespace fidl {
namespace {

// Some notes:
//
// - All tests of out-of-line bounded allocation overruns need to have
//   another big out-of-line allocation following it. This
//   distinguishes "the buffer is too small" from "the bits on the
//   wire asked for more than the type allowed".

// TODO(kulakowski) Change the tests to check for more specific error
// values, once those are settled.

constexpr zx_handle_t dummy_handle_0 = static_cast<zx_handle_t>(23);
constexpr zx_handle_t dummy_handle_1 = static_cast<zx_handle_t>(24);
constexpr zx_handle_t dummy_handle_2 = static_cast<zx_handle_t>(25);
constexpr zx_handle_t dummy_handle_3 = static_cast<zx_handle_t>(26);
constexpr zx_handle_t dummy_handle_4 = static_cast<zx_handle_t>(27);
constexpr zx_handle_t dummy_handle_5 = static_cast<zx_handle_t>(28);
constexpr zx_handle_t dummy_handle_6 = static_cast<zx_handle_t>(29);
constexpr zx_handle_t dummy_handle_7 = static_cast<zx_handle_t>(30);
constexpr zx_handle_t dummy_handle_8 = static_cast<zx_handle_t>(31);
constexpr zx_handle_t dummy_handle_9 = static_cast<zx_handle_t>(32);
constexpr zx_handle_t dummy_handle_10 = static_cast<zx_handle_t>(33);
constexpr zx_handle_t dummy_handle_11 = static_cast<zx_handle_t>(34);
constexpr zx_handle_t dummy_handle_12 = static_cast<zx_handle_t>(35);
constexpr zx_handle_t dummy_handle_13 = static_cast<zx_handle_t>(36);
constexpr zx_handle_t dummy_handle_14 = static_cast<zx_handle_t>(37);
constexpr zx_handle_t dummy_handle_15 = static_cast<zx_handle_t>(38);
constexpr zx_handle_t dummy_handle_16 = static_cast<zx_handle_t>(39);
constexpr zx_handle_t dummy_handle_17 = static_cast<zx_handle_t>(40);
constexpr zx_handle_t dummy_handle_18 = static_cast<zx_handle_t>(41);
constexpr zx_handle_t dummy_handle_19 = static_cast<zx_handle_t>(42);
constexpr zx_handle_t dummy_handle_20 = static_cast<zx_handle_t>(43);
constexpr zx_handle_t dummy_handle_21 = static_cast<zx_handle_t>(44);
constexpr zx_handle_t dummy_handle_22 = static_cast<zx_handle_t>(45);
constexpr zx_handle_t dummy_handle_23 = static_cast<zx_handle_t>(46);
constexpr zx_handle_t dummy_handle_24 = static_cast<zx_handle_t>(47);
constexpr zx_handle_t dummy_handle_25 = static_cast<zx_handle_t>(48);
constexpr zx_handle_t dummy_handle_26 = static_cast<zx_handle_t>(49);
constexpr zx_handle_t dummy_handle_27 = static_cast<zx_handle_t>(50);
constexpr zx_handle_t dummy_handle_28 = static_cast<zx_handle_t>(51);
constexpr zx_handle_t dummy_handle_29 = static_cast<zx_handle_t>(52);

zx_status_t fidl_validate_v2_transactional(const fidl_type_t* type, void* bytes, uint32_t num_bytes,
                                           uint32_t num_handles, const char** error_msg_out) {
  uint8_t* trimmed_bytes;
  uint32_t trimmed_num_bytes;
  zx_status_t trim_status = ::fidl::internal::fidl_exclude_header_bytes(
      bytes, num_bytes, &trimmed_bytes, &trimmed_num_bytes, error_msg_out);
  if (unlikely(trim_status != ZX_OK)) {
    return ZX_ERR_INVALID_ARGS;
  }

  return internal__fidl_validate__v2__may_break(type, trimmed_bytes, trimmed_num_bytes, num_handles,
                                                error_msg_out);
}

TEST(NullParameters, validate_v2_null_validate_parameters) {
  zx_handle_t handles[] = {static_cast<zx_handle_t>(23)};

  // Null message type.
  {
    nonnullable_handle_message_layout message = {};
    message.inline_struct.handle = FIDL_HANDLE_PRESENT;
    const char* error = nullptr;
    auto status = fidl_validate_v2_transactional(
        nullptr, &message, sizeof(nonnullable_handle_message_layout), ArrayCount(handles), &error);
    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
    EXPECT_NOT_NULL(error);
  }

  // Null message.
  {
    const char* error = nullptr;
    auto status = internal__fidl_validate__v2__may_break(&nonnullable_handle_message_type, nullptr,
                                                         sizeof(nonnullable_handle_message_layout),
                                                         ArrayCount(handles), &error);
    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
    EXPECT_NOT_NULL(error);
  }

  // Zero handles, for a message that has a handle.
  {
    nonnullable_handle_message_layout message = {};
    message.inline_struct.handle = FIDL_HANDLE_PRESENT;
    const char* error = nullptr;
    auto status = internal__fidl_validate__v2__may_break(&nonnullable_handle_message_type, &message,
                                                         sizeof(nonnullable_handle_message_layout),
                                                         0, &error);
    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
    EXPECT_NOT_NULL(error);
  }

  // A null error string pointer is ok, though.
  {
    auto status = internal__fidl_validate__v2__may_break(nullptr, nullptr, 0u, 0u, nullptr);
    EXPECT_NE(status, ZX_OK);
  }

  // A null error is also ok in success cases.
  {
    nonnullable_handle_message_layout message = {};
    message.inline_struct.handle = FIDL_HANDLE_PRESENT;
    auto status = fidl_validate_v2_transactional(&nonnullable_handle_message_type, &message,
                                                 sizeof(nonnullable_handle_message_layout),
                                                 ArrayCount(handles), nullptr);
    EXPECT_EQ(status, ZX_OK);
  }
}

// The Walker tests are disabled for host because they depend on fidl
// generated LLCPP code that can't run on host.

// TODO(https://fxbug.dev/42129678): Move this test to GIDL.
#ifdef __Fuchsia__
TEST(Walker, validate_v2_walker_recursive_struct_max_out_of_line_depth) {
  // Up to 32 out of line objects are allowed - here there are 33 pointers.
  uintptr_t message[34];
  for (int i = 0; i < 33; i++) {
    message[i] = 0xffffffffffffffff;
  }
  message[33] = 0;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_RecursiveOptionalTable,
                                                       &message[0], sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_STREQ(error, "recursion depth exceeded");

  // Reduce the max recursion depth by 1.
  status =
      internal__fidl_validate__v2__may_break(&fidl_test_coding_RecursiveOptionalTable, &message[1],
                                             sizeof(message) - sizeof(uintptr_t), 0, &error);
  EXPECT_EQ(status, ZX_OK);
}
#endif

// TODO(https://fxbug.dev/42129678): Move this test to GIDL.
#ifdef __Fuchsia__
TEST(Walker, validate_v2_walker_table_max_out_of_line_depth_exceeded) {
  // 1 table + 31 non-null pointers + 1 null pointer = 33 out of line elements.
  uint8_t message[sizeof(fidl_vector_t) + sizeof(fidl_envelope_t) + sizeof(uintptr_t) * 32];
  fidl_vector_t* vec = reinterpret_cast<fidl_vector_t*>(message);
  fidl_envelope_t* envelope = reinterpret_cast<fidl_envelope_t*>(message + sizeof(fidl_vector_t));
  uintptr_t* opt_structs =
      reinterpret_cast<uintptr_t*>(message + sizeof(fidl_vector_t) + sizeof(fidl_envelope_t));
  vec->count = 1;
  vec->data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT);
  envelope->num_bytes = 256;
  envelope->num_handles = 0;
  envelope->flags = 0;
  for (int i = 0; i < 31; i++) {
    opt_structs[i] = FIDL_ALLOC_PRESENT;
  }
  opt_structs[31] = 0;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_RecursiveTableTable,
                                                       &message[0], sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_STREQ(error, "recursion depth exceeded");
}

// TODO(https://fxbug.dev/42129678): Move this test to GIDL.
TEST(Walker, validate_v2_walker_table_max_out_of_line_depth_matched) {
  // 1 table + 30 non-null pointers + 1 null pointer = 32 out of line elements.
  uint8_t message[sizeof(fidl_vector_t) + sizeof(fidl_envelope_t) + sizeof(uintptr_t) * 31];
  fidl_vector_t* vec = reinterpret_cast<fidl_vector_t*>(message);
  fidl_envelope_t* envelope = reinterpret_cast<fidl_envelope_t*>(message + sizeof(fidl_vector_t));
  uintptr_t* opt_structs =
      reinterpret_cast<uintptr_t*>(message + sizeof(fidl_vector_t) + sizeof(fidl_envelope_t));
  vec->count = 1;
  vec->data = reinterpret_cast<void*>(FIDL_ALLOC_PRESENT);
  envelope->num_bytes = 248;
  envelope->num_handles = 0;
  envelope->flags = 0;
  for (int i = 0; i < 30; i++) {
    opt_structs[i] = FIDL_ALLOC_PRESENT;
  }
  opt_structs[30] = 0;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_RecursiveTableTable,
                                                       &message[0], sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_OK);
}
#endif

TEST(BufferTooSmall, validate_v2_overflow_buffer_on_FidlAlign) {
  // Message: Struct with 1 1-byte (uint8) field.
  // Field type.
  const FidlCodedPrimitive element_field_type = {
      .tag = kFidlTypePrimitive,
      .type = kFidlCodedPrimitiveSubtype_Uint8,
  };
  // Field.
  const FidlStructElement element = {
      .field =
          {
              .header =
                  {
                      .element_type = kFidlStructElementType_Field,
                      .is_resource = kFidlIsResource_NotResource,
                  },
              .offset_v2 = 0,
              .field_type = &element_field_type,
          },
  };
  // Struct.
  const FidlCodedStruct type = {
      .tag = kFidlTypeStruct,
      .element_count = 1,
      .size_v2 = 1,
      .elements = &element,
      .name = nullptr,
  };
  // Message: Aligned and 0-padded to exercise checks after 0-pad check.
  alignas(FIDL_ALIGNMENT) uint8_t message[2 * FIDL_ALIGNMENT] = {};
  const char* error = nullptr;

  // Message intended to contain 1 byte (though more bytes prepared/0-padded).
  auto status = internal__fidl_validate__v2__may_break(&type, &message, 1, 0, &error);

  // Expect error to be something about buffer too small (for for properly padded message).
  EXPECT_EQ(status, ZX_ERR_BUFFER_TOO_SMALL);
  EXPECT_NOT_NULL(error);
  ASSERT_SUBSTR(error, "too small");
}

TEST(Handles, validate_v2_single_present_handle_unaligned_error) {
  // Test a short, unaligned version of nonnullable message
  // handle. All fidl message objects should be 8 byte aligned.
  //
  // We use a 16 bytes array rather than fidl_message_header_t, and
  // manually place the |message| structure at a 4 bytes offset,
  // to avoid aligning to 8 bytes.
  struct unaligned_nonnullable_handle_inline_data {
    uint8_t header[sizeof(fidl_message_header_t)];
    zx_handle_t handle;
  };
  struct unaligned_nonnullable_handle_message_layout {
    unaligned_nonnullable_handle_inline_data inline_struct;
  };

  uint8_t message_buffer[FIDL_ALIGN(sizeof(unaligned_nonnullable_handle_message_layout) +
                                    sizeof(zx_handle_t))] = {};
  unaligned_nonnullable_handle_message_layout& message =
      *reinterpret_cast<unaligned_nonnullable_handle_message_layout*>(
          &message_buffer[sizeof(zx_handle_t)]);
  message.inline_struct.handle = FIDL_HANDLE_PRESENT;

  zx_handle_t handles[] = {
      dummy_handle_0,
  };

  // Validating the unaligned version of the struct should fail.
  const char* error = nullptr;
  auto status = fidl_validate_v2_transactional(&nonnullable_handle_message_type, &message,
                                               sizeof(message), ArrayCount(handles), &error);

  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
}

TEST(Structs, validate_v2_nested_nonnullable_structs) {
  nested_structs_message_layout message = {};
  message.inline_struct.l0.handle_0 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0.l1.handle_1 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0.l1.l2.handle_2 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0.l1.l2.l3.handle_3 = FIDL_HANDLE_PRESENT;

  zx_handle_t handles[] = {
      dummy_handle_0,
      dummy_handle_1,
      dummy_handle_2,
      dummy_handle_3,
  };

  const char* error = nullptr;
  auto status = fidl_validate_v2_transactional(&nested_structs_message_type, &message,
                                               sizeof(message), ArrayCount(handles), &error);

  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
  // Note the traversal order! l1 -> l3 -> l2 -> l0
  EXPECT_EQ(message.inline_struct.l0.l1.handle_1, FIDL_HANDLE_PRESENT);
  EXPECT_EQ(message.inline_struct.l0.l1.l2.l3.handle_3, FIDL_HANDLE_PRESENT);
  EXPECT_EQ(message.inline_struct.l0.l1.l2.handle_2, FIDL_HANDLE_PRESENT);
  EXPECT_EQ(message.inline_struct.l0.handle_0, FIDL_HANDLE_PRESENT);
}

TEST(Structs, validate_v2_nested_nonnullable_structs_check_padding) {
  // Wire-format:
  // message
  // - 16 bytes header
  // + struct_level_0  -------------  offset 16 = 4 * 4
  //   - uint64_t
  //   + struct_level_1  -----------  offset 24 = 4 * 6
  //     - zx_handle_t
  //     - (4 bytes padding)  ------  offset 28 = 4 * 7
  //     + struct_level_2  ---------  offset 32 = 4 * 8
  //       - uint64_t
  //       + struct_level_3  -------  offset 40 = 4 * 10
  //         - uint32_t
  //         - zx_handle_t
  //       - zx_handle_t
  //       - (4 bytes padding)  ----  offset 52 = 4 * 13
  //     - uint64_t
  //   - zx_handle_t
  //   - (4 bytes padding)  --------  offset 68 = 4 * 17
  static_assert(sizeof(nested_structs_message_layout) == 68 + 4);
  // Hence the padding bytes are located at:
  size_t padding_offsets[] = {
      28, 29, 30, 31, 52, 53, 54, 55, 68, 69, 70, 71,
  };

  for (const auto padding_offset : padding_offsets) {
    constexpr size_t kBufferSize = sizeof(nested_structs_message_layout);
    nested_structs_message_layout message;
    uint8_t* buffer = reinterpret_cast<uint8_t*>(&message);
    memset(buffer, 0, kBufferSize);

    message.inline_struct.l0.handle_0 = FIDL_HANDLE_PRESENT;
    message.inline_struct.l0.l1.handle_1 = FIDL_HANDLE_PRESENT;
    message.inline_struct.l0.l1.l2.handle_2 = FIDL_HANDLE_PRESENT;
    message.inline_struct.l0.l1.l2.l3.handle_3 = FIDL_HANDLE_PRESENT;
    constexpr uint32_t kNumHandles = 4;

    buffer[padding_offset] = 0xAA;

    const char* error = nullptr;
    auto status = fidl_validate_v2_transactional(&nested_structs_message_type, &message,
                                                 kBufferSize, kNumHandles, &error);

    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
    ASSERT_NOT_NULL(error);
    EXPECT_STREQ(error, "non-zero padding bytes detected");
  }
}

TEST(Structs, validate_v2_nested_nullable_structs) {
  // See below for the handle traversal order.
  nested_struct_ptrs_message_layout message = {};

  message.inline_struct.l0_present = reinterpret_cast<struct_ptr_level_0*>(FIDL_ALLOC_PRESENT);
  message.inline_struct.l0_inline.l1_present =
      reinterpret_cast<struct_ptr_level_1*>(FIDL_ALLOC_PRESENT);
  message.inline_struct.l0_inline.l1_inline.l2_present =
      reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_PRESENT);
  message.inline_struct.l0_inline.l1_inline.l2_inline.l3_present =
      reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.in_in_out_2.l3_present = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.in_out_1.l2_present = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_PRESENT);
  message.in_out_1.l2_inline.l3_present = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.in_out_out_2.l3_present = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.out_0.l1_present = reinterpret_cast<struct_ptr_level_1*>(FIDL_ALLOC_PRESENT);
  message.out_0.l1_inline.l2_present = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_PRESENT);
  message.out_0.l1_inline.l2_inline.l3_present =
      reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.out_in_out_2.l3_present = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.out_out_1.l2_present = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_PRESENT);
  message.out_out_1.l2_inline.l3_present =
      reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);
  message.out_out_out_2.l3_present = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_PRESENT);

  message.inline_struct.l0_absent = reinterpret_cast<struct_ptr_level_0*>(FIDL_ALLOC_ABSENT);
  message.inline_struct.l0_inline.l1_absent =
      reinterpret_cast<struct_ptr_level_1*>(FIDL_ALLOC_ABSENT);
  message.inline_struct.l0_inline.l1_inline.l2_absent =
      reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_ABSENT);
  message.inline_struct.l0_inline.l1_inline.l2_inline.l3_absent =
      reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.in_in_out_2.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.in_out_1.l2_absent = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_ABSENT);
  message.in_out_1.l2_inline.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.in_out_out_2.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.out_0.l1_absent = reinterpret_cast<struct_ptr_level_1*>(FIDL_ALLOC_ABSENT);
  message.out_0.l1_inline.l2_absent = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_ABSENT);
  message.out_0.l1_inline.l2_inline.l3_absent =
      reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.out_in_out_2.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.out_out_1.l2_absent = reinterpret_cast<struct_ptr_level_2*>(FIDL_ALLOC_ABSENT);
  message.out_out_1.l2_inline.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);
  message.out_out_out_2.l3_absent = reinterpret_cast<struct_ptr_level_3*>(FIDL_ALLOC_ABSENT);

  message.inline_struct.l0_inline.l1_inline.handle_1 = FIDL_HANDLE_PRESENT;
  message.in_in_out_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_in_out_2.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_in_out_2.handle_2 = FIDL_HANDLE_PRESENT;
  message.in_in_in_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0_inline.l1_inline.l2_inline.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0_inline.l1_inline.l2_inline.handle_2 = FIDL_HANDLE_PRESENT;
  message.inline_struct.l0_inline.handle_0 = FIDL_HANDLE_PRESENT;
  message.in_out_1.handle_1 = FIDL_HANDLE_PRESENT;
  message.in_out_out_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_out_out_2.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_out_out_2.handle_2 = FIDL_HANDLE_PRESENT;
  message.in_out_in_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_out_1.l2_inline.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.in_out_1.l2_inline.handle_2 = FIDL_HANDLE_PRESENT;
  message.out_0.l1_inline.handle_1 = FIDL_HANDLE_PRESENT;
  message.out_in_out_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_in_out_2.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_in_out_2.handle_2 = FIDL_HANDLE_PRESENT;
  message.out_in_in_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_0.l1_inline.l2_inline.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_0.l1_inline.l2_inline.handle_2 = FIDL_HANDLE_PRESENT;
  message.out_0.handle_0 = FIDL_HANDLE_PRESENT;
  message.out_out_1.handle_1 = FIDL_HANDLE_PRESENT;
  message.out_out_out_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_out_out_2.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_out_out_2.handle_2 = FIDL_HANDLE_PRESENT;
  message.out_out_in_out_3.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_out_1.l2_inline.l3_inline.handle_3 = FIDL_HANDLE_PRESENT;
  message.out_out_1.l2_inline.handle_2 = FIDL_HANDLE_PRESENT;

  zx_handle_t handles[] = {
      dummy_handle_0,  dummy_handle_1,  dummy_handle_2,  dummy_handle_3,  dummy_handle_4,
      dummy_handle_5,  dummy_handle_6,  dummy_handle_7,  dummy_handle_8,  dummy_handle_9,
      dummy_handle_10, dummy_handle_11, dummy_handle_12, dummy_handle_13, dummy_handle_14,
      dummy_handle_15, dummy_handle_16, dummy_handle_17, dummy_handle_18, dummy_handle_19,
      dummy_handle_20, dummy_handle_21, dummy_handle_22, dummy_handle_23, dummy_handle_24,
      dummy_handle_25, dummy_handle_26, dummy_handle_27, dummy_handle_28, dummy_handle_29,
  };

  const char* error = nullptr;
  auto status = fidl_validate_v2_transactional(&nested_struct_ptrs_message_type, &message,
                                               sizeof(message), ArrayCount(handles), &error);

  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Xunions, validate_v2_valid_empty_nullable_xunion) {
  SampleNullableXUnionV2Struct message = {};

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &fidl_test_coding_SampleNullableXUnionStructTable, &message, sizeof(fidl_union_t), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Xunions, validate_v2_empty_nonnullable_xunion) {
  SampleXUnionV2Struct message = {};

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_SampleXUnionStructTable,
                                                       &message, sizeof(fidl_union_t), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
  EXPECT_STREQ(error, "non-nullable xunion is absent");
}

TEST(Xunions, validate_v2_empty_nullable_xunion_nonzero_ordinal) {
  SampleNullableXUnionV2Struct message = {};
  message.opt_xu.header.tag = kSampleXUnionIntStructOrdinal;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &fidl_test_coding_SampleNullableXUnionStructTable, &message, sizeof(fidl_union_t), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
  EXPECT_STREQ(error, "empty xunion must have zero as ordinal");
}

TEST(Xunions, validate_v2_nonempty_xunion_zero_ordinal) {
  SampleXUnionV2Struct message = {};
  message.xu.header.envelope = (fidl_envelope_t){.num_bytes = 8, .num_handles = 0};

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &fidl_test_coding_SampleXUnionStructTable, &message, sizeof(SampleXUnionV2Struct), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
  EXPECT_STREQ(error, "xunion with zero as ordinal must be empty");
}

TEST(Xunions, validate_v2_nonempty_nullable_xunion_zero_ordinal) {
  SampleNullableXUnionV2Struct message = {};
  message.opt_xu.header.envelope = (fidl_envelope_t){.num_bytes = 8, .num_handles = 0};

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &fidl_test_coding_SampleNullableXUnionStructTable, &message,
      sizeof(SampleNullableXUnionV2Struct), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
  EXPECT_STREQ(error, "xunion with zero as ordinal must be empty");
}

TEST(Xunions, validate_v2_strict_xunion_unknown_ordinal) {
  uint8_t bytes[] = {
      0xf0, 0x05, 0xc1, 0x0a,                          // invalid ordinal
      0x00, 0x00, 0x00, 0x00,                          // padding
      0x08, 0x00, 0x00, 0x00,                          // envelope: # of bytes
      0x00, 0x00, 0x00, 0x00,                          // envelope: # of handles
      0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,  // fake out-of-line data
  };

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &fidl_test_coding_SampleStrictXUnionStructTable, bytes, sizeof(bytes), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_NOT_NULL(error);
  EXPECT_STREQ(error, "strict xunion has unknown ordinal");
}

TEST(Xunions, validate_v2_flexible_xunion_unknown_ordinal) {
  uint8_t bytes[] = {
      0xf0, 0x05, 0xc1, 0x0a,                          // invalid ordinal
      0x00, 0x00, 0x00, 0x00,                          // padding
      0x08, 0x00, 0x00, 0x00,                          // envelope: # of bytes
      0x00, 0x00, 0x00, 0x00,                          // envelope: # of handles
      0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,  // fake out-of-line data
  };

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_SampleXUnionStructTable,
                                                       bytes, sizeof(bytes), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error);
}

TEST(Primitives, validate_v2_invalid_bool) {
  uint8_t data[] = {
      0x88,  // bool, not 0 or 1*/
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  };

  const char* error = nullptr;
  fflush(stdout);
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_BoolStructTable, data,
                                                       sizeof(data), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_STREQ(error, "not a valid bool value");
}

TEST(Bits, validate_v2_zero_16bit_bits) {
  Int16Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = 0;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int16BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Bits, validate_v2_valid_16bit_bits) {
  Int16Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = 1u | 16u;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int16BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Bits, validate_v2_invalid_16bit_bits) {
  Int16Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = 1u << 7u;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int16BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_STREQ(error, "not a valid bits member");
}

TEST(Bits, validate_v2_zero_32bit_bits) {
  Int32Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = 0;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int32BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Bits, validate_v2_valid_32bit_bits) {
  // The valid bits are position 7, 12, and 27.
  Int32Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = (1u << 6u) | (1u << 11u) | (1u << 26u);

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int32BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error, "%s", error);
}

TEST(Bits, validate_v2_invalid_32bit_bits) {
  // The valid bits are position 7, 12, and 27.
  Int32Bits message;
  memset(std::launder(&message), 0, sizeof(message));
  message.bits = 1u;

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(&fidl_test_coding_Int32BitsStructTable,
                                                       &message, sizeof(message), 0, &error);
  EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
  EXPECT_STREQ(error, "not a valid bits member");
}

template <typename T>
void TestValidEnum(const fidl_type_t* coding_table) {
  // See extra_messages.test.fidl for the list of valid members.
  using Underlying = decltype(T::e);
  for (const Underlying valid_value : {
           static_cast<Underlying>(42),
           std::numeric_limits<Underlying>::min(),
           std::numeric_limits<Underlying>::max(),
       }) {
    T message;
    memset(std::launder(&message), 0, sizeof(message));
    message.e = valid_value;
    const char* error = nullptr;
    auto status =
        internal__fidl_validate__v2__may_break(coding_table, &message, sizeof(message), 0, &error);
    EXPECT_EQ(status, ZX_OK);
    EXPECT_NULL(error);
  }
}

template <typename T>
void TestInvalidEnum(const fidl_type_t* coding_table) {
  // See extra_messages.test.fidl for the list of valid members.
  using Underlying = decltype(T::e);
  for (const Underlying invalid_value : {
           static_cast<Underlying>(7),
           static_cast<Underlying>(30),
           static_cast<Underlying>(std::numeric_limits<Underlying>::min() + 1),
           static_cast<Underlying>(std::numeric_limits<Underlying>::max() - 1),
       }) {
    T message;
    memset(std::launder(&message), 0, sizeof(message));
    message.e = invalid_value;
    const char* error = nullptr;
    auto status =
        internal__fidl_validate__v2__may_break(coding_table, &message, sizeof(message), 0, &error);
    EXPECT_EQ(status, ZX_ERR_INVALID_ARGS);
    EXPECT_STREQ(error, "not a valid enum member");
  }
}

TEST(Enums, validate_v2_int8_enum) {
  TestValidEnum<Int8Enum>(&fidl_test_coding_Int8EnumStructTable);
}

TEST(Enums, validate_v2_int16_enum) {
  TestValidEnum<Int16Enum>(&fidl_test_coding_Int16EnumStructTable);
}

TEST(Enums, validate_v2_int32_enum) {
  TestValidEnum<Int32Enum>(&fidl_test_coding_Int32EnumStructTable);
}

TEST(Enums, validate_v2_int64_enum) {
  TestValidEnum<Int64Enum>(&fidl_test_coding_Int64EnumStructTable);
}

TEST(Enums, validate_v2_uint8_enum) {
  TestValidEnum<Uint8Enum>(&fidl_test_coding_Uint8EnumStructTable);
}

TEST(Enums, validate_v2_uint16_enum) {
  TestValidEnum<Uint16Enum>(&fidl_test_coding_Uint16EnumStructTable);
}

TEST(Enums, validate_v2_uint32_enum) {
  TestValidEnum<Uint32Enum>(&fidl_test_coding_Uint32EnumStructTable);
}

TEST(Enums, validate_v2_uint64_enum) {
  TestValidEnum<Uint64Enum>(&fidl_test_coding_Uint64EnumStructTable);
}

TEST(Enums, validate_v2_invalid_int8_enum) {
  TestInvalidEnum<Int8Enum>(&fidl_test_coding_Int8EnumStructTable);
}

TEST(Enums, validate_v2_invalid_int16_enum) {
  TestInvalidEnum<Int16Enum>(&fidl_test_coding_Int16EnumStructTable);
}

TEST(Enums, validate_v2_invalid_int32_enum) {
  TestInvalidEnum<Int32Enum>(&fidl_test_coding_Int32EnumStructTable);
}

TEST(Enums, validate_v2_invalid_int64_enum) {
  TestInvalidEnum<Int64Enum>(&fidl_test_coding_Int64EnumStructTable);
}

TEST(Enums, validate_v2_invalid_uint8_enum) {
  TestInvalidEnum<Uint8Enum>(&fidl_test_coding_Uint8EnumStructTable);
}

TEST(Enums, validate_v2_invalid_uint16_enum) {
  TestInvalidEnum<Uint16Enum>(&fidl_test_coding_Uint16EnumStructTable);
}

TEST(Enums, validate_v2_invalid_uint32_enum) {
  TestInvalidEnum<Uint32Enum>(&fidl_test_coding_Uint32EnumStructTable);
}

TEST(Enums, validate_v2_invalid_uint64_enum) {
  TestInvalidEnum<Uint64Enum>(&fidl_test_coding_Uint64EnumStructTable);
}

TEST(Primitives, validate_v2_primitives_struct) {
  // TODO(https://fxbug.dev/42129903): Use generated types - primitive struct fields actually have null type.
  // The following coding table is equivalent to this FIDL struct definition:
  //
  // struct PrimitiveStruct {
  //   bool b;
  //   int8 i8;
  //   int16 i16;
  //   int32 i32;
  //   int64 i64;
  //   uint8 u8;
  //   uint16 u16;
  //   uint32 u32;
  //   uint64 u64;
  //   float32 f32;
  //   float64 f64;
  // };
  static const FidlCodedPrimitive kBoolType = {.tag = kFidlTypePrimitive,
                                               .type = kFidlCodedPrimitiveSubtype_Bool};
  static const FidlCodedPrimitive kInt8Type = {.tag = kFidlTypePrimitive,
                                               .type = kFidlCodedPrimitiveSubtype_Int8};
  static const FidlCodedPrimitive kInt16Type = {.tag = kFidlTypePrimitive,
                                                .type = kFidlCodedPrimitiveSubtype_Int16};
  static const FidlCodedPrimitive kInt32Type = {.tag = kFidlTypePrimitive,
                                                .type = kFidlCodedPrimitiveSubtype_Int32};
  static const FidlCodedPrimitive kInt64Type = {.tag = kFidlTypePrimitive,
                                                .type = kFidlCodedPrimitiveSubtype_Int64};
  static const FidlCodedPrimitive kUint8Type = {.tag = kFidlTypePrimitive,
                                                .type = kFidlCodedPrimitiveSubtype_Uint8};
  static const FidlCodedPrimitive kUint16Type = {.tag = kFidlTypePrimitive,
                                                 .type = kFidlCodedPrimitiveSubtype_Uint16};
  static const FidlCodedPrimitive kUint32Type = {.tag = kFidlTypePrimitive,
                                                 .type = kFidlCodedPrimitiveSubtype_Uint32};
  static const FidlCodedPrimitive kUint64Type = {.tag = kFidlTypePrimitive,
                                                 .type = kFidlCodedPrimitiveSubtype_Uint64};
  static const FidlCodedPrimitive kFloat32Type = {.tag = kFidlTypePrimitive,
                                                  .type = kFidlCodedPrimitiveSubtype_Float32};
  static const FidlCodedPrimitive kFloat64Type = {.tag = kFidlTypePrimitive,
                                                  .type = kFidlCodedPrimitiveSubtype_Float64};
  static const struct FidlStructElement kFields[] = {
      FidlStructElement::Field(&kBoolType, 0u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kInt8Type, 1u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kInt16Type, 2u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kInt32Type, 4u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kInt64Type, 8u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kUint8Type, 16u, kFidlIsResource_NotResource),
      FidlStructElement::Padding16(16u, 0x00ff),
      FidlStructElement::Field(&kUint16Type, 18u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kUint32Type, 20u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kUint64Type, 24u, kFidlIsResource_NotResource),
      FidlStructElement::Field(&kFloat32Type, 32u, kFidlIsResource_NotResource),
      FidlStructElement::Padding32(36u, 0xffffffff),
      FidlStructElement::Field(&kFloat64Type, 40u, kFidlIsResource_NotResource),
  };
  static const FidlCodedStruct kPrimitiveStructCodingTable = {
      .tag = kFidlTypeStruct,
      .element_count = ArrayCount(kFields),
      .size_v2 = 48u,
      .elements = kFields,
      .name = "fidl.test.coding/PrimitiveStruct",
  };

  uint8_t data[kPrimitiveStructCodingTable.coded_struct().size_v2];
  memset(data, 0, sizeof(data));

  const char* error = nullptr;
  auto status = internal__fidl_validate__v2__may_break(
      &kPrimitiveStructCodingTable, data, static_cast<uint32_t>(sizeof(data)), 0, &error);
  EXPECT_EQ(status, ZX_OK);
  EXPECT_NULL(error);
}

}  // namespace
}  // namespace fidl