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