xref: /aosp_15_r20/external/cronet/net/socket/sequenced_socket_data_unittest.cc (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b)
1 // Copyright 2015 The Chromium Authors
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 <memory>
6 #include <string>
7 
8 #include "base/functional/bind.h"
9 #include "base/memory/raw_ptr.h"
10 #include "base/memory/ref_counted.h"
11 #include "base/run_loop.h"
12 #include "net/base/completion_once_callback.h"
13 #include "net/base/io_buffer.h"
14 #include "net/base/test_completion_callback.h"
15 #include "net/log/net_log_with_source.h"
16 #include "net/socket/socket_test_util.h"
17 #include "net/test/gtest_util.h"
18 #include "net/test/test_with_task_environment.h"
19 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
20 #include "testing/gmock/include/gmock/gmock.h"
21 #include "testing/gtest/include/gtest/gtest-spi.h"
22 #include "testing/gtest/include/gtest/gtest.h"
23 #include "testing/platform_test.h"
24 
25 using net::test::IsError;
26 using net::test::IsOk;
27 
28 //-----------------------------------------------------------------------------
29 
30 namespace net {
31 
32 namespace {
33 
34 const char kMsg1[] = "\0hello!\xff";
35 const int kLen1 = std::size(kMsg1);
36 const char kMsg2[] = "\0a2345678\0";
37 const int kLen2 = std::size(kMsg2);
38 const char kMsg3[] = "bye!";
39 const int kLen3 = std::size(kMsg3);
40 const char kMsg4[] = "supercalifragilisticexpialidocious";
41 const int kLen4 = std::size(kMsg4);
42 
43 // Helper class for starting the next operation operation reentrantly after the
44 // previous operation completed asynchronously. When OnIOComplete is called,
45 // it will first verify that the previous operation behaved as expected. This is
46 // specified by either SetExpectedRead or SetExpectedWrite. It will then invoke
47 // a read or write operation specified by SetInvokeRead or SetInvokeWrite.
48 class ReentrantHelper {
49  public:
ReentrantHelper(StreamSocket * socket)50   explicit ReentrantHelper(StreamSocket* socket) : socket_(socket) {}
51 
52   ReentrantHelper(const ReentrantHelper&) = delete;
53   ReentrantHelper& operator=(const ReentrantHelper&) = delete;
54 
55   // Expect that the previous operation will return |first_len| and will fill
56   // |first_read_data_| with |first_read_data|.
SetExpectedRead(const char * first_read_data,int first_len)57   void SetExpectedRead(const char* first_read_data, int first_len) {
58     verify_read_ = true;
59     first_read_buf_ = base::MakeRefCounted<IOBufferWithSize>(first_len);
60     first_read_data_ = first_read_data;
61     first_len_ = first_len;
62   }
63 
64   // Expect that the previous operation will return |first_len|.
SetExpectedWrite(int first_len)65   void SetExpectedWrite(int first_len) {
66     verify_read_ = false;
67     first_len_ = first_len;
68   }
69 
70   // After verifying expectations, invoke a read of |read_len| bytes into
71   // |read_buf|, notifying |callback| when complete.
SetInvokeRead(scoped_refptr<IOBuffer> read_buf,int read_len,int second_rv,CompletionOnceCallback callback)72   void SetInvokeRead(scoped_refptr<IOBuffer> read_buf,
73                      int read_len,
74                      int second_rv,
75                      CompletionOnceCallback callback) {
76     second_read_ = true;
77     second_read_buf_ = read_buf;
78     second_rv_ = second_rv;
79     second_callback_ = std::move(callback);
80     second_len_ = read_len;
81   }
82 
83   // After verifying expectations, invoke a write of |write_len| bytes from
84   // |write_data|, notifying |callback| when complete.
SetInvokeWrite(const char * write_data,int write_len,int second_rv,CompletionOnceCallback callback)85   void SetInvokeWrite(const char* write_data,
86                       int write_len,
87                       int second_rv,
88                       CompletionOnceCallback callback) {
89     second_read_ = false;
90     second_rv_ = second_rv;
91     second_write_data_ = write_data;
92     second_callback_ = std::move(callback);
93     second_len_ = write_len;
94   }
95 
96   // Returns the OnIOComplete callback for this helper.
callback()97   CompletionOnceCallback callback() {
98     return base::BindOnce(&ReentrantHelper::OnIOComplete,
99                           base::Unretained(this));
100   }
101 
102   // Retuns the buffer where data is expected to have been written,
103   // when checked by SetExpectRead()
read_buf()104   scoped_refptr<IOBuffer> read_buf() { return first_read_buf_; }
105 
106  private:
OnIOComplete(int rv)107   void OnIOComplete(int rv) {
108     CHECK_NE(-1, first_len_) << "Expectation not set.";
109     CHECK_NE(-1, second_len_) << "Invocation not set.";
110     ASSERT_EQ(first_len_, rv);
111     if (verify_read_) {
112       ASSERT_EQ(std::string(first_read_data_, first_len_),
113                 std::string(first_read_buf_->data(), rv));
114     }
115 
116     if (second_read_) {
117       ASSERT_EQ(second_rv_, socket_->Read(second_read_buf_.get(), second_len_,
118                                           std::move(second_callback_)));
119     } else {
120       auto write_buf = base::MakeRefCounted<IOBufferWithSize>(second_len_);
121       memcpy(write_buf->data(), second_write_data_, second_len_);
122       ASSERT_EQ(second_rv_, socket_->Write(write_buf.get(), second_len_,
123                                            std::move(second_callback_),
124                                            TRAFFIC_ANNOTATION_FOR_TESTS));
125     }
126   }
127 
128   raw_ptr<StreamSocket> socket_;
129 
130   bool verify_read_ = false;
131   scoped_refptr<IOBuffer> first_read_buf_;
132   const char* first_read_data_ = nullptr;
133   int first_len_ = -1;
134 
135   CompletionOnceCallback second_callback_;
136   bool second_read_ = false;
137   int second_rv_;
138   scoped_refptr<IOBuffer> second_read_buf_;
139   const char* second_write_data_ = nullptr;
140   int second_len_ = -1;
141 };
142 
143 class SequencedSocketDataTest : public TestWithTaskEnvironment {
144  public:
145   SequencedSocketDataTest();
146   ~SequencedSocketDataTest() override;
147 
148   // This method is used as the completion callback for an async read
149   // operation and when invoked, it verifies that the correct data was read,
150   // then reads from the socket and verifies that that it returns the correct
151   // value.
152   void ReentrantReadCallback(const char* data,
153                              int len1,
154                              int len2,
155                              int expected_rv2,
156                              int rv);
157 
158   // This method is used at the completion callback for an async operation.
159   // When executed, verifies that |rv| equals |expected_rv| and then
160   // attempts an aync read from the socket into |read_buf_| (initialized
161   // to |read_buf_len|) using |callback|.
162   void ReentrantAsyncReadCallback(int len1, int len2, int rv);
163 
164   // This method is used as the completion callback for an async write
165   // operation and when invoked, it verifies that the write returned correctly,
166   // then
167   // attempts to write to the socket and verifies that that it returns the
168   // correct value.
169   void ReentrantWriteCallback(int expected_rv1,
170                               const char* data,
171                               int len,
172                               int expected_rv2,
173                               int rv);
174 
175   // This method is used at the completion callback for an async operation.
176   // When executed, verifies that |rv| equals |expected_rv| and then
177   // attempts an aync write of |data| with |callback|
178   void ReentrantAsyncWriteCallback(const char* data,
179                                    int len,
180                                    CompletionOnceCallback callback,
181                                    int expected_rv,
182                                    int rv);
183 
184   // Callback which adds a failure if it's ever called.
185   void FailingCompletionCallback(int rv);
186 
187  protected:
188   void Initialize(base::span<const MockRead> reads,
189                   base::span<const MockWrite> writes);
190 
191   void AssertSyncReadEquals(const char* data, int len);
192   void AssertAsyncReadEquals(const char* data, int len);
193   void AssertReadReturns(int len, int rv);
194   void AssertReadBufferEquals(const char* data, int len);
195 
196   void AssertSyncWriteEquals(const char* data, int len);
197   void AssertAsyncWriteEquals(const char* data, int len);
198   void AssertWriteReturns(const char* data, int len, int rv);
199 
200   bool IsPaused() const;
201   void Resume();
202   void RunUntilPaused();
203 
204   // When a given test completes, data_.at_eof() is expected to
205   // match the value specified here. Most test should consume all
206   // reads and writes, but some tests verify error handling behavior
207   // do not consume all data.
set_expect_eof(bool expect_eof)208   void set_expect_eof(bool expect_eof) { expect_eof_ = expect_eof; }
209 
failing_callback()210   CompletionOnceCallback failing_callback() {
211     return base::BindOnce(&SequencedSocketDataTest::FailingCompletionCallback,
212                           base::Unretained(this));
213   }
214 
215   TestCompletionCallback read_callback_;
216   scoped_refptr<IOBuffer> read_buf_;
217   TestCompletionCallback write_callback_;
218 
219   std::unique_ptr<SequencedSocketData> data_;
220 
221   MockClientSocketFactory socket_factory_;
222   bool expect_eof_ = true;
223 
224   std::unique_ptr<StreamSocket> sock_;
225 };
226 
227 SequencedSocketDataTest::SequencedSocketDataTest() = default;
228 
~SequencedSocketDataTest()229 SequencedSocketDataTest::~SequencedSocketDataTest() {
230   // Make sure no unexpected pending tasks will cause a failure.
231   base::RunLoop().RunUntilIdle();
232   if (expect_eof_) {
233     EXPECT_EQ(expect_eof_, data_->AllReadDataConsumed());
234     EXPECT_EQ(expect_eof_, data_->AllWriteDataConsumed());
235   }
236 }
237 
Initialize(base::span<const MockRead> reads,base::span<const MockWrite> writes)238 void SequencedSocketDataTest::Initialize(base::span<const MockRead> reads,
239                                          base::span<const MockWrite> writes) {
240   data_ = std::make_unique<SequencedSocketData>(MockConnect(SYNCHRONOUS, OK),
241                                                 reads, writes);
242   socket_factory_.AddSocketDataProvider(data_.get());
243   sock_ = socket_factory_.CreateTransportClientSocket(
244       AddressList(IPEndPoint(IPAddress::IPv4Localhost(), 443)),
245       nullptr /* socket_performance_watcher */,
246       nullptr /* network_quality_estimator */, nullptr /* net_log */,
247       NetLogSource());
248   TestCompletionCallback callback;
249   EXPECT_EQ(OK, sock_->Connect(callback.callback()));
250 }
251 
AssertSyncReadEquals(const char * data,int len)252 void SequencedSocketDataTest::AssertSyncReadEquals(const char* data, int len) {
253   // Issue the read, which will complete immediately.
254   AssertReadReturns(len, len);
255   AssertReadBufferEquals(data, len);
256 }
257 
AssertAsyncReadEquals(const char * data,int len)258 void SequencedSocketDataTest::AssertAsyncReadEquals(const char* data, int len) {
259   // Issue the read, which will be completed asynchronously.
260   AssertReadReturns(len, ERR_IO_PENDING);
261 
262   EXPECT_TRUE(sock_->IsConnected());
263 
264   // Now the read should complete.
265   ASSERT_EQ(len, read_callback_.WaitForResult());
266   AssertReadBufferEquals(data, len);
267 }
268 
AssertReadReturns(int len,int rv)269 void SequencedSocketDataTest::AssertReadReturns(int len, int rv) {
270   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(len);
271   if (rv == ERR_IO_PENDING) {
272     ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback()));
273     ASSERT_FALSE(read_callback_.have_result());
274   } else {
275     ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, failing_callback()));
276   }
277 }
278 
AssertReadBufferEquals(const char * data,int len)279 void SequencedSocketDataTest::AssertReadBufferEquals(const char* data,
280                                                      int len) {
281   ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
282 }
283 
AssertSyncWriteEquals(const char * data,int len)284 void SequencedSocketDataTest::AssertSyncWriteEquals(const char* data, int len) {
285   // Issue the write, which should be complete immediately.
286   AssertWriteReturns(data, len, len);
287   ASSERT_FALSE(write_callback_.have_result());
288 }
289 
AssertAsyncWriteEquals(const char * data,int len)290 void SequencedSocketDataTest::AssertAsyncWriteEquals(const char* data,
291                                                      int len) {
292   // Issue the read, which should be completed asynchronously.
293   AssertWriteReturns(data, len, ERR_IO_PENDING);
294 
295   EXPECT_FALSE(read_callback_.have_result());
296   EXPECT_TRUE(sock_->IsConnected());
297 
298   ASSERT_EQ(len, write_callback_.WaitForResult());
299 }
300 
IsPaused() const301 bool SequencedSocketDataTest::IsPaused() const {
302   return data_->IsPaused();
303 }
304 
Resume()305 void SequencedSocketDataTest::Resume() {
306   data_->Resume();
307 }
308 
RunUntilPaused()309 void SequencedSocketDataTest::RunUntilPaused() {
310   data_->RunUntilPaused();
311 }
312 
AssertWriteReturns(const char * data,int len,int rv)313 void SequencedSocketDataTest::AssertWriteReturns(const char* data,
314                                                  int len,
315                                                  int rv) {
316   auto buf = base::MakeRefCounted<IOBufferWithSize>(len);
317   memcpy(buf->data(), data, len);
318 
319   if (rv == ERR_IO_PENDING) {
320     ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback(),
321                                TRAFFIC_ANNOTATION_FOR_TESTS));
322     ASSERT_FALSE(write_callback_.have_result());
323   } else {
324     ASSERT_EQ(rv, sock_->Write(buf.get(), len, failing_callback(),
325                                TRAFFIC_ANNOTATION_FOR_TESTS));
326   }
327 }
328 
ReentrantReadCallback(const char * data,int len1,int len2,int expected_rv2,int rv)329 void SequencedSocketDataTest::ReentrantReadCallback(const char* data,
330                                                     int len1,
331                                                     int len2,
332                                                     int expected_rv2,
333                                                     int rv) {
334   ASSERT_EQ(len1, rv);
335   AssertReadBufferEquals(data, len1);
336 
337   AssertReadReturns(len2, expected_rv2);
338 }
339 
ReentrantAsyncReadCallback(int expected_rv,int len,int rv)340 void SequencedSocketDataTest::ReentrantAsyncReadCallback(int expected_rv,
341                                                          int len,
342                                                          int rv) {
343   ASSERT_EQ(expected_rv, rv);
344 
345   AssertReadReturns(len, ERR_IO_PENDING);
346 }
347 
ReentrantWriteCallback(int expected_rv1,const char * data,int len,int expected_rv2,int rv)348 void SequencedSocketDataTest::ReentrantWriteCallback(int expected_rv1,
349                                                      const char* data,
350                                                      int len,
351                                                      int expected_rv2,
352                                                      int rv) {
353   ASSERT_EQ(expected_rv1, rv);
354 
355   AssertWriteReturns(data, len, expected_rv2);
356 }
357 
ReentrantAsyncWriteCallback(const char * data,int len,CompletionOnceCallback callback,int expected_rv,int rv)358 void SequencedSocketDataTest::ReentrantAsyncWriteCallback(
359     const char* data,
360     int len,
361     CompletionOnceCallback callback,
362     int expected_rv,
363     int rv) {
364   EXPECT_EQ(expected_rv, rv);
365   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(len);
366   memcpy(write_buf->data(), data, len);
367   EXPECT_THAT(sock_->Write(write_buf.get(), len, std::move(callback),
368                            TRAFFIC_ANNOTATION_FOR_TESTS),
369               IsError(ERR_IO_PENDING));
370 }
371 
FailingCompletionCallback(int rv)372 void SequencedSocketDataTest::FailingCompletionCallback(int rv) {
373   ADD_FAILURE() << "Callback should not have been invoked";
374 }
375 
376 // ----------- Read
377 
TEST_F(SequencedSocketDataTest,SingleSyncRead)378 TEST_F(SequencedSocketDataTest, SingleSyncRead) {
379   MockRead reads[] = {
380       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
381   };
382 
383   Initialize(reads, base::span<MockWrite>());
384   AssertSyncReadEquals(kMsg1, kLen1);
385 }
386 
TEST_F(SequencedSocketDataTest,MultipleSyncReads)387 TEST_F(SequencedSocketDataTest, MultipleSyncReads) {
388   MockRead reads[] = {
389       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
390       MockRead(SYNCHRONOUS, kMsg2, kLen2, 1),
391       MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),
392       MockRead(SYNCHRONOUS, kMsg3, kLen3, 3),
393       MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),
394       MockRead(SYNCHRONOUS, kMsg3, kLen3, 5),
395       MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),
396   };
397 
398   Initialize(reads, base::span<MockWrite>());
399 
400   AssertSyncReadEquals(kMsg1, kLen1);
401   AssertSyncReadEquals(kMsg2, kLen2);
402   AssertSyncReadEquals(kMsg3, kLen3);
403   AssertSyncReadEquals(kMsg3, kLen3);
404   AssertSyncReadEquals(kMsg2, kLen2);
405   AssertSyncReadEquals(kMsg3, kLen3);
406   AssertSyncReadEquals(kMsg1, kLen1);
407 }
408 
TEST_F(SequencedSocketDataTest,SingleAsyncRead)409 TEST_F(SequencedSocketDataTest, SingleAsyncRead) {
410   MockRead reads[] = {
411       MockRead(ASYNC, kMsg1, kLen1, 0),
412   };
413 
414   Initialize(reads, base::span<MockWrite>());
415 
416   AssertAsyncReadEquals(kMsg1, kLen1);
417 }
418 
TEST_F(SequencedSocketDataTest,MultipleAsyncReads)419 TEST_F(SequencedSocketDataTest, MultipleAsyncReads) {
420   MockRead reads[] = {
421       MockRead(ASYNC, kMsg1, kLen1, 0),
422       MockRead(ASYNC, kMsg2, kLen2, 1),
423       MockRead(ASYNC, kMsg3, kLen3, 2),
424       MockRead(ASYNC, kMsg3, kLen3, 3),
425       MockRead(ASYNC, kMsg2, kLen2, 4),
426       MockRead(ASYNC, kMsg3, kLen3, 5),
427       MockRead(ASYNC, kMsg1, kLen1, 6),
428   };
429 
430   Initialize(reads, base::span<MockWrite>());
431 
432   AssertAsyncReadEquals(kMsg1, kLen1);
433   AssertAsyncReadEquals(kMsg2, kLen2);
434   AssertAsyncReadEquals(kMsg3, kLen3);
435   AssertAsyncReadEquals(kMsg3, kLen3);
436   AssertAsyncReadEquals(kMsg2, kLen2);
437   AssertAsyncReadEquals(kMsg3, kLen3);
438   AssertAsyncReadEquals(kMsg1, kLen1);
439 }
440 
TEST_F(SequencedSocketDataTest,MixedReads)441 TEST_F(SequencedSocketDataTest, MixedReads) {
442   MockRead reads[] = {
443       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
444       MockRead(ASYNC, kMsg2, kLen2, 1),
445       MockRead(SYNCHRONOUS, kMsg3, kLen3, 2),
446       MockRead(ASYNC, kMsg3, kLen3, 3),
447       MockRead(SYNCHRONOUS, kMsg2, kLen2, 4),
448       MockRead(ASYNC, kMsg3, kLen3, 5),
449       MockRead(SYNCHRONOUS, kMsg1, kLen1, 6),
450   };
451 
452   Initialize(reads, base::span<MockWrite>());
453 
454   AssertSyncReadEquals(kMsg1, kLen1);
455   AssertAsyncReadEquals(kMsg2, kLen2);
456   AssertSyncReadEquals(kMsg3, kLen3);
457   AssertAsyncReadEquals(kMsg3, kLen3);
458   AssertSyncReadEquals(kMsg2, kLen2);
459   AssertAsyncReadEquals(kMsg3, kLen3);
460   AssertSyncReadEquals(kMsg1, kLen1);
461 }
462 
TEST_F(SequencedSocketDataTest,SyncReadFromCompletionCallback)463 TEST_F(SequencedSocketDataTest, SyncReadFromCompletionCallback) {
464   MockRead reads[] = {
465       MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(SYNCHRONOUS, kMsg2, kLen2, 1),
466   };
467 
468   Initialize(reads, base::span<MockWrite>());
469 
470   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen1);
471   ASSERT_EQ(
472       ERR_IO_PENDING,
473       sock_->Read(
474           read_buf_.get(), kLen1,
475           base::BindOnce(&SequencedSocketDataTest::ReentrantReadCallback,
476                          base::Unretained(this), kMsg1, kLen1, kLen2, kLen2)));
477 
478   base::RunLoop().RunUntilIdle();
479   AssertReadBufferEquals(kMsg2, kLen2);
480 }
481 
TEST_F(SequencedSocketDataTest,ManyReentrantReads)482 TEST_F(SequencedSocketDataTest, ManyReentrantReads) {
483   MockRead reads[] = {
484       MockRead(ASYNC, kMsg1, kLen1, 0),
485       MockRead(ASYNC, kMsg2, kLen2, 1),
486       MockRead(ASYNC, kMsg3, kLen3, 2),
487       MockRead(ASYNC, kMsg4, kLen4, 3),
488   };
489 
490   Initialize(reads, base::span<MockWrite>());
491 
492   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
493 
494   ReentrantHelper helper3(sock_.get());
495   helper3.SetExpectedRead(kMsg3, kLen3);
496   helper3.SetInvokeRead(read_buf_, kLen4, ERR_IO_PENDING,
497                         read_callback_.callback());
498 
499   ReentrantHelper helper2(sock_.get());
500   helper2.SetExpectedRead(kMsg2, kLen2);
501   helper2.SetInvokeRead(helper3.read_buf(), kLen3, ERR_IO_PENDING,
502                         helper3.callback());
503 
504   ReentrantHelper helper(sock_.get());
505   helper.SetExpectedRead(kMsg1, kLen1);
506   helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
507                        helper2.callback());
508 
509   sock_->Read(helper.read_buf().get(), kLen1, helper.callback());
510 
511   ASSERT_EQ(kLen4, read_callback_.WaitForResult());
512   AssertReadBufferEquals(kMsg4, kLen4);
513 }
514 
TEST_F(SequencedSocketDataTest,AsyncReadFromCompletionCallback)515 TEST_F(SequencedSocketDataTest, AsyncReadFromCompletionCallback) {
516   MockRead reads[] = {
517       MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg2, kLen2, 1),
518   };
519 
520   Initialize(reads, base::span<MockWrite>());
521 
522   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen1);
523   ASSERT_EQ(ERR_IO_PENDING,
524             sock_->Read(
525                 read_buf_.get(), kLen1,
526                 base::BindOnce(&SequencedSocketDataTest::ReentrantReadCallback,
527                                base::Unretained(this), kMsg1, kLen1, kLen2,
528                                ERR_IO_PENDING)));
529 
530   ASSERT_FALSE(read_callback_.have_result());
531   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
532   AssertReadBufferEquals(kMsg2, kLen2);
533 }
534 
TEST_F(SequencedSocketDataTest,SingleSyncReadTooEarly)535 TEST_F(SequencedSocketDataTest, SingleSyncReadTooEarly) {
536   MockRead reads[] = {
537       MockRead(SYNCHRONOUS, kMsg1, kLen1, 1),
538   };
539 
540   MockWrite writes[] = {MockWrite(SYNCHRONOUS, 0, 0)};
541 
542   Initialize(reads, writes);
543 
544   EXPECT_NONFATAL_FAILURE(AssertReadReturns(kLen1, ERR_UNEXPECTED),
545                           "Unable to perform synchronous IO while stopped");
546   set_expect_eof(false);
547 }
548 
TEST_F(SequencedSocketDataTest,SingleSyncReadSmallBuffer)549 TEST_F(SequencedSocketDataTest, SingleSyncReadSmallBuffer) {
550   MockRead reads[] = {
551       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
552   };
553 
554   Initialize(reads, base::span<MockWrite>());
555 
556   // Read the first chunk.
557   AssertReadReturns(kLen1 - 1, kLen1 - 1);
558   AssertReadBufferEquals(kMsg1, kLen1 - 1);
559   // Then read the second chunk.
560   AssertReadReturns(1, 1);
561   AssertReadBufferEquals(kMsg1 + kLen1 - 1, 1);
562 }
563 
TEST_F(SequencedSocketDataTest,SingleSyncReadLargeBuffer)564 TEST_F(SequencedSocketDataTest, SingleSyncReadLargeBuffer) {
565   MockRead reads[] = {
566       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
567   };
568 
569   Initialize(reads, base::span<MockWrite>());
570   auto read_buf = base::MakeRefCounted<IOBufferWithSize>(2 * kLen1);
571   ASSERT_EQ(kLen1, sock_->Read(read_buf.get(), 2 * kLen1, failing_callback()));
572   ASSERT_EQ(std::string(kMsg1, kLen1), std::string(read_buf->data(), kLen1));
573 }
574 
TEST_F(SequencedSocketDataTest,SingleAsyncReadLargeBuffer)575 TEST_F(SequencedSocketDataTest, SingleAsyncReadLargeBuffer) {
576   MockRead reads[] = {
577       MockRead(ASYNC, kMsg1, kLen1, 0),
578   };
579 
580   Initialize(reads, base::span<MockWrite>());
581 
582   auto read_buf = base::MakeRefCounted<IOBufferWithSize>(2 * kLen1);
583   ASSERT_EQ(ERR_IO_PENDING,
584             sock_->Read(read_buf.get(), 2 * kLen1, read_callback_.callback()));
585   ASSERT_EQ(kLen1, read_callback_.WaitForResult());
586   ASSERT_EQ(std::string(kMsg1, kLen1), std::string(read_buf->data(), kLen1));
587 }
588 
TEST_F(SequencedSocketDataTest,HangingRead)589 TEST_F(SequencedSocketDataTest, HangingRead) {
590   MockRead reads[] = {
591       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0),
592   };
593 
594   Initialize(reads, base::span<MockWrite>());
595 
596   auto read_buf = base::MakeRefCounted<IOBufferWithSize>(1);
597   ASSERT_EQ(ERR_IO_PENDING,
598             sock_->Read(read_buf.get(), 1, read_callback_.callback()));
599   ASSERT_FALSE(read_callback_.have_result());
600 
601   // Even though the read is scheduled to complete at sequence number 0,
602   // verify that the read callback in never called.
603   base::RunLoop().RunUntilIdle();
604   ASSERT_FALSE(read_callback_.have_result());
605 }
606 
607 // ----------- Write
608 
TEST_F(SequencedSocketDataTest,SingleSyncWriteTooEarly)609 TEST_F(SequencedSocketDataTest, SingleSyncWriteTooEarly) {
610   MockWrite writes[] = {
611       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1),
612   };
613 
614   MockRead reads[] = {MockRead(SYNCHRONOUS, 0, 0)};
615 
616   Initialize(reads, writes);
617 
618   EXPECT_NONFATAL_FAILURE(AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED),
619                           "Unable to perform synchronous IO while stopped");
620 
621   set_expect_eof(false);
622 }
623 
TEST_F(SequencedSocketDataTest,SingleSyncWriteTooSmall)624 TEST_F(SequencedSocketDataTest, SingleSyncWriteTooSmall) {
625   MockWrite writes[] = {
626       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
627   };
628 
629   Initialize(base::span<MockRead>(), writes);
630 
631   // Expecting too small of a write triggers multiple expectation failures.
632   //
633   // The gtest infrastructure does not have a macro similar to
634   // EXPECT_NONFATAL_FAILURE which works when there is more than one
635   // failure.
636   //
637   // However, tests can gather the TestPartResultArray and directly
638   // validate the test failures. That's what the rest of this test does.
639 
640   ::testing::TestPartResultArray gtest_failures;
641 
642   {
643     ::testing::ScopedFakeTestPartResultReporter gtest_reporter(
644         ::testing::ScopedFakeTestPartResultReporter::
645             INTERCEPT_ONLY_CURRENT_THREAD,
646         &gtest_failures);
647     AssertSyncWriteEquals(kMsg1, kLen1 - 1);
648   }
649 
650   static const char* kExpectedFailures[] = {
651       "Value of: actual_data == expected_data\n  Actual: false\nExpected: true",
652       "Expected equality of these values:\n  rv"};
653   ASSERT_EQ(std::size(kExpectedFailures),
654             static_cast<size_t>(gtest_failures.size()));
655 
656   for (int i = 0; i < gtest_failures.size(); ++i) {
657     const ::testing::TestPartResult& result =
658         gtest_failures.GetTestPartResult(i);
659     EXPECT_TRUE(strstr(result.message(), kExpectedFailures[i]) != nullptr);
660   }
661 
662   set_expect_eof(false);
663 }
664 
TEST_F(SequencedSocketDataTest,SingleSyncPartialWrite)665 TEST_F(SequencedSocketDataTest, SingleSyncPartialWrite) {
666   MockWrite writes[] = {
667       MockWrite(SYNCHRONOUS, kMsg1, kLen1 - 1, 0),
668       MockWrite(SYNCHRONOUS, kMsg1 + kLen1 - 1, 1, 1),
669   };
670 
671   Initialize(base::span<MockRead>(), writes);
672 
673   // Attempt to write all of the message, but only some will be written.
674   AssertSyncWriteEquals(kMsg1, kLen1 - 1);
675   // Write the rest of the message.
676   AssertSyncWriteEquals(kMsg1 + kLen1 - 1, 1);
677 }
678 
TEST_F(SequencedSocketDataTest,SingleSyncWrite)679 TEST_F(SequencedSocketDataTest, SingleSyncWrite) {
680   MockWrite writes[] = {
681       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
682   };
683 
684   Initialize(base::span<MockRead>(), writes);
685 
686   AssertSyncWriteEquals(kMsg1, kLen1);
687 }
688 
TEST_F(SequencedSocketDataTest,MultipleSyncWrites)689 TEST_F(SequencedSocketDataTest, MultipleSyncWrites) {
690   MockWrite writes[] = {
691       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
692       MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
693       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
694       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3),
695       MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),
696       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5),
697       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),
698   };
699 
700   Initialize(base::span<MockRead>(), writes);
701 
702   AssertSyncWriteEquals(kMsg1, kLen1);
703   AssertSyncWriteEquals(kMsg2, kLen2);
704   AssertSyncWriteEquals(kMsg3, kLen3);
705   AssertSyncWriteEquals(kMsg3, kLen3);
706   AssertSyncWriteEquals(kMsg2, kLen2);
707   AssertSyncWriteEquals(kMsg3, kLen3);
708   AssertSyncWriteEquals(kMsg1, kLen1);
709 }
710 
TEST_F(SequencedSocketDataTest,SingleAsyncWrite)711 TEST_F(SequencedSocketDataTest, SingleAsyncWrite) {
712   MockWrite writes[] = {
713       MockWrite(ASYNC, kMsg1, kLen1, 0),
714   };
715 
716   Initialize(base::span<MockRead>(), writes);
717 
718   AssertAsyncWriteEquals(kMsg1, kLen1);
719 }
720 
TEST_F(SequencedSocketDataTest,MultipleAsyncWrites)721 TEST_F(SequencedSocketDataTest, MultipleAsyncWrites) {
722   MockWrite writes[] = {
723       MockWrite(ASYNC, kMsg1, kLen1, 0),
724       MockWrite(ASYNC, kMsg2, kLen2, 1),
725       MockWrite(ASYNC, kMsg3, kLen3, 2),
726       MockWrite(ASYNC, kMsg3, kLen3, 3),
727       MockWrite(ASYNC, kMsg2, kLen2, 4),
728       MockWrite(ASYNC, kMsg3, kLen3, 5),
729       MockWrite(ASYNC, kMsg1, kLen1, 6),
730   };
731 
732   Initialize(base::span<MockRead>(), writes);
733 
734   AssertAsyncWriteEquals(kMsg1, kLen1);
735   AssertAsyncWriteEquals(kMsg2, kLen2);
736   AssertAsyncWriteEquals(kMsg3, kLen3);
737   AssertAsyncWriteEquals(kMsg3, kLen3);
738   AssertAsyncWriteEquals(kMsg2, kLen2);
739   AssertAsyncWriteEquals(kMsg3, kLen3);
740   AssertAsyncWriteEquals(kMsg1, kLen1);
741 }
742 
TEST_F(SequencedSocketDataTest,MixedWrites)743 TEST_F(SequencedSocketDataTest, MixedWrites) {
744   MockWrite writes[] = {
745       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
746       MockWrite(ASYNC, kMsg2, kLen2, 1),
747       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
748       MockWrite(ASYNC, kMsg3, kLen3, 3),
749       MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),
750       MockWrite(ASYNC, kMsg3, kLen3, 5),
751       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),
752   };
753 
754   Initialize(base::span<MockRead>(), writes);
755 
756   AssertSyncWriteEquals(kMsg1, kLen1);
757   AssertAsyncWriteEquals(kMsg2, kLen2);
758   AssertSyncWriteEquals(kMsg3, kLen3);
759   AssertAsyncWriteEquals(kMsg3, kLen3);
760   AssertSyncWriteEquals(kMsg2, kLen2);
761   AssertAsyncWriteEquals(kMsg3, kLen3);
762   AssertSyncWriteEquals(kMsg1, kLen1);
763 }
764 
TEST_F(SequencedSocketDataTest,SyncWriteFromCompletionCallback)765 TEST_F(SequencedSocketDataTest, SyncWriteFromCompletionCallback) {
766   MockWrite writes[] = {
767       MockWrite(ASYNC, kMsg1, kLen1, 0),
768       MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
769   };
770 
771   Initialize(base::span<MockRead>(), writes);
772 
773   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
774   memcpy(write_buf->data(), kMsg1, kLen1);
775   ASSERT_EQ(
776       ERR_IO_PENDING,
777       sock_->Write(
778           write_buf.get(), kLen1,
779           base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
780                          base::Unretained(this), kLen1, kMsg2, kLen2, kLen2),
781           TRAFFIC_ANNOTATION_FOR_TESTS));
782 
783   base::RunLoop().RunUntilIdle();
784 }
785 
TEST_F(SequencedSocketDataTest,AsyncWriteFromCompletionCallback)786 TEST_F(SequencedSocketDataTest, AsyncWriteFromCompletionCallback) {
787   MockWrite writes[] = {
788       MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg2, kLen2, 1),
789   };
790 
791   Initialize(base::span<MockRead>(), writes);
792 
793   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
794   memcpy(write_buf->data(), kMsg1, kLen1);
795   ASSERT_EQ(ERR_IO_PENDING,
796             sock_->Write(
797                 write_buf.get(), kLen1,
798                 base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
799                                base::Unretained(this), kLen1, kMsg2, kLen2,
800                                ERR_IO_PENDING),
801                 TRAFFIC_ANNOTATION_FOR_TESTS));
802 
803   ASSERT_FALSE(write_callback_.have_result());
804   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
805 }
806 
TEST_F(SequencedSocketDataTest,ManyReentrantWrites)807 TEST_F(SequencedSocketDataTest, ManyReentrantWrites) {
808   MockWrite writes[] = {
809       MockWrite(ASYNC, kMsg1, kLen1, 0),
810       MockWrite(ASYNC, kMsg2, kLen2, 1),
811       MockWrite(ASYNC, kMsg3, kLen3, 2),
812       MockWrite(ASYNC, kMsg4, kLen4, 3),
813   };
814 
815   Initialize(base::span<MockRead>(), writes);
816 
817   ReentrantHelper helper3(sock_.get());
818   helper3.SetExpectedWrite(kLen3);
819   helper3.SetInvokeWrite(kMsg4, kLen4, ERR_IO_PENDING,
820                          write_callback_.callback());
821 
822   ReentrantHelper helper2(sock_.get());
823   helper2.SetExpectedWrite(kLen2);
824   helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
825 
826   ReentrantHelper helper(sock_.get());
827   helper.SetExpectedWrite(kLen1);
828   helper.SetInvokeWrite(kMsg2, kLen2, ERR_IO_PENDING, helper2.callback());
829 
830   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
831   memcpy(write_buf->data(), kMsg1, kLen1);
832   sock_->Write(write_buf.get(), kLen1, helper.callback(),
833                TRAFFIC_ANNOTATION_FOR_TESTS);
834 
835   ASSERT_EQ(kLen4, write_callback_.WaitForResult());
836 }
837 
838 // ----------- Mixed Reads and Writes
839 
TEST_F(SequencedSocketDataTest,MixedSyncOperations)840 TEST_F(SequencedSocketDataTest, MixedSyncOperations) {
841   MockRead reads[] = {
842       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
843       MockRead(SYNCHRONOUS, kMsg2, kLen2, 3),
844   };
845 
846   MockWrite writes[] = {
847       MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
848       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
849   };
850 
851   Initialize(reads, writes);
852 
853   AssertSyncReadEquals(kMsg1, kLen1);
854   AssertSyncWriteEquals(kMsg2, kLen2);
855   AssertSyncWriteEquals(kMsg3, kLen3);
856   AssertSyncReadEquals(kMsg2, kLen2);
857 }
858 
TEST_F(SequencedSocketDataTest,MixedAsyncOperations)859 TEST_F(SequencedSocketDataTest, MixedAsyncOperations) {
860   MockRead reads[] = {
861       MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg2, kLen2, 3),
862   };
863 
864   MockWrite writes[] = {
865       MockWrite(ASYNC, kMsg2, kLen2, 1), MockWrite(ASYNC, kMsg3, kLen3, 2),
866   };
867 
868   Initialize(reads, writes);
869 
870   AssertAsyncReadEquals(kMsg1, kLen1);
871   AssertAsyncWriteEquals(kMsg2, kLen2);
872   AssertAsyncWriteEquals(kMsg3, kLen3);
873   AssertAsyncReadEquals(kMsg2, kLen2);
874 }
875 
TEST_F(SequencedSocketDataTest,InterleavedAsyncOperations)876 TEST_F(SequencedSocketDataTest, InterleavedAsyncOperations) {
877   // Order of completion is read, write, write, read.
878   MockRead reads[] = {
879       MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg2, kLen2, 3),
880   };
881 
882   MockWrite writes[] = {
883       MockWrite(ASYNC, kMsg2, kLen2, 1), MockWrite(ASYNC, kMsg3, kLen3, 2),
884   };
885 
886   Initialize(reads, writes);
887 
888   // Issue the write, which will block until the read completes.
889   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
890 
891   // Issue the read which will return first.
892   AssertReadReturns(kLen1, ERR_IO_PENDING);
893 
894   ASSERT_EQ(kLen1, read_callback_.WaitForResult());
895   AssertReadBufferEquals(kMsg1, kLen1);
896 
897   // Run posted OnWriteComplete().
898   base::RunLoop().RunUntilIdle();
899 
900   ASSERT_TRUE(write_callback_.have_result());
901   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
902 
903   // Issue the read, which will block until the write completes.
904   AssertReadReturns(kLen2, ERR_IO_PENDING);
905 
906   // Issue the writes which will return first.
907   AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
908   ASSERT_EQ(kLen3, write_callback_.WaitForResult());
909 
910   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
911   AssertReadBufferEquals(kMsg2, kLen2);
912 }
913 
TEST_F(SequencedSocketDataTest,InterleavedMixedOperations)914 TEST_F(SequencedSocketDataTest, InterleavedMixedOperations) {
915   // Order of completion is read, write, write, read.
916   MockRead reads[] = {
917       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
918       MockRead(ASYNC, kMsg2, kLen2, 3),
919       MockRead(ASYNC, kMsg3, kLen3, 5),
920   };
921 
922   MockWrite writes[] = {
923       MockWrite(ASYNC, kMsg2, kLen2, 1),
924       MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
925       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 4),
926   };
927 
928   Initialize(reads, writes);
929 
930   // Issue the write, which will block until the read completes.
931   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
932 
933   // Issue the writes which will complete immediately.
934   AssertSyncReadEquals(kMsg1, kLen1);
935 
936   ASSERT_FALSE(write_callback_.have_result());
937   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
938 
939   // Issue the read, which will block until the write completes.
940   AssertReadReturns(kLen2, ERR_IO_PENDING);
941 
942   // Issue the writes which will complete immediately.
943   AssertSyncWriteEquals(kMsg3, kLen3);
944 
945   ASSERT_FALSE(read_callback_.have_result());
946   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
947   AssertReadBufferEquals(kMsg2, kLen2);
948 
949   // Issue the read, which will block until the write completes.
950   AssertReadReturns(kLen2, ERR_IO_PENDING);
951 
952   // Issue the writes which will complete immediately.
953   AssertSyncWriteEquals(kMsg1, kLen1);
954 
955   ASSERT_FALSE(read_callback_.have_result());
956   ASSERT_EQ(kLen3, read_callback_.WaitForResult());
957   AssertReadBufferEquals(kMsg3, kLen3);
958 }
959 
TEST_F(SequencedSocketDataTest,AsyncReadFromWriteCompletionCallback)960 TEST_F(SequencedSocketDataTest, AsyncReadFromWriteCompletionCallback) {
961   MockWrite writes[] = {
962       MockWrite(ASYNC, kMsg1, kLen1, 0),
963   };
964 
965   MockRead reads[] = {
966       MockRead(ASYNC, kMsg2, kLen2, 1),
967   };
968 
969   Initialize(reads, writes);
970 
971   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
972   memcpy(write_buf->data(), kMsg1, kLen1);
973   ASSERT_EQ(
974       ERR_IO_PENDING,
975       sock_->Write(
976           write_buf.get(), kLen1,
977           base::BindOnce(&SequencedSocketDataTest::ReentrantAsyncReadCallback,
978                          base::Unretained(this), kLen1, kLen2),
979           TRAFFIC_ANNOTATION_FOR_TESTS));
980 
981   ASSERT_FALSE(read_callback_.have_result());
982   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
983   AssertReadBufferEquals(kMsg2, kLen2);
984 }
985 
TEST_F(SequencedSocketDataTest,AsyncWriteFromReadCompletionCallback)986 TEST_F(SequencedSocketDataTest, AsyncWriteFromReadCompletionCallback) {
987   MockWrite writes[] = {
988       MockWrite(ASYNC, kMsg2, kLen2, 1),
989   };
990 
991   MockRead reads[] = {
992       MockRead(ASYNC, kMsg1, kLen1, 0),
993   };
994 
995   Initialize(reads, writes);
996 
997   auto read_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
998   ASSERT_EQ(
999       ERR_IO_PENDING,
1000       sock_->Read(
1001           read_buf.get(), kLen1,
1002           base::BindOnce(&SequencedSocketDataTest::ReentrantAsyncWriteCallback,
1003                          base::Unretained(this), kMsg2, kLen2,
1004                          write_callback_.callback(), kLen1)));
1005 
1006   ASSERT_FALSE(write_callback_.have_result());
1007   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
1008 }
1009 
TEST_F(SequencedSocketDataTest,MixedReentrantOperations)1010 TEST_F(SequencedSocketDataTest, MixedReentrantOperations) {
1011   MockWrite writes[] = {
1012       MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg3, kLen3, 2),
1013   };
1014 
1015   MockRead reads[] = {
1016       MockRead(ASYNC, kMsg2, kLen2, 1), MockRead(ASYNC, kMsg4, kLen4, 3),
1017   };
1018 
1019   Initialize(reads, writes);
1020 
1021   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1022 
1023   ReentrantHelper helper3(sock_.get());
1024   helper3.SetExpectedWrite(kLen3);
1025   helper3.SetInvokeRead(read_buf_, kLen4, ERR_IO_PENDING,
1026                         read_callback_.callback());
1027 
1028   ReentrantHelper helper2(sock_.get());
1029   helper2.SetExpectedRead(kMsg2, kLen2);
1030   helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
1031 
1032   ReentrantHelper helper(sock_.get());
1033   helper.SetExpectedWrite(kLen1);
1034   helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
1035                        helper2.callback());
1036 
1037   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
1038   memcpy(write_buf->data(), kMsg1, kLen1);
1039   sock_->Write(write_buf.get(), kLen1, helper.callback(),
1040                TRAFFIC_ANNOTATION_FOR_TESTS);
1041 
1042   ASSERT_EQ(kLen4, read_callback_.WaitForResult());
1043 }
1044 
TEST_F(SequencedSocketDataTest,MixedReentrantOperationsThenSynchronousRead)1045 TEST_F(SequencedSocketDataTest, MixedReentrantOperationsThenSynchronousRead) {
1046   MockWrite writes[] = {
1047       MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg3, kLen3, 2),
1048   };
1049 
1050   MockRead reads[] = {
1051       MockRead(ASYNC, kMsg2, kLen2, 1), MockRead(SYNCHRONOUS, kMsg4, kLen4, 3),
1052   };
1053 
1054   Initialize(reads, writes);
1055 
1056   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1057 
1058   ReentrantHelper helper3(sock_.get());
1059   helper3.SetExpectedWrite(kLen3);
1060   helper3.SetInvokeRead(read_buf_, kLen4, kLen4, failing_callback());
1061 
1062   ReentrantHelper helper2(sock_.get());
1063   helper2.SetExpectedRead(kMsg2, kLen2);
1064   helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
1065 
1066   ReentrantHelper helper(sock_.get());
1067   helper.SetExpectedWrite(kLen1);
1068   helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
1069                        helper2.callback());
1070 
1071   auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
1072   memcpy(write_buf->data(), kMsg1, kLen1);
1073   ASSERT_EQ(ERR_IO_PENDING,
1074             sock_->Write(write_buf.get(), kLen1, helper.callback(),
1075                          TRAFFIC_ANNOTATION_FOR_TESTS));
1076 
1077   base::RunLoop().RunUntilIdle();
1078   AssertReadBufferEquals(kMsg4, kLen4);
1079 }
1080 
TEST_F(SequencedSocketDataTest,MixedReentrantOperationsThenSynchronousWrite)1081 TEST_F(SequencedSocketDataTest, MixedReentrantOperationsThenSynchronousWrite) {
1082   MockWrite writes[] = {
1083       MockWrite(ASYNC, kMsg2, kLen2, 1),
1084       MockWrite(SYNCHRONOUS, kMsg4, kLen4, 3),
1085   };
1086 
1087   MockRead reads[] = {
1088       MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg3, kLen3, 2),
1089   };
1090 
1091   Initialize(reads, writes);
1092 
1093   read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1094 
1095   ReentrantHelper helper3(sock_.get());
1096   helper3.SetExpectedRead(kMsg3, kLen3);
1097   helper3.SetInvokeWrite(kMsg4, kLen4, kLen4, failing_callback());
1098 
1099   ReentrantHelper helper2(sock_.get());
1100   helper2.SetExpectedWrite(kLen2);
1101   helper2.SetInvokeRead(helper3.read_buf(), kLen3, ERR_IO_PENDING,
1102                         helper3.callback());
1103 
1104   ReentrantHelper helper(sock_.get());
1105   helper.SetExpectedRead(kMsg1, kLen1);
1106   helper.SetInvokeWrite(kMsg2, kLen2, ERR_IO_PENDING, helper2.callback());
1107 
1108   ASSERT_EQ(ERR_IO_PENDING,
1109             sock_->Read(helper.read_buf().get(), kLen1, helper.callback()));
1110 
1111   base::RunLoop().RunUntilIdle();
1112 }
1113 
1114 // Test the basic case where a read is paused.
TEST_F(SequencedSocketDataTest,PauseAndResume_PauseRead)1115 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseRead) {
1116   MockRead reads[] = {
1117       MockRead(ASYNC, ERR_IO_PENDING, 0), MockRead(ASYNC, kMsg1, kLen1, 1),
1118   };
1119 
1120   Initialize(reads, base::span<MockWrite>());
1121 
1122   AssertReadReturns(kLen1, ERR_IO_PENDING);
1123   ASSERT_FALSE(read_callback_.have_result());
1124 
1125   RunUntilPaused();
1126   ASSERT_TRUE(IsPaused());
1127 
1128   // Spinning the message loop should do nothing.
1129   base::RunLoop().RunUntilIdle();
1130   ASSERT_FALSE(read_callback_.have_result());
1131   ASSERT_TRUE(IsPaused());
1132 
1133   Resume();
1134   ASSERT_FALSE(IsPaused());
1135   ASSERT_TRUE(read_callback_.have_result());
1136   ASSERT_EQ(kLen1, read_callback_.WaitForResult());
1137   AssertReadBufferEquals(kMsg1, kLen1);
1138 }
1139 
1140 // Test the case where a read that will be paused is started before write that
1141 // completes before the pause.
TEST_F(SequencedSocketDataTest,PauseAndResume_WritePauseRead)1142 TEST_F(SequencedSocketDataTest, PauseAndResume_WritePauseRead) {
1143   MockWrite writes[] = {
1144       MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
1145   };
1146 
1147   MockRead reads[] = {
1148       MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, kMsg2, kLen2, 2),
1149   };
1150 
1151   Initialize(reads, writes);
1152 
1153   AssertReadReturns(kLen2, ERR_IO_PENDING);
1154   ASSERT_FALSE(read_callback_.have_result());
1155 
1156   // Nothing should happen until the write starts.
1157   base::RunLoop().RunUntilIdle();
1158   ASSERT_FALSE(read_callback_.have_result());
1159   ASSERT_FALSE(IsPaused());
1160 
1161   AssertSyncWriteEquals(kMsg1, kLen1);
1162 
1163   RunUntilPaused();
1164   ASSERT_FALSE(read_callback_.have_result());
1165   ASSERT_TRUE(IsPaused());
1166 
1167   // Spinning the message loop should do nothing.
1168   base::RunLoop().RunUntilIdle();
1169   ASSERT_FALSE(read_callback_.have_result());
1170   ASSERT_TRUE(IsPaused());
1171 
1172   Resume();
1173   ASSERT_FALSE(IsPaused());
1174   ASSERT_TRUE(read_callback_.have_result());
1175   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
1176   AssertReadBufferEquals(kMsg2, kLen2);
1177 }
1178 
1179 // Test the basic case where a write is paused.
TEST_F(SequencedSocketDataTest,PauseAndResume_PauseWrite)1180 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseWrite) {
1181   MockWrite writes[] = {
1182       MockWrite(ASYNC, ERR_IO_PENDING, 0), MockWrite(ASYNC, kMsg1, kLen1, 1),
1183   };
1184 
1185   Initialize(base::span<MockRead>(), writes);
1186 
1187   AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
1188   ASSERT_FALSE(write_callback_.have_result());
1189 
1190   RunUntilPaused();
1191   ASSERT_TRUE(IsPaused());
1192 
1193   // Spinning the message loop should do nothing.
1194   base::RunLoop().RunUntilIdle();
1195   ASSERT_FALSE(write_callback_.have_result());
1196   ASSERT_TRUE(IsPaused());
1197 
1198   Resume();
1199   ASSERT_FALSE(IsPaused());
1200   ASSERT_TRUE(write_callback_.have_result());
1201   ASSERT_EQ(kLen1, write_callback_.WaitForResult());
1202 }
1203 
1204 // Test the case where a write that will be paused is started before read that
1205 // completes before the pause.
TEST_F(SequencedSocketDataTest,PauseAndResume_ReadPauseWrite)1206 TEST_F(SequencedSocketDataTest, PauseAndResume_ReadPauseWrite) {
1207   MockWrite writes[] = {
1208       MockWrite(ASYNC, ERR_IO_PENDING, 1), MockWrite(ASYNC, kMsg2, kLen2, 2),
1209   };
1210 
1211   MockRead reads[] = {
1212       MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
1213   };
1214 
1215   Initialize(reads, writes);
1216 
1217   AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
1218   ASSERT_FALSE(write_callback_.have_result());
1219 
1220   // Nothing should happen until the write starts.
1221   base::RunLoop().RunUntilIdle();
1222   ASSERT_FALSE(write_callback_.have_result());
1223   ASSERT_FALSE(IsPaused());
1224 
1225   AssertSyncReadEquals(kMsg1, kLen1);
1226 
1227   RunUntilPaused();
1228   ASSERT_FALSE(write_callback_.have_result());
1229   ASSERT_TRUE(IsPaused());
1230 
1231   // Spinning the message loop should do nothing.
1232   base::RunLoop().RunUntilIdle();
1233   ASSERT_FALSE(write_callback_.have_result());
1234   ASSERT_TRUE(IsPaused());
1235 
1236   Resume();
1237   ASSERT_FALSE(IsPaused());
1238   ASSERT_TRUE(write_callback_.have_result());
1239   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
1240 }
1241 
1242 }  // namespace
1243 
1244 }  // namespace net
1245