Implement unions as members of structs.

mojo/public/cpp/bindings/tests/union_unittest.cc

 // Copyright 2014 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.
 
 #include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/interfaces/bindings/tests/test_unions.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 90 matching lines @@
 }
 
 TEST(UnionTest, SerializationPod) {
   PodUnionPtr pod1(PodUnion::New());
   pod1->set_f_int8(10);
 
   size_t size = GetSerializedSize_(pod1);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBuffer buf(size);
-  internal::PodUnion_Data* data;
-  Serialize_(pod1.Pass(), &buf, &data);
+  internal::PodUnion_Data* data = nullptr;
+  SerializeUnion_(pod1.Pass(), &buf, &data, false);
 
   PodUnionPtr pod2;
   Deserialize_(data, &pod2);
 
   EXPECT_EQ(10, pod2->get_f_int8());
   EXPECT_TRUE(pod2->is_f_int8());
   EXPECT_EQ(pod2->which(), PodUnion::Tag::F_INT8);
 }
 
-TEST(UnionTest, ValidationJustWorksPod) {
+TEST(UnionTest, PodValidation) {
   PodUnionPtr pod(PodUnion::New());
   pod->set_f_int8(10);
 
   size_t size = GetSerializedSize_(pod);
   EXPECT_EQ(16U, size);
 
   mojo::internal::FixedBuffer buf(size);
-  internal::PodUnion_Data* data;
-  Serialize_(pod.Pass(), &buf, &data);
+  internal::PodUnion_Data* data = nullptr;
+  SerializeUnion_(pod.Pass(), &buf, &data, false);
   void* raw_buf = buf.Leak();
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
-  EXPECT_TRUE(internal::PodUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_TRUE(
+      internal::PodUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
+TEST(UnionTest, SerializeNotNull) {
+  PodUnionPtr pod(PodUnion::New());
+  pod->set_f_int8(0);
+  size_t size = GetSerializedSize_(pod);
+  mojo::internal::FixedBuffer buf(size);
+  internal::PodUnion_Data* data = nullptr;
+  SerializeUnion_(pod.Pass(), &buf, &data, false);
+  EXPECT_FALSE(data->is_null());
+}
+
+TEST(UnionTest, SerializeIsNull) {
+  PodUnionPtr pod;
+  size_t size = GetSerializedSize_(pod);
+  EXPECT_EQ(16U, size);
+  mojo::internal::FixedBuffer buf(size);
+  internal::PodUnion_Data* data = nullptr;
+  SerializeUnion_(pod.Pass(), &buf, &data, false);
+  EXPECT_TRUE(data->is_null());
+
+  PodUnionPtr pod2;
+  Deserialize_(data, &pod2);
+  EXPECT_TRUE(pod2.is_null());
+}
+
 TEST(UnionTest, NullValidation) {
   void* buf = nullptr;
   mojo::internal::BoundsChecker bounds_checker(buf, 0, 0);
-  EXPECT_TRUE(internal::PodUnion_Data::Validate(buf, &bounds_checker));
+  EXPECT_TRUE(internal::PodUnion_Data::Validate(buf, &bounds_checker, false));
 }
 
 TEST(UnionTest, OutOfAlignmentValidation) {
   Environment environment;
   size_t size = sizeof(internal::PodUnion_Data);
   // Get an aligned object and shift the alignment.
   mojo::internal::FixedBuffer aligned_buf(size + 1);
   void* raw_buf = aligned_buf.Leak();
   char* buf = reinterpret_cast<char*>(raw_buf) + 1;
 
   internal::PodUnion_Data* data =
       reinterpret_cast<internal::PodUnion_Data*>(buf);
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
-  EXPECT_FALSE(internal::PodUnion_Data::Validate(buf, &bounds_checker));
+  EXPECT_FALSE(internal::PodUnion_Data::Validate(buf, &bounds_checker, false));
   free(raw_buf);
 }
 
 TEST(UnionTest, OOBValidation) {
   Environment environment;
   size_t size = sizeof(internal::PodUnion_Data) - 1;
   mojo::internal::FixedBuffer buf(size);
   internal::PodUnion_Data* data = internal::PodUnion_Data::New(&buf);
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
   void* raw_buf = buf.Leak();
-  EXPECT_FALSE(internal::PodUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_FALSE(
+      internal::PodUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
 TEST(UnionTest, UnknownTagValidation) {
   Environment environment;
   size_t size = sizeof(internal::PodUnion_Data);
   mojo::internal::FixedBuffer buf(size);
   internal::PodUnion_Data* data = internal::PodUnion_Data::New(&buf);
   data->tag = static_cast<internal::PodUnion_Data::PodUnion_Tag>(0xFFFFFF);
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
   void* raw_buf = buf.Leak();
-  EXPECT_FALSE(internal::PodUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_FALSE(
+      internal::PodUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
 TEST(UnionTest, StringGetterSetter) {
   ObjectUnionPtr pod(ObjectUnion::New());
 
   String hello("hello world");
   pod->set_f_string(hello);
   EXPECT_EQ(hello, pod->get_f_string());
   EXPECT_TRUE(pod->is_f_string());
@@ skipping 24 matching lines @@
 }
 
 TEST(UnionTest, StringSerialization) {
   ObjectUnionPtr pod1(ObjectUnion::New());
 
   String hello("hello world");
   pod1->set_f_string(hello);
 
   size_t size = GetSerializedSize_(pod1);
   mojo::internal::FixedBuffer buf(size);
-  internal::ObjectUnion_Data* data;
-  Serialize_(pod1.Pass(), &buf, &data);
+  internal::ObjectUnion_Data* data = nullptr;
+  SerializeUnion_(pod1.Pass(), &buf, &data, false);
 
   ObjectUnionPtr pod2;
   Deserialize_(data, &pod2);
   EXPECT_EQ(hello, pod2->get_f_string());
   EXPECT_TRUE(pod2->is_f_string());
   EXPECT_EQ(pod2->which(), ObjectUnion::Tag::F_STRING);
 }
 
-TEST(UnionTest, StringValidationNull) {
+TEST(UnionTest, NullStringValidation) {
   Environment environment;
   size_t size = sizeof(internal::ObjectUnion_Data);
   mojo::internal::FixedBuffer buf(size);
   internal::ObjectUnion_Data* data = internal::ObjectUnion_Data::New(&buf);
   data->tag = internal::ObjectUnion_Data::ObjectUnion_Tag::F_STRING;
   data->data.unknown = 0x0;
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
   void* raw_buf = buf.Leak();
-  EXPECT_FALSE(internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_FALSE(
+      internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
-TEST(UnionTest, StringValidationPointerOverflow) {
+TEST(UnionTest, StringPointerOverflowValidation) {
   Environment environment;
   size_t size = sizeof(internal::ObjectUnion_Data);
   mojo::internal::FixedBuffer buf(size);
   internal::ObjectUnion_Data* data = internal::ObjectUnion_Data::New(&buf);
   data->tag = internal::ObjectUnion_Data::ObjectUnion_Tag::F_STRING;
   data->data.unknown = 0xFFFFFFFFFFFFFFFF;
   mojo::internal::BoundsChecker bounds_checker(data,
                                                static_cast<uint32_t>(size), 0);
   void* raw_buf = buf.Leak();
-  EXPECT_FALSE(internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_FALSE(
+      internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 
-TEST(UnionTest, StringValidationValidateString) {
+TEST(UnionTest, StringValidateOOB) {
   Environment environment;
   size_t size = 32;
   mojo::internal::FixedBuffer buf(size);
   internal::ObjectUnion_Data* data = internal::ObjectUnion_Data::New(&buf);
   data->tag = internal::ObjectUnion_Data::ObjectUnion_Tag::F_STRING;
 
   data->data.f_f_string = 8;
   char* ptr = reinterpret_cast<char*>(&data->data.f_f_string);
   mojo::internal::ArrayHeader* array_header =
       reinterpret_cast<mojo::internal::ArrayHeader*>(ptr + *ptr);
   array_header->num_bytes = 20;  // This should go out of bounds.
   array_header->num_elements = 20;
   mojo::internal::BoundsChecker bounds_checker(data, 32, 0);
   void* raw_buf = buf.Leak();
-  EXPECT_FALSE(internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker));
+  EXPECT_FALSE(
+      internal::ObjectUnion_Data::Validate(raw_buf, &bounds_checker, false));
   free(raw_buf);
 }
 }  // namespace test
 }  // namespace mojo