Refactor unix domain socket.

net/socket/unix_domain_client_socket_posix_unittest.cc

+// Copyright 2014 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/bind.h"
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/run_loop.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/socket/unix_domain_client_socket_posix.h"

[mmenke, 2014/07/10 19:07:28]

nit:  This should go up top

[byungchul, 2014/07/11 02:56:33]

Done.

+#include "net/socket/unix_domain_server_socket_posix.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+const char kSocketFilename[] = "unix_domain_socket_for_testing";
+
+std::string MakeSocketPathForTesting() {

[mmenke, 2014/07/10 19:07:28]

nit:  Maybe Make -> Get?

[mmenke, 2014/07/10 19:07:28]

nit:  "ForTesting" generally not needed in a unittest file.

[byungchul, 2014/07/11 02:56:33]

Done.

[byungchul, 2014/07/11 02:56:33]

Done.

+  base::FilePath temp_dir;
+  base::GetTempDir(&temp_dir);
+  return temp_dir.Append(kSocketFilename).value();

[mmenke, 2014/07/10 19:07:28]

This doesn't work - multiple tests should be able to run in parallel.  Should
create a distinct filename each time the test is run.  I don't know if
CreateTemporaryFile, which actually creates the file itself, works with unix
domain sockets, or if we should just create a temporary directory and then just
use some filename we like there.

Know this is what the old code does, but it's a bug.

[byungchul, 2014/07/11 02:56:33]

Creates a temp dir instead.

+}
+
+bool UserCanConnectCallback(bool allow_user, uid_t uid, gid_t gid) {
+  return allow_user;
+}
+
+UnixDomainServerSocket::AuthCallback GetAuthCallback(bool allow_user) {
+  return base::Bind(&UserCanConnectCallback, allow_user);
+}
+
+void CallbackWithExpectedResultValue(int expected_rv, int rv) {
+  EXPECT_EQ(expected_rv, rv);
+}
+
+CompletionCallback GetCompletionCallback(int expected_rv) {

[mmenke, 2014/07/10 19:07:28]

nit:  Maybe Get -> Create?

[byungchul, 2014/07/11 02:56:33]

Done.

+  return base::Bind(&CallbackWithExpectedResultValue, expected_rv);
+}
+
+}  // namespace
+
+class UnixDomainClientSocketTest : public testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    DeleteSocketPathForTesting();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    DeleteSocketPathForTesting();
+  }
+
+  void DeleteSocketPathForTesting() {

[mmenke, 2014/07/10 19:07:28]

nit:  "ForTesting" generally not needed in a unittest file.

[byungchul, 2014/07/11 02:56:33]

Done.

+    base::DeleteFile(base::FilePath(MakeSocketPathForTesting()), false);
+  }
+};
+
+TEST_F(UnixDomainClientSocketTest, Connect) {
+  const std::string socket_path(MakeSocketPathForTesting());
+  const bool use_abstract_namespace = false;

[mmenke, 2014/07/10 19:07:28]

Sure use kConstNamingScheme for consts, I believe.

[byungchul, 2014/07/11 02:56:33]

Done.

+
+  UnixDomainServerSocket server_socket(GetAuthCallback(true),
+                                       use_abstract_namespace);
+  EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path, 0, 1));
+
+  scoped_ptr<StreamSocket> accepted_socket;
+  EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket,
+                                                 GetCompletionCallback(OK)));
+  EXPECT_TRUE(!accepted_socket);
+
+  UnixDomainClientSocket client_socket(socket_path, use_abstract_namespace);
+  EXPECT_FALSE(client_socket.IsConnected());
+
+  EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK)));
+  EXPECT_TRUE(client_socket.IsConnected());
+  // Not yet notified to server.
+  EXPECT_TRUE(!accepted_socket);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(accepted_socket);
+  EXPECT_TRUE(accepted_socket->IsConnected());
+}
+
+TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) {
+  const std::string socket_path(MakeSocketPathForTesting());
+  const bool use_abstract_namespace = true;
+
+  UnixDomainClientSocket client_socket(socket_path, use_abstract_namespace);
+  EXPECT_FALSE(client_socket.IsConnected());
+
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+  UnixDomainServerSocket server_socket(GetAuthCallback(true),
+                                       use_abstract_namespace);
+  EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path, 0, 1));
+
+  scoped_ptr<StreamSocket> accepted_socket;
+  EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket,
+                                                 GetCompletionCallback(OK)));
+  EXPECT_TRUE(!accepted_socket);
+
+  EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK)));
+  EXPECT_TRUE(client_socket.IsConnected());
+  // Not yet notified to server.
+  EXPECT_TRUE(!accepted_socket);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(accepted_socket);
+  EXPECT_TRUE(accepted_socket->IsConnected());
+#else
+  EXPECT_EQ(ERR_ADDRESS_INVALID,
+            client_socket.Connect(GetCompletionCallback(OK)));
+#endif
+}
+
+TEST_F(UnixDomainClientSocketTest, ConnectToNonExistingSocket) {
+  const std::string socket_path(MakeSocketPathForTesting());
+  const bool use_abstract_namespace = false;
+
+  UnixDomainClientSocket client_socket(socket_path, use_abstract_namespace);
+  EXPECT_FALSE(client_socket.IsConnected());
+  EXPECT_EQ(ERR_FILE_NOT_FOUND,
+            client_socket.Connect(GetCompletionCallback(OK)));
+}
+
+TEST_F(UnixDomainClientSocketTest,
+       ConnectToNonExistingSocketWithAbstractNamespace) {
+  const std::string socket_path(MakeSocketPathForTesting());
+  const bool use_abstract_namespace = true;
+
+  UnixDomainClientSocket client_socket(socket_path, use_abstract_namespace);
+  EXPECT_FALSE(client_socket.IsConnected());
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+  EXPECT_EQ(ERR_CONNECTION_REFUSED,
+            client_socket.Connect(GetCompletionCallback(OK)));
+#else
+  EXPECT_EQ(ERR_ADDRESS_INVALID,
+            client_socket.Connect(GetCompletionCallback(OK)));
+#endif
+}
+
+TEST_F(UnixDomainClientSocketTest, ReadWrite) {
+  const std::string socket_path(MakeSocketPathForTesting());
+
+  UnixDomainServerSocket server_socket(GetAuthCallback(true), false);
+  EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path, 0, 1));
+  scoped_ptr<StreamSocket> accepted_socket;
+  EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket,
+                                                 GetCompletionCallback(OK)));
+  UnixDomainClientSocket client_socket(socket_path, false);
+  EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK)));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(accepted_socket->IsConnected());
+  EXPECT_TRUE(client_socket.IsConnected());
+
+  // Sends data from client to server.
+  const int write_data_size = 10;
+  scoped_refptr<IOBuffer> write_buffer(
+      new StringIOBuffer(std::string(write_data_size, 'd')));
+  EXPECT_EQ(write_data_size,
+            client_socket.Write(write_buffer, write_data_size,
+                                GetCompletionCallback(OK)));
+  // Buffer bigger than write data size.
+  const int read_buffer_size = write_data_size * 2;
+  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(read_buffer_size));
+  EXPECT_EQ(write_data_size,
+            accepted_socket->Read(read_buffer, read_buffer_size,
+                                  GetCompletionCallback(OK)));
+
+  // Sends data from server and client
+  EXPECT_EQ(write_data_size,
+            accepted_socket->Write(write_buffer, write_data_size,
+                                   GetCompletionCallback(OK)));
+  // Reads multiple times.
+  const int small_read_buffer_size = write_data_size / 3;
+  EXPECT_EQ(small_read_buffer_size,
+            client_socket.Read(read_buffer, small_read_buffer_size,
+                               GetCompletionCallback(OK)));
+  EXPECT_EQ(write_data_size - small_read_buffer_size,
+            client_socket.Read(read_buffer, read_buffer_size,
+                               GetCompletionCallback(OK)));
+  // No more data.
+  EXPECT_EQ(ERR_IO_PENDING,
+            client_socket.Read(read_buffer, read_buffer_size,
+                               GetCompletionCallback(ERR_CONNECTION_CLOSED)));
+}
+
+TEST_F(UnixDomainClientSocketTest, ReadWriteAsynchronously) {
+  const std::string socket_path(MakeSocketPathForTesting());
+
+  UnixDomainServerSocket server_socket(GetAuthCallback(true), false);
+  EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path, 0, 1));
+  scoped_ptr<StreamSocket> accepted_socket;
+  EXPECT_EQ(ERR_IO_PENDING, server_socket.Accept(&accepted_socket,
+                                                 GetCompletionCallback(OK)));
+  UnixDomainClientSocket client_socket(socket_path, false);
+  EXPECT_EQ(OK, client_socket.Connect(GetCompletionCallback(OK)));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(accepted_socket->IsConnected());
+  EXPECT_TRUE(client_socket.IsConnected());
+
+  // Waits for data from client.
+  const int write_data_size = 10;
+  const int read_buffer_size = write_data_size * 2;
+  const int small_read_buffer_size = write_data_size / 3;
+  // Reads smaller than write data size first.
+  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(read_buffer_size));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      accepted_socket->Read(read_buffer, small_read_buffer_size,
+                            GetCompletionCallback(small_read_buffer_size)));
+
+  scoped_refptr<IOBuffer> write_buffer(
+      new StringIOBuffer(std::string(write_data_size, 'd')));
+  EXPECT_EQ(write_data_size,
+            client_socket.Write(write_buffer, write_data_size,
+                                GetCompletionCallback(OK)));
+
+  base::RunLoop().RunUntilIdle();
+  // First read completed.
+
+  // Reads remaining data.
+  EXPECT_EQ(write_data_size - small_read_buffer_size,
+            accepted_socket->Read(read_buffer, read_buffer_size,
+                                  GetCompletionCallback(OK)));
+  // No more data.
+  EXPECT_EQ(ERR_IO_PENDING,
+            accepted_socket->Read(
+                read_buffer, read_buffer_size,
+                GetCompletionCallback(ERR_CONNECTION_CLOSED)));
+}
+
+}  // namespace net