1 // Copyright (c) 2011 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 "testing/platform_test.h"
8 #include "testing/gtest/include/gtest/gtest.h"
9
10 //-----------------------------------------------------------------------------
11
12 namespace {
13
14 static const char kMsg1[] = "\0hello!\xff";
15 static const int kLen1 = arraysize(kMsg1);
16 static const char kMsg2[] = "\012345678\0";
17 static const int kLen2 = arraysize(kMsg2);
18 static const char kMsg3[] = "bye!";
19 static const int kLen3 = arraysize(kMsg3);
20
21 } // anonymous namespace
22
23 namespace net {
24
25 class DeterministicSocketDataTest : public PlatformTest {
26 public:
27 DeterministicSocketDataTest();
28
29 virtual void TearDown();
30
31 protected:
32 void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
33 size_t writes_count);
34
35 void AssertSyncReadEquals(const char* data, int len);
36 void AssertAsyncReadEquals(const char* data, int len);
37 void AssertReadReturns(const char* data, int len, int rv);
38 void AssertReadBufferEquals(const char* data, int len);
39
40 void AssertSyncWriteEquals(const char* data, int len);
41 void AssertAsyncWriteEquals(const char* data, int len);
42 void AssertWriteReturns(const char* data, int len, int rv);
43
44 TestCompletionCallback read_callback_;
45 TestCompletionCallback write_callback_;
46 ClientSocket* sock_;
47 scoped_refptr<DeterministicSocketData> data_;
48
49 private:
50 scoped_refptr<IOBuffer> read_buf_;
51 MockConnect connect_data_;
52
53 GURL url_;
54 HostPortPair endpoint_;
55 scoped_refptr<TransportSocketParams> tcp_params_;
56 ClientSocketPoolHistograms histograms_;
57 DeterministicMockClientSocketFactory socket_factory_;
58 MockTransportClientSocketPool socket_pool_;
59 ClientSocketHandle connection_;
60
61 DISALLOW_COPY_AND_ASSIGN(DeterministicSocketDataTest);
62 };
63
DeterministicSocketDataTest()64 DeterministicSocketDataTest::DeterministicSocketDataTest()
65 : read_callback_(),
66 write_callback_(),
67 sock_(NULL),
68 data_(NULL),
69 read_buf_(NULL),
70 connect_data_(false, OK),
71 url_("https://www.google.com"),
72 endpoint_("www.google.com", 443),
73 tcp_params_(new TransportSocketParams(endpoint_,
74 LOWEST,
75 url_,
76 false,
77 false)),
78 histograms_(""),
79 socket_pool_(10, 10, &histograms_, &socket_factory_) {
80 }
81
TearDown()82 void DeterministicSocketDataTest::TearDown() {
83 // Empty the current queue.
84 MessageLoop::current()->RunAllPending();
85 PlatformTest::TearDown();
86 }
87
Initialize(MockRead * reads,size_t reads_count,MockWrite * writes,size_t writes_count)88 void DeterministicSocketDataTest::Initialize(MockRead* reads,
89 size_t reads_count,
90 MockWrite* writes,
91 size_t writes_count) {
92 data_ = new DeterministicSocketData(reads, reads_count, 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 NULL,
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_, len, &read_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, len, &write_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, len, &write_callback_));
167 }
168
169 // ----------- Read
170
TEST_F(DeterministicSocketDataTest,SingleSyncReadWhileStopped)171 TEST_F(DeterministicSocketDataTest, SingleSyncReadWhileStopped) {
172 MockRead reads[] = {
173 MockRead(false, kMsg1, kLen1, 0), // Sync Read
174 MockRead(false, 0, 1), // EOF
175 };
176
177 Initialize(reads, arraysize(reads), NULL, 0);
178
179 data_->SetStopped(true);
180 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
181 }
182
TEST_F(DeterministicSocketDataTest,SingleSyncReadTooEarly)183 TEST_F(DeterministicSocketDataTest, SingleSyncReadTooEarly) {
184 MockRead reads[] = {
185 MockRead(false, kMsg1, kLen1, 1), // Sync Read
186 MockRead(false, 0, 2), // EOF
187 };
188
189 Initialize(reads, arraysize(reads), NULL, 0);
190
191 data_->StopAfter(2);
192 ASSERT_FALSE(data_->stopped());
193 AssertReadReturns(kMsg1, kLen1, ERR_UNEXPECTED);
194 }
195
TEST_F(DeterministicSocketDataTest,SingleSyncRead)196 TEST_F(DeterministicSocketDataTest, SingleSyncRead) {
197 MockRead reads[] = {
198 MockRead(false, kMsg1, kLen1, 0), // Sync Read
199 MockRead(false, 0, 1), // EOF
200 };
201
202 Initialize(reads, arraysize(reads), NULL, 0);
203 // Make sure we don't stop before we've read all the data
204 data_->StopAfter(1);
205 AssertSyncReadEquals(kMsg1, kLen1);
206 }
207
TEST_F(DeterministicSocketDataTest,MultipleSyncReads)208 TEST_F(DeterministicSocketDataTest, MultipleSyncReads) {
209 MockRead reads[] = {
210 MockRead(false, kMsg1, kLen1, 0), // Sync Read
211 MockRead(false, kMsg2, kLen2, 1), // Sync Read
212 MockRead(false, kMsg3, kLen3, 2), // Sync Read
213 MockRead(false, kMsg3, kLen3, 3), // Sync Read
214 MockRead(false, kMsg2, kLen2, 4), // Sync Read
215 MockRead(false, kMsg3, kLen3, 5), // Sync Read
216 MockRead(false, kMsg1, kLen1, 6), // Sync Read
217 MockRead(false, 0, 7), // EOF
218 };
219
220 Initialize(reads, arraysize(reads), NULL, 0);
221
222 // Make sure we don't stop before we've read all the data
223 data_->StopAfter(10);
224 AssertSyncReadEquals(kMsg1, kLen1);
225 AssertSyncReadEquals(kMsg2, kLen2);
226 AssertSyncReadEquals(kMsg3, kLen3);
227 AssertSyncReadEquals(kMsg3, kLen3);
228 AssertSyncReadEquals(kMsg2, kLen2);
229 AssertSyncReadEquals(kMsg3, kLen3);
230 AssertSyncReadEquals(kMsg1, kLen1);
231 }
232
TEST_F(DeterministicSocketDataTest,SingleAsyncRead)233 TEST_F(DeterministicSocketDataTest, SingleAsyncRead) {
234 MockRead reads[] = {
235 MockRead(true, kMsg1, kLen1, 0), // Async Read
236 MockRead(false, 0, 1), // EOF
237 };
238
239 Initialize(reads, arraysize(reads), NULL, 0);
240
241 AssertAsyncReadEquals(kMsg1, kLen1);
242 }
243
TEST_F(DeterministicSocketDataTest,MultipleAsyncReads)244 TEST_F(DeterministicSocketDataTest, MultipleAsyncReads) {
245 MockRead reads[] = {
246 MockRead(true, kMsg1, kLen1, 0), // Async Read
247 MockRead(true, kMsg2, kLen2, 1), // Async Read
248 MockRead(true, kMsg3, kLen3, 2), // Async Read
249 MockRead(true, kMsg3, kLen3, 3), // Async Read
250 MockRead(true, kMsg2, kLen2, 4), // Async Read
251 MockRead(true, kMsg3, kLen3, 5), // Async Read
252 MockRead(true, kMsg1, kLen1, 6), // Async Read
253 MockRead(false, 0, 7), // EOF
254 };
255
256 Initialize(reads, arraysize(reads), NULL, 0);
257
258 AssertAsyncReadEquals(kMsg1, kLen1);
259 AssertAsyncReadEquals(kMsg2, kLen2);
260 AssertAsyncReadEquals(kMsg3, kLen3);
261 AssertAsyncReadEquals(kMsg3, kLen3);
262 AssertAsyncReadEquals(kMsg2, kLen2);
263 AssertAsyncReadEquals(kMsg3, kLen3);
264 AssertAsyncReadEquals(kMsg1, kLen1);
265 }
266
TEST_F(DeterministicSocketDataTest,MixedReads)267 TEST_F(DeterministicSocketDataTest, MixedReads) {
268 MockRead reads[] = {
269 MockRead(false, kMsg1, kLen1, 0), // Sync Read
270 MockRead(true, kMsg2, kLen2, 1), // Async Read
271 MockRead(false, kMsg3, kLen3, 2), // Sync Read
272 MockRead(true, kMsg3, kLen3, 3), // Async Read
273 MockRead(false, kMsg2, kLen2, 4), // Sync Read
274 MockRead(true, kMsg3, kLen3, 5), // Async Read
275 MockRead(false, kMsg1, kLen1, 6), // Sync Read
276 MockRead(false, 0, 7), // EOF
277 };
278
279 Initialize(reads, arraysize(reads), NULL, 0);
280
281 data_->StopAfter(1);
282 AssertSyncReadEquals(kMsg1, kLen1);
283 AssertAsyncReadEquals(kMsg2, kLen2);
284 data_->StopAfter(1);
285 AssertSyncReadEquals(kMsg3, kLen3);
286 AssertAsyncReadEquals(kMsg3, kLen3);
287 data_->StopAfter(1);
288 AssertSyncReadEquals(kMsg2, kLen2);
289 AssertAsyncReadEquals(kMsg3, kLen3);
290 data_->StopAfter(1);
291 AssertSyncReadEquals(kMsg1, kLen1);
292 }
293
294 // ----------- Write
295
TEST_F(DeterministicSocketDataTest,SingleSyncWriteWhileStopped)296 TEST_F(DeterministicSocketDataTest, SingleSyncWriteWhileStopped) {
297 MockWrite writes[] = {
298 MockWrite(false, kMsg1, kLen1, 0), // Sync Read
299 };
300
301 Initialize(NULL, 0, writes, arraysize(writes));
302
303 data_->SetStopped(true);
304 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
305 }
306
TEST_F(DeterministicSocketDataTest,SingleSyncWriteTooEarly)307 TEST_F(DeterministicSocketDataTest, SingleSyncWriteTooEarly) {
308 MockWrite writes[] = {
309 MockWrite(false, kMsg1, kLen1, 1), // Sync Write
310 };
311
312 Initialize(NULL, 0, writes, arraysize(writes));
313
314 data_->StopAfter(2);
315 ASSERT_FALSE(data_->stopped());
316 AssertWriteReturns(kMsg1, kLen1, ERR_UNEXPECTED);
317 }
318
TEST_F(DeterministicSocketDataTest,SingleSyncWrite)319 TEST_F(DeterministicSocketDataTest, SingleSyncWrite) {
320 MockWrite writes[] = {
321 MockWrite(false, kMsg1, kLen1, 0), // Sync Write
322 };
323
324 Initialize(NULL, 0, writes, arraysize(writes));
325
326 // Make sure we don't stop before we've read all the data
327 data_->StopAfter(1);
328 AssertSyncWriteEquals(kMsg1, kLen1);
329 }
330
TEST_F(DeterministicSocketDataTest,MultipleSyncWrites)331 TEST_F(DeterministicSocketDataTest, MultipleSyncWrites) {
332 MockWrite writes[] = {
333 MockWrite(false, kMsg1, kLen1, 0), // Sync Write
334 MockWrite(false, kMsg2, kLen2, 1), // Sync Write
335 MockWrite(false, kMsg3, kLen3, 2), // Sync Write
336 MockWrite(false, kMsg3, kLen3, 3), // Sync Write
337 MockWrite(false, kMsg2, kLen2, 4), // Sync Write
338 MockWrite(false, kMsg3, kLen3, 5), // Sync Write
339 MockWrite(false, kMsg1, kLen1, 6), // Sync Write
340 };
341
342 Initialize(NULL, 0, writes, arraysize(writes));
343
344 // Make sure we don't stop before we've read all the data
345 data_->StopAfter(10);
346 AssertSyncWriteEquals(kMsg1, kLen1);
347 AssertSyncWriteEquals(kMsg2, kLen2);
348 AssertSyncWriteEquals(kMsg3, kLen3);
349 AssertSyncWriteEquals(kMsg3, kLen3);
350 AssertSyncWriteEquals(kMsg2, kLen2);
351 AssertSyncWriteEquals(kMsg3, kLen3);
352 AssertSyncWriteEquals(kMsg1, kLen1);
353 }
354
TEST_F(DeterministicSocketDataTest,SingleAsyncWrite)355 TEST_F(DeterministicSocketDataTest, SingleAsyncWrite) {
356 MockWrite writes[] = {
357 MockWrite(true, kMsg1, kLen1, 0), // Async Write
358 };
359
360 Initialize(NULL, 0, writes, arraysize(writes));
361
362 AssertAsyncWriteEquals(kMsg1, kLen1);
363 }
364
TEST_F(DeterministicSocketDataTest,MultipleAsyncWrites)365 TEST_F(DeterministicSocketDataTest, MultipleAsyncWrites) {
366 MockWrite writes[] = {
367 MockWrite(true, kMsg1, kLen1, 0), // Async Write
368 MockWrite(true, kMsg2, kLen2, 1), // Async Write
369 MockWrite(true, kMsg3, kLen3, 2), // Async Write
370 MockWrite(true, kMsg3, kLen3, 3), // Async Write
371 MockWrite(true, kMsg2, kLen2, 4), // Async Write
372 MockWrite(true, kMsg3, kLen3, 5), // Async Write
373 MockWrite(true, kMsg1, kLen1, 6), // Async Write
374 };
375
376 Initialize(NULL, 0, writes, arraysize(writes));
377
378 AssertAsyncWriteEquals(kMsg1, kLen1);
379 AssertAsyncWriteEquals(kMsg2, kLen2);
380 AssertAsyncWriteEquals(kMsg3, kLen3);
381 AssertAsyncWriteEquals(kMsg3, kLen3);
382 AssertAsyncWriteEquals(kMsg2, kLen2);
383 AssertAsyncWriteEquals(kMsg3, kLen3);
384 AssertAsyncWriteEquals(kMsg1, kLen1);
385 }
386
TEST_F(DeterministicSocketDataTest,MixedWrites)387 TEST_F(DeterministicSocketDataTest, MixedWrites) {
388 MockWrite writes[] = {
389 MockWrite(false, kMsg1, kLen1, 0), // Sync Write
390 MockWrite(true, kMsg2, kLen2, 1), // Async Write
391 MockWrite(false, kMsg3, kLen3, 2), // Sync Write
392 MockWrite(true, kMsg3, kLen3, 3), // Async Write
393 MockWrite(false, kMsg2, kLen2, 4), // Sync Write
394 MockWrite(true, kMsg3, kLen3, 5), // Async Write
395 MockWrite(false, kMsg1, kLen1, 6), // Sync Write
396 };
397
398 Initialize(NULL, 0, writes, arraysize(writes));
399
400 data_->StopAfter(1);
401 AssertSyncWriteEquals(kMsg1, kLen1);
402 AssertAsyncWriteEquals(kMsg2, kLen2);
403 data_->StopAfter(1);
404 AssertSyncWriteEquals(kMsg3, kLen3);
405 AssertAsyncWriteEquals(kMsg3, kLen3);
406 data_->StopAfter(1);
407 AssertSyncWriteEquals(kMsg2, kLen2);
408 AssertAsyncWriteEquals(kMsg3, kLen3);
409 data_->StopAfter(1);
410 AssertSyncWriteEquals(kMsg1, kLen1);
411 }
412
413 // ----------- Mixed Reads and Writes
414
TEST_F(DeterministicSocketDataTest,MixedSyncOperations)415 TEST_F(DeterministicSocketDataTest, MixedSyncOperations) {
416 MockRead reads[] = {
417 MockRead(false, kMsg1, kLen1, 0), // Sync Read
418 MockRead(false, kMsg2, kLen2, 3), // Sync Read
419 MockRead(false, 0, 4), // EOF
420 };
421
422 MockWrite writes[] = {
423 MockWrite(false, kMsg2, kLen2, 1), // Sync Write
424 MockWrite(false, kMsg3, kLen3, 2), // Sync Write
425 };
426
427 Initialize(reads, arraysize(reads), writes, arraysize(writes));
428
429 // Make sure we don't stop before we've read/written everything
430 data_->StopAfter(10);
431 AssertSyncReadEquals(kMsg1, kLen1);
432 AssertSyncWriteEquals(kMsg2, kLen2);
433 AssertSyncWriteEquals(kMsg3, kLen3);
434 AssertSyncReadEquals(kMsg2, kLen2);
435 }
436
TEST_F(DeterministicSocketDataTest,MixedAsyncOperations)437 TEST_F(DeterministicSocketDataTest, MixedAsyncOperations) {
438 MockRead reads[] = {
439 MockRead(true, kMsg1, kLen1, 0), // Sync Read
440 MockRead(true, kMsg2, kLen2, 3), // Sync Read
441 MockRead(true, 0, 4), // EOF
442 };
443
444 MockWrite writes[] = {
445 MockWrite(true, kMsg2, kLen2, 1), // Sync Write
446 MockWrite(true, kMsg3, kLen3, 2), // Sync Write
447 };
448
449 Initialize(reads, arraysize(reads), writes, arraysize(writes));
450
451 AssertAsyncReadEquals(kMsg1, kLen1);
452 AssertAsyncWriteEquals(kMsg2, kLen2);
453 AssertAsyncWriteEquals(kMsg3, kLen3);
454 AssertAsyncReadEquals(kMsg2, kLen2);
455 }
456
TEST_F(DeterministicSocketDataTest,InterleavedAsyncOperations)457 TEST_F(DeterministicSocketDataTest, InterleavedAsyncOperations) {
458 // Order of completion is read, write, write, read
459 MockRead reads[] = {
460 MockRead(true, kMsg1, kLen1, 0), // Async Read
461 MockRead(true, kMsg2, kLen2, 3), // Async Read
462 MockRead(true, 0, 4), // EOF
463 };
464
465 MockWrite writes[] = {
466 MockWrite(true, kMsg2, kLen2, 1), // Async Write
467 MockWrite(true, kMsg3, kLen3, 2), // Async Write
468 };
469
470 Initialize(reads, arraysize(reads), writes, arraysize(writes));
471
472 // Issue the write, which will block until the read completes
473 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
474
475 // Issue the read which will return first
476 AssertReadReturns(kMsg1, kLen1, ERR_IO_PENDING);
477
478 data_->RunFor(1);
479 ASSERT_EQ(kLen1, read_callback_.WaitForResult());
480 AssertReadBufferEquals(kMsg1, kLen1);
481
482 data_->RunFor(1);
483 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
484
485 data_->StopAfter(1);
486 // Issue the read, which will block until the write completes
487 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
488
489 // Issue the writes which will return first
490 AssertWriteReturns(kMsg3, kLen3, ERR_IO_PENDING);
491
492 data_->RunFor(1);
493 ASSERT_EQ(kLen3, write_callback_.WaitForResult());
494
495 data_->RunFor(1);
496 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
497 AssertReadBufferEquals(kMsg2, kLen2);
498 }
499
TEST_F(DeterministicSocketDataTest,InterleavedMixedOperations)500 TEST_F(DeterministicSocketDataTest, InterleavedMixedOperations) {
501 // Order of completion is read, write, write, read
502 MockRead reads[] = {
503 MockRead(false, kMsg1, kLen1, 0), // Sync Read
504 MockRead(true, kMsg2, kLen2, 3), // Async Read
505 MockRead(false, 0, 4), // EOF
506 };
507
508 MockWrite writes[] = {
509 MockWrite(true, kMsg2, kLen2, 1), // Async Write
510 MockWrite(false, kMsg3, kLen3, 2), // Sync Write
511 };
512
513 Initialize(reads, arraysize(reads), writes, arraysize(writes));
514
515 // Issue the write, which will block until the read completes
516 AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
517
518 // Issue the writes which will complete immediately
519 data_->StopAfter(1);
520 AssertSyncReadEquals(kMsg1, kLen1);
521
522 data_->RunFor(1);
523 ASSERT_EQ(kLen2, write_callback_.WaitForResult());
524
525 // Issue the read, which will block until the write completes
526 AssertReadReturns(kMsg2, kLen2, ERR_IO_PENDING);
527
528 // Issue the writes which will complete immediately
529 data_->StopAfter(1);
530 AssertSyncWriteEquals(kMsg3, kLen3);
531
532 data_->RunFor(1);
533 ASSERT_EQ(kLen2, read_callback_.WaitForResult());
534 AssertReadBufferEquals(kMsg2, kLen2);
535 }
536
537 } // namespace net
538