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
12namespace {
13
14static const char kMsg1[] = "\0hello!\xff";
15static const int kLen1 = arraysize(kMsg1);
16static const char kMsg2[] = "\012345678\0";
17static const int kLen2 = arraysize(kMsg2);
18static const char kMsg3[] = "bye!";
19static const int kLen3 = arraysize(kMsg3);
20
21}  // anonymous namespace
22
23namespace net {
24
25class 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
64DeterministicSocketDataTest::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
82void DeterministicSocketDataTest::TearDown() {
83  // Empty the current queue.
84  MessageLoop::current()->RunAllPending();
85  PlatformTest::TearDown();
86}
87
88void 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
107void 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
114void 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
128void 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
134void DeterministicSocketDataTest::AssertReadBufferEquals(const char* data,
135                                                         int len) {
136  ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
137}
138
139void 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
148void 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
160void 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
171TEST_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
183TEST_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
196TEST_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
208TEST_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
233TEST_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
244TEST_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
267TEST_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
296TEST_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
307TEST_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
319TEST_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
331TEST_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
355TEST_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
365TEST_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
387TEST_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
415TEST_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
437TEST_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
457TEST_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
500TEST_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