OLD | NEW |
| (Empty) |
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/bindings/tests/test_structs.mojom.h" | |
6 #include "mojo/public/cpp/bindings/allocation_scope.h" | |
7 #include "mojo/public/cpp/environment/environment.h" | |
8 #include "testing/gtest/include/gtest/gtest.h" | |
9 | |
10 namespace mojo { | |
11 namespace { | |
12 | |
13 struct RedmondRect { | |
14 int32_t left; | |
15 int32_t top; | |
16 int32_t right; | |
17 int32_t bottom; | |
18 }; | |
19 | |
20 struct RedmondNamedRegion { | |
21 std::string name; | |
22 std::vector<RedmondRect> rects; | |
23 }; | |
24 | |
25 } // namespace | |
26 | |
27 template <> | |
28 class TypeConverter<test_structs::Rect, RedmondRect> { | |
29 public: | |
30 static test_structs::Rect ConvertFrom(const RedmondRect& input, Buffer* buf) { | |
31 test_structs::Rect::Builder rect(buf); | |
32 rect.set_x(input.left); | |
33 rect.set_y(input.top); | |
34 rect.set_width(input.right - input.left); | |
35 rect.set_height(input.bottom - input.top); | |
36 return rect.Finish(); | |
37 } | |
38 static RedmondRect ConvertTo(const test_structs::Rect& input) { | |
39 RedmondRect rect; | |
40 rect.left = input.x(); | |
41 rect.top = input.y(); | |
42 rect.right = input.x() + input.width(); | |
43 rect.bottom = input.y() + input.height(); | |
44 return rect; | |
45 } | |
46 }; | |
47 | |
48 template <> | |
49 class TypeConverter<test_structs::NamedRegion, RedmondNamedRegion> { | |
50 public: | |
51 static test_structs::NamedRegion ConvertFrom(const RedmondNamedRegion& input, | |
52 Buffer* buf) { | |
53 test_structs::NamedRegion::Builder region(buf); | |
54 region.set_name(String(input.name, buf)); | |
55 region.set_rects(mojo::Array<test_structs::Rect>(input.rects, buf)); | |
56 return region.Finish(); | |
57 } | |
58 static RedmondNamedRegion ConvertTo(const test_structs::NamedRegion& input) { | |
59 RedmondNamedRegion region; | |
60 region.name = input.name().To<std::string>(); | |
61 region.rects = input.rects().To<std::vector<RedmondRect> >(); | |
62 return region; | |
63 } | |
64 }; | |
65 | |
66 namespace test { | |
67 namespace { | |
68 | |
69 class TypeConversionTest : public testing::Test { | |
70 private: | |
71 Environment env_; | |
72 }; | |
73 | |
74 TEST_F(TypeConversionTest, String) { | |
75 AllocationScope scope; | |
76 | |
77 const char kText[6] = "hello"; | |
78 | |
79 String a = std::string(kText); | |
80 String b(kText); | |
81 String c(static_cast<const char*>(kText)); | |
82 | |
83 EXPECT_EQ(std::string(kText), a.To<std::string>()); | |
84 EXPECT_EQ(std::string(kText), b.To<std::string>()); | |
85 EXPECT_EQ(std::string(kText), c.To<std::string>()); | |
86 } | |
87 | |
88 TEST_F(TypeConversionTest, String_Null) { | |
89 String a; | |
90 EXPECT_TRUE(a.is_null()); | |
91 EXPECT_EQ(std::string(), a.To<std::string>()); | |
92 | |
93 String b(static_cast<const char*>(NULL)); | |
94 EXPECT_TRUE(b.is_null()); | |
95 } | |
96 | |
97 TEST_F(TypeConversionTest, String_Empty) { | |
98 AllocationScope scope; | |
99 String a = String::Builder(0).Finish(); | |
100 EXPECT_EQ(std::string(), a.To<std::string>()); | |
101 | |
102 String b = std::string(); | |
103 EXPECT_FALSE(b.is_null()); | |
104 EXPECT_EQ(std::string(), b.To<std::string>()); | |
105 } | |
106 | |
107 TEST_F(TypeConversionTest, String_ShallowCopy) { | |
108 AllocationScope scope; | |
109 | |
110 String a("hello"); | |
111 String b(a); | |
112 | |
113 EXPECT_EQ(&a[0], &b[0]); | |
114 EXPECT_EQ(a.To<std::string>(), b.To<std::string>()); | |
115 } | |
116 | |
117 TEST_F(TypeConversionTest, StringWithEmbeddedNull) { | |
118 AllocationScope scope; | |
119 | |
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_F(TypeConversionTest, CustomTypeConverter) { | |
131 AllocationScope scope; | |
132 | |
133 test_structs::Rect::Builder rect_builder; | |
134 rect_builder.set_x(10); | |
135 rect_builder.set_y(20); | |
136 rect_builder.set_width(50); | |
137 rect_builder.set_height(45); | |
138 test_structs::Rect rect = rect_builder.Finish(); | |
139 | |
140 RedmondRect rr = rect.To<RedmondRect>(); | |
141 EXPECT_EQ(10, rr.left); | |
142 EXPECT_EQ(20, rr.top); | |
143 EXPECT_EQ(60, rr.right); | |
144 EXPECT_EQ(65, rr.bottom); | |
145 | |
146 test_structs::Rect rect2(rr); | |
147 EXPECT_EQ(rect.x(), rect2.x()); | |
148 EXPECT_EQ(rect.y(), rect2.y()); | |
149 EXPECT_EQ(rect.width(), rect2.width()); | |
150 EXPECT_EQ(rect.height(), rect2.height()); | |
151 } | |
152 | |
153 TEST_F(TypeConversionTest, CustomTypeConverter_Array_Null) { | |
154 Array<test_structs::Rect> rects; | |
155 | |
156 std::vector<RedmondRect> redmond_rects = | |
157 rects.To<std::vector<RedmondRect> >(); | |
158 | |
159 EXPECT_TRUE(redmond_rects.empty()); | |
160 } | |
161 | |
162 TEST_F(TypeConversionTest, CustomTypeConverter_Array) { | |
163 AllocationScope scope; | |
164 | |
165 const RedmondRect kBase = { 10, 20, 30, 40 }; | |
166 | |
167 Array<test_structs::Rect>::Builder rects_builder(10); | |
168 for (size_t i = 0; i < rects_builder.size(); ++i) { | |
169 RedmondRect rr = kBase; | |
170 rr.left += static_cast<int32_t>(i); | |
171 rr.top += static_cast<int32_t>(i); | |
172 rects_builder[i] = test_structs::Rect(rr); | |
173 } | |
174 Array<test_structs::Rect> rects = rects_builder.Finish(); | |
175 | |
176 std::vector<RedmondRect> redmond_rects = | |
177 rects.To<std::vector<RedmondRect> >(); | |
178 | |
179 // Note: assignment broken in two lines tests default constructor with | |
180 // assignment operator. We will also test conversion constructor. | |
181 Array<test_structs::Rect> rects2; | |
182 rects2 = redmond_rects; | |
183 | |
184 EXPECT_EQ(rects.size(), rects2.size()); | |
185 for (size_t i = 0; i < rects.size(); ++i) { | |
186 EXPECT_EQ(rects[i].x(), rects2[i].x()); | |
187 EXPECT_EQ(rects[i].y(), rects2[i].y()); | |
188 EXPECT_EQ(rects[i].width(), rects2[i].width()); | |
189 EXPECT_EQ(rects[i].height(), rects2[i].height()); | |
190 } | |
191 | |
192 // Test conversion constructor. | |
193 Array<test_structs::Rect> rects3(redmond_rects); | |
194 | |
195 EXPECT_EQ(rects.size(), rects3.size()); | |
196 for (size_t i = 0; i < rects.size(); ++i) { | |
197 EXPECT_EQ(rects[i].x(), rects3[i].x()); | |
198 EXPECT_EQ(rects[i].y(), rects3[i].y()); | |
199 EXPECT_EQ(rects[i].width(), rects3[i].width()); | |
200 EXPECT_EQ(rects[i].height(), rects3[i].height()); | |
201 } | |
202 } | |
203 | |
204 TEST_F(TypeConversionTest, CustomTypeConverter_Nested) { | |
205 AllocationScope scope; | |
206 | |
207 RedmondNamedRegion redmond_region; | |
208 redmond_region.name = "foopy"; | |
209 | |
210 const RedmondRect kBase = { 10, 20, 30, 40 }; | |
211 | |
212 for (size_t i = 0; i < 10; ++i) { | |
213 RedmondRect rect = kBase; | |
214 rect.left += static_cast<int32_t>(i); | |
215 rect.top += static_cast<int32_t>(i); | |
216 redmond_region.rects.push_back(rect); | |
217 } | |
218 | |
219 // Round-trip through generated struct and TypeConverter. | |
220 | |
221 test_structs::NamedRegion copy = redmond_region; | |
222 RedmondNamedRegion redmond_region2 = copy.To<RedmondNamedRegion>(); | |
223 | |
224 EXPECT_EQ(redmond_region.name, redmond_region2.name); | |
225 EXPECT_EQ(redmond_region.rects.size(), redmond_region2.rects.size()); | |
226 for (size_t i = 0; i < redmond_region.rects.size(); ++i) { | |
227 EXPECT_EQ(redmond_region.rects[i].left, redmond_region2.rects[i].left); | |
228 EXPECT_EQ(redmond_region.rects[i].top, redmond_region2.rects[i].top); | |
229 EXPECT_EQ(redmond_region.rects[i].right, redmond_region2.rects[i].right); | |
230 EXPECT_EQ(redmond_region.rects[i].bottom, redmond_region2.rects[i].bottom); | |
231 } | |
232 } | |
233 | |
234 } // namespace | |
235 } // namespace test | |
236 } // namespace mojo | |
OLD | NEW |