1 // Copyright (c) 2012 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
5 #include "net/socket/socket_test_util.h"
6
7 #include <string.h>
8
9 #include "base/memory/ref_counted.h"
10 #include "testing/platform_test.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 //-----------------------------------------------------------------------------
14
15 namespace {
16
17 static const char kMsg1[] = "\0hello!\xff";
18 static const int kLen1 = arraysize(kMsg1);
19 static const char kMsg2[] = "\012345678\0";
20 static const int kLen2 = arraysize(kMsg2);
21 static const char kMsg3[] = "bye!";
22 static const int kLen3 = arraysize(kMsg3);
23
24 } // anonymous namespace
25
26 namespace net {
27
28 class DeterministicSocketDataTest : public PlatformTest {
29 public:
30 DeterministicSocketDataTest();
31
32 virtual void TearDown();
33
34 void ReentrantReadCallback(int len, int rv);
35 void ReentrantWriteCallback(const char* data, int len, int rv);
36
37 protected:
38 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
39 size_t writes_count);
40
41 void AssertSyncReadEquals(const char* data, int len);
42 void AssertAsyncReadEquals(const char* data, int len);
43 void AssertReadReturns(const char* data, int len, int rv);
44 void AssertReadBufferEquals(const char* data, int len);
45
46 void AssertSyncWriteEquals(const char* data, int len);
47 void AssertAsyncWriteEquals(const char* data, int len);
48 void AssertWriteReturns(const char* data, int len, int rv);
49
50 TestCompletionCallback read_callback_;
51 TestCompletionCallback write_callback_;
52 StreamSocket* sock_;
53 scoped_ptr<DeterministicSocketData> data_;
54
55 private:
56 scoped_refptr<IOBuffer> read_buf_;
57 MockConnect connect_data_;
58
59 HostPortPair endpoint_;
60 scoped_refptr<TransportSocketParams> tcp_params_;
61 ClientSocketPoolHistograms histograms_;
62 DeterministicMockClientSocketFactory socket_factory_;
63 MockTransportClientSocketPool socket_pool_;
64 ClientSocketHandle connection_;
65
66 DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest);
67 };
68
DeterministicSocketDataTest()69 DeterministicSocketDataTest::DeterministicSocketDataTest()
70 : sock_(NULL),
71 read_buf_(NULL),
72 connect_data_(SYNCHRONOUS, OK),
73 endpoint_("www.google.com", 443),
74 tcp_params_(new TransportSocketParams(endpoint_,
75 false,
76 false,
77 OnHostResolutionCallback())),
78 histograms_(std::string()),
79 socket_pool_(10, 10, &histograms_, &socket_factory_) {}
80
TearDown()81 void DeterministicSocketDataTest::TearDown() {
82 // Empty the current queue.
83 base::MessageLoop::current()->RunUntilIdle();
84 PlatformTest::TearDown();
85 }
86
Initialize(MockRead * reads,size_t reads_count,MockWrite * writes,size_t writes_count)87 void DeterministicSocketDataTest::Initialize(MockRead* reads,
88 size_t reads_count,
89 MockWrite* writes,
90 size_t writes_count) {
91 data_.reset(new DeterministicSocketData(reads, reads_count,
92 writes, writes_count));
93 data_->set_connect_data(connect_data_);
94 socket_factory_.AddSocketDataProvider(data_.get());
95
96 // Perform the TCP connect
97 EXPECT_EQ(OK,
98 connection_.Init(endpoint_.ToString(),
99 tcp_params_,
100 LOWEST,
101 CompletionCallback(),
102 reinterpret_cast<TransportClientSocketPool*>(&socket_pool_),
103 BoundNetLog()));
104 sock_ = connection_.socket();
105 }
106
AssertSyncReadEquals(const char * data,int len)107 void DeterministicSocketDataTest::AssertSyncReadEquals(const char* data,
108 int len) {
109 // Issue the read, which will complete immediately
110 AssertReadReturns(data, len, len);
111 AssertReadBufferEquals(data, len);
112 }
113
AssertAsyncReadEquals(const char * data,int len)114 void DeterministicSocketDataTest::AssertAsyncReadEquals(const char* data,
115 int len) {
116 // Issue the read, which will be completed asynchronously
117 AssertReadReturns(data, len, ERR_IO_PENDING);
118
119 EXPECT_FALSE(read_callback_.have_result());
120 EXPECT_TRUE(sock_->IsConnected());
121 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked
122
123 // Now the read should complete
124 ASSERT_EQ(len, read_callback_.WaitForResult());
125 AssertReadBufferEquals(data, len);
126 }
127
AssertReadReturns(const char * data,int len,int rv)128 void DeterministicSocketDataTest::AssertReadReturns(const char* data,
129 int len, int rv) {
130 read_buf_ = new IOBuffer(len);
131 ASSERT_EQ(rv, sock_->Read(read_buf_.get(), len, read_callback_.callback()));
132 }
133
AssertReadBufferEquals(const char * data,int len)134 void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
135 int len) {
136 ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
137 }
138
AssertSyncWriteEquals(const char * data,int len)139 void DeterministicSocketDataTest::AssertSyncWriteEquals(const char* data,
140 int len) {
141 scoped_refptr<IOBuffer> buf(new IOBuffer(len));
142 memcpy(buf->data(), data, len);
143
144 // Issue the write, which will complete immediately
145 ASSERT_EQ(len, sock_->Write(buf.get(), len, write_callback_.callback()));
146 }
147
AssertAsyncWriteEquals(const char * data,int len)148 void DeterministicSocketDataTest::AssertAsyncWriteEquals(const char* data,
149 int len) {
150 // Issue the read, which will be completed asynchronously
151 AssertWriteReturns(data, len, ERR_IO_PENDING);
152
153 EXPECT_FALSE(read_callback_.have_result());
154 EXPECT_TRUE(sock_->IsConnected());
155 data_->RunFor(1); // Runs 1 step, to cause the callbacks to be invoked
156
157 ASSERT_EQ(len, write_callback_.WaitForResult());
158 }
159
AssertWriteReturns(const char * data,int len,int rv)160 void DeterministicSocketDataTest::AssertWriteReturns(const char* data,
161 int len, int rv) {
162 scoped_refptr<IOBuffer> buf(new IOBuffer(len));
163 memcpy(buf->data(), data, len);
164
165 // Issue the read, which will complete asynchronously
166 ASSERT_EQ(rv, sock_->Write(buf.get(), len, write_callback_.callback()));
167 }
168
ReentrantReadCallback(int len,int rv)169 void DeterministicSocketDataTest::ReentrantReadCallback(int len, int rv) {
170 scoped_refptr<IOBuffer> read_buf(new IOBuffer(len));
171 EXPECT_EQ(len,
172 sock_->Read(
173 read_buf.get(),
174 len,
175 base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
176 base::Unretained(this),
177 len)));
178 }
179
ReentrantWriteCallback(const char * data,int len,int rv)180 void DeterministicSocketDataTest::ReentrantWriteCallback(
181 const char* data, int len, int rv) {
182 scoped_refptr<IOBuffer> write_buf(new IOBuffer(len));
183 memcpy(write_buf->data(), data, len);
184 EXPECT_EQ(len,
185 sock_->Write(
186 write_buf.get(),
187 len,
188 base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
189 base::Unretained(this),
190 data,
191 len)));
192 }
193
194 // ----------- Read
195
TEST_F(DeterministicSocketDataTest,SingleSyncReadWhileStopped)196 TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) {
197 MockRead reads[] = {
198 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
199 MockRead(SYNCHRONOUS, 0, 1), // EOF
200 };
201
202 Initialize(reads, arraysize(reads), NULL, 0);
203
204 data_->SetStopped(true);
205 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
206 }
207
TEST_F(DeterministicSocketDataTest,SingleSyncReadTooEarly)208 TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) {
209 MockRead reads[] = {
210 MockRead(SYNCHRONOUS, kMsg1, kLen1, 1), // Sync Read
211 MockRead(SYNCHRONOUS, 0, 2), // EOF
212 };
213
214 MockWrite writes[] = {
215 MockWrite(SYNCHRONOUS, 0, 0)
216 };
217
218 Initialize(reads, arraysize(reads), writes, arraysize(writes));
219
220 data_->StopAfter(2);
221 ASSERT_FALSE(data_->stopped());
222 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
223 }
224
TEST_F(DeterministicSocketDataTest,SingleSyncRead)225 TEST_F(DeterministicSocketDataTest, SingleSyncRead) {
226 MockRead reads[] = {
227 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
228 MockRead(SYNCHRONOUS, 0, 1), // EOF
229 };
230
231 Initialize(reads, arraysize(reads), NULL, 0);
232 // Make sure we don't stop before we've read all the data
233 data_->StopAfter(1);
234 AssertSyncReadEquals(kMsg1, kLen1);
235 }
236
TEST_F(DeterministicSocketDataTest,MultipleSyncReads)237 TEST_F(DeterministicSocketDataTest, MultipleSyncReads) {
238 MockRead reads[] = {
239 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
240 MockRead(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Read
241 MockRead(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Read
242 MockRead(SYNCHRONOUS, kMsg3, kLen3, 3), // Sync Read
243 MockRead(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Read
244 MockRead(SYNCHRONOUS, kMsg3, kLen3, 5), // Sync Read
245 MockRead(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Read
246 MockRead(SYNCHRONOUS, 0, 7), // EOF
247 };
248
249 Initialize(reads, arraysize(reads), NULL, 0);
250
251 // Make sure we don't stop before we've read all the data
252 data_->StopAfter(10);
253 AssertSyncReadEquals(kMsg1, kLen1);
254 AssertSyncReadEquals(kMsg2, kLen2);
255 AssertSyncReadEquals(kMsg3, kLen3);
256 AssertSyncReadEquals(kMsg3, kLen3);
257 AssertSyncReadEquals(kMsg2, kLen2);
258 AssertSyncReadEquals(kMsg3, kLen3);
259 AssertSyncReadEquals(kMsg1, kLen1);
260 }
261
TEST_F(DeterministicSocketDataTest,SingleAsyncRead)262 TEST_F(DeterministicSocketDataTest, SingleAsyncRead) {
263 MockRead reads[] = {
264 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read
265 MockRead(SYNCHRONOUS, 0, 1), // EOF
266 };
267
268 Initialize(reads, arraysize(reads), NULL, 0);
269
270 AssertAsyncReadEquals(kMsg1, kLen1);
271 }
272
TEST_F(DeterministicSocketDataTest,MultipleAsyncReads)273 TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) {
274 MockRead reads[] = {
275 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read
276 MockRead(ASYNC, kMsg2, kLen2, 1), // Async Read
277 MockRead(ASYNC, kMsg3, kLen3, 2), // Async Read
278 MockRead(ASYNC, kMsg3, kLen3, 3), // Async Read
279 MockRead(ASYNC, kMsg2, kLen2, 4), // Async Read
280 MockRead(ASYNC, kMsg3, kLen3, 5), // Async Read
281 MockRead(ASYNC, kMsg1, kLen1, 6), // Async Read
282 MockRead(SYNCHRONOUS, 0, 7), // EOF
283 };
284
285 Initialize(reads, arraysize(reads), NULL, 0);
286
287 AssertAsyncReadEquals(kMsg1, kLen1);
288 AssertAsyncReadEquals(kMsg2, kLen2);
289 AssertAsyncReadEquals(kMsg3, kLen3);
290 AssertAsyncReadEquals(kMsg3, kLen3);
291 AssertAsyncReadEquals(kMsg2, kLen2);
292 AssertAsyncReadEquals(kMsg3, kLen3);
293 AssertAsyncReadEquals(kMsg1, kLen1);
294 }
295
TEST_F(DeterministicSocketDataTest,MixedReads)296 TEST_F(DeterministicSocketDataTest, MixedReads) {
297 MockRead reads[] = {
298 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
299 MockRead(ASYNC, kMsg2, kLen2, 1), // Async Read
300 MockRead(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Read
301 MockRead(ASYNC, kMsg3, kLen3, 3), // Async Read
302 MockRead(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Read
303 MockRead(ASYNC, kMsg3, kLen3, 5), // Async Read
304 MockRead(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Read
305 MockRead(SYNCHRONOUS, 0, 7), // EOF
306 };
307
308 Initialize(reads, arraysize(reads), NULL, 0);
309
310 data_->StopAfter(1);
311 AssertSyncReadEquals(kMsg1, kLen1);
312 AssertAsyncReadEquals(kMsg2, kLen2);
313 data_->StopAfter(1);
314 AssertSyncReadEquals(kMsg3, kLen3);
315 AssertAsyncReadEquals(kMsg3, kLen3);
316 data_->StopAfter(1);
317 AssertSyncReadEquals(kMsg2, kLen2);
318 AssertAsyncReadEquals(kMsg3, kLen3);
319 data_->StopAfter(1);
320 AssertSyncReadEquals(kMsg1, kLen1);
321 }
322
TEST_F(DeterministicSocketDataTest,SyncReadFromCompletionCallback)323 TEST_F(DeterministicSocketDataTest, SyncReadFromCompletionCallback) {
324 MockRead reads[] = {
325 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read
326 MockRead(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Read
327 };
328
329 Initialize(reads, arraysize(reads), NULL, 0);
330
331 data_->StopAfter(2);
332
333 scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
334 ASSERT_EQ(ERR_IO_PENDING,
335 sock_->Read(
336 read_buf.get(),
337 kLen1,
338 base::Bind(&DeterministicSocketDataTest::ReentrantReadCallback,
339 base::Unretained(this),
340 kLen2)));
341 data_->Run();
342 }
343
344 // ----------- Write
345
TEST_F(DeterministicSocketDataTest,SingleSyncWriteWhileStopped)346 TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) {
347 MockWrite writes[] = {
348 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
349 };
350
351 Initialize(NULL, 0, writes, arraysize(writes));
352
353 data_->SetStopped(true);
354 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
355 }
356
TEST_F(DeterministicSocketDataTest,SingleSyncWriteTooEarly)357 TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) {
358 MockWrite writes[] = {
359 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 1), // Sync Write
360 };
361
362 MockRead reads[] = {
363 MockRead(SYNCHRONOUS, 0, 0)
364 };
365
366 Initialize(reads, arraysize(reads), writes, arraysize(writes));
367
368 data_->StopAfter(2);
369 ASSERT_FALSE(data_->stopped());
370 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
371 }
372
TEST_F(DeterministicSocketDataTest,SingleSyncWrite)373 TEST_F(DeterministicSocketDataTest, SingleSyncWrite) {
374 MockWrite writes[] = {
375 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write
376 };
377
378 Initialize(NULL, 0, writes, arraysize(writes));
379
380 // Make sure we don't stop before we've read all the data
381 data_->StopAfter(1);
382 AssertSyncWriteEquals(kMsg1, kLen1);
383 }
384
TEST_F(DeterministicSocketDataTest,MultipleSyncWrites)385 TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) {
386 MockWrite writes[] = {
387 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write
388 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write
389 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write
390 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 3), // Sync Write
391 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Write
392 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 5), // Sync Write
393 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Write
394 };
395
396 Initialize(NULL, 0, writes, arraysize(writes));
397
398 // Make sure we don't stop before we've read all the data
399 data_->StopAfter(10);
400 AssertSyncWriteEquals(kMsg1, kLen1);
401 AssertSyncWriteEquals(kMsg2, kLen2);
402 AssertSyncWriteEquals(kMsg3, kLen3);
403 AssertSyncWriteEquals(kMsg3, kLen3);
404 AssertSyncWriteEquals(kMsg2, kLen2);
405 AssertSyncWriteEquals(kMsg3, kLen3);
406 AssertSyncWriteEquals(kMsg1, kLen1);
407 }
408
TEST_F(DeterministicSocketDataTest,SingleAsyncWrite)409 TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) {
410 MockWrite writes[] = {
411 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write
412 };
413
414 Initialize(NULL, 0, writes, arraysize(writes));
415
416 AssertAsyncWriteEquals(kMsg1, kLen1);
417 }
418
TEST_F(DeterministicSocketDataTest,MultipleAsyncWrites)419 TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) {
420 MockWrite writes[] = {
421 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write
422 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write
423 MockWrite(ASYNC, kMsg3, kLen3, 2), // Async Write
424 MockWrite(ASYNC, kMsg3, kLen3, 3), // Async Write
425 MockWrite(ASYNC, kMsg2, kLen2, 4), // Async Write
426 MockWrite(ASYNC, kMsg3, kLen3, 5), // Async Write
427 MockWrite(ASYNC, kMsg1, kLen1, 6), // Async Write
428 };
429
430 Initialize(NULL, 0, writes, arraysize(writes));
431
432 AssertAsyncWriteEquals(kMsg1, kLen1);
433 AssertAsyncWriteEquals(kMsg2, kLen2);
434 AssertAsyncWriteEquals(kMsg3, kLen3);
435 AssertAsyncWriteEquals(kMsg3, kLen3);
436 AssertAsyncWriteEquals(kMsg2, kLen2);
437 AssertAsyncWriteEquals(kMsg3, kLen3);
438 AssertAsyncWriteEquals(kMsg1, kLen1);
439 }
440
TEST_F(DeterministicSocketDataTest,MixedWrites)441 TEST_F(DeterministicSocketDataTest, MixedWrites) {
442 MockWrite writes[] = {
443 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Write
444 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write
445 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write
446 MockWrite(ASYNC, kMsg3, kLen3, 3), // Async Write
447 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 4), // Sync Write
448 MockWrite(ASYNC, kMsg3, kLen3, 5), // Async Write
449 MockWrite(SYNCHRONOUS, kMsg1, kLen1, 6), // Sync Write
450 };
451
452 Initialize(NULL, 0, writes, arraysize(writes));
453
454 data_->StopAfter(1);
455 AssertSyncWriteEquals(kMsg1, kLen1);
456 AssertAsyncWriteEquals(kMsg2, kLen2);
457 data_->StopAfter(1);
458 AssertSyncWriteEquals(kMsg3, kLen3);
459 AssertAsyncWriteEquals(kMsg3, kLen3);
460 data_->StopAfter(1);
461 AssertSyncWriteEquals(kMsg2, kLen2);
462 AssertAsyncWriteEquals(kMsg3, kLen3);
463 data_->StopAfter(1);
464 AssertSyncWriteEquals(kMsg1, kLen1);
465 }
466
TEST_F(DeterministicSocketDataTest,SyncWriteFromCompletionCallback)467 TEST_F(DeterministicSocketDataTest, SyncWriteFromCompletionCallback) {
468 MockWrite writes[] = {
469 MockWrite(ASYNC, kMsg1, kLen1, 0), // Async Write
470 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write
471 };
472
473 Initialize(NULL, 0, writes, arraysize(writes));
474
475 data_->StopAfter(2);
476
477 scoped_refptr<IOBuffer> write_buf(new IOBuffer(kLen1));
478 memcpy(write_buf->data(), kMsg1, kLen1);
479 ASSERT_EQ(ERR_IO_PENDING,
480 sock_->Write(
481 write_buf.get(),
482 kLen1,
483 base::Bind(&DeterministicSocketDataTest::ReentrantWriteCallback,
484 base::Unretained(this),
485 kMsg2,
486 kLen2)));
487 data_->Run();
488 }
489
490 // ----------- Mixed Reads and Writes
491
TEST_F(DeterministicSocketDataTest,MixedSyncOperations)492 TEST_F(DeterministicSocketDataTest, MixedSyncOperations) {
493 MockRead reads[] = {
494 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
495 MockRead(SYNCHRONOUS, kMsg2, kLen2, 3), // Sync Read
496 MockRead(SYNCHRONOUS, 0, 4), // EOF
497 };
498
499 MockWrite writes[] = {
500 MockWrite(SYNCHRONOUS, kMsg2, kLen2, 1), // Sync Write
501 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write
502 };
503
504 Initialize(reads, arraysize(reads), writes, arraysize(writes));
505
506 // Make sure we don't stop before we've read/written everything
507 data_->StopAfter(10);
508 AssertSyncReadEquals(kMsg1, kLen1);
509 AssertSyncWriteEquals(kMsg2, kLen2);
510 AssertSyncWriteEquals(kMsg3, kLen3);
511 AssertSyncReadEquals(kMsg2, kLen2);
512 }
513
TEST_F(DeterministicSocketDataTest,MixedAsyncOperations)514 TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) {
515 MockRead reads[] = {
516 MockRead(ASYNC, kMsg1, kLen1, 0), // Sync Read
517 MockRead(ASYNC, kMsg2, kLen2, 3), // Sync Read
518 MockRead(ASYNC, 0, 4), // EOF
519 };
520
521 MockWrite writes[] = {
522 MockWrite(ASYNC, kMsg2, kLen2, 1), // Sync Write
523 MockWrite(ASYNC, kMsg3, kLen3, 2), // Sync Write
524 };
525
526 Initialize(reads, arraysize(reads), writes, arraysize(writes));
527
528 AssertAsyncReadEquals(kMsg1, kLen1);
529 AssertAsyncWriteEquals(kMsg2, kLen2);
530 AssertAsyncWriteEquals(kMsg3, kLen3);
531 AssertAsyncReadEquals(kMsg2, kLen2);
532 }
533
TEST_F(DeterministicSocketDataTest,InterleavedAsyncOperations)534 TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) {
535 // Order of completion is read, write, write, read
536 MockRead reads[] = {
537 MockRead(ASYNC, kMsg1, kLen1, 0), // Async Read
538 MockRead(ASYNC, kMsg2, kLen2, 3), // Async Read
539 MockRead(ASYNC, 0, 4), // EOF
540 };
541
542 MockWrite writes[] = {
543 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write
544 MockWrite(ASYNC, kMsg3, kLen3, 2), // Async Write
545 };
546
547 Initialize(reads, arraysize(reads), writes, arraysize(writes));
548
549 // Issue the write, which will block until the read completes
550 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
551
552 // Issue the read which will return first
553 AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING);
554
555 data_->RunFor(1);
556 ASSERT_TRUE(read_callback_.have_result());
557 ASSERT_EQ(kLen1, read_callback_.WaitForResult());
558 AssertReadBufferEquals(kMsg1, kLen1);
559
560 data_->RunFor(1);
561 ASSERT_TRUE(write_callback_.have_result());
562 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
563
564 data_->StopAfter(1);
565 // Issue the read, which will block until the write completes
566 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
567
568 // Issue the writes which will return first
569 AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
570
571 data_->RunFor(1);
572 ASSERT_TRUE(write_callback_.have_result());
573 ASSERT_EQ(kLen3, write_callback_.WaitForResult());
574
575 data_->RunFor(1);
576 ASSERT_TRUE(read_callback_.have_result());
577 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
578 AssertReadBufferEquals(kMsg2, kLen2);
579 }
580
TEST_F(DeterministicSocketDataTest,InterleavedMixedOperations)581 TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) {
582 // Order of completion is read, write, write, read
583 MockRead reads[] = {
584 MockRead(SYNCHRONOUS, kMsg1, kLen1, 0), // Sync Read
585 MockRead(ASYNC, kMsg2, kLen2, 3), // Async Read
586 MockRead(SYNCHRONOUS, 0, 4), // EOF
587 };
588
589 MockWrite writes[] = {
590 MockWrite(ASYNC, kMsg2, kLen2, 1), // Async Write
591 MockWrite(SYNCHRONOUS, kMsg3, kLen3, 2), // Sync Write
592 };
593
594 Initialize(reads, arraysize(reads), writes, arraysize(writes));
595
596 // Issue the write, which will block until the read completes
597 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
598
599 // Issue the writes which will complete immediately
600 data_->StopAfter(1);
601 AssertSyncReadEquals(kMsg1, kLen1);
602
603 data_->RunFor(1);
604 ASSERT_TRUE(write_callback_.have_result());
605 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
606
607 // Issue the read, which will block until the write completes
608 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
609
610 // Issue the writes which will complete immediately
611 data_->StopAfter(1);
612 AssertSyncWriteEquals(kMsg3, kLen3);
613
614 data_->RunFor(1);
615 ASSERT_TRUE(read_callback_.have_result());
616 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
617 AssertReadBufferEquals(kMsg2, kLen2);
618 }
619
620 } // namespace net
621