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[] = "\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  protected:
  35   void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
  36                   size_t writes_count);
  37
  38   void AssertSyncReadEquals(const char* data, int len);
  39   void AssertAsyncReadEquals(const char* data, int len);
  40   void AssertReadReturns(const char* data, int len, int rv);
  41   void AssertReadBufferEquals(const char* data, int len);
  42
  43   void AssertSyncWriteEquals(const char* data, int len);
  44   void AssertAsyncWriteEquals(const char* data, int len);
  45   void AssertWriteReturns(const char* data, int len, int rv);
  46
  47   TestCompletionCallback read_callback_;
  48   TestCompletionCallback write_callback_;
  49   StreamSocket* sock_;
  50   scoped_ptr<DeterministicSocketData> data_;
  51
  52  private:
  53   scoped_refptr<IOBuffer> read_buf_;
  54   MockConnect connect_data_;
  55
  56   HostPortPair endpoint_;
  57   scoped_refptr<TransportSocketParams> tcp_params_;
  58   ClientSocketPoolHistograms histograms_;
  59   DeterministicMockClientSocketFactory socket_factory_;
  60   MockTransportClientSocketPool socket_pool_;
  61   ClientSocketHandle connection_;
  62
  63   DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest);
  64 };
  65
  66 DeterministicSocketDataTest::DeterministicSocketDataTest()
  67     : sock_(NULL),
  68       data_(NULL),
  69       read_buf_(NULL),
  70       connect_data_(SYNCHRONOUS, OK),
  71       endpoint_("www.google.com", 443),
  72       tcp_params_(new TransportSocketParams(endpoint_,
  73                                             LOWEST,
  74                                             false,
  75                                             false,
  76                                             OnHostResolutionCallback())),
  77       histograms_(""),
  78       socket_pool_(10, 10, &histograms_, &socket_factory_) {
  79 }
  80
  81 void DeterministicSocketDataTest::TearDown() {
  82   // Empty the current queue.
  83   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_, 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, 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, len, write_callback_.callback()));
 167 }
 168
 169 // ----------- Read
 170
 171 TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) {
 172   MockRead reads[] = {
 173     MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 174     MockRead(SYNCHRONOUS, 0, 1),  // EOF
 175   };
 176
 177   Initialize(reads, arraysize(reads), NULL, 0);
 178
 179   data_->SetStopped(true);
 180   AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
 181 }
 182
 183 TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) {
 184   MockRead reads[] = {
 185     MockRead(SYNCHRONOUS, kMsg1, kLen1, 1),  // Sync Read
 186     MockRead(SYNCHRONOUS, 0, 2),  // EOF
 187   };
 188
 189   MockWrite writes[] = {
 190     MockWrite(SYNCHRONOUS, 0, 0)
 191   };
 192
 193   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 194
 195   data_->StopAfter(2);
 196   ASSERT_FALSE(data_->stopped());
 197   AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
 198 }
 199
 200 TEST_F(DeterministicSocketDataTest, SingleSyncRead) {
 201   MockRead reads[] = {
 202     MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 203     MockRead(SYNCHRONOUS, 0, 1),  // EOF
 204   };
 205
 206   Initialize(reads, arraysize(reads), NULL, 0);
 207   // Make sure we don't stop before we've read all the data
 208   data_->StopAfter(1);
 209   AssertSyncReadEquals(kMsg1, kLen1);
 210 }
 211
 212 TEST_F(DeterministicSocketDataTest, MultipleSyncReads) {
 213   MockRead reads[] = {
 214     MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 215     MockRead(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Read
 216     MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Read
 217     MockRead(SYNCHRONOUS, kMsg3, kLen3, 3),  // Sync Read
 218     MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Read
 219     MockRead(SYNCHRONOUS, kMsg3, kLen3, 5),  // Sync Read
 220     MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Read
 221     MockRead(SYNCHRONOUS, 0, 7),  // EOF
 222   };
 223
 224   Initialize(reads, arraysize(reads), NULL, 0);
 225
 226   // Make sure we don't stop before we've read all the data
 227   data_->StopAfter(10);
 228   AssertSyncReadEquals(kMsg1, kLen1);
 229   AssertSyncReadEquals(kMsg2, kLen2);
 230   AssertSyncReadEquals(kMsg3, kLen3);
 231   AssertSyncReadEquals(kMsg3, kLen3);
 232   AssertSyncReadEquals(kMsg2, kLen2);
 233   AssertSyncReadEquals(kMsg3, kLen3);
 234   AssertSyncReadEquals(kMsg1, kLen1);
 235 }
 236
 237 TEST_F(DeterministicSocketDataTest, SingleAsyncRead) {
 238   MockRead reads[] = {
 239     MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
 240     MockRead(SYNCHRONOUS, 0, 1),  // EOF
 241   };
 242
 243   Initialize(reads, arraysize(reads), NULL, 0);
 244
 245   AssertAsyncReadEquals(kMsg1, kLen1);
 246 }
 247
 248 TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) {
 249   MockRead reads[] = {
 250       MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
 251       MockRead(ASYNC, kMsg2, kLen2, 1),  // Async Read
 252       MockRead(ASYNC, kMsg3, kLen3, 2),  // Async Read
 253       MockRead(ASYNC, kMsg3, kLen3, 3),  // Async Read
 254       MockRead(ASYNC, kMsg2, kLen2, 4),  // Async Read
 255       MockRead(ASYNC, kMsg3, kLen3, 5),  // Async Read
 256       MockRead(ASYNC, kMsg1, kLen1, 6),  // Async Read
 257       MockRead(SYNCHRONOUS, 0, 7),  // EOF
 258   };
 259
 260   Initialize(reads, arraysize(reads), NULL, 0);
 261
 262   AssertAsyncReadEquals(kMsg1, kLen1);
 263   AssertAsyncReadEquals(kMsg2, kLen2);
 264   AssertAsyncReadEquals(kMsg3, kLen3);
 265   AssertAsyncReadEquals(kMsg3, kLen3);
 266   AssertAsyncReadEquals(kMsg2, kLen2);
 267   AssertAsyncReadEquals(kMsg3, kLen3);
 268   AssertAsyncReadEquals(kMsg1, kLen1);
 269 }
 270
 271 TEST_F(DeterministicSocketDataTest, MixedReads) {
 272   MockRead reads[] = {
 273       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 274       MockRead(ASYNC, kMsg2, kLen2, 1),   // Async Read
 275       MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Read
 276       MockRead(ASYNC, kMsg3, kLen3, 3),   // Async Read
 277       MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Read
 278       MockRead(ASYNC, kMsg3, kLen3, 5),   // Async Read
 279       MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Read
 280       MockRead(SYNCHRONOUS, 0, 7),  // EOF
 281   };
 282
 283   Initialize(reads, arraysize(reads), NULL, 0);
 284
 285   data_->StopAfter(1);
 286   AssertSyncReadEquals(kMsg1, kLen1);
 287   AssertAsyncReadEquals(kMsg2, kLen2);
 288   data_->StopAfter(1);
 289   AssertSyncReadEquals(kMsg3, kLen3);
 290   AssertAsyncReadEquals(kMsg3, kLen3);
 291   data_->StopAfter(1);
 292   AssertSyncReadEquals(kMsg2, kLen2);
 293   AssertAsyncReadEquals(kMsg3, kLen3);
 294   data_->StopAfter(1);
 295   AssertSyncReadEquals(kMsg1, kLen1);
 296 }
 297
 298 // ----------- Write
 299
 300 TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) {
 301   MockWrite writes[] = {
 302     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 303   };
 304
 305   Initialize(NULL, 0, writes, arraysize(writes));
 306
 307   data_->SetStopped(true);
 308   AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
 309 }
 310
 311 TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) {
 312   MockWrite writes[] = {
 313     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1),  // Sync Write
 314   };
 315
 316   MockRead reads[] = {
 317     MockRead(SYNCHRONOUS, 0, 0)
 318   };
 319
 320   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 321
 322   data_->StopAfter(2);
 323   ASSERT_FALSE(data_->stopped());
 324   AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
 325 }
 326
 327 TEST_F(DeterministicSocketDataTest, SingleSyncWrite) {
 328   MockWrite writes[] = {
 329     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
 330   };
 331
 332   Initialize(NULL, 0, writes, arraysize(writes));
 333
 334   // Make sure we don't stop before we've read all the data
 335   data_->StopAfter(1);
 336   AssertSyncWriteEquals(kMsg1, kLen1);
 337 }
 338
 339 TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) {
 340   MockWrite writes[] = {
 341     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
 342     MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Write
 343     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
 344     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3),  // Sync Write
 345     MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Write
 346     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5),  // Sync Write
 347     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Write
 348   };
 349
 350   Initialize(NULL, 0, writes, arraysize(writes));
 351
 352   // Make sure we don't stop before we've read all the data
 353   data_->StopAfter(10);
 354   AssertSyncWriteEquals(kMsg1, kLen1);
 355   AssertSyncWriteEquals(kMsg2, kLen2);
 356   AssertSyncWriteEquals(kMsg3, kLen3);
 357   AssertSyncWriteEquals(kMsg3, kLen3);
 358   AssertSyncWriteEquals(kMsg2, kLen2);
 359   AssertSyncWriteEquals(kMsg3, kLen3);
 360   AssertSyncWriteEquals(kMsg1, kLen1);
 361 }
 362
 363 TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) {
 364   MockWrite writes[] = {
 365     MockWrite(ASYNC, kMsg1, kLen1, 0),  // Async Write
 366   };
 367
 368   Initialize(NULL, 0, writes, arraysize(writes));
 369
 370   AssertAsyncWriteEquals(kMsg1, kLen1);
 371 }
 372
 373 TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) {
 374   MockWrite writes[] = {
 375     MockWrite(ASYNC, kMsg1, kLen1, 0),  // Async Write
 376     MockWrite(ASYNC, kMsg2, kLen2, 1),  // Async Write
 377     MockWrite(ASYNC, kMsg3, kLen3, 2),  // Async Write
 378     MockWrite(ASYNC, kMsg3, kLen3, 3),  // Async Write
 379     MockWrite(ASYNC, kMsg2, kLen2, 4),  // Async Write
 380     MockWrite(ASYNC, kMsg3, kLen3, 5),  // Async Write
 381     MockWrite(ASYNC, kMsg1, kLen1, 6),  // Async Write
 382   };
 383
 384   Initialize(NULL, 0, writes, arraysize(writes));
 385
 386   AssertAsyncWriteEquals(kMsg1, kLen1);
 387   AssertAsyncWriteEquals(kMsg2, kLen2);
 388   AssertAsyncWriteEquals(kMsg3, kLen3);
 389   AssertAsyncWriteEquals(kMsg3, kLen3);
 390   AssertAsyncWriteEquals(kMsg2, kLen2);
 391   AssertAsyncWriteEquals(kMsg3, kLen3);
 392   AssertAsyncWriteEquals(kMsg1, kLen1);
 393 }
 394
 395 TEST_F(DeterministicSocketDataTest, MixedWrites) {
 396   MockWrite writes[] = {
 397     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Write
 398     MockWrite(ASYNC, kMsg2, kLen2, 1),   // Async Write
 399     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
 400     MockWrite(ASYNC, kMsg3, kLen3, 3),   // Async Write
 401     MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),  // Sync Write
 402     MockWrite(ASYNC, kMsg3, kLen3, 5),   // Async Write
 403     MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),  // Sync Write
 404   };
 405
 406   Initialize(NULL, 0, writes, arraysize(writes));
 407
 408   data_->StopAfter(1);
 409   AssertSyncWriteEquals(kMsg1, kLen1);
 410   AssertAsyncWriteEquals(kMsg2, kLen2);
 411   data_->StopAfter(1);
 412   AssertSyncWriteEquals(kMsg3, kLen3);
 413   AssertAsyncWriteEquals(kMsg3, kLen3);
 414   data_->StopAfter(1);
 415   AssertSyncWriteEquals(kMsg2, kLen2);
 416   AssertAsyncWriteEquals(kMsg3, kLen3);
 417   data_->StopAfter(1);
 418   AssertSyncWriteEquals(kMsg1, kLen1);
 419 }
 420
 421 // ----------- Mixed Reads and Writes
 422
 423 TEST_F(DeterministicSocketDataTest, MixedSyncOperations) {
 424   MockRead reads[] = {
 425     MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 426     MockRead(SYNCHRONOUS, kMsg2, kLen2, 3),  // Sync Read
 427     MockRead(SYNCHRONOUS, 0, 4),  // EOF
 428   };
 429
 430   MockWrite writes[] = {
 431     MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),  // Sync Write
 432     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
 433   };
 434
 435   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 436
 437   // Make sure we don't stop before we've read/written everything
 438   data_->StopAfter(10);
 439   AssertSyncReadEquals(kMsg1, kLen1);
 440   AssertSyncWriteEquals(kMsg2, kLen2);
 441   AssertSyncWriteEquals(kMsg3, kLen3);
 442   AssertSyncReadEquals(kMsg2, kLen2);
 443 }
 444
 445 TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) {
 446   MockRead reads[] = {
 447     MockRead(ASYNC, kMsg1, kLen1, 0),  // Sync Read
 448     MockRead(ASYNC, kMsg2, kLen2, 3),  // Sync Read
 449     MockRead(ASYNC, 0, 4),  // EOF
 450   };
 451
 452   MockWrite writes[] = {
 453     MockWrite(ASYNC, kMsg2, kLen2, 1),  // Sync Write
 454     MockWrite(ASYNC, kMsg3, kLen3, 2),  // Sync Write
 455   };
 456
 457   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 458
 459   AssertAsyncReadEquals(kMsg1, kLen1);
 460   AssertAsyncWriteEquals(kMsg2, kLen2);
 461   AssertAsyncWriteEquals(kMsg3, kLen3);
 462   AssertAsyncReadEquals(kMsg2, kLen2);
 463 }
 464
 465 TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) {
 466   // Order of completion is read, write, write, read
 467   MockRead reads[] = {
 468     MockRead(ASYNC, kMsg1, kLen1, 0),  // Async Read
 469     MockRead(ASYNC, kMsg2, kLen2, 3),  // Async Read
 470     MockRead(ASYNC, 0, 4),  // EOF
 471   };
 472
 473   MockWrite writes[] = {
 474     MockWrite(ASYNC, kMsg2, kLen2, 1),  // Async Write
 475     MockWrite(ASYNC, kMsg3, kLen3, 2),  // Async Write
 476   };
 477
 478   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 479
 480   // Issue the write, which will block until the read completes
 481   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
 482
 483   // Issue the read which will return first
 484   AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING);
 485
 486   data_->RunFor(1);
 487   ASSERT_EQ(kLen1, read_callback_.WaitForResult());
 488   AssertReadBufferEquals(kMsg1, kLen1);
 489
 490   data_->RunFor(1);
 491   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
 492
 493   data_->StopAfter(1);
 494   // Issue the read, which will block until the write completes
 495   AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
 496
 497   // Issue the writes which will return first
 498   AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
 499
 500   data_->RunFor(1);
 501   ASSERT_EQ(kLen3, write_callback_.WaitForResult());
 502
 503   data_->RunFor(1);
 504   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
 505   AssertReadBufferEquals(kMsg2, kLen2);
 506 }
 507
 508 TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) {
 509   // Order of completion is read, write, write, read
 510   MockRead reads[] = {
 511     MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),  // Sync Read
 512     MockRead(ASYNC, kMsg2, kLen2, 3),   // Async Read
 513     MockRead(SYNCHRONOUS, 0, 4),  // EOF
 514   };
 515
 516   MockWrite writes[] = {
 517     MockWrite(ASYNC, kMsg2, kLen2, 1),   // Async Write
 518     MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),  // Sync Write
 519   };
 520
 521   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 522
 523   // Issue the write, which will block until the read completes
 524   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
 525
 526   // Issue the writes which will complete immediately
 527   data_->StopAfter(1);
 528   AssertSyncReadEquals(kMsg1, kLen1);
 529
 530   data_->RunFor(1);
 531   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
 532
 533   // Issue the read, which will block until the write completes
 534   AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
 535
 536   // Issue the writes which will complete immediately
 537   data_->StopAfter(1);
 538   AssertSyncWriteEquals(kMsg3, kLen3);
 539
 540   data_->RunFor(1);
 541   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
 542   AssertReadBufferEquals(kMsg2, kLen2);
 543 }
 544
 545 }  // namespace net