Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(189)

Side by Side Diff: net/socket/tcp_socket_unittest.cc

Issue 22861033: Move server socket functionality from TCPServerSocket into TCPSocket. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « net/socket/tcp_socket_libevent.cc ('k') | net/socket/tcp_socket_win.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2013 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/tcp_socket.h"
6
7 #include <string>
8
9 #include "base/memory/scoped_ptr.h"
10 #include "net/base/address_list.h"
11 #include "net/base/ip_endpoint.h"
12 #include "net/base/net_errors.h"
13 #include "net/base/test_completion_callback.h"
14 #include "net/socket/tcp_client_socket.h"
15 #include "testing/gtest/include/gtest/gtest.h"
16 #include "testing/platform_test.h"
17
18 namespace net {
19
20 namespace {
21 const int kListenBacklog = 5;
22
23 class TCPSocketTest : public PlatformTest {
24 protected:
25 TCPSocketTest() : socket_(NULL, NetLog::Source()) {
26 }
27
28 void SetUpListenIPv4() {
29 IPEndPoint address;
30 ParseAddress("127.0.0.1", 0, &address);
31
32 ASSERT_EQ(OK, socket_.Create(ADDRESS_FAMILY_IPV4));
33 ASSERT_EQ(OK, socket_.Bind(address));
34 ASSERT_EQ(OK, socket_.Listen(kListenBacklog));
35 ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
36 }
37
38 void SetUpListenIPv6(bool* success) {
39 *success = false;
40 IPEndPoint address;
41 ParseAddress("::1", 0, &address);
42
43 if (socket_.Create(ADDRESS_FAMILY_IPV6) != OK ||
44 socket_.Bind(address) != OK ||
45 socket_.Listen(kListenBacklog) != OK) {
46 LOG(ERROR) << "Failed to listen on ::1 - probably because IPv6 is "
47 "disabled. Skipping the test";
48 return;
49 }
50 ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
51 *success = true;
52 }
53
54 void ParseAddress(const std::string& ip_str, int port, IPEndPoint* address) {
55 IPAddressNumber ip_number;
56 bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
57 if (!rv)
58 return;
59 *address = IPEndPoint(ip_number, port);
60 }
61
62 AddressList local_address_list() const {
63 return AddressList(local_address_);
64 }
65
66 TCPSocket socket_;
67 IPEndPoint local_address_;
68 };
69
70 // Test listening and accepting with a socket bound to an IPv4 address.
71 TEST_F(TCPSocketTest, Accept) {
72 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
73
74 TestCompletionCallback connect_callback;
75 // TODO(yzshen): Switch to use TCPSocket when it supports client socket
76 // operations.
77 TCPClientSocket connecting_socket(local_address_list(),
78 NULL, NetLog::Source());
79 connecting_socket.Connect(connect_callback.callback());
80
81 TestCompletionCallback accept_callback;
82 scoped_ptr<TCPSocket> accepted_socket;
83 IPEndPoint accepted_address;
84 int result = socket_.Accept(&accepted_socket, &accepted_address,
85 accept_callback.callback());
86 if (result == ERR_IO_PENDING)
87 result = accept_callback.WaitForResult();
88 ASSERT_EQ(OK, result);
89
90 EXPECT_TRUE(accepted_socket.get());
91
92 // Both sockets should be on the loopback network interface.
93 EXPECT_EQ(accepted_address.address(), local_address_.address());
94
95 EXPECT_EQ(OK, connect_callback.WaitForResult());
96 }
97
98 // Test Accept() callback.
99 TEST_F(TCPSocketTest, AcceptAsync) {
100 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
101
102 TestCompletionCallback accept_callback;
103 scoped_ptr<TCPSocket> accepted_socket;
104 IPEndPoint accepted_address;
105 ASSERT_EQ(ERR_IO_PENDING,
106 socket_.Accept(&accepted_socket, &accepted_address,
107 accept_callback.callback()));
108
109 TestCompletionCallback connect_callback;
110 TCPClientSocket connecting_socket(local_address_list(),
111 NULL, NetLog::Source());
112 connecting_socket.Connect(connect_callback.callback());
113
114 EXPECT_EQ(OK, connect_callback.WaitForResult());
115 EXPECT_EQ(OK, accept_callback.WaitForResult());
116
117 EXPECT_TRUE(accepted_socket.get());
118
119 // Both sockets should be on the loopback network interface.
120 EXPECT_EQ(accepted_address.address(), local_address_.address());
121 }
122
123 // Accept two connections simultaneously.
124 TEST_F(TCPSocketTest, Accept2Connections) {
125 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
126
127 TestCompletionCallback accept_callback;
128 scoped_ptr<TCPSocket> accepted_socket;
129 IPEndPoint accepted_address;
130
131 ASSERT_EQ(ERR_IO_PENDING,
132 socket_.Accept(&accepted_socket, &accepted_address,
133 accept_callback.callback()));
134
135 TestCompletionCallback connect_callback;
136 TCPClientSocket connecting_socket(local_address_list(),
137 NULL, NetLog::Source());
138 connecting_socket.Connect(connect_callback.callback());
139
140 TestCompletionCallback connect_callback2;
141 TCPClientSocket connecting_socket2(local_address_list(),
142 NULL, NetLog::Source());
143 connecting_socket2.Connect(connect_callback2.callback());
144
145 EXPECT_EQ(OK, accept_callback.WaitForResult());
146
147 TestCompletionCallback accept_callback2;
148 scoped_ptr<TCPSocket> accepted_socket2;
149 IPEndPoint accepted_address2;
150
151 int result = socket_.Accept(&accepted_socket2, &accepted_address2,
152 accept_callback2.callback());
153 if (result == ERR_IO_PENDING)
154 result = accept_callback2.WaitForResult();
155 ASSERT_EQ(OK, result);
156
157 EXPECT_EQ(OK, connect_callback.WaitForResult());
158 EXPECT_EQ(OK, connect_callback2.WaitForResult());
159
160 EXPECT_TRUE(accepted_socket.get());
161 EXPECT_TRUE(accepted_socket2.get());
162 EXPECT_NE(accepted_socket.get(), accepted_socket2.get());
163
164 EXPECT_EQ(accepted_address.address(), local_address_.address());
165 EXPECT_EQ(accepted_address2.address(), local_address_.address());
166 }
167
168 // Test listening and accepting with a socket bound to an IPv6 address.
169 TEST_F(TCPSocketTest, AcceptIPv6) {
170 bool initialized = false;
171 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv6(&initialized));
172 if (!initialized)
173 return;
174
175 TestCompletionCallback connect_callback;
176 TCPClientSocket connecting_socket(local_address_list(),
177 NULL, NetLog::Source());
178 connecting_socket.Connect(connect_callback.callback());
179
180 TestCompletionCallback accept_callback;
181 scoped_ptr<TCPSocket> accepted_socket;
182 IPEndPoint accepted_address;
183 int result = socket_.Accept(&accepted_socket, &accepted_address,
184 accept_callback.callback());
185 if (result == ERR_IO_PENDING)
186 result = accept_callback.WaitForResult();
187 ASSERT_EQ(OK, result);
188
189 EXPECT_TRUE(accepted_socket.get());
190
191 // Both sockets should be on the loopback network interface.
192 EXPECT_EQ(accepted_address.address(), local_address_.address());
193
194 EXPECT_EQ(OK, connect_callback.WaitForResult());
195 }
196
197 } // namespace
198 } // namespace net
OLDNEW
« no previous file with comments | « net/socket/tcp_socket_libevent.cc ('k') | net/socket/tcp_socket_win.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698