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

   1 // Copyright 2013 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/environment/environment.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 {
  11
  12 struct RedmondRect {
  13   int32_t left;
  14   int32_t top;
  15   int32_t right;
  16   int32_t bottom;
  17 };
  18
  19 struct RedmondNamedRegion {
  20   std::string name;
  21   std::vector<RedmondRect> rects;
  22 };
  23
  24 bool AreEqualRectArrays(const Array<test::RectPtr>& rects1,
  25                         const Array<test::RectPtr>& rects2) {
  26   if (rects1.size() != rects2.size())
  27     return false;
  28
  29   for (size_t i = 0; i < rects1.size(); ++i) {
  30     if (rects1[i]->x != rects2[i]->x || rects1[i]->y != rects2[i]->y ||
  31         rects1[i]->width != rects2[i]->width ||
  32         rects1[i]->height != rects2[i]->height) {
  33       return false;
  34     }
  35   }
  36
  37   return true;
  38 }
  39
  40 }  // namespace
  41
  42 template <>
  43 struct TypeConverter<test::RectPtr, RedmondRect> {
  44   static test::RectPtr Convert(const RedmondRect& input) {
  45     test::RectPtr rect(test::Rect::New());
  46     rect->x = input.left;
  47     rect->y = input.top;
  48     rect->width = input.right - input.left;
  49     rect->height = input.bottom - input.top;
  50     return rect.Pass();
  51   }
  52 };
  53
  54 template <>
  55 struct TypeConverter<RedmondRect, test::RectPtr> {
  56   static RedmondRect Convert(const test::RectPtr& input) {
  57     RedmondRect rect;
  58     rect.left = input->x;
  59     rect.top = input->y;
  60     rect.right = input->x + input->width;
  61     rect.bottom = input->y + input->height;
  62     return rect;
  63   }
  64 };
  65
  66 template <>
  67 struct TypeConverter<test::NamedRegionPtr, RedmondNamedRegion> {
  68   static test::NamedRegionPtr Convert(const RedmondNamedRegion& input) {
  69     test::NamedRegionPtr region(test::NamedRegion::New());
  70     region->name = input.name;
  71     region->rects = Array<test::RectPtr>::From(input.rects);
  72     return region.Pass();
  73   }
  74 };
  75
  76 template <>
  77 struct TypeConverter<RedmondNamedRegion, test::NamedRegionPtr> {
  78   static RedmondNamedRegion Convert(const test::NamedRegionPtr& input) {
  79     RedmondNamedRegion region;
  80     region.name = input->name;
  81     region.rects = input->rects.To<std::vector<RedmondRect>>();
  82     return region;
  83   }
  84 };
  85
  86 namespace test {
  87 namespace {
  88
  89 TEST(TypeConversionTest, String) {
  90   const char kText[6] = "hello";
  91
  92   String a = std::string(kText);
  93   String b(kText);
  94   String c(static_cast<const char*>(kText));
  95
  96   EXPECT_EQ(std::string(kText), a.To<std::string>());
  97   EXPECT_EQ(std::string(kText), b.To<std::string>());
  98   EXPECT_EQ(std::string(kText), c.To<std::string>());
  99 }
 100
 101 TEST(TypeConversionTest, String_Null) {
 102   String a;
 103   EXPECT_TRUE(a.is_null());
 104   EXPECT_EQ(std::string(), a.To<std::string>());
 105
 106   String b = String::From(static_cast<const char*>(nullptr));
 107   EXPECT_TRUE(b.is_null());
 108 }
 109
 110 TEST(TypeConversionTest, String_Empty) {
 111   String a = "";
 112   EXPECT_EQ(std::string(), a.To<std::string>());
 113
 114   String b = std::string();
 115   EXPECT_FALSE(b.is_null());
 116   EXPECT_EQ(std::string(), b.To<std::string>());
 117 }
 118
 119 TEST(TypeConversionTest, StringWithEmbeddedNull) {
 120   const std::string kText("hel\0lo", 6);
 121
 122   String a(kText);
 123   EXPECT_EQ(kText, a.To<std::string>());
 124
 125   // Expect truncation:
 126   String b(kText.c_str());
 127   EXPECT_EQ(std::string("hel"), b.To<std::string>());
 128 }
 129
 130 TEST(TypeConversionTest, CustomTypeConverter) {
 131   RectPtr rect(Rect::New());
 132   rect->x = 10;
 133   rect->y = 20;
 134   rect->width = 50;
 135   rect->height = 45;
 136
 137   RedmondRect rr = rect.To<RedmondRect>();
 138   EXPECT_EQ(10, rr.left);
 139   EXPECT_EQ(20, rr.top);
 140   EXPECT_EQ(60, rr.right);
 141   EXPECT_EQ(65, rr.bottom);
 142
 143   RectPtr rect2(Rect::From(rr));
 144   EXPECT_EQ(rect->x, rect2->x);
 145   EXPECT_EQ(rect->y, rect2->y);
 146   EXPECT_EQ(rect->width, rect2->width);
 147   EXPECT_EQ(rect->height, rect2->height);
 148 }
 149
 150 TEST(TypeConversionTest, CustomTypeConverter_Array_Null) {
 151   Array<RectPtr> rects;
 152
 153   std::vector<RedmondRect> redmond_rects = rects.To<std::vector<RedmondRect>>();
 154
 155   EXPECT_TRUE(redmond_rects.empty());
 156 }
 157
 158 TEST(TypeConversionTest, CustomTypeConverter_Array) {
 159   const RedmondRect kBase = {10, 20, 30, 40};
 160
 161   Array<RectPtr> rects(10);
 162   for (size_t i = 0; i < rects.size(); ++i) {
 163     RedmondRect rr = kBase;
 164     rr.left += static_cast<int32_t>(i);
 165     rr.top += static_cast<int32_t>(i);
 166     rects[i] = Rect::From(rr);
 167   }
 168
 169   std::vector<RedmondRect> redmond_rects = rects.To<std::vector<RedmondRect>>();
 170
 171   Array<RectPtr> rects2 = Array<RectPtr>::From(redmond_rects);
 172   EXPECT_TRUE(AreEqualRectArrays(rects, rects2));
 173 }
 174
 175 TEST(TypeConversionTest, CustomTypeConverter_Nested) {
 176   RedmondNamedRegion redmond_region;
 177   redmond_region.name = "foopy";
 178
 179   const RedmondRect kBase = {10, 20, 30, 40};
 180
 181   for (size_t i = 0; i < 10; ++i) {
 182     RedmondRect rect = kBase;
 183     rect.left += static_cast<int32_t>(i);
 184     rect.top += static_cast<int32_t>(i);
 185     redmond_region.rects.push_back(rect);
 186   }
 187
 188   // Round-trip through generated struct and TypeConverter.
 189
 190   NamedRegionPtr copy = NamedRegion::From(redmond_region);
 191   RedmondNamedRegion redmond_region2 = copy.To<RedmondNamedRegion>();
 192
 193   EXPECT_EQ(redmond_region.name, redmond_region2.name);
 194   EXPECT_EQ(redmond_region.rects.size(), redmond_region2.rects.size());
 195   for (size_t i = 0; i < redmond_region.rects.size(); ++i) {
 196     EXPECT_EQ(redmond_region.rects[i].left, redmond_region2.rects[i].left);
 197     EXPECT_EQ(redmond_region.rects[i].top, redmond_region2.rects[i].top);
 198     EXPECT_EQ(redmond_region.rects[i].right, redmond_region2.rects[i].right);
 199     EXPECT_EQ(redmond_region.rects[i].bottom, redmond_region2.rects[i].bottom);
 200   }
 201 }
 202
 203 }  // namespace
 204 }  // namespace test
 205 }  // namespace mojo