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 "mojo/public/cpp/bindings/array.h" |
| 6 |
5 #include <stddef.h> | 7 #include <stddef.h> |
6 #include <stdint.h> | 8 #include <stdint.h> |
| 9 #include <utility> |
7 | 10 |
8 #include "mojo/public/cpp/bindings/array.h" | |
9 #include "mojo/public/cpp/bindings/lib/array_internal.h" | 11 #include "mojo/public/cpp/bindings/lib/array_internal.h" |
10 #include "mojo/public/cpp/bindings/lib/array_serialization.h" | 12 #include "mojo/public/cpp/bindings/lib/array_serialization.h" |
11 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h" | 13 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h" |
12 #include "mojo/public/cpp/bindings/tests/container_test_util.h" | 14 #include "mojo/public/cpp/bindings/tests/container_test_util.h" |
13 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h" | 15 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
15 | 17 |
16 namespace mojo { | 18 namespace mojo { |
17 namespace test { | 19 namespace test { |
18 namespace { | 20 namespace { |
(...skipping 22 matching lines...) Expand all Loading... |
41 bool val = i % 3 == 0; | 43 bool val = i % 3 == 0; |
42 array[i] = val; | 44 array[i] = val; |
43 EXPECT_EQ(val, array.at(i)); | 45 EXPECT_EQ(val, array.at(i)); |
44 } | 46 } |
45 } | 47 } |
46 | 48 |
47 // Tests that Array<ScopedMessagePipeHandle> supports transferring handles. | 49 // Tests that Array<ScopedMessagePipeHandle> supports transferring handles. |
48 TEST_F(ArrayTest, Handle) { | 50 TEST_F(ArrayTest, Handle) { |
49 MessagePipe pipe; | 51 MessagePipe pipe; |
50 Array<ScopedMessagePipeHandle> handles(2); | 52 Array<ScopedMessagePipeHandle> handles(2); |
51 handles[0] = pipe.handle0.Pass(); | 53 handles[0] = std::move(pipe.handle0); |
52 handles[1].reset(pipe.handle1.release()); | 54 handles[1].reset(pipe.handle1.release()); |
53 | 55 |
54 EXPECT_FALSE(pipe.handle0.is_valid()); | 56 EXPECT_FALSE(pipe.handle0.is_valid()); |
55 EXPECT_FALSE(pipe.handle1.is_valid()); | 57 EXPECT_FALSE(pipe.handle1.is_valid()); |
56 | 58 |
57 Array<ScopedMessagePipeHandle> handles2 = handles.Pass(); | 59 Array<ScopedMessagePipeHandle> handles2 = std::move(handles); |
58 EXPECT_TRUE(handles2[0].is_valid()); | 60 EXPECT_TRUE(handles2[0].is_valid()); |
59 EXPECT_TRUE(handles2[1].is_valid()); | 61 EXPECT_TRUE(handles2[1].is_valid()); |
60 | 62 |
61 ScopedMessagePipeHandle pipe_handle = handles2[0].Pass(); | 63 ScopedMessagePipeHandle pipe_handle = std::move(handles2[0]); |
62 EXPECT_TRUE(pipe_handle.is_valid()); | 64 EXPECT_TRUE(pipe_handle.is_valid()); |
63 EXPECT_FALSE(handles2[0].is_valid()); | 65 EXPECT_FALSE(handles2[0].is_valid()); |
64 } | 66 } |
65 | 67 |
66 // Tests that Array<ScopedMessagePipeHandle> supports closing handles. | 68 // Tests that Array<ScopedMessagePipeHandle> supports closing handles. |
67 TEST_F(ArrayTest, HandlesAreClosed) { | 69 TEST_F(ArrayTest, HandlesAreClosed) { |
68 MessagePipe pipe; | 70 MessagePipe pipe; |
69 MojoHandle pipe0_value = pipe.handle0.get().value(); | 71 MojoHandle pipe0_value = pipe.handle0.get().value(); |
70 MojoHandle pipe1_value = pipe.handle0.get().value(); | 72 MojoHandle pipe1_value = pipe.handle0.get().value(); |
71 | 73 |
72 { | 74 { |
73 Array<ScopedMessagePipeHandle> handles(2); | 75 Array<ScopedMessagePipeHandle> handles(2); |
74 handles[0] = pipe.handle0.Pass(); | 76 handles[0] = std::move(pipe.handle0); |
75 handles[1].reset(pipe.handle0.release()); | 77 handles[1].reset(pipe.handle0.release()); |
76 } | 78 } |
77 | 79 |
78 // We expect the pipes to have been closed. | 80 // We expect the pipes to have been closed. |
79 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe0_value)); | 81 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe0_value)); |
80 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe1_value)); | 82 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(pipe1_value)); |
81 } | 83 } |
82 | 84 |
83 TEST_F(ArrayTest, Clone) { | 85 TEST_F(ArrayTest, Clone) { |
84 { | 86 { |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
149 Array<int32_t> array(4); | 151 Array<int32_t> array(4); |
150 for (size_t i = 0; i < array.size(); ++i) | 152 for (size_t i = 0; i < array.size(); ++i) |
151 array[i] = static_cast<int32_t>(i); | 153 array[i] = static_cast<int32_t>(i); |
152 | 154 |
153 size_t size = GetSerializedSize_(array); | 155 size_t size = GetSerializedSize_(array); |
154 EXPECT_EQ(8U + 4 * 4U, size); | 156 EXPECT_EQ(8U + 4 * 4U, size); |
155 | 157 |
156 FixedBufferForTesting buf(size); | 158 FixedBufferForTesting buf(size); |
157 Array_Data<int32_t>* data; | 159 Array_Data<int32_t>* data; |
158 ArrayValidateParams validate_params(0, false, nullptr); | 160 ArrayValidateParams validate_params(0, false, nullptr); |
159 SerializeArray_(array.Pass(), &buf, &data, &validate_params); | 161 SerializeArray_(std::move(array), &buf, &data, &validate_params); |
160 | 162 |
161 Array<int32_t> array2; | 163 Array<int32_t> array2; |
162 Deserialize_(data, &array2, nullptr); | 164 Deserialize_(data, &array2, nullptr); |
163 | 165 |
164 EXPECT_EQ(4U, array2.size()); | 166 EXPECT_EQ(4U, array2.size()); |
165 for (size_t i = 0; i < array2.size(); ++i) | 167 for (size_t i = 0; i < array2.size(); ++i) |
166 EXPECT_EQ(static_cast<int32_t>(i), array2[i]); | 168 EXPECT_EQ(static_cast<int32_t>(i), array2[i]); |
167 } | 169 } |
168 | 170 |
169 TEST_F(ArrayTest, Serialization_EmptyArrayOfPOD) { | 171 TEST_F(ArrayTest, Serialization_EmptyArrayOfPOD) { |
170 Array<int32_t> array(0); | 172 Array<int32_t> array(0); |
171 size_t size = GetSerializedSize_(array); | 173 size_t size = GetSerializedSize_(array); |
172 EXPECT_EQ(8U, size); | 174 EXPECT_EQ(8U, size); |
173 | 175 |
174 FixedBufferForTesting buf(size); | 176 FixedBufferForTesting buf(size); |
175 Array_Data<int32_t>* data; | 177 Array_Data<int32_t>* data; |
176 ArrayValidateParams validate_params(0, false, nullptr); | 178 ArrayValidateParams validate_params(0, false, nullptr); |
177 SerializeArray_(array.Pass(), &buf, &data, &validate_params); | 179 SerializeArray_(std::move(array), &buf, &data, &validate_params); |
178 | 180 |
179 Array<int32_t> array2; | 181 Array<int32_t> array2; |
180 Deserialize_(data, &array2, nullptr); | 182 Deserialize_(data, &array2, nullptr); |
181 EXPECT_EQ(0U, array2.size()); | 183 EXPECT_EQ(0U, array2.size()); |
182 } | 184 } |
183 | 185 |
184 TEST_F(ArrayTest, Serialization_ArrayOfArrayOfPOD) { | 186 TEST_F(ArrayTest, Serialization_ArrayOfArrayOfPOD) { |
185 Array<Array<int32_t>> array(2); | 187 Array<Array<int32_t>> array(2); |
186 for (size_t j = 0; j < array.size(); ++j) { | 188 for (size_t j = 0; j < array.size(); ++j) { |
187 Array<int32_t> inner(4); | 189 Array<int32_t> inner(4); |
188 for (size_t i = 0; i < inner.size(); ++i) | 190 for (size_t i = 0; i < inner.size(); ++i) |
189 inner[i] = static_cast<int32_t>(i + (j * 10)); | 191 inner[i] = static_cast<int32_t>(i + (j * 10)); |
190 array[j] = inner.Pass(); | 192 array[j] = std::move(inner); |
191 } | 193 } |
192 | 194 |
193 size_t size = GetSerializedSize_(array); | 195 size_t size = GetSerializedSize_(array); |
194 EXPECT_EQ(8U + 2 * 8U + 2 * (8U + 4 * 4U), size); | 196 EXPECT_EQ(8U + 2 * 8U + 2 * (8U + 4 * 4U), size); |
195 | 197 |
196 FixedBufferForTesting buf(size); | 198 FixedBufferForTesting buf(size); |
197 Array_Data<Array_Data<int32_t>*>* data; | 199 Array_Data<Array_Data<int32_t>*>* data; |
198 ArrayValidateParams validate_params( | 200 ArrayValidateParams validate_params( |
199 0, false, new ArrayValidateParams(0, false, nullptr)); | 201 0, false, new ArrayValidateParams(0, false, nullptr)); |
200 SerializeArray_(array.Pass(), &buf, &data, &validate_params); | 202 SerializeArray_(std::move(array), &buf, &data, &validate_params); |
201 | 203 |
202 Array<Array<int32_t>> array2; | 204 Array<Array<int32_t>> array2; |
203 Deserialize_(data, &array2, nullptr); | 205 Deserialize_(data, &array2, nullptr); |
204 | 206 |
205 EXPECT_EQ(2U, array2.size()); | 207 EXPECT_EQ(2U, array2.size()); |
206 for (size_t j = 0; j < array2.size(); ++j) { | 208 for (size_t j = 0; j < array2.size(); ++j) { |
207 const Array<int32_t>& inner = array2[j]; | 209 const Array<int32_t>& inner = array2[j]; |
208 EXPECT_EQ(4U, inner.size()); | 210 EXPECT_EQ(4U, inner.size()); |
209 for (size_t i = 0; i < inner.size(); ++i) | 211 for (size_t i = 0; i < inner.size(); ++i) |
210 EXPECT_EQ(static_cast<int32_t>(i + (j * 10)), inner[i]); | 212 EXPECT_EQ(static_cast<int32_t>(i + (j * 10)), inner[i]); |
211 } | 213 } |
212 } | 214 } |
213 | 215 |
214 TEST_F(ArrayTest, Serialization_ArrayOfBool) { | 216 TEST_F(ArrayTest, Serialization_ArrayOfBool) { |
215 Array<bool> array(10); | 217 Array<bool> array(10); |
216 for (size_t i = 0; i < array.size(); ++i) | 218 for (size_t i = 0; i < array.size(); ++i) |
217 array[i] = i % 2 ? true : false; | 219 array[i] = i % 2 ? true : false; |
218 | 220 |
219 size_t size = GetSerializedSize_(array); | 221 size_t size = GetSerializedSize_(array); |
220 EXPECT_EQ(8U + 8U, size); | 222 EXPECT_EQ(8U + 8U, size); |
221 | 223 |
222 FixedBufferForTesting buf(size); | 224 FixedBufferForTesting buf(size); |
223 Array_Data<bool>* data; | 225 Array_Data<bool>* data; |
224 ArrayValidateParams validate_params(0, false, nullptr); | 226 ArrayValidateParams validate_params(0, false, nullptr); |
225 SerializeArray_(array.Pass(), &buf, &data, &validate_params); | 227 SerializeArray_(std::move(array), &buf, &data, &validate_params); |
226 | 228 |
227 Array<bool> array2; | 229 Array<bool> array2; |
228 Deserialize_(data, &array2, nullptr); | 230 Deserialize_(data, &array2, nullptr); |
229 | 231 |
230 EXPECT_EQ(10U, array2.size()); | 232 EXPECT_EQ(10U, array2.size()); |
231 for (size_t i = 0; i < array2.size(); ++i) | 233 for (size_t i = 0; i < array2.size(); ++i) |
232 EXPECT_EQ(i % 2 ? true : false, array2[i]); | 234 EXPECT_EQ(i % 2 ? true : false, array2[i]); |
233 } | 235 } |
234 | 236 |
235 TEST_F(ArrayTest, Serialization_ArrayOfString) { | 237 TEST_F(ArrayTest, Serialization_ArrayOfString) { |
236 Array<String> array(10); | 238 Array<String> array(10); |
237 for (size_t i = 0; i < array.size(); ++i) { | 239 for (size_t i = 0; i < array.size(); ++i) { |
238 char c = 'A' + static_cast<char>(i); | 240 char c = 'A' + static_cast<char>(i); |
239 array[i] = String(&c, 1); | 241 array[i] = String(&c, 1); |
240 } | 242 } |
241 | 243 |
242 size_t size = GetSerializedSize_(array); | 244 size_t size = GetSerializedSize_(array); |
243 EXPECT_EQ(8U + // array header | 245 EXPECT_EQ(8U + // array header |
244 10 * 8U + // array payload (10 pointers) | 246 10 * 8U + // array payload (10 pointers) |
245 10 * (8U + // string header | 247 10 * (8U + // string header |
246 8U), // string length of 1 padded to 8 | 248 8U), // string length of 1 padded to 8 |
247 size); | 249 size); |
248 | 250 |
249 FixedBufferForTesting buf(size); | 251 FixedBufferForTesting buf(size); |
250 Array_Data<String_Data*>* data; | 252 Array_Data<String_Data*>* data; |
251 ArrayValidateParams validate_params( | 253 ArrayValidateParams validate_params( |
252 0, false, new ArrayValidateParams(0, false, nullptr)); | 254 0, false, new ArrayValidateParams(0, false, nullptr)); |
253 SerializeArray_(array.Pass(), &buf, &data, &validate_params); | 255 SerializeArray_(std::move(array), &buf, &data, &validate_params); |
254 | 256 |
255 Array<String> array2; | 257 Array<String> array2; |
256 Deserialize_(data, &array2, nullptr); | 258 Deserialize_(data, &array2, nullptr); |
257 | 259 |
258 EXPECT_EQ(10U, array2.size()); | 260 EXPECT_EQ(10U, array2.size()); |
259 for (size_t i = 0; i < array2.size(); ++i) { | 261 for (size_t i = 0; i < array2.size(); ++i) { |
260 char c = 'A' + static_cast<char>(i); | 262 char c = 'A' + static_cast<char>(i); |
261 EXPECT_EQ(String(&c, 1), array2[i]); | 263 EXPECT_EQ(String(&c, 1), array2[i]); |
262 } | 264 } |
263 } | 265 } |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
403 | 405 |
404 TEST_F(ArrayTest, PushBack_MoveOnly) { | 406 TEST_F(ArrayTest, PushBack_MoveOnly) { |
405 ASSERT_EQ(0u, MoveOnlyType::num_instances()); | 407 ASSERT_EQ(0u, MoveOnlyType::num_instances()); |
406 mojo::Array<MoveOnlyType> array(2); | 408 mojo::Array<MoveOnlyType> array(2); |
407 array.reset(); | 409 array.reset(); |
408 std::vector<MoveOnlyType*> value_ptrs; | 410 std::vector<MoveOnlyType*> value_ptrs; |
409 size_t capacity = array.storage().capacity(); | 411 size_t capacity = array.storage().capacity(); |
410 for (size_t i = 0; i < capacity; i++) { | 412 for (size_t i = 0; i < capacity; i++) { |
411 MoveOnlyType value; | 413 MoveOnlyType value; |
412 value_ptrs.push_back(value.ptr()); | 414 value_ptrs.push_back(value.ptr()); |
413 array.push_back(value.Pass()); | 415 array.push_back(std::move(value)); |
414 ASSERT_EQ(i + 1, array.size()); | 416 ASSERT_EQ(i + 1, array.size()); |
415 ASSERT_EQ(i + 1, value_ptrs.size()); | 417 ASSERT_EQ(i + 1, value_ptrs.size()); |
416 EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances()); | 418 EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances()); |
417 EXPECT_TRUE(array[i].moved()); | 419 EXPECT_TRUE(array[i].moved()); |
418 EXPECT_EQ(value_ptrs[i], array[i].ptr()); | 420 EXPECT_EQ(value_ptrs[i], array[i].ptr()); |
419 array[i].ResetMoved(); | 421 array[i].ResetMoved(); |
420 EXPECT_TRUE(array); | 422 EXPECT_TRUE(array); |
421 } | 423 } |
422 { | 424 { |
423 MoveOnlyType value; | 425 MoveOnlyType value; |
424 value_ptrs.push_back(value.ptr()); | 426 value_ptrs.push_back(value.ptr()); |
425 array.push_back(value.Pass()); | 427 array.push_back(std::move(value)); |
426 EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances()); | 428 EXPECT_EQ(array.size() + 1, MoveOnlyType::num_instances()); |
427 } | 429 } |
428 ASSERT_EQ(capacity + 1, array.size()); | 430 ASSERT_EQ(capacity + 1, array.size()); |
429 EXPECT_EQ(array.size(), MoveOnlyType::num_instances()); | 431 EXPECT_EQ(array.size(), MoveOnlyType::num_instances()); |
430 | 432 |
431 for (size_t i = 0; i < array.size(); i++) { | 433 for (size_t i = 0; i < array.size(); i++) { |
432 EXPECT_TRUE(array[i].moved()); | 434 EXPECT_TRUE(array[i].moved()); |
433 EXPECT_EQ(value_ptrs[i], array[i].ptr()); | 435 EXPECT_EQ(value_ptrs[i], array[i].ptr()); |
434 } | 436 } |
435 array.reset(); | 437 array.reset(); |
436 EXPECT_EQ(0u, MoveOnlyType::num_instances()); | 438 EXPECT_EQ(0u, MoveOnlyType::num_instances()); |
437 } | 439 } |
438 | 440 |
439 } // namespace | 441 } // namespace |
440 } // namespace test | 442 } // namespace test |
441 } // namespace mojo | 443 } // namespace mojo |
OLD | NEW |