Implement unions as members of structs.

mojo/public/cpp/bindings/tests/struct_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 <string.h>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
+#include "mojo/public/interfaces/bindings/tests/test_unions.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 RectPtr MakeRect(int32_t factor = 1) {
   RectPtr rect(Rect::New());
   rect->x = 1 * factor;
   rect->y = 2 * factor;
@@ skipping 391 matching lines @@
     MultiVersionStructV0Ptr expected_output(MultiVersionStructV0::New());
     expected_output->f_int32 = 123;
 
     MultiVersionStructV0Ptr output =
         SerializeAndDeserialize<MultiVersionStructV0Ptr>(input.Pass());
     EXPECT_TRUE(output);
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 }
 
+TEST_F(StructTest, 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_F(StructTest, PodUnionInStructSerialization) {

[yzshen1, 2015/03/26 07:30:14]

nit: the naming is not very consistent within this file. The existing tests use
"Serialization_XXX", "Construction_XXX", "Versioning_XXX"

[azani, 2015/03/26 22:27:39]

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);
+
+  SmallStructPtr deserialized;
+  Deserialize_(data, &deserialized);
+
+  EXPECT_EQ(10, deserialized->pod_union->get_f_int32());
+}
+
+TEST_F(StructTest, 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_F(StructTest, UnionsInStructsValidation) {
+  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_F(StructTest, PodUnionInStructValidationFailure) {
+  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_F(StructTest, NullUnionValidationFailure) {
+  SmallStructNonNullableUnionPtr small_struct(
+      SmallStructNonNullableUnion::New());
+
+  size_t size = GetSerializedSize_(small_struct);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::SmallStructNonNullableUnion_Data* data =
+      internal::SmallStructNonNullableUnion_Data::New(&buf);
+
+  void* raw_buf = buf.Leak();
+  mojo::internal::BoundsChecker bounds_checker(data, size, 0);
+  EXPECT_FALSE(internal::SmallStructNonNullableUnion_Data::Validate(
+      raw_buf, &bounds_checker));
+  free(raw_buf);
+}
+
+TEST_F(StructTest, NullableUnionValidation) {
+  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_TRUE(internal::SmallStruct_Data::Validate(raw_buf, &bounds_checker));
+  free(raw_buf);
+}
+
 }  // namespace test
 }  // namespace mojo