Move server socket functionality from TCPServerSocket into TCPSocket.

net/socket/tcp_socket_unittest.cc

Index: net/socket/tcp_socket_unittest.cc
diff --git a/net/socket/tcp_socket_unittest.cc b/net/socket/tcp_socket_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6c9a29a39b4eca18f45715f8aa1b203ad1940008
--- /dev/null
+++ b/net/socket/tcp_socket_unittest.cc
@@ -0,0 +1,198 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/socket/tcp_socket.h"
+
+// TODO(yzshen): revisit includes.
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/address_list.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/socket/tcp_client_socket.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+namespace net {
+
+namespace {
+const int kListenBacklog = 5;
+
+class TCPSocketTest : public PlatformTest {
+ protected:
+  TCPSocketTest() : socket_(NULL, NetLog::Source()) {
+  }
+
+  void SetUpListenIPv4() {
+    IPEndPoint address;
+    ParseAddress("127.0.0.1", 0, &address);
+
+    ASSERT_EQ(OK, socket_.Create(ADDRESS_FAMILY_IPV4));
+    ASSERT_EQ(OK, socket_.Bind(address));
+    ASSERT_EQ(OK, socket_.Listen(kListenBacklog));
+    ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
+  }
+
+  void SetUpListenIPv6(bool* success) {
+    *success = false;
+    IPEndPoint address;
+    ParseAddress("::1", 0, &address);
+
+    if (socket_.Create(ADDRESS_FAMILY_IPV6) != OK ||
+        socket_.Bind(address) != OK ||
+        socket_.Listen(kListenBacklog) != OK) {
+      LOG(ERROR) << "Failed to listen on ::1 - probably because IPv6 is "
+          "disabled. Skipping the test";
+      return;
+    }
+    ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
+    *success = true;
+  }
+
+  void ParseAddress(const std::string& ip_str, int port, IPEndPoint* address) {
+    IPAddressNumber ip_number;
+    bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
+    if (!rv)
+      return;
+    *address = IPEndPoint(ip_number, port);
+  }
+
+  AddressList local_address_list() const {
+    return AddressList(local_address_);
+  }
+
+  TCPSocket socket_;
+  IPEndPoint local_address_;
+};
+
+TEST_F(TCPSocketTest, Accept) {

[akalin, 2013/08/29 22:08:33]

can you add comments for Accept and AcceptIPV6?

[yzshen1, 2013/08/29 23:04:18]

Done.

+  ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
+
+  TestCompletionCallback connect_callback;
+  // TODO(yzshen): Switch to use TCPSocket when it supports client socket
+  // operations.
+  TCPClientSocket connecting_socket(local_address_list(),
+                                    NULL, NetLog::Source());
+  connecting_socket.Connect(connect_callback.callback());
+
+  TestCompletionCallback accept_callback;
+  scoped_ptr<TCPSocket> accepted_socket;
+  IPEndPoint accepted_address;
+  int result = socket_.Accept(&accepted_socket, &accepted_address,
+                              accept_callback.callback());
+  if (result == ERR_IO_PENDING)
+    result = accept_callback.WaitForResult();
+  ASSERT_EQ(OK, result);
+
+  EXPECT_TRUE(accepted_socket.get());
+
+  // Both sockets should be on the loopback network interface.
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+
+  EXPECT_EQ(OK, connect_callback.WaitForResult());
+}
+
+// Test Accept() callback.
+TEST_F(TCPSocketTest, AcceptAsync) {
+  ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
+
+  TestCompletionCallback accept_callback;
+  scoped_ptr<TCPSocket> accepted_socket;
+  IPEndPoint accepted_address;
+  ASSERT_EQ(ERR_IO_PENDING,
+            socket_.Accept(&accepted_socket, &accepted_address,
+                           accept_callback.callback()));
+
+  TestCompletionCallback connect_callback;
+  TCPClientSocket connecting_socket(local_address_list(),
+                                    NULL, NetLog::Source());
+  connecting_socket.Connect(connect_callback.callback());
+
+  EXPECT_EQ(OK, connect_callback.WaitForResult());
+  EXPECT_EQ(OK, accept_callback.WaitForResult());
+
+  EXPECT_TRUE(accepted_socket.get());
+
+  // Both sockets should be on the loopback network interface.
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+}
+
+// Accept two connections simultaneously.
+TEST_F(TCPSocketTest, Accept2Connections) {
+  ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
+
+  TestCompletionCallback accept_callback;
+  scoped_ptr<TCPSocket> accepted_socket;
+  IPEndPoint accepted_address;
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            socket_.Accept(&accepted_socket, &accepted_address,
+                           accept_callback.callback()));
+
+  TestCompletionCallback connect_callback;
+  TCPClientSocket connecting_socket(local_address_list(),
+                                    NULL, NetLog::Source());
+  connecting_socket.Connect(connect_callback.callback());
+
+  TestCompletionCallback connect_callback2;
+  TCPClientSocket connecting_socket2(local_address_list(),
+                                     NULL, NetLog::Source());
+  connecting_socket2.Connect(connect_callback2.callback());
+
+  EXPECT_EQ(OK, accept_callback.WaitForResult());
+
+  TestCompletionCallback accept_callback2;
+  scoped_ptr<TCPSocket> accepted_socket2;
+  IPEndPoint accepted_address2;
+
+  int result = socket_.Accept(&accepted_socket2, &accepted_address2,
+                              accept_callback2.callback());
+  if (result == ERR_IO_PENDING)
+    result = accept_callback2.WaitForResult();
+  ASSERT_EQ(OK, result);
+
+  EXPECT_EQ(OK, connect_callback.WaitForResult());
+  EXPECT_EQ(OK, connect_callback2.WaitForResult());
+
+  EXPECT_TRUE(accepted_socket.get());
+  EXPECT_TRUE(accepted_socket2.get());
+  EXPECT_NE(accepted_socket.get(), accepted_socket2.get());
+
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+  EXPECT_EQ(accepted_address2.address(), local_address_.address());
+}
+
+TEST_F(TCPSocketTest, AcceptIPv6) {
+  bool initialized = false;
+  ASSERT_NO_FATAL_FAILURE(SetUpListenIPv6(&initialized));
+  if (!initialized)
+    return;
+
+  TestCompletionCallback connect_callback;
+  TCPClientSocket connecting_socket(local_address_list(),
+                                    NULL, NetLog::Source());
+  connecting_socket.Connect(connect_callback.callback());
+
+  TestCompletionCallback accept_callback;
+  scoped_ptr<TCPSocket> accepted_socket;
+  IPEndPoint accepted_address;
+  int result = socket_.Accept(&accepted_socket, &accepted_address,
+                              accept_callback.callback());
+  if (result == ERR_IO_PENDING)
+    result = accept_callback.WaitForResult();
+  ASSERT_EQ(OK, result);
+
+  EXPECT_TRUE(accepted_socket.get());
+
+  // Both sockets should be on the loopback network interface.
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+
+  EXPECT_EQ(OK, connect_callback.WaitForResult());
+}
+
+}  // namespace
+}  // namespace net