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