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