src/mojo/public/cpp/bindings/tests/struct_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
   6 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace mojo {
  10 namespace test {
  11 namespace {
  12
  13 RectPtr MakeRect(int32_t factor = 1) {
  14   RectPtr rect(Rect::New());
  15   rect->x = 1 * factor;
  16   rect->y = 2 * factor;
  17   rect->width = 10 * factor;
  18   rect->height = 20 * factor;
  19   return rect.Pass();
  20 }
  21
  22 void CheckRect(const Rect& rect, int32_t factor = 1) {
  23   EXPECT_EQ(1 * factor, rect.x);
  24   EXPECT_EQ(2 * factor, rect.y);
  25   EXPECT_EQ(10 * factor, rect.width);
  26   EXPECT_EQ(20 * factor, rect.height);
  27 }
  28
  29 }  // namespace
  30
  31 TEST(StructTest, Rect) {
  32   RectPtr rect;
  33   EXPECT_TRUE(rect.is_null());
  34   EXPECT_TRUE(!rect);
  35   EXPECT_FALSE(rect);
  36
  37   rect = MakeRect();
  38   EXPECT_FALSE(rect.is_null());
  39   EXPECT_FALSE(!rect);
  40   EXPECT_TRUE(rect);
  41
  42   CheckRect(*rect);
  43 }
  44
  45 // Serialization test of a struct with no pointer or handle members.
  46 TEST(StructTest, Serialization_Basic) {
  47   RectPtr rect(MakeRect());
  48
  49   size_t size = GetSerializedSize_(rect);
  50   EXPECT_EQ(8U + 16U, size);
  51
  52   mojo::internal::FixedBuffer buf(size);
  53   internal::Rect_Data* data;
  54   Serialize_(rect.Pass(), &buf, &data);
  55
  56   RectPtr rect2;
  57   Deserialize_(data, &rect2);
  58
  59   CheckRect(*rect2);
  60 }
  61
  62 // Serialization test of a struct with struct pointers.
  63 TEST(StructTest, Serialization_StructPointers) {
  64   RectPairPtr pair(RectPair::New());
  65   pair->first = MakeRect();
  66   pair->second = MakeRect();
  67
  68   size_t size = GetSerializedSize_(pair);
  69   EXPECT_EQ(8U + 16U + 2*(8U + 16U), size);
  70
  71   mojo::internal::FixedBuffer buf(size);
  72   internal::RectPair_Data* data;
  73   Serialize_(pair.Pass(), &buf, &data);
  74
  75   RectPairPtr pair2;
  76   Deserialize_(data, &pair2);
  77
  78   CheckRect(*pair2->first);
  79   CheckRect(*pair2->second);
  80 }
  81
  82 // Serialization test of a struct with an array member.
  83 TEST(StructTest, Serialization_ArrayPointers) {
  84   NamedRegionPtr region(NamedRegion::New());
  85   region->name = "region";
  86   region->rects = Array<RectPtr>::New(4);
  87   for (size_t i = 0; i < region->rects.size(); ++i)
  88     region->rects[i] = MakeRect(static_cast<int32_t>(i) + 1);
  89
  90   size_t size = GetSerializedSize_(region);
  91   EXPECT_EQ(8U +  // header
  92             8U +  // name pointer
  93             8U +  // rects pointer
  94             8U +  // name header
  95             8U +  // name payload (rounded up)
  96             8U +    // rects header
  97             4*8U +  // rects payload (four pointers)
  98             4*(8U +   // rect header
  99                16U),  // rect payload (four ints)
 100             size);
 101
 102   mojo::internal::FixedBuffer buf(size);
 103   internal::NamedRegion_Data* data;
 104   Serialize_(region.Pass(), &buf, &data);
 105
 106   NamedRegionPtr region2;
 107   Deserialize_(data, &region2);
 108
 109   EXPECT_EQ(String("region"), region2->name);
 110
 111   EXPECT_EQ(4U, region2->rects.size());
 112   for (size_t i = 0; i < region2->rects.size(); ++i)
 113     CheckRect(*region2->rects[i], static_cast<int32_t>(i) + 1);
 114 }
 115
 116 // Serialization test of a struct with null array pointers.
 117 TEST(StructTest, Serialization_NullArrayPointers) {
 118   NamedRegionPtr region(NamedRegion::New());
 119   EXPECT_TRUE(region->name.is_null());
 120   EXPECT_TRUE(region->rects.is_null());
 121
 122   size_t size = GetSerializedSize_(region);
 123   EXPECT_EQ(8U +  // header
 124             8U +  // name pointer
 125             8U,   // rects pointer
 126             size);
 127
 128   mojo::internal::FixedBuffer buf(size);
 129   internal::NamedRegion_Data* data;
 130   Serialize_(region.Pass(), &buf, &data);
 131
 132   NamedRegionPtr region2;
 133   Deserialize_(data, &region2);
 134
 135   EXPECT_TRUE(region2->name.is_null());
 136   EXPECT_TRUE(region2->rects.is_null());
 137 }
 138
 139 }  // namespace test
 140 }  // namespace mojo