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 >est_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