net/socket/deterministic_socket_data_unittest.cc

   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[] = "\0a2345678\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   void TearDown() override;
  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(
  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
  83 void DeterministicSocketDataTest::TearDown() {
  84   // Empty the current queue.
  85   base::MessageLoop::current()->RunUntilIdle();
  86   PlatformTest::TearDown();
  87 }
  88
  89 void 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
 109 void 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
 116 void 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
 130 void 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
 136 void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
 137                                                          int len) {
 138   ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
 139 }
 140
 141 void 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
 150 void 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
 162 void 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
 171 void 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
 182 void 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
 198 TEST_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
 210 TEST_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
 227 TEST_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
 239 TEST_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
 264 TEST_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
 275 TEST_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
 298 TEST_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
 325 TEST_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
 348 TEST_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
 359 TEST_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
 375 TEST_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
 387 TEST_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
 411 TEST_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
 421 TEST_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
 443 TEST_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
 469 TEST_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
 494 TEST_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
 516 TEST_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
 536 TEST_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
 583 TEST_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