Mojo: more idiomatic C++ bindings

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 "mojo/public/cpp/bindings/lib/fixed_buffer.h"
+#include "mojo/public/interfaces/bindings/tests/test_structs.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;
+  rect->width = 10 * factor;
+  rect->height = 20 * factor;
+  return rect.Pass();
+}
+
+void CheckRect(const Rect& rect, int32_t factor = 1) {
+  EXPECT_EQ(1 * factor, rect.x);
+  EXPECT_EQ(2 * factor, rect.y);
+  EXPECT_EQ(10 * factor, rect.width);
+  EXPECT_EQ(20 * factor, rect.height);
+}
+
+}  // namespace
+
+TEST(StructTest, Rect) {
+  RectPtr rect;
+  EXPECT_TRUE(rect.is_null());
+  EXPECT_TRUE(!rect);
+  EXPECT_FALSE(rect);
+
+  rect = MakeRect();
+  EXPECT_FALSE(rect.is_null());
+  EXPECT_FALSE(!rect);
+  EXPECT_TRUE(rect);
+
+  CheckRect(*rect);
+}
+
+// Serialization test of a struct with no pointer or handle members.
+TEST(StructTest, Serialization_Basic) {
+  RectPtr rect(MakeRect());
+
+  size_t size = GetSerializedSize_(rect);
+  EXPECT_EQ(8U + 16U, size);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::Rect_Data* data;
+  Serialize_(rect.Pass(), &buf, &data);
+
+  RectPtr rect2;
+  Deserialize_(data, &rect2);
+
+  CheckRect(*rect2);
+}
+
+// Serialization test of a struct with struct pointers.
+TEST(StructTest, Serialization_StructPointers) {
+  RectPairPtr pair(RectPair::New());
+  pair->first = MakeRect();
+  pair->second = MakeRect();
+
+  size_t size = GetSerializedSize_(pair);
+  EXPECT_EQ(8U + 16U + 2*(8U + 16U), size);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::RectPair_Data* data;
+  Serialize_(pair.Pass(), &buf, &data);
+
+  RectPairPtr pair2;
+  Deserialize_(data, &pair2);
+
+  CheckRect(*pair2->first);
+  CheckRect(*pair2->second);
+}
+
+// Serialization test of a struct with an array member.
+TEST(StructTest, Serialization_ArrayPointers) {
+  NamedRegionPtr region(NamedRegion::New());
+  region->name = "region";
+  region->rects = Array<RectPtr>::New(4);
+  for (size_t i = 0; i < region->rects.size(); ++i)
+    region->rects[i] = MakeRect(static_cast<int32_t>(i) + 1);
+
+  size_t size = GetSerializedSize_(region);
+  EXPECT_EQ(8U +  // header
+            8U +  // name pointer
+            8U +  // rects pointer
+            8U +  // name header
+            8U +  // name payload (rounded up)
+            8U +    // rects header
+            4*8U +  // rects payload (four pointers)
+            4*(8U +   // rect header
+               16U),  // rect payload (four ints)
+            size);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::NamedRegion_Data* data;
+  Serialize_(region.Pass(), &buf, &data);
+
+  NamedRegionPtr region2;
+  Deserialize_(data, &region2);
+
+  EXPECT_EQ(String("region"), region2->name);
+
+  EXPECT_EQ(4U, region2->rects.size());
+  for (size_t i = 0; i < region2->rects.size(); ++i)
+    CheckRect(*region2->rects[i], static_cast<int32_t>(i) + 1);
+}
+
+// Serialization test of a struct with null array pointers.
+TEST(StructTest, Serialization_NullArrayPointers) {
+  NamedRegionPtr region(NamedRegion::New());
+  EXPECT_TRUE(region->name.is_null());
+  EXPECT_TRUE(region->rects.is_null());
+
+  size_t size = GetSerializedSize_(region);
+  EXPECT_EQ(8U +  // header
+            8U +  // name pointer
+            8U,   // rects pointer
+            size);
+
+  mojo::internal::FixedBuffer buf(size);
+  internal::NamedRegion_Data* data;
+  Serialize_(region.Pass(), &buf, &data);
+
+  NamedRegionPtr region2;
+  Deserialize_(data, &region2);
+
+  EXPECT_TRUE(region2->name.is_null());
+  EXPECT_TRUE(region2->rects.is_null());
+}
+
+}  // namespace test
+}  // namespace mojo