OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 #include <string.h> | 7 #include <string.h> |
| 8 #include <utility> |
8 | 9 |
9 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h" | 10 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h" |
10 #include "mojo/public/cpp/system/message_pipe.h" | 11 #include "mojo/public/cpp/system/message_pipe.h" |
11 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h" | 12 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
13 | 14 |
14 namespace mojo { | 15 namespace mojo { |
15 namespace test { | 16 namespace test { |
16 namespace { | 17 namespace { |
17 | 18 |
18 RectPtr MakeRect(int32_t factor = 1) { | 19 RectPtr MakeRect(int32_t factor = 1) { |
19 RectPtr rect(Rect::New()); | 20 RectPtr rect(Rect::New()); |
20 rect->x = 1 * factor; | 21 rect->x = 1 * factor; |
21 rect->y = 2 * factor; | 22 rect->y = 2 * factor; |
22 rect->width = 10 * factor; | 23 rect->width = 10 * factor; |
23 rect->height = 20 * factor; | 24 rect->height = 20 * factor; |
24 return rect.Pass(); | 25 return rect; |
25 } | 26 } |
26 | 27 |
27 void CheckRect(const Rect& rect, int32_t factor = 1) { | 28 void CheckRect(const Rect& rect, int32_t factor = 1) { |
28 EXPECT_EQ(1 * factor, rect.x); | 29 EXPECT_EQ(1 * factor, rect.x); |
29 EXPECT_EQ(2 * factor, rect.y); | 30 EXPECT_EQ(2 * factor, rect.y); |
30 EXPECT_EQ(10 * factor, rect.width); | 31 EXPECT_EQ(10 * factor, rect.width); |
31 EXPECT_EQ(20 * factor, rect.height); | 32 EXPECT_EQ(20 * factor, rect.height); |
32 } | 33 } |
33 | 34 |
34 MultiVersionStructPtr MakeMultiVersionStruct() { | 35 MultiVersionStructPtr MakeMultiVersionStruct() { |
35 MultiVersionStructPtr output(MultiVersionStruct::New()); | 36 MultiVersionStructPtr output(MultiVersionStruct::New()); |
36 output->f_int32 = 123; | 37 output->f_int32 = 123; |
37 output->f_rect = MakeRect(5); | 38 output->f_rect = MakeRect(5); |
38 output->f_string = "hello"; | 39 output->f_string = "hello"; |
39 output->f_array = Array<int8_t>(3); | 40 output->f_array = Array<int8_t>(3); |
40 output->f_array[0] = 10; | 41 output->f_array[0] = 10; |
41 output->f_array[1] = 9; | 42 output->f_array[1] = 9; |
42 output->f_array[2] = 8; | 43 output->f_array[2] = 8; |
43 MessagePipe pipe; | 44 MessagePipe pipe; |
44 output->f_message_pipe = pipe.handle0.Pass(); | 45 output->f_message_pipe = std::move(pipe.handle0); |
45 output->f_int16 = 42; | 46 output->f_int16 = 42; |
46 | 47 |
47 return output.Pass(); | 48 return output; |
48 } | 49 } |
49 | 50 |
50 template <typename U, typename T> | 51 template <typename U, typename T> |
51 U SerializeAndDeserialize(T input) { | 52 U SerializeAndDeserialize(T input) { |
52 typedef typename mojo::internal::WrapperTraits<T>::DataType InputDataType; | 53 typedef typename mojo::internal::WrapperTraits<T>::DataType InputDataType; |
53 typedef typename mojo::internal::WrapperTraits<U>::DataType OutputDataType; | 54 typedef typename mojo::internal::WrapperTraits<U>::DataType OutputDataType; |
54 | 55 |
55 size_t size = GetSerializedSize_(input); | 56 size_t size = GetSerializedSize_(input); |
56 mojo::internal::FixedBufferForTesting buf(size + 32); | 57 mojo::internal::FixedBufferForTesting buf(size + 32); |
57 InputDataType data; | 58 InputDataType data; |
58 Serialize_(input.Pass(), &buf, &data); | 59 Serialize_(std::move(input), &buf, &data); |
59 | 60 |
60 std::vector<Handle> handles; | 61 std::vector<Handle> handles; |
61 data->EncodePointersAndHandles(&handles); | 62 data->EncodePointersAndHandles(&handles); |
62 | 63 |
63 // Set the subsequent area to a special value, so that we can find out if we | 64 // Set the subsequent area to a special value, so that we can find out if we |
64 // mistakenly access the area. | 65 // mistakenly access the area. |
65 void* subsequent_area = buf.Allocate(32); | 66 void* subsequent_area = buf.Allocate(32); |
66 memset(subsequent_area, 0xAA, 32); | 67 memset(subsequent_area, 0xAA, 32); |
67 | 68 |
68 OutputDataType output_data = reinterpret_cast<OutputDataType>(data); | 69 OutputDataType output_data = reinterpret_cast<OutputDataType>(data); |
69 output_data->DecodePointersAndHandles(&handles); | 70 output_data->DecodePointersAndHandles(&handles); |
70 | 71 |
71 U output; | 72 U output; |
72 Deserialize_(output_data, &output, nullptr); | 73 Deserialize_(output_data, &output, nullptr); |
73 return output.Pass(); | 74 return std::move(output); |
74 } | 75 } |
75 | 76 |
76 using StructTest = testing::Test; | 77 using StructTest = testing::Test; |
77 | 78 |
78 } // namespace | 79 } // namespace |
79 | 80 |
80 TEST_F(StructTest, Rect) { | 81 TEST_F(StructTest, Rect) { |
81 RectPtr rect; | 82 RectPtr rect; |
82 EXPECT_TRUE(rect.is_null()); | 83 EXPECT_TRUE(rect.is_null()); |
83 EXPECT_TRUE(!rect); | 84 EXPECT_TRUE(!rect); |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
131 | 132 |
132 // Serialization test of a struct with no pointer or handle members. | 133 // Serialization test of a struct with no pointer or handle members. |
133 TEST_F(StructTest, Serialization_Basic) { | 134 TEST_F(StructTest, Serialization_Basic) { |
134 RectPtr rect(MakeRect()); | 135 RectPtr rect(MakeRect()); |
135 | 136 |
136 size_t size = GetSerializedSize_(rect); | 137 size_t size = GetSerializedSize_(rect); |
137 EXPECT_EQ(8U + 16U, size); | 138 EXPECT_EQ(8U + 16U, size); |
138 | 139 |
139 mojo::internal::FixedBufferForTesting buf(size); | 140 mojo::internal::FixedBufferForTesting buf(size); |
140 internal::Rect_Data* data; | 141 internal::Rect_Data* data; |
141 Serialize_(rect.Pass(), &buf, &data); | 142 Serialize_(std::move(rect), &buf, &data); |
142 | 143 |
143 RectPtr rect2; | 144 RectPtr rect2; |
144 Deserialize_(data, &rect2, nullptr); | 145 Deserialize_(data, &rect2, nullptr); |
145 | 146 |
146 CheckRect(*rect2); | 147 CheckRect(*rect2); |
147 } | 148 } |
148 | 149 |
149 // Construction of a struct with struct pointers from null. | 150 // Construction of a struct with struct pointers from null. |
150 TEST_F(StructTest, Construction_StructPointers) { | 151 TEST_F(StructTest, Construction_StructPointers) { |
151 RectPairPtr pair; | 152 RectPairPtr pair; |
(...skipping 12 matching lines...) Expand all Loading... |
164 TEST_F(StructTest, Serialization_StructPointers) { | 165 TEST_F(StructTest, Serialization_StructPointers) { |
165 RectPairPtr pair(RectPair::New()); | 166 RectPairPtr pair(RectPair::New()); |
166 pair->first = MakeRect(); | 167 pair->first = MakeRect(); |
167 pair->second = MakeRect(); | 168 pair->second = MakeRect(); |
168 | 169 |
169 size_t size = GetSerializedSize_(pair); | 170 size_t size = GetSerializedSize_(pair); |
170 EXPECT_EQ(8U + 16U + 2 * (8U + 16U), size); | 171 EXPECT_EQ(8U + 16U + 2 * (8U + 16U), size); |
171 | 172 |
172 mojo::internal::FixedBufferForTesting buf(size); | 173 mojo::internal::FixedBufferForTesting buf(size); |
173 internal::RectPair_Data* data; | 174 internal::RectPair_Data* data; |
174 Serialize_(pair.Pass(), &buf, &data); | 175 Serialize_(std::move(pair), &buf, &data); |
175 | 176 |
176 RectPairPtr pair2; | 177 RectPairPtr pair2; |
177 Deserialize_(data, &pair2, nullptr); | 178 Deserialize_(data, &pair2, nullptr); |
178 | 179 |
179 CheckRect(*pair2->first); | 180 CheckRect(*pair2->first); |
180 CheckRect(*pair2->second); | 181 CheckRect(*pair2->second); |
181 } | 182 } |
182 | 183 |
183 // Serialization test of a struct with an array member. | 184 // Serialization test of a struct with an array member. |
184 TEST_F(StructTest, Serialization_ArrayPointers) { | 185 TEST_F(StructTest, Serialization_ArrayPointers) { |
(...skipping 10 matching lines...) Expand all Loading... |
195 8U + // name header | 196 8U + // name header |
196 8U + // name payload (rounded up) | 197 8U + // name payload (rounded up) |
197 8U + // rects header | 198 8U + // rects header |
198 4 * 8U + // rects payload (four pointers) | 199 4 * 8U + // rects payload (four pointers) |
199 4 * (8U + // rect header | 200 4 * (8U + // rect header |
200 16U), // rect payload (four ints) | 201 16U), // rect payload (four ints) |
201 size); | 202 size); |
202 | 203 |
203 mojo::internal::FixedBufferForTesting buf(size); | 204 mojo::internal::FixedBufferForTesting buf(size); |
204 internal::NamedRegion_Data* data; | 205 internal::NamedRegion_Data* data; |
205 Serialize_(region.Pass(), &buf, &data); | 206 Serialize_(std::move(region), &buf, &data); |
206 | 207 |
207 NamedRegionPtr region2; | 208 NamedRegionPtr region2; |
208 Deserialize_(data, ®ion2, nullptr); | 209 Deserialize_(data, ®ion2, nullptr); |
209 | 210 |
210 EXPECT_EQ(String("region"), region2->name); | 211 EXPECT_EQ(String("region"), region2->name); |
211 | 212 |
212 EXPECT_EQ(4U, region2->rects.size()); | 213 EXPECT_EQ(4U, region2->rects.size()); |
213 for (size_t i = 0; i < region2->rects.size(); ++i) | 214 for (size_t i = 0; i < region2->rects.size(); ++i) |
214 CheckRect(*region2->rects[i], static_cast<int32_t>(i) + 1); | 215 CheckRect(*region2->rects[i], static_cast<int32_t>(i) + 1); |
215 } | 216 } |
216 | 217 |
217 // Serialization test of a struct with null array pointers. | 218 // Serialization test of a struct with null array pointers. |
218 TEST_F(StructTest, Serialization_NullArrayPointers) { | 219 TEST_F(StructTest, Serialization_NullArrayPointers) { |
219 NamedRegionPtr region(NamedRegion::New()); | 220 NamedRegionPtr region(NamedRegion::New()); |
220 EXPECT_TRUE(region->name.is_null()); | 221 EXPECT_TRUE(region->name.is_null()); |
221 EXPECT_TRUE(region->rects.is_null()); | 222 EXPECT_TRUE(region->rects.is_null()); |
222 | 223 |
223 size_t size = GetSerializedSize_(region); | 224 size_t size = GetSerializedSize_(region); |
224 EXPECT_EQ(8U + // header | 225 EXPECT_EQ(8U + // header |
225 8U + // name pointer | 226 8U + // name pointer |
226 8U, // rects pointer | 227 8U, // rects pointer |
227 size); | 228 size); |
228 | 229 |
229 mojo::internal::FixedBufferForTesting buf(size); | 230 mojo::internal::FixedBufferForTesting buf(size); |
230 internal::NamedRegion_Data* data; | 231 internal::NamedRegion_Data* data; |
231 Serialize_(region.Pass(), &buf, &data); | 232 Serialize_(std::move(region), &buf, &data); |
232 | 233 |
233 NamedRegionPtr region2; | 234 NamedRegionPtr region2; |
234 Deserialize_(data, ®ion2, nullptr); | 235 Deserialize_(data, ®ion2, nullptr); |
235 | 236 |
236 EXPECT_TRUE(region2->name.is_null()); | 237 EXPECT_TRUE(region2->name.is_null()); |
237 EXPECT_TRUE(region2->rects.is_null()); | 238 EXPECT_TRUE(region2->rects.is_null()); |
238 } | 239 } |
239 | 240 |
240 // Tests deserializing structs as a newer version. | 241 // Tests deserializing structs as a newer version. |
241 TEST_F(StructTest, Versioning_OldToNew) { | 242 TEST_F(StructTest, Versioning_OldToNew) { |
242 { | 243 { |
243 MultiVersionStructV0Ptr input(MultiVersionStructV0::New()); | 244 MultiVersionStructV0Ptr input(MultiVersionStructV0::New()); |
244 input->f_int32 = 123; | 245 input->f_int32 = 123; |
245 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); | 246 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); |
246 expected_output->f_int32 = 123; | 247 expected_output->f_int32 = 123; |
247 | 248 |
248 MultiVersionStructPtr output = | 249 MultiVersionStructPtr output = |
249 SerializeAndDeserialize<MultiVersionStructPtr>(input.Pass()); | 250 SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input)); |
250 EXPECT_TRUE(output); | 251 EXPECT_TRUE(output); |
251 EXPECT_TRUE(output->Equals(*expected_output)); | 252 EXPECT_TRUE(output->Equals(*expected_output)); |
252 } | 253 } |
253 | 254 |
254 { | 255 { |
255 MultiVersionStructV1Ptr input(MultiVersionStructV1::New()); | 256 MultiVersionStructV1Ptr input(MultiVersionStructV1::New()); |
256 input->f_int32 = 123; | 257 input->f_int32 = 123; |
257 input->f_rect = MakeRect(5); | 258 input->f_rect = MakeRect(5); |
258 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); | 259 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); |
259 expected_output->f_int32 = 123; | 260 expected_output->f_int32 = 123; |
260 expected_output->f_rect = MakeRect(5); | 261 expected_output->f_rect = MakeRect(5); |
261 | 262 |
262 MultiVersionStructPtr output = | 263 MultiVersionStructPtr output = |
263 SerializeAndDeserialize<MultiVersionStructPtr>(input.Pass()); | 264 SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input)); |
264 EXPECT_TRUE(output); | 265 EXPECT_TRUE(output); |
265 EXPECT_TRUE(output->Equals(*expected_output)); | 266 EXPECT_TRUE(output->Equals(*expected_output)); |
266 } | 267 } |
267 | 268 |
268 { | 269 { |
269 MultiVersionStructV3Ptr input(MultiVersionStructV3::New()); | 270 MultiVersionStructV3Ptr input(MultiVersionStructV3::New()); |
270 input->f_int32 = 123; | 271 input->f_int32 = 123; |
271 input->f_rect = MakeRect(5); | 272 input->f_rect = MakeRect(5); |
272 input->f_string = "hello"; | 273 input->f_string = "hello"; |
273 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); | 274 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); |
274 expected_output->f_int32 = 123; | 275 expected_output->f_int32 = 123; |
275 expected_output->f_rect = MakeRect(5); | 276 expected_output->f_rect = MakeRect(5); |
276 expected_output->f_string = "hello"; | 277 expected_output->f_string = "hello"; |
277 | 278 |
278 MultiVersionStructPtr output = | 279 MultiVersionStructPtr output = |
279 SerializeAndDeserialize<MultiVersionStructPtr>(input.Pass()); | 280 SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input)); |
280 EXPECT_TRUE(output); | 281 EXPECT_TRUE(output); |
281 EXPECT_TRUE(output->Equals(*expected_output)); | 282 EXPECT_TRUE(output->Equals(*expected_output)); |
282 } | 283 } |
283 | 284 |
284 { | 285 { |
285 MultiVersionStructV5Ptr input(MultiVersionStructV5::New()); | 286 MultiVersionStructV5Ptr input(MultiVersionStructV5::New()); |
286 input->f_int32 = 123; | 287 input->f_int32 = 123; |
287 input->f_rect = MakeRect(5); | 288 input->f_rect = MakeRect(5); |
288 input->f_string = "hello"; | 289 input->f_string = "hello"; |
289 input->f_array = Array<int8_t>(3); | 290 input->f_array = Array<int8_t>(3); |
290 input->f_array[0] = 10; | 291 input->f_array[0] = 10; |
291 input->f_array[1] = 9; | 292 input->f_array[1] = 9; |
292 input->f_array[2] = 8; | 293 input->f_array[2] = 8; |
293 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); | 294 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); |
294 expected_output->f_int32 = 123; | 295 expected_output->f_int32 = 123; |
295 expected_output->f_rect = MakeRect(5); | 296 expected_output->f_rect = MakeRect(5); |
296 expected_output->f_string = "hello"; | 297 expected_output->f_string = "hello"; |
297 expected_output->f_array = Array<int8_t>(3); | 298 expected_output->f_array = Array<int8_t>(3); |
298 expected_output->f_array[0] = 10; | 299 expected_output->f_array[0] = 10; |
299 expected_output->f_array[1] = 9; | 300 expected_output->f_array[1] = 9; |
300 expected_output->f_array[2] = 8; | 301 expected_output->f_array[2] = 8; |
301 | 302 |
302 MultiVersionStructPtr output = | 303 MultiVersionStructPtr output = |
303 SerializeAndDeserialize<MultiVersionStructPtr>(input.Pass()); | 304 SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input)); |
304 EXPECT_TRUE(output); | 305 EXPECT_TRUE(output); |
305 EXPECT_TRUE(output->Equals(*expected_output)); | 306 EXPECT_TRUE(output->Equals(*expected_output)); |
306 } | 307 } |
307 | 308 |
308 { | 309 { |
309 MultiVersionStructV7Ptr input(MultiVersionStructV7::New()); | 310 MultiVersionStructV7Ptr input(MultiVersionStructV7::New()); |
310 input->f_int32 = 123; | 311 input->f_int32 = 123; |
311 input->f_rect = MakeRect(5); | 312 input->f_rect = MakeRect(5); |
312 input->f_string = "hello"; | 313 input->f_string = "hello"; |
313 input->f_array = Array<int8_t>(3); | 314 input->f_array = Array<int8_t>(3); |
314 input->f_array[0] = 10; | 315 input->f_array[0] = 10; |
315 input->f_array[1] = 9; | 316 input->f_array[1] = 9; |
316 input->f_array[2] = 8; | 317 input->f_array[2] = 8; |
317 MessagePipe pipe; | 318 MessagePipe pipe; |
318 input->f_message_pipe = pipe.handle0.Pass(); | 319 input->f_message_pipe = std::move(pipe.handle0); |
319 | 320 |
320 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); | 321 MultiVersionStructPtr expected_output(MultiVersionStruct::New()); |
321 expected_output->f_int32 = 123; | 322 expected_output->f_int32 = 123; |
322 expected_output->f_rect = MakeRect(5); | 323 expected_output->f_rect = MakeRect(5); |
323 expected_output->f_string = "hello"; | 324 expected_output->f_string = "hello"; |
324 expected_output->f_array = Array<int8_t>(3); | 325 expected_output->f_array = Array<int8_t>(3); |
325 expected_output->f_array[0] = 10; | 326 expected_output->f_array[0] = 10; |
326 expected_output->f_array[1] = 9; | 327 expected_output->f_array[1] = 9; |
327 expected_output->f_array[2] = 8; | 328 expected_output->f_array[2] = 8; |
328 // Save the raw handle value separately so that we can compare later. | 329 // Save the raw handle value separately so that we can compare later. |
329 MojoHandle expected_handle = input->f_message_pipe.get().value(); | 330 MojoHandle expected_handle = input->f_message_pipe.get().value(); |
330 | 331 |
331 MultiVersionStructPtr output = | 332 MultiVersionStructPtr output = |
332 SerializeAndDeserialize<MultiVersionStructPtr>(input.Pass()); | 333 SerializeAndDeserialize<MultiVersionStructPtr>(std::move(input)); |
333 EXPECT_TRUE(output); | 334 EXPECT_TRUE(output); |
334 EXPECT_EQ(expected_handle, output->f_message_pipe.get().value()); | 335 EXPECT_EQ(expected_handle, output->f_message_pipe.get().value()); |
335 output->f_message_pipe.reset(); | 336 output->f_message_pipe.reset(); |
336 EXPECT_TRUE(output->Equals(*expected_output)); | 337 EXPECT_TRUE(output->Equals(*expected_output)); |
337 } | 338 } |
338 } | 339 } |
339 | 340 |
340 // Tests deserializing structs as an older version. | 341 // Tests deserializing structs as an older version. |
341 TEST_F(StructTest, Versioning_NewToOld) { | 342 TEST_F(StructTest, Versioning_NewToOld) { |
342 { | 343 { |
343 MultiVersionStructPtr input = MakeMultiVersionStruct(); | 344 MultiVersionStructPtr input = MakeMultiVersionStruct(); |
344 MultiVersionStructV7Ptr expected_output(MultiVersionStructV7::New()); | 345 MultiVersionStructV7Ptr expected_output(MultiVersionStructV7::New()); |
345 expected_output->f_int32 = 123; | 346 expected_output->f_int32 = 123; |
346 expected_output->f_rect = MakeRect(5); | 347 expected_output->f_rect = MakeRect(5); |
347 expected_output->f_string = "hello"; | 348 expected_output->f_string = "hello"; |
348 expected_output->f_array = Array<int8_t>(3); | 349 expected_output->f_array = Array<int8_t>(3); |
349 expected_output->f_array[0] = 10; | 350 expected_output->f_array[0] = 10; |
350 expected_output->f_array[1] = 9; | 351 expected_output->f_array[1] = 9; |
351 expected_output->f_array[2] = 8; | 352 expected_output->f_array[2] = 8; |
352 // Save the raw handle value separately so that we can compare later. | 353 // Save the raw handle value separately so that we can compare later. |
353 MojoHandle expected_handle = input->f_message_pipe.get().value(); | 354 MojoHandle expected_handle = input->f_message_pipe.get().value(); |
354 | 355 |
355 MultiVersionStructV7Ptr output = | 356 MultiVersionStructV7Ptr output = |
356 SerializeAndDeserialize<MultiVersionStructV7Ptr>(input.Pass()); | 357 SerializeAndDeserialize<MultiVersionStructV7Ptr>(std::move(input)); |
357 EXPECT_TRUE(output); | 358 EXPECT_TRUE(output); |
358 EXPECT_EQ(expected_handle, output->f_message_pipe.get().value()); | 359 EXPECT_EQ(expected_handle, output->f_message_pipe.get().value()); |
359 output->f_message_pipe.reset(); | 360 output->f_message_pipe.reset(); |
360 EXPECT_TRUE(output->Equals(*expected_output)); | 361 EXPECT_TRUE(output->Equals(*expected_output)); |
361 } | 362 } |
362 | 363 |
363 { | 364 { |
364 MultiVersionStructPtr input = MakeMultiVersionStruct(); | 365 MultiVersionStructPtr input = MakeMultiVersionStruct(); |
365 MultiVersionStructV5Ptr expected_output(MultiVersionStructV5::New()); | 366 MultiVersionStructV5Ptr expected_output(MultiVersionStructV5::New()); |
366 expected_output->f_int32 = 123; | 367 expected_output->f_int32 = 123; |
367 expected_output->f_rect = MakeRect(5); | 368 expected_output->f_rect = MakeRect(5); |
368 expected_output->f_string = "hello"; | 369 expected_output->f_string = "hello"; |
369 expected_output->f_array = Array<int8_t>(3); | 370 expected_output->f_array = Array<int8_t>(3); |
370 expected_output->f_array[0] = 10; | 371 expected_output->f_array[0] = 10; |
371 expected_output->f_array[1] = 9; | 372 expected_output->f_array[1] = 9; |
372 expected_output->f_array[2] = 8; | 373 expected_output->f_array[2] = 8; |
373 | 374 |
374 MultiVersionStructV5Ptr output = | 375 MultiVersionStructV5Ptr output = |
375 SerializeAndDeserialize<MultiVersionStructV5Ptr>(input.Pass()); | 376 SerializeAndDeserialize<MultiVersionStructV5Ptr>(std::move(input)); |
376 EXPECT_TRUE(output); | 377 EXPECT_TRUE(output); |
377 EXPECT_TRUE(output->Equals(*expected_output)); | 378 EXPECT_TRUE(output->Equals(*expected_output)); |
378 } | 379 } |
379 | 380 |
380 { | 381 { |
381 MultiVersionStructPtr input = MakeMultiVersionStruct(); | 382 MultiVersionStructPtr input = MakeMultiVersionStruct(); |
382 MultiVersionStructV3Ptr expected_output(MultiVersionStructV3::New()); | 383 MultiVersionStructV3Ptr expected_output(MultiVersionStructV3::New()); |
383 expected_output->f_int32 = 123; | 384 expected_output->f_int32 = 123; |
384 expected_output->f_rect = MakeRect(5); | 385 expected_output->f_rect = MakeRect(5); |
385 expected_output->f_string = "hello"; | 386 expected_output->f_string = "hello"; |
386 | 387 |
387 MultiVersionStructV3Ptr output = | 388 MultiVersionStructV3Ptr output = |
388 SerializeAndDeserialize<MultiVersionStructV3Ptr>(input.Pass()); | 389 SerializeAndDeserialize<MultiVersionStructV3Ptr>(std::move(input)); |
389 EXPECT_TRUE(output); | 390 EXPECT_TRUE(output); |
390 EXPECT_TRUE(output->Equals(*expected_output)); | 391 EXPECT_TRUE(output->Equals(*expected_output)); |
391 } | 392 } |
392 | 393 |
393 { | 394 { |
394 MultiVersionStructPtr input = MakeMultiVersionStruct(); | 395 MultiVersionStructPtr input = MakeMultiVersionStruct(); |
395 MultiVersionStructV1Ptr expected_output(MultiVersionStructV1::New()); | 396 MultiVersionStructV1Ptr expected_output(MultiVersionStructV1::New()); |
396 expected_output->f_int32 = 123; | 397 expected_output->f_int32 = 123; |
397 expected_output->f_rect = MakeRect(5); | 398 expected_output->f_rect = MakeRect(5); |
398 | 399 |
399 MultiVersionStructV1Ptr output = | 400 MultiVersionStructV1Ptr output = |
400 SerializeAndDeserialize<MultiVersionStructV1Ptr>(input.Pass()); | 401 SerializeAndDeserialize<MultiVersionStructV1Ptr>(std::move(input)); |
401 EXPECT_TRUE(output); | 402 EXPECT_TRUE(output); |
402 EXPECT_TRUE(output->Equals(*expected_output)); | 403 EXPECT_TRUE(output->Equals(*expected_output)); |
403 } | 404 } |
404 | 405 |
405 { | 406 { |
406 MultiVersionStructPtr input = MakeMultiVersionStruct(); | 407 MultiVersionStructPtr input = MakeMultiVersionStruct(); |
407 MultiVersionStructV0Ptr expected_output(MultiVersionStructV0::New()); | 408 MultiVersionStructV0Ptr expected_output(MultiVersionStructV0::New()); |
408 expected_output->f_int32 = 123; | 409 expected_output->f_int32 = 123; |
409 | 410 |
410 MultiVersionStructV0Ptr output = | 411 MultiVersionStructV0Ptr output = |
411 SerializeAndDeserialize<MultiVersionStructV0Ptr>(input.Pass()); | 412 SerializeAndDeserialize<MultiVersionStructV0Ptr>(std::move(input)); |
412 EXPECT_TRUE(output); | 413 EXPECT_TRUE(output); |
413 EXPECT_TRUE(output->Equals(*expected_output)); | 414 EXPECT_TRUE(output->Equals(*expected_output)); |
414 } | 415 } |
415 } | 416 } |
416 } // namespace test | 417 } // namespace test |
417 } // namespace mojo | 418 } // namespace mojo |
OLD | NEW |