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;
+  internal::PodUnion_Data* data = nullptr;
   Serialize_(pod1.Pass(), &buf, &data);
 
   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) {
   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;
+  internal::PodUnion_Data* data = nullptr;
   Serialize_(pod.Pass(), &buf, &data);
   void* raw_buf = buf.Leak();
   mojo::internal::BoundsChecker bounds_checker(data, size, 0);
   EXPECT_TRUE(internal::PodUnion_Data::Validate(raw_buf, &bounds_checker));
   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;
+  Serialize_(pod.Pass(), &buf, &data);
+  EXPECT_FALSE(data->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));
 }
 
 TEST(UnionTest, OutOfAlignmentValidation) {
   Environment environment;
   size_t size = sizeof(internal::PodUnion_Data);
   // Get an aligned object and shift the alignment.
@@ skipping 65 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;
+  internal::ObjectUnion_Data* data = nullptr;
   Serialize_(pod1.Pass(), &buf, &data);
 
   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) {
@@ skipping 33 matching lines @@
   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));
   free(raw_buf);
 }
+
+TEST(UnionTest, PodUnionInStruct) {
+  SmallStructPtr small_struct(SmallStruct::New());

[yzshen1, 2015/02/17 19:34:35]

Why do we need this test and ObjectUnionInStruct? It seems they are very
obvious, and other test failures will be triggered if such basic functionality
doesn't work.

[azani, 2015/02/18 00:27:57]

Artefacts of TDD. Gone now.

+  small_struct->pod_union = PodUnion::New();
+  small_struct->pod_union->set_f_int8(10);
+  EXPECT_EQ(10, small_struct->pod_union->get_f_int8());
+}
+
+TEST(UnionTest, PodUnionInStructClone) {
+  SmallStructPtr small_struct(SmallStruct::New());
+  small_struct->pod_union = PodUnion::New();
+  small_struct->pod_union->set_f_int8(10);
+
+  SmallStructPtr clone = small_struct.Clone();
+  EXPECT_EQ(10, clone->pod_union->get_f_int8());
+}
+
+TEST(UnionTest, ObjectUnionInStruct) {
+  SmallObjStructPtr small_struct(SmallObjStruct::New());
+  String hello("hello world");
+  small_struct->obj_union = ObjectUnion::New();
+  small_struct->obj_union->set_f_string(hello);
+  EXPECT_EQ(hello, small_struct->obj_union->get_f_string());
+}
+
+TEST(UnionTest, PodUnionInStructSerialization) {
+  SmallStructPtr small_struct(SmallStruct::New());
+  small_struct->pod_union = PodUnion::New();
+  small_struct->pod_union->set_f_int32(10);
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStruct_Data* data = nullptr;
+  Serialize_(small_struct.Pass(), &buf, &data);
+
+  SmallStructPtr deserialized;
+  Deserialize_(data, &deserialized);
+
+  EXPECT_EQ(10, deserialized->pod_union->get_f_int32());
+}
+
+TEST(UnionTest, ObjectUnionInStructSerialization) {
+  SmallObjStructPtr obj_struct(SmallObjStruct::New());
+  obj_struct->obj_union = ObjectUnion::New();
+  String hello("hello world");
+  obj_struct->obj_union->set_f_string(hello);
+
+  size_t size = GetSerializedSize_(obj_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallObjStruct_Data* data = nullptr;
+  Serialize_(obj_struct.Pass(), &buf, &data);
+
+  SmallObjStructPtr deserialized;
+  Deserialize_(data, &deserialized);
+
+  EXPECT_EQ(hello, deserialized->obj_union->get_f_string());
+}
+
+TEST(UnionTest, ValidationJustWorksForUnionsInStructs) {

[yzshen1, 2015/02/17 19:34:35]

Nit: maybe UnionsInStructsValidation?

[azani, 2015/02/18 00:27:57]

Done.

+  SmallStructPtr small_struct(SmallStruct::New());
+  small_struct->pod_union = PodUnion::New();
+  small_struct->pod_union->set_f_int32(10);
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStruct_Data* data = nullptr;
+  Serialize_(small_struct.Pass(), &buf, &data);
+
+  void* raw_buf = buf.Leak();
+  mojo::internal::BoundsChecker bounds_checker(data, size, 0);
+  EXPECT_TRUE(internal::SmallStruct_Data::Validate(raw_buf, &bounds_checker));
+  free(raw_buf);
+}
+
+TEST(UnionTest, PodUnionInStructValidationFails) {

[yzshen1, 2015/02/17 19:34:35]

Maybe use the same style across multiple test names?

XXXValidation
XXXValidationFailure

[azani, 2015/02/18 00:27:57]

Done.

+  Environment environment;
+  SmallStructPtr small_struct(SmallStruct::New());
+  small_struct->pod_union = PodUnion::New();
+  small_struct->pod_union->set_f_int32(10);
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStruct_Data* data = nullptr;
+  Serialize_(small_struct.Pass(), &buf, &data);
+  data->pod_union.tag = static_cast<internal::PodUnion_Data::PodUnion_Tag>(100);
+
+  void* raw_buf = buf.Leak();
+  mojo::internal::BoundsChecker bounds_checker(data, size, 0);
+  EXPECT_FALSE(internal::SmallStruct_Data::Validate(raw_buf, &bounds_checker));
+  free(raw_buf);
+}
+
+TEST(UnionTest, ValidationNullUnionFailure) {
+  Environment environment;
+  SmallStructPtr small_struct(SmallStruct::New());
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStruct_Data* data = nullptr;
+  Serialize_(small_struct.Pass(), &buf, &data);
+
+  void* raw_buf = buf.Leak();
+  mojo::internal::BoundsChecker bounds_checker(data, size, 0);
+  EXPECT_FALSE(internal::SmallStruct_Data::Validate(raw_buf, &bounds_checker));
+  free(raw_buf);
+}
+
+TEST(UnionTest, ValidationNullbleUnion) {
+  Environment environment;
+  SmallStructNullableUnionPtr small_struct(SmallStructNullableUnion::New());
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStructNullableUnion_Data* data = nullptr;
+  Serialize_(small_struct.Pass(), &buf, &data);
+
+  void* raw_buf = buf.Leak();
+  mojo::internal::BoundsChecker bounds_checker(data, size, 0);
+  EXPECT_TRUE(internal::SmallStructNullableUnion_Data::Validate(
+      raw_buf, &bounds_checker));
+  free(raw_buf);
+}
 }  // namespace test
 }  // namespace mojo