C bindings: Implement _DeepCopy() & some unittests.

mojo/public/c/bindings/tests/union_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/union.h"
 
 #include "mojo/public/c/bindings/array.h"
+#include "mojo/public/c/bindings/tests/testing_util.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 {
 
 struct mojo_test_StructOfUnionOfReferences* MakeStructOfUnionReference(
     struct MojomBuffer* buf) {
   auto* struct_with_union =
       static_cast<struct mojo_test_StructOfUnionOfReferences*>(
@@ skipping 40 matching lines @@
   EXPECT_EQ(8u + 1 * 16u  // 1 union type (set to PodUnion)
                 + 16u,    // PodUnion is out of line.
             mojo_test_StructOfUnionOfReferences_ComputeSerializedSize(
                 struct_with_union));
 
   // 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));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
   mojo_test_StructOfUnionOfReferences_EncodePointersAndHandles(
-      struct_with_union, buf.num_bytes_used, &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+      struct_with_union, buf.num_bytes_used, NULL);
 
   EXPECT_EQ(sizeof(struct mojo_test_StructOfUnionOfReferences) -
                 offsetof(struct mojo_test_StructOfUnionOfReferences, u.data),
             struct_with_union->u.data.f_pod_union.offset);
 
   mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles(
       struct_with_union, 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, struct_with_union, buf.num_bytes_used,
+        mojo_test_StructOfUnionOfReferences_DeepCopy,
+        mojo_test_StructOfUnionOfReferences_EncodePointersAndHandles,
+        mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles);
+  }
 }
 
 // Test when a union points to a struct.
 TEST(UnionSerializationTest, UnionOfStruct) {
   char buffer_bytes[1000];
   MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
 
   struct mojo_test_StructOfUnionOfReferences* struct_with_union =
       MakeStructOfUnionReference(&buf);
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(8u + 1 * 16u  // 1 union type (set to DummyStruct)
                 + 16u,    // DummyStruct is out of line.
             mojo_test_StructOfUnionOfReferences_ComputeSerializedSize(
                 struct_with_union));
 
   // 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));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
   mojo_test_StructOfUnionOfReferences_EncodePointersAndHandles(
-      struct_with_union, buf.num_bytes_used, &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+      struct_with_union, buf.num_bytes_used, NULL);
 
   EXPECT_EQ(sizeof(struct mojo_test_StructOfUnionOfReferences) -
                 offsetof(struct mojo_test_StructOfUnionOfReferences, u.data),
             struct_with_union->u.data.f_dummy_struct.offset);
 
   mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles(
       struct_with_union, 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, struct_with_union, buf.num_bytes_used,
+        mojo_test_StructOfUnionOfReferences_DeepCopy,
+        mojo_test_StructOfUnionOfReferences_EncodePointersAndHandles,
+        mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles);
+  }
 }
 
 // Test when a union points to an array of int32
 TEST(UnionSerializationTest, UnionOfArray) {
   char buffer_bytes[1000];
   MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
   struct mojo_test_StructOfUnionOfReferences* struct_with_union =
       MakeStructOfUnionReference(&buf);
 
   struct MojomArrayHeader* array_of_int32 =
@@ skipping 23 matching lines @@
       struct_with_union, buf.num_bytes_used, &handle_buf);
   EXPECT_EQ(0u, handle_buf.num_handles_used);
 
   EXPECT_EQ(sizeof(struct mojo_test_StructOfUnionOfReferences) -
                 offsetof(struct mojo_test_StructOfUnionOfReferences, u.data),
             struct_with_union->u.data.f_int_array.offset);
 
   mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles(
       struct_with_union, 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, struct_with_union, buf.num_bytes_used,
+        mojo_test_StructOfUnionOfReferences_DeepCopy,
+        mojo_test_StructOfUnionOfReferences_EncodePointersAndHandles,
+        mojo_test_StructOfUnionOfReferences_DecodePointersAndHandles);
+  }
 }
 
 }  // namespace