C bindings: Implement _DeepCopy() & some unittests.

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

 // 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/public/c/bindings/array.h"
 
 #include <stddef.h>
 
 #include "mojo/public/c/bindings/struct.h"
+#include "mojo/public/c/bindings/tests/testing_util.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom-c.h"
 #include "mojo/public/interfaces/bindings/tests/test_unions.mojom-c.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Tests MojomArray_New().
 TEST(ArrayTest, New) {
   char bytes_buffer[1000];
@@ skipping 56 matching lines @@
   small_struct->nullable_pod_union_array.ptr =
       MojomArray_New(&buf, 2, sizeof(struct mojo_test_PodUnion));
 
   // 0th element is NULL.
   MOJOM_ARRAY_INDEX(small_struct->nullable_pod_union_array.ptr,
                     struct mojo_test_PodUnion, 0)
       ->size = 0;
   // 1st element is not NULL.
   struct mojo_test_PodUnion* e1 = MOJOM_ARRAY_INDEX(
       small_struct->nullable_pod_union_array.ptr, struct mojo_test_PodUnion, 0);
-  e1->size = 16;
+  e1->size = sizeof(struct mojo_test_PodUnion);
   e1->tag = mojo_test_PodUnion_Tag_f_int8;
   e1->data.f_f_int8 = 13;
 
   EXPECT_EQ(8u + 6 * 8u            // 6 references types
                 + 1 * 16u          // 1 union type
                 + (8u + 16u * 2),  // array of 2 unions
             mojo_test_SmallStruct_ComputeSerializedSize(small_struct));
 
   // Save the underlying buffer before encoding, so we can decode+compare
   // later.
   char bytes_buffer_copy[sizeof(bytes_buffer)];
   memcpy(bytes_buffer_copy, bytes_buffer, sizeof(bytes_buffer));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
-  mojo_test_SmallStruct_EncodePointersAndHandles(
-      small_struct, buf.num_bytes_used, &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+  mojo_test_SmallStruct_EncodePointersAndHandles(small_struct,
+                                                 buf.num_bytes_used, NULL);
 
   // The null pointers should now be 0-offsets:
   EXPECT_EQ(0u, small_struct->dummy_struct.offset);
   EXPECT_EQ(0u, small_struct->pod_union_array.offset);
   EXPECT_EQ(0u, small_struct->s_array.offset);
   EXPECT_EQ(0u, small_struct->pod_union_map.offset);
   EXPECT_EQ(0u, small_struct->nullable_pod_union_map.offset);
 
   // Test the pod_union_array offset:
   EXPECT_EQ(
       sizeof(struct mojo_test_SmallStruct) -
           offsetof(struct mojo_test_SmallStruct, nullable_pod_union_array),
       small_struct->nullable_pod_union_array.offset);
 
   mojo_test_SmallStruct_DecodePointersAndHandles(small_struct,
                                                  buf.num_bytes_used, NULL, 0);
   EXPECT_EQ(0, memcmp(buf.buf, bytes_buffer_copy, buf.num_bytes_used));
+
+  {
+    char bytes_buffer2[sizeof(bytes_buffer)] = {0};
+    struct MojomBuffer buf2 = {bytes_buffer2, sizeof(bytes_buffer2), 0};
+    CopyAndCompare(&buf2, small_struct, buf.num_bytes_used,
+                   mojo_test_SmallStruct_DeepCopy,
+                   mojo_test_SmallStruct_EncodePointersAndHandles,
+                   mojo_test_SmallStruct_DecodePointersAndHandles);
+  }
 }
 
 // Tests serialized size of an array of arrays.
 TEST(ArraySerializationTest, ArrayOfArrays) {
   char bytes_buffer[1000] = {0};
   MojomBuffer buf = {bytes_buffer, sizeof(bytes_buffer), 0};
 
   struct mojo_test_ArrayOfArrays* arr =
       static_cast<struct mojo_test_ArrayOfArrays*>(
           MojomBuffer_Allocate(&buf, sizeof(struct mojo_test_ArrayOfArrays)));
@@ skipping 26 matching lines @@
   EXPECT_EQ(24u + (8u + 2 * 8u)  // a (with 2 arrays, 1 of them NULL)
                 + 0u             // b (null altogether)
                 + (8u + 8u),     // first array<int> in a
             mojo_test_ArrayOfArrays_ComputeSerializedSize(arr));
 
   // Save the underlying buffer before encoding, so we can decode+compare
   // later.
   char bytes_buffer_copy[sizeof(bytes_buffer)];
   memcpy(bytes_buffer_copy, bytes_buffer, sizeof(bytes_buffer));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
   mojo_test_ArrayOfArrays_EncodePointersAndHandles(arr, buf.num_bytes_used,
-                                                   &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+                                                   NULL);
 
   EXPECT_EQ(sizeof(struct mojo_test_ArrayOfArrays) -
                 offsetof(struct mojo_test_ArrayOfArrays, a),
             arr->a.offset);
 
   // Array of int32 should occur at the end of the array of 2 arrays -- so the
   // offset is 2 pointer-sizes (1st one pointers to the array of int32, second
   // one is NULL).
   EXPECT_EQ(2 * sizeof(union MojomArrayHeaderPtr),
             MOJOM_ARRAY_INDEX(a_array, union MojomArrayHeaderPtr, 0)->offset);
   EXPECT_EQ(0u,
             MOJOM_ARRAY_INDEX(a_array, union MojomArrayHeaderPtr, 1)->offset);
 
   mojo_test_ArrayOfArrays_DecodePointersAndHandles(arr, buf.num_bytes_used,
                                                    NULL, 0);
   EXPECT_EQ(0, memcmp(buf.buf, bytes_buffer_copy, buf.num_bytes_used));
+
+  {
+    char bytes_buffer2[sizeof(bytes_buffer)] = {0};
+    struct MojomBuffer buf2 = {bytes_buffer2, sizeof(bytes_buffer2), 0};
+    CopyAndCompare(&buf2, arr, buf.num_bytes_used,
+                   mojo_test_ArrayOfArrays_DeepCopy,
+                   mojo_test_ArrayOfArrays_EncodePointersAndHandles,
+                   mojo_test_ArrayOfArrays_DecodePointersAndHandles);
+  }
 }
 
 // Tests serialization of an array of handles.
 TEST(ArraySerializationTest, ArrayOfHandles) {
   char buffer_bytes[1000] = {0};
   MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
 
   struct mojo_test_StructWithNullableHandles* handle_struct =
       static_cast<struct mojo_test_StructWithNullableHandles*>(
           MojomBuffer_Allocate(
@@ skipping 44 matching lines @@
             handle_struct->array_h.offset);
 
   mojo_test_StructWithNullableHandles_DecodePointersAndHandles(
       handle_struct, buf.num_bytes_used, handles, MOJO_ARRAYSIZE(handles));
   EXPECT_EQ(0, memcmp(buf.buf, buffer_bytes_copy, buf.num_bytes_used));
 
   // Check that the handles in the handles array are invalidated:
   EXPECT_EQ(MOJO_HANDLE_INVALID, handles[0]);
   EXPECT_EQ(MOJO_HANDLE_INVALID, handles[1]);
   EXPECT_EQ(MOJO_HANDLE_INVALID, handles[2]);
+
+  {
+    char buffer_bytes2[sizeof(buffer_bytes)] = {0};
+    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
+    auto* copied_struct =
+        mojo_test_StructWithNullableHandles_DeepCopy(&buf2, handle_struct);
+
+    // The copy should still have the handles.
+    EXPECT_EQ(static_cast<MojoHandle>(10u), handle_struct->h);
+    EXPECT_EQ(static_cast<MojoHandle>(20u),
+              *MOJOM_ARRAY_INDEX(handle_struct->array_h.ptr, MojoHandle, 0));
+    EXPECT_EQ(MOJO_HANDLE_INVALID,
+              *MOJOM_ARRAY_INDEX(handle_struct->array_h.ptr, MojoHandle, 1));
+    EXPECT_EQ(static_cast<MojoHandle>(30u),
+              *MOJOM_ARRAY_INDEX(handle_struct->array_h.ptr, MojoHandle, 2));
+    // The new struct should have the handles now:
+    EXPECT_EQ(static_cast<MojoHandle>(10u), copied_struct->h);
+    EXPECT_EQ(static_cast<MojoHandle>(20u),
+              *MOJOM_ARRAY_INDEX(copied_struct->array_h.ptr, MojoHandle, 0));
+    EXPECT_EQ(MOJO_HANDLE_INVALID,
+              *MOJOM_ARRAY_INDEX(copied_struct->array_h.ptr, MojoHandle, 1));
+    EXPECT_EQ(static_cast<MojoHandle>(30u),
+              *MOJOM_ARRAY_INDEX(copied_struct->array_h.ptr, MojoHandle, 2));
+  }
 }
 
 }  // namespace