Added TCPServerSocket.

net/socket/tcp_server_socket_unittest.cc

Index: net/socket/tcp_server_socket_unittest.cc
diff --git a/net/socket/tcp_server_socket_unittest.cc b/net/socket/tcp_server_socket_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2f718cc7425891e679658b84d198971977755981
--- /dev/null
+++ b/net/socket/tcp_server_socket_unittest.cc
@@ -0,0 +1,145 @@
+// Copyright (c) 2011 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 "base/compiler_specific.h"
+#include "base/scoped_ptr.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/socket/tcp_server_socket.h"
+#include "net/base/test_completion_callback.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+namespace net {
+
+namespace {
+int kListenBacklog = 5;
+}  // namespace
+
+class TCPServerSocketTest : public PlatformTest {
+ protected:
+  void SetUp() OVERRIDE {
+    socket_.reset(new TCPServerSocket(NULL, NetLog::Source()));
+    IPEndPoint address;
+    ParseAddress("127.0.0.1", 0, &address);
+    ASSERT_EQ(0, socket_->Bind(address, kListenBacklog));
+    ASSERT_EQ(0, socket_->GetLocalAddress(&local_address_));
+  }
+
+  void ParseAddress(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);
+  }
+
+  scoped_ptr<TCPServerSocket> socket_;
+  IPEndPoint local_address_;
+};
+
+TEST_F(TCPServerSocketTest, Accept) {
+  TestCompletionCallback connect_callback;
+  scoped_ptr<TCPClientSocket> connecting_socket(
+      new TCPClientSocket(AddressList(local_address_.address(),
+                                      local_address_.port(), false),
+                          NULL, NetLog::Source()));
+  connecting_socket->Connect(&connect_callback);
+
+  TestCompletionCallback accept_callback;
+  TCPClientSocket* accepted_socket;
+  IPEndPoint accepted_address;
+  int result = socket_->Accept(&accepted_socket, &accepted_address,
+                               &accept_callback);
+  if (result == ERR_IO_PENDING)
+    result = accept_callback.WaitForResult();
+  ASSERT_EQ(0, result);
+
+  EXPECT_TRUE(accepted_socket != NULL);
+  // Both sockets should be on the loopback network interface.
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+
+  EXPECT_EQ(0, connect_callback.WaitForResult());
+
+  delete accepted_socket;
+}
+
+// Test Accept() callback.
+TEST_F(TCPServerSocketTest, AcceptAsync) {
+  TestCompletionCallback accept_callback;
+  TCPClientSocket* accepted_socket;
+  IPEndPoint accepted_address;
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            socket_->Accept(&accepted_socket, &accepted_address,
+                            &accept_callback));
+
+  TestCompletionCallback connect_callback;
+  scoped_ptr<TCPClientSocket> connecting_socket(
+      new TCPClientSocket(AddressList(local_address_.address(),
+                                      local_address_.port(), false),
+                          NULL, NetLog::Source()));
+  connecting_socket->Connect(&connect_callback);
+
+  EXPECT_EQ(0, connect_callback.WaitForResult());
+  EXPECT_EQ(0, accept_callback.WaitForResult());
+
+  EXPECT_TRUE(accepted_socket != NULL);
+
+  // Both sockets should be on the loopback network interface.
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+
+  delete accepted_socket;
+}
+
+// Accept two connections simultaneously.
+TEST_F(TCPServerSocketTest, Accept2Connections) {
+  TestCompletionCallback accept_callback;
+  TCPClientSocket* accepted_socket;
+  IPEndPoint accepted_address;
+
+  ASSERT_EQ(ERR_IO_PENDING,
+            socket_->Accept(&accepted_socket, &accepted_address,
+                            &accept_callback));
+
+  TestCompletionCallback connect_callback;
+  scoped_ptr<TCPClientSocket> connecting_socket(
+      new TCPClientSocket(AddressList(local_address_.address(),
+                                      local_address_.port(), false),
+                          NULL, NetLog::Source()));
+  connecting_socket->Connect(&connect_callback);
+
+  TestCompletionCallback connect_callback2;
+  scoped_ptr<TCPClientSocket> connecting_socket2(
+      new TCPClientSocket(AddressList(local_address_.address(),
+                                      local_address_.port(), false),
+                          NULL, NetLog::Source()));
+  connecting_socket2->Connect(&connect_callback2);
+
+  EXPECT_EQ(0, accept_callback.WaitForResult());
+
+  TestCompletionCallback accept_callback2;
+  TCPClientSocket* accepted_socket2;
+  IPEndPoint accepted_address2;
+  int result = socket_->Accept(&accepted_socket2, &accepted_address2,
+                               &accept_callback2);
+  if (result == ERR_IO_PENDING)
+    result = accept_callback2.WaitForResult();
+  ASSERT_EQ(0, result);
+
+  EXPECT_EQ(0, connect_callback.WaitForResult());
+
+  EXPECT_TRUE(accepted_socket != NULL);
+  EXPECT_TRUE(accepted_socket2 != NULL);
+  EXPECT_NE(accepted_socket, accepted_socket2);
+
+  EXPECT_EQ(accepted_address.address(), local_address_.address());
+  EXPECT_EQ(accepted_address2.address(), local_address_.address());
+
+  delete accepted_socket;
+  delete accepted_socket2;
+}
+
+
+}  // namespace net