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 // This file tests the C++ Mojo system core wrappers. | 5 // This file tests the C++ Mojo system core wrappers. |
6 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets | 6 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets |
7 // compiled into a different binary from the C API tests. | 7 // compiled into a different binary from the C API tests. |
8 | 8 |
9 #include "mojo/public/cpp/system/core.h" | 9 #include "mojo/public/cpp/system/core.h" |
10 | 10 |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
117 EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid()); | 117 EXPECT_FALSE(MakeScopedHandle(DataPipeConsumerHandle()).is_valid()); |
118 EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid()); | 118 EXPECT_FALSE(MakeScopedHandle(SharedBufferHandle()).is_valid()); |
119 } | 119 } |
120 | 120 |
121 // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions: | 121 // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions: |
122 { | 122 { |
123 MessagePipeHandle h_invalid; | 123 MessagePipeHandle h_invalid; |
124 EXPECT_FALSE(h_invalid.is_valid()); | 124 EXPECT_FALSE(h_invalid.is_valid()); |
125 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 125 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
126 WriteMessageRaw(h_invalid, | 126 WriteMessageRaw(h_invalid, |
127 NULL, 0, | 127 nullptr, 0, |
128 NULL, 0, | 128 nullptr, 0, |
129 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 129 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
130 char buffer[10] = { 0 }; | 130 char buffer[10] = { 0 }; |
131 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 131 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
132 WriteMessageRaw(h_invalid, | 132 WriteMessageRaw(h_invalid, |
133 buffer, sizeof(buffer), | 133 buffer, sizeof(buffer), |
134 NULL, 0, | 134 nullptr, 0, |
135 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 135 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
136 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 136 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
137 ReadMessageRaw(h_invalid, | 137 ReadMessageRaw(h_invalid, |
138 NULL, NULL, | 138 nullptr, nullptr, |
139 NULL, NULL, | 139 nullptr, nullptr, |
140 MOJO_READ_MESSAGE_FLAG_NONE)); | 140 MOJO_READ_MESSAGE_FLAG_NONE)); |
141 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 141 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
142 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 142 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
143 ReadMessageRaw(h_invalid, | 143 ReadMessageRaw(h_invalid, |
144 buffer, &buffer_size, | 144 buffer, &buffer_size, |
145 NULL, NULL, | 145 nullptr, nullptr, |
146 MOJO_READ_MESSAGE_FLAG_NONE)); | 146 MOJO_READ_MESSAGE_FLAG_NONE)); |
147 | 147 |
148 // Basic tests of waiting and closing. | 148 // Basic tests of waiting and closing. |
149 MojoHandle hv0 = kInvalidHandleValue; | 149 MojoHandle hv0 = kInvalidHandleValue; |
150 { | 150 { |
151 ScopedMessagePipeHandle h0; | 151 ScopedMessagePipeHandle h0; |
152 ScopedMessagePipeHandle h1; | 152 ScopedMessagePipeHandle h1; |
153 EXPECT_FALSE(h0.get().is_valid()); | 153 EXPECT_FALSE(h0.get().is_valid()); |
154 EXPECT_FALSE(h1.get().is_valid()); | 154 EXPECT_FALSE(h1.get().is_valid()); |
155 | 155 |
156 CreateMessagePipe(NULL, &h0, &h1); | 156 CreateMessagePipe(nullptr, &h0, &h1); |
157 EXPECT_TRUE(h0.get().is_valid()); | 157 EXPECT_TRUE(h0.get().is_valid()); |
158 EXPECT_TRUE(h1.get().is_valid()); | 158 EXPECT_TRUE(h1.get().is_valid()); |
159 EXPECT_NE(h0.get().value(), h1.get().value()); | 159 EXPECT_NE(h0.get().value(), h1.get().value()); |
160 // Save the handle values, so we can check that things got closed | 160 // Save the handle values, so we can check that things got closed |
161 // correctly. | 161 // correctly. |
162 hv0 = h0.get().value(); | 162 hv0 = h0.get().value(); |
163 MojoHandle hv1 = h1.get().value(); | 163 MojoHandle hv1 = h1.get().value(); |
164 | 164 |
165 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | 165 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
166 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, 0)); | 166 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE, 0)); |
(...skipping 19 matching lines...) Expand all Loading... |
186 MOJO_DEADLINE_INDEFINITE)); | 186 MOJO_DEADLINE_INDEFINITE)); |
187 } | 187 } |
188 // |hv0| should have been closed when |h0| went out of scope, so this close | 188 // |hv0| should have been closed when |h0| went out of scope, so this close |
189 // should fail. | 189 // should fail. |
190 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0)); | 190 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv0)); |
191 | 191 |
192 // Actually test writing/reading messages. | 192 // Actually test writing/reading messages. |
193 { | 193 { |
194 ScopedMessagePipeHandle h0; | 194 ScopedMessagePipeHandle h0; |
195 ScopedMessagePipeHandle h1; | 195 ScopedMessagePipeHandle h1; |
196 CreateMessagePipe(NULL, &h0, &h1); | 196 CreateMessagePipe(nullptr, &h0, &h1); |
197 | 197 |
198 const char kHello[] = "hello"; | 198 const char kHello[] = "hello"; |
199 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | 199 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); |
200 EXPECT_EQ(MOJO_RESULT_OK, | 200 EXPECT_EQ(MOJO_RESULT_OK, |
201 WriteMessageRaw(h0.get(), | 201 WriteMessageRaw(h0.get(), |
202 kHello, kHelloSize, | 202 kHello, kHelloSize, |
203 NULL, 0, | 203 nullptr, 0, |
204 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 204 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
205 EXPECT_EQ(MOJO_RESULT_OK, | 205 EXPECT_EQ(MOJO_RESULT_OK, |
206 Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE, | 206 Wait(h1.get(), MOJO_HANDLE_SIGNAL_READABLE, |
207 MOJO_DEADLINE_INDEFINITE)); | 207 MOJO_DEADLINE_INDEFINITE)); |
208 char buffer[10] = { 0 }; | 208 char buffer[10] = { 0 }; |
209 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); | 209 uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); |
210 EXPECT_EQ(MOJO_RESULT_OK, | 210 EXPECT_EQ(MOJO_RESULT_OK, |
211 ReadMessageRaw(h1.get(), | 211 ReadMessageRaw(h1.get(), |
212 buffer, &buffer_size, | 212 buffer, &buffer_size, |
213 NULL, NULL, | 213 nullptr, nullptr, |
214 MOJO_READ_MESSAGE_FLAG_NONE)); | 214 MOJO_READ_MESSAGE_FLAG_NONE)); |
215 EXPECT_EQ(kHelloSize, buffer_size); | 215 EXPECT_EQ(kHelloSize, buffer_size); |
216 EXPECT_STREQ(kHello, buffer); | 216 EXPECT_STREQ(kHello, buffer); |
217 | 217 |
218 // Send a handle over the previously-establish message pipe. Use the | 218 // Send a handle over the previously-establish message pipe. Use the |
219 // |MessagePipe| wrapper (to test it), which automatically creates a | 219 // |MessagePipe| wrapper (to test it), which automatically creates a |
220 // message pipe. | 220 // message pipe. |
221 MessagePipe mp; | 221 MessagePipe mp; |
222 | 222 |
223 // Write a message to |mp.handle0|, before we send |mp.handle1|. | 223 // Write a message to |mp.handle0|, before we send |mp.handle1|. |
224 const char kWorld[] = "world!"; | 224 const char kWorld[] = "world!"; |
225 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | 225 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); |
226 EXPECT_EQ(MOJO_RESULT_OK, | 226 EXPECT_EQ(MOJO_RESULT_OK, |
227 WriteMessageRaw(mp.handle0.get(), | 227 WriteMessageRaw(mp.handle0.get(), |
228 kWorld, kWorldSize, | 228 kWorld, kWorldSize, |
229 NULL, 0, | 229 nullptr, 0, |
230 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 230 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
231 | 231 |
232 // Send |mp.handle1| over |h1| to |h0|. | 232 // Send |mp.handle1| over |h1| to |h0|. |
233 MojoHandle handles[5]; | 233 MojoHandle handles[5]; |
234 handles[0] = mp.handle1.release().value(); | 234 handles[0] = mp.handle1.release().value(); |
235 EXPECT_NE(kInvalidHandleValue, handles[0]); | 235 EXPECT_NE(kInvalidHandleValue, handles[0]); |
236 EXPECT_FALSE(mp.handle1.get().is_valid()); | 236 EXPECT_FALSE(mp.handle1.get().is_valid()); |
237 uint32_t handles_count = 1; | 237 uint32_t handles_count = 1; |
238 EXPECT_EQ(MOJO_RESULT_OK, | 238 EXPECT_EQ(MOJO_RESULT_OK, |
239 WriteMessageRaw(h1.get(), | 239 WriteMessageRaw(h1.get(), |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
289 // TODO(vtl): Test |CloseRaw()|. | 289 // TODO(vtl): Test |CloseRaw()|. |
290 // TODO(vtl): Test |reset()| more thoroughly? | 290 // TODO(vtl): Test |reset()| more thoroughly? |
291 } | 291 } |
292 | 292 |
293 TEST(CoreCppTest, TearDownWithMessagesEnqueued) { | 293 TEST(CoreCppTest, TearDownWithMessagesEnqueued) { |
294 // Tear down a message pipe which still has a message enqueued, with the | 294 // Tear down a message pipe which still has a message enqueued, with the |
295 // message also having a valid message pipe handle. | 295 // message also having a valid message pipe handle. |
296 { | 296 { |
297 ScopedMessagePipeHandle h0; | 297 ScopedMessagePipeHandle h0; |
298 ScopedMessagePipeHandle h1; | 298 ScopedMessagePipeHandle h1; |
299 CreateMessagePipe(NULL, &h0, &h1); | 299 CreateMessagePipe(nullptr, &h0, &h1); |
300 | 300 |
301 // Send a handle over the previously-establish message pipe. | 301 // Send a handle over the previously-establish message pipe. |
302 ScopedMessagePipeHandle h2; | 302 ScopedMessagePipeHandle h2; |
303 ScopedMessagePipeHandle h3; | 303 ScopedMessagePipeHandle h3; |
304 CreateMessagePipe(NULL, &h2, &h3); | 304 CreateMessagePipe(nullptr, &h2, &h3); |
305 | 305 |
306 // Write a message to |h2|, before we send |h3|. | 306 // Write a message to |h2|, before we send |h3|. |
307 const char kWorld[] = "world!"; | 307 const char kWorld[] = "world!"; |
308 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | 308 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); |
309 EXPECT_EQ(MOJO_RESULT_OK, | 309 EXPECT_EQ(MOJO_RESULT_OK, |
310 WriteMessageRaw(h2.get(), | 310 WriteMessageRaw(h2.get(), |
311 kWorld, kWorldSize, | 311 kWorld, kWorldSize, |
312 NULL, 0, | 312 nullptr, 0, |
313 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 313 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
314 // And also a message to |h3|. | 314 // And also a message to |h3|. |
315 EXPECT_EQ(MOJO_RESULT_OK, | 315 EXPECT_EQ(MOJO_RESULT_OK, |
316 WriteMessageRaw(h3.get(), | 316 WriteMessageRaw(h3.get(), |
317 kWorld, kWorldSize, | 317 kWorld, kWorldSize, |
318 NULL, 0, | 318 nullptr, 0, |
319 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 319 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
320 | 320 |
321 // Send |h3| over |h1| to |h0|. | 321 // Send |h3| over |h1| to |h0|. |
322 const char kHello[] = "hello"; | 322 const char kHello[] = "hello"; |
323 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | 323 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); |
324 MojoHandle h3_value; | 324 MojoHandle h3_value; |
325 h3_value = h3.release().value(); | 325 h3_value = h3.release().value(); |
326 EXPECT_NE(kInvalidHandleValue, h3_value); | 326 EXPECT_NE(kInvalidHandleValue, h3_value); |
327 EXPECT_FALSE(h3.get().is_valid()); | 327 EXPECT_FALSE(h3.get().is_valid()); |
328 EXPECT_EQ(MOJO_RESULT_OK, | 328 EXPECT_EQ(MOJO_RESULT_OK, |
329 WriteMessageRaw(h1.get(), | 329 WriteMessageRaw(h1.get(), |
330 kHello, kHelloSize, | 330 kHello, kHelloSize, |
331 &h3_value, 1, | 331 &h3_value, 1, |
332 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 332 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
333 // |h3_value| should actually be invalid now. | 333 // |h3_value| should actually be invalid now. |
334 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value)); | 334 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value)); |
335 | 335 |
336 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value())); | 336 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value())); |
337 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value())); | 337 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value())); |
338 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value())); | 338 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value())); |
339 } | 339 } |
340 | 340 |
341 // Do this in a different order: make the enqueued message pipe handle only | 341 // Do this in a different order: make the enqueued message pipe handle only |
342 // half-alive. | 342 // half-alive. |
343 { | 343 { |
344 ScopedMessagePipeHandle h0; | 344 ScopedMessagePipeHandle h0; |
345 ScopedMessagePipeHandle h1; | 345 ScopedMessagePipeHandle h1; |
346 CreateMessagePipe(NULL, &h0, &h1); | 346 CreateMessagePipe(nullptr, &h0, &h1); |
347 | 347 |
348 // Send a handle over the previously-establish message pipe. | 348 // Send a handle over the previously-establish message pipe. |
349 ScopedMessagePipeHandle h2; | 349 ScopedMessagePipeHandle h2; |
350 ScopedMessagePipeHandle h3; | 350 ScopedMessagePipeHandle h3; |
351 CreateMessagePipe(NULL, &h2, &h3); | 351 CreateMessagePipe(nullptr, &h2, &h3); |
352 | 352 |
353 // Write a message to |h2|, before we send |h3|. | 353 // Write a message to |h2|, before we send |h3|. |
354 const char kWorld[] = "world!"; | 354 const char kWorld[] = "world!"; |
355 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | 355 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); |
356 EXPECT_EQ(MOJO_RESULT_OK, | 356 EXPECT_EQ(MOJO_RESULT_OK, |
357 WriteMessageRaw(h2.get(), | 357 WriteMessageRaw(h2.get(), |
358 kWorld, kWorldSize, | 358 kWorld, kWorldSize, |
359 NULL, 0, | 359 nullptr, 0, |
360 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 360 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
361 // And also a message to |h3|. | 361 // And also a message to |h3|. |
362 EXPECT_EQ(MOJO_RESULT_OK, | 362 EXPECT_EQ(MOJO_RESULT_OK, |
363 WriteMessageRaw(h3.get(), | 363 WriteMessageRaw(h3.get(), |
364 kWorld, kWorldSize, | 364 kWorld, kWorldSize, |
365 NULL, 0, | 365 nullptr, 0, |
366 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 366 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
367 | 367 |
368 // Send |h3| over |h1| to |h0|. | 368 // Send |h3| over |h1| to |h0|. |
369 const char kHello[] = "hello"; | 369 const char kHello[] = "hello"; |
370 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | 370 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); |
371 MojoHandle h3_value; | 371 MojoHandle h3_value; |
372 h3_value = h3.release().value(); | 372 h3_value = h3.release().value(); |
373 EXPECT_NE(kInvalidHandleValue, h3_value); | 373 EXPECT_NE(kInvalidHandleValue, h3_value); |
374 EXPECT_FALSE(h3.get().is_valid()); | 374 EXPECT_FALSE(h3.get().is_valid()); |
375 EXPECT_EQ(MOJO_RESULT_OK, | 375 EXPECT_EQ(MOJO_RESULT_OK, |
376 WriteMessageRaw(h1.get(), | 376 WriteMessageRaw(h1.get(), |
377 kHello, kHelloSize, | 377 kHello, kHelloSize, |
378 &h3_value, 1, | 378 &h3_value, 1, |
379 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 379 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
380 // |h3_value| should actually be invalid now. | 380 // |h3_value| should actually be invalid now. |
381 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value)); | 381 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h3_value)); |
382 | 382 |
383 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value())); | 383 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h2.release().value())); |
384 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value())); | 384 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h0.release().value())); |
385 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value())); | 385 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h1.release().value())); |
386 } | 386 } |
387 } | 387 } |
388 | 388 |
389 TEST(CoreCppTest, ScopedHandleMoveCtor) { | 389 TEST(CoreCppTest, ScopedHandleMoveCtor) { |
390 ScopedSharedBufferHandle buffer1; | 390 ScopedSharedBufferHandle buffer1; |
391 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer1)); | 391 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1)); |
392 EXPECT_TRUE(buffer1.is_valid()); | 392 EXPECT_TRUE(buffer1.is_valid()); |
393 | 393 |
394 ScopedSharedBufferHandle buffer2; | 394 ScopedSharedBufferHandle buffer2; |
395 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer2)); | 395 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer2)); |
396 EXPECT_TRUE(buffer2.is_valid()); | 396 EXPECT_TRUE(buffer2.is_valid()); |
397 | 397 |
398 // If this fails to close buffer1, ScopedHandleBase::CloseIfNecessary() will | 398 // If this fails to close buffer1, ScopedHandleBase::CloseIfNecessary() will |
399 // assert. | 399 // assert. |
400 buffer1 = buffer2.Pass(); | 400 buffer1 = buffer2.Pass(); |
401 | 401 |
402 EXPECT_TRUE(buffer1.is_valid()); | 402 EXPECT_TRUE(buffer1.is_valid()); |
403 EXPECT_FALSE(buffer2.is_valid()); | 403 EXPECT_FALSE(buffer2.is_valid()); |
404 } | 404 } |
405 | 405 |
406 TEST(CoreCppTest, ScopedHandleMoveCtorSelf) { | 406 TEST(CoreCppTest, ScopedHandleMoveCtorSelf) { |
407 ScopedSharedBufferHandle buffer1; | 407 ScopedSharedBufferHandle buffer1; |
408 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(NULL, 1024, &buffer1)); | 408 EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1)); |
409 EXPECT_TRUE(buffer1.is_valid()); | 409 EXPECT_TRUE(buffer1.is_valid()); |
410 | 410 |
411 buffer1 = buffer1.Pass(); | 411 buffer1 = buffer1.Pass(); |
412 | 412 |
413 EXPECT_TRUE(buffer1.is_valid()); | 413 EXPECT_TRUE(buffer1.is_valid()); |
414 } | 414 } |
415 | 415 |
416 // TODO(vtl): Write data pipe tests. | 416 // TODO(vtl): Write data pipe tests. |
417 | 417 |
418 } // namespace | 418 } // namespace |
419 } // namespace mojo | 419 } // namespace mojo |
OLD | NEW |