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