1// Copyright (c) 2012 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 "net/socket/socket_test_util.h" 6 7#include <string.h> 8 9#include "base/memory/ref_counted.h" 10#include "testing/platform_test.h" 11#include "testing/gtest/include/gtest/gtest.h" 12 13//----------------------------------------------------------------------------- 14 15namespace { 16 17static const char kMsg1[] = "\0hello!\xff"; 18static const int kLen1 = arraysize(kMsg1); 19static const char kMsg2[] = "\0a2345678\0"; 20static const int kLen2 = arraysize(kMsg2); 21static const char kMsg3[] = "bye!"; 22static const int kLen3 = arraysize(kMsg3); 23 24} // anonymous namespace 25 26namespace net { 27 28class DeterministicSocketDataTest : public PlatformTest { 29 public: 30 DeterministicSocketDataTest(); 31 32 virtual void TearDown(); 33 34 void ReentrantReadCallback(int len, int rv); 35 void ReentrantWriteCallback(const char* data, int len, int rv); 36 37 protected: 38 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes, 39 size_t writes_count); 40 41 void AssertSyncReadEquals(const char* data, int len); 42 void AssertAsyncReadEquals(const char* data, int len); 43 void AssertReadReturns(const char* data, int len, int rv); 44 void AssertReadBufferEquals(const char* data, int len); 45 46 void AssertSyncWriteEquals(const char* data, int len); 47 void AssertAsyncWriteEquals(const char* data, int len); 48 void AssertWriteReturns(const char* data, int len, int rv); 49 50 TestCompletionCallback read_callback_; 51 TestCompletionCallback write_callback_; 52 StreamSocket* sock_; 53 scoped_ptr<DeterministicSocketData> data_; 54 55 private: 56 scoped_refptr<IOBuffer> read_buf_; 57 MockConnect connect_data_; 58 59 HostPortPair endpoint_; 60 scoped_refptr<TransportSocketParams> tcp_params_; 61 ClientSocketPoolHistograms histograms_; 62 DeterministicMockClientSocketFactory socket_factory_; 63 MockTransportClientSocketPool socket_pool_; 64 ClientSocketHandle connection_; 65 66 DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest); 67}; 68 69DeterministicSocketDataTest::DeterministicSocketDataTest() 70 : sock_(NULL), 71 read_buf_(NULL), 72 connect_data_(SYNCHRONOUS, OK), 73 endpoint_("www.google.com", 443), 74 tcp_params_(new TransportSocketParams( 75 endpoint_, 76 false, 77 false, 78 OnHostResolutionCallback(), 79 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)), 80 histograms_(std::string()), 81 socket_pool_(10, 10, &histograms_, &socket_factory_) {} 82 83void DeterministicSocketDataTest::TearDown() { 84 // Empty the current queue. 85 base::MessageLoop::current()->RunUntilIdle(); 86 PlatformTest::TearDown(); 87} 88 89void DeterministicSocketDataTest::Initialize(MockRead* reads, 90 size_t reads_count, 91 MockWrite* writes, 92 size_t writes_count) { 93 data_.reset(new DeterministicSocketData(reads, reads_count, 94 writes, writes_count)); 95 data_->set_connect_data(connect_data_); 96 socket_factory_.AddSocketDataProvider(data_.get()); 97 98 // Perform the TCP connect 99 EXPECT_EQ(OK, 100 connection_.Init(endpoint_.ToString(), 101 tcp_params_, 102 LOWEST, 103 CompletionCallback(), 104 reinterpret_cast<TransportClientSocketPool*>(&socket_pool_), 105 BoundNetLog())); 106 sock_ = connection_.socket(); 107} 108 109void DeterministicSocketDataTest::AssertSyncReadEquals(const char* data, 110 int len) { 111 // Issue the read, which will complete immediately 112 AssertReadReturns(data, len, len); 113 AssertReadBufferEquals(data, len); 114} 115 116void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data, 117 int len) { 118 // Issue the read, which will be completed asynchronously 119 AssertReadReturns(data, len, ERR_IO_PENDING); 120 121 EXPECT_FALSE(read_callback_.have_result()); 122 EXPECT_TRUE(sock_->IsConnected()); 123 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked 124 125 // Now the read should complete 126 ASSERT_EQ(len, read_callback_.WaitForResult()); 127 AssertReadBufferEquals(data, len); 128} 129 130void DeterministicSocketDataTest::AssertReadReturns(const char* data, 131 int len, int rv) { 132 read_buf_ = new IOBuffer(len); 133 ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback())); 134} 135 136void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data, 137 int len) { 138 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len)); 139} 140 141void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data, 142 int len) { 143 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 144 memcpy(buf->data(), data, len); 145 146 // Issue the write, which will complete immediately 147 ASSERT_EQ(len, sock_->Write(buf.get(), len, write_callback_.callback())); 148} 149 150void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data, 151 int len) { 152 // Issue the read, which will be completed asynchronously 153 AssertWriteReturns(data, len, ERR_IO_PENDING); 154 155 EXPECT_FALSE(read_callback_.have_result()); 156 EXPECT_TRUE(sock_->IsConnected()); 157 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked 158 159 ASSERT_EQ(len, write_callback_.WaitForResult()); 160} 161 162void DeterministicSocketDataTest::AssertWriteReturns(const char* data, 163 int len, int rv) { 164 scoped_refptr<IOBuffer> buf(new IOBuffer(len)); 165 memcpy(buf->data(), data, len); 166 167 // Issue the read, which will complete asynchronously 168 ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback())); 169} 170 171void DeterministicSocketDataTest::ReentrantReadCallback(int len, int rv) { 172 scoped_refptr<IOBuffer> read_buf(new IOBuffer(len)); 173 EXPECT_EQ(len, 174 sock_->Read( 175 read_buf.get(), 176 len, 177 base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback, 178 base::Unretained(this), 179 len))); 180} 181 182void DeterministicSocketDataTest::ReentrantWriteCallback( 183 const char* data, int len, int rv) { 184 scoped_refptr<IOBuffer> write_buf(new IOBuffer(len)); 185 memcpy(write_buf->data(), data, len); 186 EXPECT_EQ(len, 187 sock_->Write( 188 write_buf.get(), 189 len, 190 base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback, 191 base::Unretained(this), 192 data, 193 len))); 194} 195 196// ----------- Read 197 198TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) { 199 MockRead reads[] = { 200 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 201 MockRead(SYNCHRONOUS, 0, 1), // EOF 202 }; 203 204 Initialize(reads, arraysize(reads), NULL, 0); 205 206 data_->SetStopped(true); 207 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED); 208} 209 210TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) { 211 MockRead reads[] = { 212 MockRead(SYNCHRONOUS, kMsg1, kLen1, 1), // Sync Read 213 MockRead(SYNCHRONOUS, 0, 2), // EOF 214 }; 215 216 MockWrite writes[] = { 217 MockWrite(SYNCHRONOUS, 0, 0) 218 }; 219 220 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 221 222 data_->StopAfter(2); 223 ASSERT_FALSE(data_->stopped()); 224 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED); 225} 226 227TEST_F(DeterministicSocketDataTest, SingleSyncRead) { 228 MockRead reads[] = { 229 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 230 MockRead(SYNCHRONOUS, 0, 1), // EOF 231 }; 232 233 Initialize(reads, arraysize(reads), NULL, 0); 234 // Make sure we don't stop before we've read all the data 235 data_->StopAfter(1); 236 AssertSyncReadEquals(kMsg1, kLen1); 237} 238 239TEST_F(DeterministicSocketDataTest, MultipleSyncReads) { 240 MockRead reads[] = { 241 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 242 MockRead(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Read 243 MockRead(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Read 244 MockRead(SYNCHRONOUS, kMsg3, kLen3, 3), // Sync Read 245 MockRead(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Read 246 MockRead(SYNCHRONOUS, kMsg3, kLen3, 5), // Sync Read 247 MockRead(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Read 248 MockRead(SYNCHRONOUS, 0, 7), // EOF 249 }; 250 251 Initialize(reads, arraysize(reads), NULL, 0); 252 253 // Make sure we don't stop before we've read all the data 254 data_->StopAfter(10); 255 AssertSyncReadEquals(kMsg1, kLen1); 256 AssertSyncReadEquals(kMsg2, kLen2); 257 AssertSyncReadEquals(kMsg3, kLen3); 258 AssertSyncReadEquals(kMsg3, kLen3); 259 AssertSyncReadEquals(kMsg2, kLen2); 260 AssertSyncReadEquals(kMsg3, kLen3); 261 AssertSyncReadEquals(kMsg1, kLen1); 262} 263 264TEST_F(DeterministicSocketDataTest, SingleAsyncRead) { 265 MockRead reads[] = { 266 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read 267 MockRead(SYNCHRONOUS, 0, 1), // EOF 268 }; 269 270 Initialize(reads, arraysize(reads), NULL, 0); 271 272 AssertAsyncReadEquals(kMsg1, kLen1); 273} 274 275TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) { 276 MockRead reads[] = { 277 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read 278 MockRead(ASYNC, kMsg2, kLen2, 1), // Async Read 279 MockRead(ASYNC, kMsg3, kLen3, 2), // Async Read 280 MockRead(ASYNC, kMsg3, kLen3, 3), // Async Read 281 MockRead(ASYNC, kMsg2, kLen2, 4), // Async Read 282 MockRead(ASYNC, kMsg3, kLen3, 5), // Async Read 283 MockRead(ASYNC, kMsg1, kLen1, 6), // Async Read 284 MockRead(SYNCHRONOUS, 0, 7), // EOF 285 }; 286 287 Initialize(reads, arraysize(reads), NULL, 0); 288 289 AssertAsyncReadEquals(kMsg1, kLen1); 290 AssertAsyncReadEquals(kMsg2, kLen2); 291 AssertAsyncReadEquals(kMsg3, kLen3); 292 AssertAsyncReadEquals(kMsg3, kLen3); 293 AssertAsyncReadEquals(kMsg2, kLen2); 294 AssertAsyncReadEquals(kMsg3, kLen3); 295 AssertAsyncReadEquals(kMsg1, kLen1); 296} 297 298TEST_F(DeterministicSocketDataTest, MixedReads) { 299 MockRead reads[] = { 300 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 301 MockRead(ASYNC, kMsg2, kLen2, 1), // Async Read 302 MockRead(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Read 303 MockRead(ASYNC, kMsg3, kLen3, 3), // Async Read 304 MockRead(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Read 305 MockRead(ASYNC, kMsg3, kLen3, 5), // Async Read 306 MockRead(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Read 307 MockRead(SYNCHRONOUS, 0, 7), // EOF 308 }; 309 310 Initialize(reads, arraysize(reads), NULL, 0); 311 312 data_->StopAfter(1); 313 AssertSyncReadEquals(kMsg1, kLen1); 314 AssertAsyncReadEquals(kMsg2, kLen2); 315 data_->StopAfter(1); 316 AssertSyncReadEquals(kMsg3, kLen3); 317 AssertAsyncReadEquals(kMsg3, kLen3); 318 data_->StopAfter(1); 319 AssertSyncReadEquals(kMsg2, kLen2); 320 AssertAsyncReadEquals(kMsg3, kLen3); 321 data_->StopAfter(1); 322 AssertSyncReadEquals(kMsg1, kLen1); 323} 324 325TEST_F(DeterministicSocketDataTest, SyncReadFromCompletionCallback) { 326 MockRead reads[] = { 327 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read 328 MockRead(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Read 329 }; 330 331 Initialize(reads, arraysize(reads), NULL, 0); 332 333 data_->StopAfter(2); 334 335 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1)); 336 ASSERT_EQ(ERR_IO_PENDING, 337 sock_->Read( 338 read_buf.get(), 339 kLen1, 340 base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback, 341 base::Unretained(this), 342 kLen2))); 343 data_->Run(); 344} 345 346// ----------- Write 347 348TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) { 349 MockWrite writes[] = { 350 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 351 }; 352 353 Initialize(NULL, 0, writes, arraysize(writes)); 354 355 data_->SetStopped(true); 356 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED); 357} 358 359TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) { 360 MockWrite writes[] = { 361 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1), // Sync Write 362 }; 363 364 MockRead reads[] = { 365 MockRead(SYNCHRONOUS, 0, 0) 366 }; 367 368 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 369 370 data_->StopAfter(2); 371 ASSERT_FALSE(data_->stopped()); 372 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED); 373} 374 375TEST_F(DeterministicSocketDataTest, SingleSyncWrite) { 376 MockWrite writes[] = { 377 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write 378 }; 379 380 Initialize(NULL, 0, writes, arraysize(writes)); 381 382 // Make sure we don't stop before we've read all the data 383 data_->StopAfter(1); 384 AssertSyncWriteEquals(kMsg1, kLen1); 385} 386 387TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) { 388 MockWrite writes[] = { 389 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write 390 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write 391 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write 392 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3), // Sync Write 393 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Write 394 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5), // Sync Write 395 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Write 396 }; 397 398 Initialize(NULL, 0, writes, arraysize(writes)); 399 400 // Make sure we don't stop before we've read all the data 401 data_->StopAfter(10); 402 AssertSyncWriteEquals(kMsg1, kLen1); 403 AssertSyncWriteEquals(kMsg2, kLen2); 404 AssertSyncWriteEquals(kMsg3, kLen3); 405 AssertSyncWriteEquals(kMsg3, kLen3); 406 AssertSyncWriteEquals(kMsg2, kLen2); 407 AssertSyncWriteEquals(kMsg3, kLen3); 408 AssertSyncWriteEquals(kMsg1, kLen1); 409} 410 411TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) { 412 MockWrite writes[] = { 413 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write 414 }; 415 416 Initialize(NULL, 0, writes, arraysize(writes)); 417 418 AssertAsyncWriteEquals(kMsg1, kLen1); 419} 420 421TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) { 422 MockWrite writes[] = { 423 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write 424 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write 425 MockWrite(ASYNC, kMsg3, kLen3, 2), // Async Write 426 MockWrite(ASYNC, kMsg3, kLen3, 3), // Async Write 427 MockWrite(ASYNC, kMsg2, kLen2, 4), // Async Write 428 MockWrite(ASYNC, kMsg3, kLen3, 5), // Async Write 429 MockWrite(ASYNC, kMsg1, kLen1, 6), // Async Write 430 }; 431 432 Initialize(NULL, 0, writes, arraysize(writes)); 433 434 AssertAsyncWriteEquals(kMsg1, kLen1); 435 AssertAsyncWriteEquals(kMsg2, kLen2); 436 AssertAsyncWriteEquals(kMsg3, kLen3); 437 AssertAsyncWriteEquals(kMsg3, kLen3); 438 AssertAsyncWriteEquals(kMsg2, kLen2); 439 AssertAsyncWriteEquals(kMsg3, kLen3); 440 AssertAsyncWriteEquals(kMsg1, kLen1); 441} 442 443TEST_F(DeterministicSocketDataTest, MixedWrites) { 444 MockWrite writes[] = { 445 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write 446 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write 447 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write 448 MockWrite(ASYNC, kMsg3, kLen3, 3), // Async Write 449 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Write 450 MockWrite(ASYNC, kMsg3, kLen3, 5), // Async Write 451 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Write 452 }; 453 454 Initialize(NULL, 0, writes, arraysize(writes)); 455 456 data_->StopAfter(1); 457 AssertSyncWriteEquals(kMsg1, kLen1); 458 AssertAsyncWriteEquals(kMsg2, kLen2); 459 data_->StopAfter(1); 460 AssertSyncWriteEquals(kMsg3, kLen3); 461 AssertAsyncWriteEquals(kMsg3, kLen3); 462 data_->StopAfter(1); 463 AssertSyncWriteEquals(kMsg2, kLen2); 464 AssertAsyncWriteEquals(kMsg3, kLen3); 465 data_->StopAfter(1); 466 AssertSyncWriteEquals(kMsg1, kLen1); 467} 468 469TEST_F(DeterministicSocketDataTest, SyncWriteFromCompletionCallback) { 470 MockWrite writes[] = { 471 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write 472 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write 473 }; 474 475 Initialize(NULL, 0, writes, arraysize(writes)); 476 477 data_->StopAfter(2); 478 479 scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1)); 480 memcpy(write_buf->data(), kMsg1, kLen1); 481 ASSERT_EQ(ERR_IO_PENDING, 482 sock_->Write( 483 write_buf.get(), 484 kLen1, 485 base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback, 486 base::Unretained(this), 487 kMsg2, 488 kLen2))); 489 data_->Run(); 490} 491 492// ----------- Mixed Reads and Writes 493 494TEST_F(DeterministicSocketDataTest, MixedSyncOperations) { 495 MockRead reads[] = { 496 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 497 MockRead(SYNCHRONOUS, kMsg2, kLen2, 3), // Sync Read 498 MockRead(SYNCHRONOUS, 0, 4), // EOF 499 }; 500 501 MockWrite writes[] = { 502 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write 503 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write 504 }; 505 506 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 507 508 // Make sure we don't stop before we've read/written everything 509 data_->StopAfter(10); 510 AssertSyncReadEquals(kMsg1, kLen1); 511 AssertSyncWriteEquals(kMsg2, kLen2); 512 AssertSyncWriteEquals(kMsg3, kLen3); 513 AssertSyncReadEquals(kMsg2, kLen2); 514} 515 516TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) { 517 MockRead reads[] = { 518 MockRead(ASYNC, kMsg1, kLen1, 0), // Sync Read 519 MockRead(ASYNC, kMsg2, kLen2, 3), // Sync Read 520 MockRead(ASYNC, 0, 4), // EOF 521 }; 522 523 MockWrite writes[] = { 524 MockWrite(ASYNC, kMsg2, kLen2, 1), // Sync Write 525 MockWrite(ASYNC, kMsg3, kLen3, 2), // Sync Write 526 }; 527 528 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 529 530 AssertAsyncReadEquals(kMsg1, kLen1); 531 AssertAsyncWriteEquals(kMsg2, kLen2); 532 AssertAsyncWriteEquals(kMsg3, kLen3); 533 AssertAsyncReadEquals(kMsg2, kLen2); 534} 535 536TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) { 537 // Order of completion is read, write, write, read 538 MockRead reads[] = { 539 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read 540 MockRead(ASYNC, kMsg2, kLen2, 3), // Async Read 541 MockRead(ASYNC, 0, 4), // EOF 542 }; 543 544 MockWrite writes[] = { 545 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write 546 MockWrite(ASYNC, kMsg3, kLen3, 2), // Async Write 547 }; 548 549 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 550 551 // Issue the write, which will block until the read completes 552 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); 553 554 // Issue the read which will return first 555 AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING); 556 557 data_->RunFor(1); 558 ASSERT_TRUE(read_callback_.have_result()); 559 ASSERT_EQ(kLen1, read_callback_.WaitForResult()); 560 AssertReadBufferEquals(kMsg1, kLen1); 561 562 data_->RunFor(1); 563 ASSERT_TRUE(write_callback_.have_result()); 564 ASSERT_EQ(kLen2, write_callback_.WaitForResult()); 565 566 data_->StopAfter(1); 567 // Issue the read, which will block until the write completes 568 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING); 569 570 // Issue the writes which will return first 571 AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING); 572 573 data_->RunFor(1); 574 ASSERT_TRUE(write_callback_.have_result()); 575 ASSERT_EQ(kLen3, write_callback_.WaitForResult()); 576 577 data_->RunFor(1); 578 ASSERT_TRUE(read_callback_.have_result()); 579 ASSERT_EQ(kLen2, read_callback_.WaitForResult()); 580 AssertReadBufferEquals(kMsg2, kLen2); 581} 582 583TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) { 584 // Order of completion is read, write, write, read 585 MockRead reads[] = { 586 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read 587 MockRead(ASYNC, kMsg2, kLen2, 3), // Async Read 588 MockRead(SYNCHRONOUS, 0, 4), // EOF 589 }; 590 591 MockWrite writes[] = { 592 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write 593 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write 594 }; 595 596 Initialize(reads, arraysize(reads), writes, arraysize(writes)); 597 598 // Issue the write, which will block until the read completes 599 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING); 600 601 // Issue the writes which will complete immediately 602 data_->StopAfter(1); 603 AssertSyncReadEquals(kMsg1, kLen1); 604 605 data_->RunFor(1); 606 ASSERT_TRUE(write_callback_.have_result()); 607 ASSERT_EQ(kLen2, write_callback_.WaitForResult()); 608 609 // Issue the read, which will block until the write completes 610 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING); 611 612 // Issue the writes which will complete immediately 613 data_->StopAfter(1); 614 AssertSyncWriteEquals(kMsg3, kLen3); 615 616 data_->RunFor(1); 617 ASSERT_TRUE(read_callback_.have_result()); 618 ASSERT_EQ(kLen2, read_callback_.WaitForResult()); 619 AssertReadBufferEquals(kMsg2, kLen2); 620} 621 622} // namespace net 623