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