sequenced_socket_data_unittest.cc 40 KB

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