Make the fuchsia mojo/public repo the source of truth.

mojo/public/c/tests/bindings/struct_unittest.cc

Index: mojo/public/c/tests/bindings/struct_unittest.cc
diff --git a/mojo/public/c/tests/bindings/struct_unittest.cc b/mojo/public/c/tests/bindings/struct_unittest.cc
deleted file mode 100644
index 8df703213fe12030473d60bca4d0b0c5d625f291..0000000000000000000000000000000000000000
--- a/mojo/public/c/tests/bindings/struct_unittest.cc
+++ /dev/null
@@ -1,365 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// TODO(vardhan): Needs a lot more testing.
-
-#include <mojo/bindings/struct.h>
-
-#include <mojo/bindings/array.h>
-#include <mojo/bindings/internal/util.h>
-#include <string.h>
-
-#include "gtest/gtest.h"
-#include "mojo/public/c/tests/bindings/testing_util.h"
-#include "mojo/public/cpp/system/macros.h"
-#include "mojo/public/interfaces/bindings/tests/rect.mojom-c.h"
-#include "mojo/public/interfaces/bindings/tests/test_structs.mojom-c.h"
-#include "mojo/public/interfaces/bindings/tests/test_unions.mojom-c.h"
-
-namespace {
-
-#define BYTES_LEFT_AFTER_FIELD(type, field) \
-  (sizeof(type) - offsetof(type, field))
-
-struct mojo_test_Rect* MakeRect(struct MojomBuffer* buf) {
-  struct mojo_test_Rect* r = static_cast<struct mojo_test_Rect*>(
-      MojomBuffer_Allocate(buf, sizeof(struct mojo_test_Rect)));
-  *r = mojo_test_Rect{// header
-                      {
-                          sizeof(struct mojo_test_Rect), 0,
-                      },
-                      0u,
-                      0u,
-                      0u,
-                      0u};
-  return r;
-}
-
-// TODO(vardhan): Move this into string.h/c if it proves useful again.
-struct MojomStringHeader* MakeMojomStringFromCString(MojomBuffer* buf,
-                                                     const char* chars,
-                                                     size_t num_chars) {
-  struct MojomArrayHeader* arr = MojomArray_New(buf, num_chars, 1);
-  assert(NULL != arr);
-
-  memcpy((char*)arr + sizeof(MojomStringHeader), chars, num_chars);
-  return (struct MojomStringHeader*)arr;
-}
-
-TEST(StructSerializedSizeTest, Basic) {
-  struct mojo_test_Rect rect = {{
-                                    sizeof(struct mojo_test_Rect), 0,
-                                },
-                                0u,
-                                0u,
-                                0u,
-                                0u};
-  size_t size = mojo_test_Rect_ComputeSerializedSize(&rect);
-  EXPECT_EQ(8U + 16U, size);
-
-  char buffer_bytes[1000];
-  struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
-  CopyAndCompare(&buf, &rect, sizeof(rect), mojo_test_Rect_DeepCopy,
-                 mojo_test_Rect_EncodePointersAndHandles,
-                 mojo_test_Rect_DecodePointersAndHandles);
-}
-
-TEST(StructSerializationTest, StructOfStructs) {
-  char buffer_bytes[1000] = {0};
-  struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
-
-  struct mojo_test_RectPair* pair = static_cast<struct mojo_test_RectPair*>(
-      MojomBuffer_Allocate(&buf, sizeof(struct mojo_test_RectPair)));
-  *pair = mojo_test_RectPair{
-      {sizeof(struct mojo_test_RectPair), 0},
-      {MakeRect(&buf)},  // first
-      {MakeRect(&buf)},  // second
-  };
-
-  EXPECT_EQ(8U + 16U + 2 * (8U + 16U),
-            mojo_test_RectPair_ComputeSerializedSize(pair));
-
-  // We save the underlying (unencoded) buffer. We can compare the two after
-  // deserialization to make sure deserialization is correct.
-  char buffer_bytes_copy[sizeof(buffer_bytes)];
-  memcpy(buffer_bytes_copy, buffer_bytes, sizeof(buffer_bytes_copy));
-
-  mojo_test_RectPair_EncodePointersAndHandles(pair, buf.num_bytes_used, NULL);
-
-  EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_RectPair, first),
-            pair->first.offset);
-  EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_RectPair, second) +
-                sizeof(struct mojo_test_Rect),
-            pair->second.offset);
-
-  mojo_test_RectPair_DecodePointersAndHandles(
-      reinterpret_cast<struct mojo_test_RectPair*>(buf.buf), buf.num_bytes_used,
-      NULL, 0);
-  EXPECT_EQ(0, memcmp(buf.buf, buffer_bytes_copy, buf.num_bytes_used));
-
-  {
-    char buffer_bytes2[1000] = {0};
-    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
-    CopyAndCompare(&buf2, pair, buf.num_bytes_used, mojo_test_RectPair_DeepCopy,
-                   mojo_test_RectPair_EncodePointersAndHandles,
-                   mojo_test_RectPair_DecodePointersAndHandles);
-  }
-}
-
-// Tests a struct that has:
-//  - nullable string which isn't null.
-//  - nullable array of rects, which isn't null.
-TEST(StructSerializationTest, StructOfArrays) {
-  char buffer_bytes[1000];
-  MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
-
-  const char* kRegionName = "region";
-
-  struct mojo_test_NamedRegion* named_region =
-      static_cast<struct mojo_test_NamedRegion*>(
-          MojomBuffer_Allocate(&buf, sizeof(struct mojo_test_NamedRegion)));
-  *named_region = mojo_test_NamedRegion{
-      // header
-      {
-          sizeof(struct mojo_test_NamedRegion), 0,
-      },
-      {NULL},
-      {NULL},
-  };
-  named_region->name.ptr =
-      MakeMojomStringFromCString(&buf, kRegionName, strlen(kRegionName));
-  // We save a pointer to |rects| so we can use it after it has been encoded
-  // within |named_region|.
-  auto rects = MojomArray_New(&buf, 4, sizeof(union mojo_test_RectPtr));
-  named_region->rects.ptr = rects;
-  ASSERT_TRUE(named_region->rects.ptr != NULL);
-
-  MOJOM_ARRAY_INDEX(named_region->rects.ptr, union mojo_test_RectPtr, 0)
-      ->ptr = MakeRect(&buf);
-  MOJOM_ARRAY_INDEX(named_region->rects.ptr, union mojo_test_RectPtr, 1)
-      ->ptr = MakeRect(&buf);
-  MOJOM_ARRAY_INDEX(named_region->rects.ptr, union mojo_test_RectPtr, 2)
-      ->ptr = MakeRect(&buf);
-  MOJOM_ARRAY_INDEX(named_region->rects.ptr, union mojo_test_RectPtr, 3)
-      ->ptr = MakeRect(&buf);
-
-  size_t size = mojo_test_NamedRegion_ComputeSerializedSize(named_region);
-  EXPECT_EQ(8U +            // header
-                8U +        // name pointer
-                8U +        // rects pointer
-                8U +        // name header
-                8U +        // name payload (rounded up)
-                8U +        // rects header
-                4 * 8U +    // rects payload (four pointers)
-                4 * (8U +   // rect header
-                     16U),  // rect payload (four ints)
-            size);
-
-  char buffer_bytes_copy[sizeof(buffer_bytes)] = {0};
-  memcpy(buffer_bytes_copy, buffer_bytes, sizeof(buffer_bytes_copy));
-
-  mojo_test_NamedRegion_EncodePointersAndHandles(named_region,
-                                                 buf.num_bytes_used, NULL);
-
-  EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_NamedRegion, name),
-            named_region->name.offset);
-  EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_NamedRegion, rects) +
-                MOJOM_INTERNAL_ROUND_TO_8(sizeof(struct MojomStringHeader) +
-                                          strlen(kRegionName)),
-            named_region->rects.offset);
-
-  // Test the offsets encoded inside the rect array.
-  EXPECT_EQ(sizeof(union mojo_test_RectPtr) * 4,
-            MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 0)->offset);
-  EXPECT_EQ(sizeof(union mojo_test_RectPtr) * 3 + sizeof(struct mojo_test_Rect),
-            MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 1)->offset);
-  EXPECT_EQ(
-      sizeof(union mojo_test_RectPtr) * 2 + sizeof(struct mojo_test_Rect) * 2,
-      MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 2)->offset);
-  EXPECT_EQ(sizeof(union mojo_test_RectPtr) + sizeof(struct mojo_test_Rect) * 3,
-            MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 3)->offset);
-
-  mojo_test_NamedRegion_DecodePointersAndHandles(
-      reinterpret_cast<struct mojo_test_NamedRegion*>(buf.buf),
-      buf.num_bytes_used, NULL, 0);
-  EXPECT_EQ(0, memcmp(buf.buf, buffer_bytes_copy, buf.num_bytes_used));
-
-  {
-    char buffer_bytes2[sizeof(buffer_bytes)] = {0};
-    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
-    CopyAndCompare(&buf2, named_region, buf.num_bytes_used,
-                   mojo_test_NamedRegion_DeepCopy,
-                   mojo_test_NamedRegion_EncodePointersAndHandles,
-                   mojo_test_NamedRegion_DecodePointersAndHandles);
-  }
-}
-
-// Tests a struct that has:
-//  - nullable string which is null.
-//  - nullable array of rects, which is null.
-TEST(StructSerializationTest, StructOfNullArrays) {
-  struct mojo_test_NamedRegion named_region = {
-      // header
-      {
-          sizeof(struct mojo_test_NamedRegion), 0,
-      },
-      {NULL},
-      {NULL},
-  };
-  struct mojo_test_NamedRegion named_region_copy = named_region;
-
-  size_t size = mojo_test_NamedRegion_ComputeSerializedSize(&named_region);
-  EXPECT_EQ(8U +      // header
-                8U +  // name pointer
-                8U,   // rects pointer
-            size);
-
-  mojo_test_NamedRegion_EncodePointersAndHandles(
-      &named_region, sizeof(struct mojo_test_NamedRegion), NULL);
-  EXPECT_EQ(0u, named_region.name.offset);
-  EXPECT_EQ(0u, named_region.rects.offset);
-
-  mojo_test_NamedRegion_DecodePointersAndHandles(
-      &named_region, sizeof(struct mojo_test_NamedRegion), NULL, 0);
-  EXPECT_EQ(0, memcmp(&named_region, &named_region_copy,
-                      sizeof(struct mojo_test_NamedRegion)));
-
-  {
-    char buffer_bytes2[sizeof(named_region)] = {0};
-    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
-    CopyAndCompare(&buf2, &named_region, sizeof(named_region),
-                   mojo_test_NamedRegion_DeepCopy,
-                   mojo_test_NamedRegion_EncodePointersAndHandles,
-                   mojo_test_NamedRegion_DecodePointersAndHandles);
-  }
-}
-
-TEST(StructSerializationTest, StructOfUnion) {
-  struct mojo_test_SmallStructNonNullableUnion u = {
-      // header
-      {
-          sizeof(struct mojo_test_SmallStructNonNullableUnion),
-          0,  // version
-      },
-      // PodUnion
-      {
-          16ul,                           // size
-          mojo_test_PodUnion_Tag_f_int8,  // tag,
-          {0},                            // data
-      },
-  };
-
-  struct mojo_test_SmallStructNonNullableUnion u_null = {
-      // header
-      {
-          sizeof(struct mojo_test_SmallStructNonNullableUnion),
-          0,  // version
-      },
-      // PodUnion
-      {
-          0ul,                                // size
-          mojo_test_PodUnion_Tag__UNKNOWN__,  // tag,
-          {0},                                // data
-      },
-  };
-
-  EXPECT_EQ(8U +      // header
-                16U,  // union
-            mojo_test_SmallStructNonNullableUnion_ComputeSerializedSize(&u));
-  EXPECT_EQ(
-      8U +      // header
-          16U,  // union
-      mojo_test_SmallStructNonNullableUnion_ComputeSerializedSize(&u_null));
-
-  // Encoding shouldn't have done anything to these structs (they have no
-  // pointers or handles):
-  struct mojo_test_SmallStructNonNullableUnion u_copy = u;
-  mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles(
-      &u, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL);
-  EXPECT_EQ(0, memcmp(&u, &u_copy, sizeof(u)));
-
-  // Similarly, decoding shouldn't change the struct at all:
-  mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles(
-      &u, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL, 0);
-  EXPECT_EQ(0, memcmp(&u, &u_copy, sizeof(u)));
-
-  struct mojo_test_SmallStructNonNullableUnion u_null_copy = u_null;
-  mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles(
-      &u_null, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL);
-  EXPECT_EQ(0, memcmp(&u_null, &u_null_copy, sizeof(u_null)));
-
-  mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles(
-      &u_null, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL, 0);
-  EXPECT_EQ(0, memcmp(&u_null, &u_null_copy, sizeof(u_null)));
-
-  {
-    char buffer_bytes[sizeof(u)] = {0};
-    struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
-    CopyAndCompare(
-        &buf, &u, sizeof(u), mojo_test_SmallStructNonNullableUnion_DeepCopy,
-        mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles,
-        mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles);
-  }
-}
-
-TEST(StructSerializationTest, StructWithHandle) {
-  struct mojo_test_NullableHandleStruct handle_struct =
-      mojo_test_NullableHandleStruct{
-          // header
-          {
-              sizeof(struct mojo_test_NullableHandleStruct), 0,
-          },
-          MOJO_HANDLE_INVALID,
-          13,
-      };
-
-  EXPECT_EQ(
-      sizeof(struct mojo_test_NullableHandleStruct),
-      mojo_test_NullableHandleStruct_ComputeSerializedSize(&handle_struct));
-
-  MojoHandle handles[1];
-  struct MojomHandleBuffer handle_buf = {handles, MOJO_ARRAYSIZE(handles), 0u};
-  mojo_test_NullableHandleStruct_EncodePointersAndHandles(
-      &handle_struct, sizeof(struct mojo_test_NullableHandleStruct),
-      &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
-  EXPECT_EQ(static_cast<MojoHandle>(-1), handle_struct.h);
-
-  mojo_test_NullableHandleStruct_DecodePointersAndHandles(
-      &handle_struct, sizeof(struct mojo_test_NullableHandleStruct), handles,
-      MOJO_ARRAYSIZE(handles));
-  EXPECT_EQ(MOJO_HANDLE_INVALID, handle_struct.h);
-
-  handle_struct.h = 123;
-  mojo_test_NullableHandleStruct_EncodePointersAndHandles(
-      &handle_struct, sizeof(struct mojo_test_NullableHandleStruct),
-      &handle_buf);
-  EXPECT_EQ(1u, handle_buf.num_handles_used);
-  EXPECT_EQ(static_cast<MojoHandle>(0), handle_struct.h);
-  EXPECT_EQ(static_cast<MojoHandle>(123), handles[0]);
-
-  mojo_test_NullableHandleStruct_DecodePointersAndHandles(
-      &handle_struct, sizeof(struct mojo_test_NullableHandleStruct), handles,
-      MOJO_ARRAYSIZE(handles));
-  EXPECT_EQ(static_cast<MojoHandle>(123), handle_struct.h);
-  EXPECT_EQ(MOJO_HANDLE_INVALID, handles[0]);
-
-  {
-    char buffer_bytes[1000] = {0};
-    struct MojomBuffer buf = {buffer_bytes, 4, 0};
-    auto* copied_struct =
-        mojo_test_NullableHandleStruct_DeepCopy(&buf, &handle_struct);
-    // Not enough space:
-    ASSERT_FALSE(copied_struct);
-    buf.buf_size = sizeof(buffer_bytes);
-    copied_struct =
-        mojo_test_NullableHandleStruct_DeepCopy(&buf, &handle_struct);
-    ASSERT_TRUE(copied_struct);
-    // The old and the new copy should both have the handles.
-    EXPECT_EQ(static_cast<MojoHandle>(123), handle_struct.h);
-    EXPECT_EQ(static_cast<MojoHandle>(123), copied_struct->h);
-  }
-}
-
-}  // namespace