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 "Expected: (data.length()) >= (expected_data.length())",
652 "Value of: actual_data == expected_data\n Actual: false\nExpected: true",
653 "Expected equality of these values:\n rv"};
654 ASSERT_EQ(std::size(kExpectedFailures),
655 static_cast<size_t>(gtest_failures.size()));
656
657 for (int i = 0; i < gtest_failures.size(); ++i) {
658 const ::testing::TestPartResult& result =
659 gtest_failures.GetTestPartResult(i);
660 EXPECT_TRUE(strstr(result.message(), kExpectedFailures[i]) != nullptr);
661 }
662
663 set_expect_eof(false);
664 }
665
TEST_F(SequencedSocketDataTest,SingleSyncPartialWrite)666 TEST_F(SequencedSocketDataTest, SingleSyncPartialWrite) {
667 MockWrite writes[] = {
668 MockWrite(SYNCHRONOUS, kMsg1, kLen1 - 1, 0),
669 MockWrite(SYNCHRONOUS, kMsg1 + kLen1 - 1, 1, 1),
670 };
671
672 Initialize(base::span<MockRead>(), writes);
673
674 // Attempt to write all of the message, but only some will be written.
675 AssertSyncWriteEquals(kMsg1, kLen1 - 1);
676 // Write the rest of the message.
677 AssertSyncWriteEquals(kMsg1 + kLen1 - 1, 1);
678 }
679
TEST_F(SequencedSocketDataTest,SingleSyncWrite)680 TEST_F(SequencedSocketDataTest, SingleSyncWrite) {
681 MockWrite writes[] = {
682 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
683 };
684
685 Initialize(base::span<MockRead>(), writes);
686
687 AssertSyncWriteEquals(kMsg1, kLen1);
688 }
689
TEST_F(SequencedSocketDataTest,MultipleSyncWrites)690 TEST_F(SequencedSocketDataTest, MultipleSyncWrites) {
691 MockWrite writes[] = {
692 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
693 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
694 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
695 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3),
696 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),
697 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5),
698 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),
699 };
700
701 Initialize(base::span<MockRead>(), writes);
702
703 AssertSyncWriteEquals(kMsg1, kLen1);
704 AssertSyncWriteEquals(kMsg2, kLen2);
705 AssertSyncWriteEquals(kMsg3, kLen3);
706 AssertSyncWriteEquals(kMsg3, kLen3);
707 AssertSyncWriteEquals(kMsg2, kLen2);
708 AssertSyncWriteEquals(kMsg3, kLen3);
709 AssertSyncWriteEquals(kMsg1, kLen1);
710 }
711
TEST_F(SequencedSocketDataTest,SingleAsyncWrite)712 TEST_F(SequencedSocketDataTest, SingleAsyncWrite) {
713 MockWrite writes[] = {
714 MockWrite(ASYNC, kMsg1, kLen1, 0),
715 };
716
717 Initialize(base::span<MockRead>(), writes);
718
719 AssertAsyncWriteEquals(kMsg1, kLen1);
720 }
721
TEST_F(SequencedSocketDataTest,MultipleAsyncWrites)722 TEST_F(SequencedSocketDataTest, MultipleAsyncWrites) {
723 MockWrite writes[] = {
724 MockWrite(ASYNC, kMsg1, kLen1, 0),
725 MockWrite(ASYNC, kMsg2, kLen2, 1),
726 MockWrite(ASYNC, kMsg3, kLen3, 2),
727 MockWrite(ASYNC, kMsg3, kLen3, 3),
728 MockWrite(ASYNC, kMsg2, kLen2, 4),
729 MockWrite(ASYNC, kMsg3, kLen3, 5),
730 MockWrite(ASYNC, kMsg1, kLen1, 6),
731 };
732
733 Initialize(base::span<MockRead>(), writes);
734
735 AssertAsyncWriteEquals(kMsg1, kLen1);
736 AssertAsyncWriteEquals(kMsg2, kLen2);
737 AssertAsyncWriteEquals(kMsg3, kLen3);
738 AssertAsyncWriteEquals(kMsg3, kLen3);
739 AssertAsyncWriteEquals(kMsg2, kLen2);
740 AssertAsyncWriteEquals(kMsg3, kLen3);
741 AssertAsyncWriteEquals(kMsg1, kLen1);
742 }
743
TEST_F(SequencedSocketDataTest,MixedWrites)744 TEST_F(SequencedSocketDataTest, MixedWrites) {
745 MockWrite writes[] = {
746 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
747 MockWrite(ASYNC, kMsg2, kLen2, 1),
748 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
749 MockWrite(ASYNC, kMsg3, kLen3, 3),
750 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4),
751 MockWrite(ASYNC, kMsg3, kLen3, 5),
752 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6),
753 };
754
755 Initialize(base::span<MockRead>(), writes);
756
757 AssertSyncWriteEquals(kMsg1, kLen1);
758 AssertAsyncWriteEquals(kMsg2, kLen2);
759 AssertSyncWriteEquals(kMsg3, kLen3);
760 AssertAsyncWriteEquals(kMsg3, kLen3);
761 AssertSyncWriteEquals(kMsg2, kLen2);
762 AssertAsyncWriteEquals(kMsg3, kLen3);
763 AssertSyncWriteEquals(kMsg1, kLen1);
764 }
765
TEST_F(SequencedSocketDataTest,SyncWriteFromCompletionCallback)766 TEST_F(SequencedSocketDataTest, SyncWriteFromCompletionCallback) {
767 MockWrite writes[] = {
768 MockWrite(ASYNC, kMsg1, kLen1, 0),
769 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
770 };
771
772 Initialize(base::span<MockRead>(), writes);
773
774 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
775 memcpy(write_buf->data(), kMsg1, kLen1);
776 ASSERT_EQ(
777 ERR_IO_PENDING,
778 sock_->Write(
779 write_buf.get(), kLen1,
780 base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
781 base::Unretained(this), kLen1, kMsg2, kLen2, kLen2),
782 TRAFFIC_ANNOTATION_FOR_TESTS));
783
784 base::RunLoop().RunUntilIdle();
785 }
786
TEST_F(SequencedSocketDataTest,AsyncWriteFromCompletionCallback)787 TEST_F(SequencedSocketDataTest, AsyncWriteFromCompletionCallback) {
788 MockWrite writes[] = {
789 MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg2, kLen2, 1),
790 };
791
792 Initialize(base::span<MockRead>(), writes);
793
794 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
795 memcpy(write_buf->data(), kMsg1, kLen1);
796 ASSERT_EQ(ERR_IO_PENDING,
797 sock_->Write(
798 write_buf.get(), kLen1,
799 base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
800 base::Unretained(this), kLen1, kMsg2, kLen2,
801 ERR_IO_PENDING),
802 TRAFFIC_ANNOTATION_FOR_TESTS));
803
804 ASSERT_FALSE(write_callback_.have_result());
805 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
806 }
807
TEST_F(SequencedSocketDataTest,ManyReentrantWrites)808 TEST_F(SequencedSocketDataTest, ManyReentrantWrites) {
809 MockWrite writes[] = {
810 MockWrite(ASYNC, kMsg1, kLen1, 0),
811 MockWrite(ASYNC, kMsg2, kLen2, 1),
812 MockWrite(ASYNC, kMsg3, kLen3, 2),
813 MockWrite(ASYNC, kMsg4, kLen4, 3),
814 };
815
816 Initialize(base::span<MockRead>(), writes);
817
818 ReentrantHelper helper3(sock_.get());
819 helper3.SetExpectedWrite(kLen3);
820 helper3.SetInvokeWrite(kMsg4, kLen4, ERR_IO_PENDING,
821 write_callback_.callback());
822
823 ReentrantHelper helper2(sock_.get());
824 helper2.SetExpectedWrite(kLen2);
825 helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
826
827 ReentrantHelper helper(sock_.get());
828 helper.SetExpectedWrite(kLen1);
829 helper.SetInvokeWrite(kMsg2, kLen2, ERR_IO_PENDING, helper2.callback());
830
831 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
832 memcpy(write_buf->data(), kMsg1, kLen1);
833 sock_->Write(write_buf.get(), kLen1, helper.callback(),
834 TRAFFIC_ANNOTATION_FOR_TESTS);
835
836 ASSERT_EQ(kLen4, write_callback_.WaitForResult());
837 }
838
839 // ----------- Mixed Reads and Writes
840
TEST_F(SequencedSocketDataTest,MixedSyncOperations)841 TEST_F(SequencedSocketDataTest, MixedSyncOperations) {
842 MockRead reads[] = {
843 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
844 MockRead(SYNCHRONOUS, kMsg2, kLen2, 3),
845 };
846
847 MockWrite writes[] = {
848 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1),
849 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
850 };
851
852 Initialize(reads, writes);
853
854 AssertSyncReadEquals(kMsg1, kLen1);
855 AssertSyncWriteEquals(kMsg2, kLen2);
856 AssertSyncWriteEquals(kMsg3, kLen3);
857 AssertSyncReadEquals(kMsg2, kLen2);
858 }
859
TEST_F(SequencedSocketDataTest,MixedAsyncOperations)860 TEST_F(SequencedSocketDataTest, MixedAsyncOperations) {
861 MockRead reads[] = {
862 MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg2, kLen2, 3),
863 };
864
865 MockWrite writes[] = {
866 MockWrite(ASYNC, kMsg2, kLen2, 1), MockWrite(ASYNC, kMsg3, kLen3, 2),
867 };
868
869 Initialize(reads, writes);
870
871 AssertAsyncReadEquals(kMsg1, kLen1);
872 AssertAsyncWriteEquals(kMsg2, kLen2);
873 AssertAsyncWriteEquals(kMsg3, kLen3);
874 AssertAsyncReadEquals(kMsg2, kLen2);
875 }
876
TEST_F(SequencedSocketDataTest,InterleavedAsyncOperations)877 TEST_F(SequencedSocketDataTest, InterleavedAsyncOperations) {
878 // Order of completion is read, write, write, read.
879 MockRead reads[] = {
880 MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg2, kLen2, 3),
881 };
882
883 MockWrite writes[] = {
884 MockWrite(ASYNC, kMsg2, kLen2, 1), MockWrite(ASYNC, kMsg3, kLen3, 2),
885 };
886
887 Initialize(reads, writes);
888
889 // Issue the write, which will block until the read completes.
890 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
891
892 // Issue the read which will return first.
893 AssertReadReturns(kLen1, ERR_IO_PENDING);
894
895 ASSERT_EQ(kLen1, read_callback_.WaitForResult());
896 AssertReadBufferEquals(kMsg1, kLen1);
897
898 // Run posted OnWriteComplete().
899 base::RunLoop().RunUntilIdle();
900
901 ASSERT_TRUE(write_callback_.have_result());
902 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
903
904 // Issue the read, which will block until the write completes.
905 AssertReadReturns(kLen2, ERR_IO_PENDING);
906
907 // Issue the writes which will return first.
908 AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
909 ASSERT_EQ(kLen3, write_callback_.WaitForResult());
910
911 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
912 AssertReadBufferEquals(kMsg2, kLen2);
913 }
914
TEST_F(SequencedSocketDataTest,InterleavedMixedOperations)915 TEST_F(SequencedSocketDataTest, InterleavedMixedOperations) {
916 // Order of completion is read, write, write, read.
917 MockRead reads[] = {
918 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
919 MockRead(ASYNC, kMsg2, kLen2, 3),
920 MockRead(ASYNC, kMsg3, kLen3, 5),
921 };
922
923 MockWrite writes[] = {
924 MockWrite(ASYNC, kMsg2, kLen2, 1),
925 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2),
926 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 4),
927 };
928
929 Initialize(reads, writes);
930
931 // Issue the write, which will block until the read completes.
932 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
933
934 // Issue the writes which will complete immediately.
935 AssertSyncReadEquals(kMsg1, kLen1);
936
937 ASSERT_FALSE(write_callback_.have_result());
938 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
939
940 // Issue the read, which will block until the write completes.
941 AssertReadReturns(kLen2, ERR_IO_PENDING);
942
943 // Issue the writes which will complete immediately.
944 AssertSyncWriteEquals(kMsg3, kLen3);
945
946 ASSERT_FALSE(read_callback_.have_result());
947 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
948 AssertReadBufferEquals(kMsg2, kLen2);
949
950 // Issue the read, which will block until the write completes.
951 AssertReadReturns(kLen2, ERR_IO_PENDING);
952
953 // Issue the writes which will complete immediately.
954 AssertSyncWriteEquals(kMsg1, kLen1);
955
956 ASSERT_FALSE(read_callback_.have_result());
957 ASSERT_EQ(kLen3, read_callback_.WaitForResult());
958 AssertReadBufferEquals(kMsg3, kLen3);
959 }
960
TEST_F(SequencedSocketDataTest,AsyncReadFromWriteCompletionCallback)961 TEST_F(SequencedSocketDataTest, AsyncReadFromWriteCompletionCallback) {
962 MockWrite writes[] = {
963 MockWrite(ASYNC, kMsg1, kLen1, 0),
964 };
965
966 MockRead reads[] = {
967 MockRead(ASYNC, kMsg2, kLen2, 1),
968 };
969
970 Initialize(reads, writes);
971
972 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
973 memcpy(write_buf->data(), kMsg1, kLen1);
974 ASSERT_EQ(
975 ERR_IO_PENDING,
976 sock_->Write(
977 write_buf.get(), kLen1,
978 base::BindOnce(&SequencedSocketDataTest::ReentrantAsyncReadCallback,
979 base::Unretained(this), kLen1, kLen2),
980 TRAFFIC_ANNOTATION_FOR_TESTS));
981
982 ASSERT_FALSE(read_callback_.have_result());
983 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
984 AssertReadBufferEquals(kMsg2, kLen2);
985 }
986
TEST_F(SequencedSocketDataTest,AsyncWriteFromReadCompletionCallback)987 TEST_F(SequencedSocketDataTest, AsyncWriteFromReadCompletionCallback) {
988 MockWrite writes[] = {
989 MockWrite(ASYNC, kMsg2, kLen2, 1),
990 };
991
992 MockRead reads[] = {
993 MockRead(ASYNC, kMsg1, kLen1, 0),
994 };
995
996 Initialize(reads, writes);
997
998 auto read_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
999 ASSERT_EQ(
1000 ERR_IO_PENDING,
1001 sock_->Read(
1002 read_buf.get(), kLen1,
1003 base::BindOnce(&SequencedSocketDataTest::ReentrantAsyncWriteCallback,
1004 base::Unretained(this), kMsg2, kLen2,
1005 write_callback_.callback(), kLen1)));
1006
1007 ASSERT_FALSE(write_callback_.have_result());
1008 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
1009 }
1010
TEST_F(SequencedSocketDataTest,MixedReentrantOperations)1011 TEST_F(SequencedSocketDataTest, MixedReentrantOperations) {
1012 MockWrite writes[] = {
1013 MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg3, kLen3, 2),
1014 };
1015
1016 MockRead reads[] = {
1017 MockRead(ASYNC, kMsg2, kLen2, 1), MockRead(ASYNC, kMsg4, kLen4, 3),
1018 };
1019
1020 Initialize(reads, writes);
1021
1022 read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1023
1024 ReentrantHelper helper3(sock_.get());
1025 helper3.SetExpectedWrite(kLen3);
1026 helper3.SetInvokeRead(read_buf_, kLen4, ERR_IO_PENDING,
1027 read_callback_.callback());
1028
1029 ReentrantHelper helper2(sock_.get());
1030 helper2.SetExpectedRead(kMsg2, kLen2);
1031 helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
1032
1033 ReentrantHelper helper(sock_.get());
1034 helper.SetExpectedWrite(kLen1);
1035 helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
1036 helper2.callback());
1037
1038 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
1039 memcpy(write_buf->data(), kMsg1, kLen1);
1040 sock_->Write(write_buf.get(), kLen1, helper.callback(),
1041 TRAFFIC_ANNOTATION_FOR_TESTS);
1042
1043 ASSERT_EQ(kLen4, read_callback_.WaitForResult());
1044 }
1045
TEST_F(SequencedSocketDataTest,MixedReentrantOperationsThenSynchronousRead)1046 TEST_F(SequencedSocketDataTest, MixedReentrantOperationsThenSynchronousRead) {
1047 MockWrite writes[] = {
1048 MockWrite(ASYNC, kMsg1, kLen1, 0), MockWrite(ASYNC, kMsg3, kLen3, 2),
1049 };
1050
1051 MockRead reads[] = {
1052 MockRead(ASYNC, kMsg2, kLen2, 1), MockRead(SYNCHRONOUS, kMsg4, kLen4, 3),
1053 };
1054
1055 Initialize(reads, writes);
1056
1057 read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1058
1059 ReentrantHelper helper3(sock_.get());
1060 helper3.SetExpectedWrite(kLen3);
1061 helper3.SetInvokeRead(read_buf_, kLen4, kLen4, failing_callback());
1062
1063 ReentrantHelper helper2(sock_.get());
1064 helper2.SetExpectedRead(kMsg2, kLen2);
1065 helper2.SetInvokeWrite(kMsg3, kLen3, ERR_IO_PENDING, helper3.callback());
1066
1067 ReentrantHelper helper(sock_.get());
1068 helper.SetExpectedWrite(kLen1);
1069 helper.SetInvokeRead(helper2.read_buf(), kLen2, ERR_IO_PENDING,
1070 helper2.callback());
1071
1072 auto write_buf = base::MakeRefCounted<IOBufferWithSize>(kLen1);
1073 memcpy(write_buf->data(), kMsg1, kLen1);
1074 ASSERT_EQ(ERR_IO_PENDING,
1075 sock_->Write(write_buf.get(), kLen1, helper.callback(),
1076 TRAFFIC_ANNOTATION_FOR_TESTS));
1077
1078 base::RunLoop().RunUntilIdle();
1079 AssertReadBufferEquals(kMsg4, kLen4);
1080 }
1081
TEST_F(SequencedSocketDataTest,MixedReentrantOperationsThenSynchronousWrite)1082 TEST_F(SequencedSocketDataTest, MixedReentrantOperationsThenSynchronousWrite) {
1083 MockWrite writes[] = {
1084 MockWrite(ASYNC, kMsg2, kLen2, 1),
1085 MockWrite(SYNCHRONOUS, kMsg4, kLen4, 3),
1086 };
1087
1088 MockRead reads[] = {
1089 MockRead(ASYNC, kMsg1, kLen1, 0), MockRead(ASYNC, kMsg3, kLen3, 2),
1090 };
1091
1092 Initialize(reads, writes);
1093
1094 read_buf_ = base::MakeRefCounted<IOBufferWithSize>(kLen4);
1095
1096 ReentrantHelper helper3(sock_.get());
1097 helper3.SetExpectedRead(kMsg3, kLen3);
1098 helper3.SetInvokeWrite(kMsg4, kLen4, kLen4, failing_callback());
1099
1100 ReentrantHelper helper2(sock_.get());
1101 helper2.SetExpectedWrite(kLen2);
1102 helper2.SetInvokeRead(helper3.read_buf(), kLen3, ERR_IO_PENDING,
1103 helper3.callback());
1104
1105 ReentrantHelper helper(sock_.get());
1106 helper.SetExpectedRead(kMsg1, kLen1);
1107 helper.SetInvokeWrite(kMsg2, kLen2, ERR_IO_PENDING, helper2.callback());
1108
1109 ASSERT_EQ(ERR_IO_PENDING,
1110 sock_->Read(helper.read_buf().get(), kLen1, helper.callback()));
1111
1112 base::RunLoop().RunUntilIdle();
1113 }
1114
1115 // Test the basic case where a read is paused.
TEST_F(SequencedSocketDataTest,PauseAndResume_PauseRead)1116 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseRead) {
1117 MockRead reads[] = {
1118 MockRead(ASYNC, ERR_IO_PENDING, 0), MockRead(ASYNC, kMsg1, kLen1, 1),
1119 };
1120
1121 Initialize(reads, base::span<MockWrite>());
1122
1123 AssertReadReturns(kLen1, ERR_IO_PENDING);
1124 ASSERT_FALSE(read_callback_.have_result());
1125
1126 RunUntilPaused();
1127 ASSERT_TRUE(IsPaused());
1128
1129 // Spinning the message loop should do nothing.
1130 base::RunLoop().RunUntilIdle();
1131 ASSERT_FALSE(read_callback_.have_result());
1132 ASSERT_TRUE(IsPaused());
1133
1134 Resume();
1135 ASSERT_FALSE(IsPaused());
1136 ASSERT_TRUE(read_callback_.have_result());
1137 ASSERT_EQ(kLen1, read_callback_.WaitForResult());
1138 AssertReadBufferEquals(kMsg1, kLen1);
1139 }
1140
1141 // Test the case where a read that will be paused is started before write that
1142 // completes before the pause.
TEST_F(SequencedSocketDataTest,PauseAndResume_WritePauseRead)1143 TEST_F(SequencedSocketDataTest, PauseAndResume_WritePauseRead) {
1144 MockWrite writes[] = {
1145 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0),
1146 };
1147
1148 MockRead reads[] = {
1149 MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, kMsg2, kLen2, 2),
1150 };
1151
1152 Initialize(reads, writes);
1153
1154 AssertReadReturns(kLen2, ERR_IO_PENDING);
1155 ASSERT_FALSE(read_callback_.have_result());
1156
1157 // Nothing should happen until the write starts.
1158 base::RunLoop().RunUntilIdle();
1159 ASSERT_FALSE(read_callback_.have_result());
1160 ASSERT_FALSE(IsPaused());
1161
1162 AssertSyncWriteEquals(kMsg1, kLen1);
1163
1164 RunUntilPaused();
1165 ASSERT_FALSE(read_callback_.have_result());
1166 ASSERT_TRUE(IsPaused());
1167
1168 // Spinning the message loop should do nothing.
1169 base::RunLoop().RunUntilIdle();
1170 ASSERT_FALSE(read_callback_.have_result());
1171 ASSERT_TRUE(IsPaused());
1172
1173 Resume();
1174 ASSERT_FALSE(IsPaused());
1175 ASSERT_TRUE(read_callback_.have_result());
1176 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
1177 AssertReadBufferEquals(kMsg2, kLen2);
1178 }
1179
1180 // Test the basic case where a write is paused.
TEST_F(SequencedSocketDataTest,PauseAndResume_PauseWrite)1181 TEST_F(SequencedSocketDataTest, PauseAndResume_PauseWrite) {
1182 MockWrite writes[] = {
1183 MockWrite(ASYNC, ERR_IO_PENDING, 0), MockWrite(ASYNC, kMsg1, kLen1, 1),
1184 };
1185
1186 Initialize(base::span<MockRead>(), writes);
1187
1188 AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
1189 ASSERT_FALSE(write_callback_.have_result());
1190
1191 RunUntilPaused();
1192 ASSERT_TRUE(IsPaused());
1193
1194 // Spinning the message loop should do nothing.
1195 base::RunLoop().RunUntilIdle();
1196 ASSERT_FALSE(write_callback_.have_result());
1197 ASSERT_TRUE(IsPaused());
1198
1199 Resume();
1200 ASSERT_FALSE(IsPaused());
1201 ASSERT_TRUE(write_callback_.have_result());
1202 ASSERT_EQ(kLen1, write_callback_.WaitForResult());
1203 }
1204
1205 // Test the case where a write that will be paused is started before read that
1206 // completes before the pause.
TEST_F(SequencedSocketDataTest,PauseAndResume_ReadPauseWrite)1207 TEST_F(SequencedSocketDataTest, PauseAndResume_ReadPauseWrite) {
1208 MockWrite writes[] = {
1209 MockWrite(ASYNC, ERR_IO_PENDING, 1), MockWrite(ASYNC, kMsg2, kLen2, 2),
1210 };
1211
1212 MockRead reads[] = {
1213 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0),
1214 };
1215
1216 Initialize(reads, writes);
1217
1218 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
1219 ASSERT_FALSE(write_callback_.have_result());
1220
1221 // Nothing should happen until the write starts.
1222 base::RunLoop().RunUntilIdle();
1223 ASSERT_FALSE(write_callback_.have_result());
1224 ASSERT_FALSE(IsPaused());
1225
1226 AssertSyncReadEquals(kMsg1, kLen1);
1227
1228 RunUntilPaused();
1229 ASSERT_FALSE(write_callback_.have_result());
1230 ASSERT_TRUE(IsPaused());
1231
1232 // Spinning the message loop should do nothing.
1233 base::RunLoop().RunUntilIdle();
1234 ASSERT_FALSE(write_callback_.have_result());
1235 ASSERT_TRUE(IsPaused());
1236
1237 Resume();
1238 ASSERT_FALSE(IsPaused());
1239 ASSERT_TRUE(write_callback_.have_result());
1240 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
1241 }
1242
1243 } // namespace
1244
1245 } // namespace net
1246