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
15namespace {
16
17static const char kMsg1[] = "\0hello!\xff";
18static const int kLen1 = arraysize(kMsg1);
19static const char kMsg2[] = "\0a2345678\0";
20static const int kLen2 = arraysize(kMsg2);
21static const char kMsg3[] = "bye!";
22static const int kLen3 = arraysize(kMsg3);
23
24}  // anonymous namespace
25
26namespace net {
27
28class 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
69DeterministicSocketDataTest::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
83void DeterministicSocketDataTest::TearDown() {
84  // Empty the current queue.
85  base::MessageLoop::current()->RunUntilIdle();
86  PlatformTest::TearDown();
87}
88
89void 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
109void 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
116void 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
130void 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
136void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
137                                                         int len) {
138  ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
139}
140
141void 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
150void 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
162void 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
171void 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
182void 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
198TEST_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
210TEST_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
227TEST_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
239TEST_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
264TEST_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
275TEST_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
298TEST_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
325TEST_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
348TEST_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
359TEST_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
375TEST_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
387TEST_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
411TEST_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
421TEST_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
443TEST_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
469TEST_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
494TEST_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
516TEST_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
536TEST_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
583TEST_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
623