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