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