Refactor net tests to use GMock matchers for checking net::Error results

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 "net/socket/unix_domain_client_socket_posix.h"
 
 #include <unistd.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/posix/eintr_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/socket_posix.h"
 #include "net/socket/unix_domain_server_socket_posix.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 namespace {
 
 const char kSocketFilename[] = "socket_for_testing";
 
 bool UserCanConnectCallback(
     bool allow_user, const UnixDomainServerSocket::Credentials& credentials) {
   // Here peers are running in same process.
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   EXPECT_EQ(getpid(), credentials.process_id);
@@ skipping 91 matching lines @@
 
   base::ScopedTempDir temp_dir_;
   std::string socket_path_;
 };
 
 TEST_F(UnixDomainClientSocketTest, Connect) {
   const bool kUseAbstractNamespace = false;
 
   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
                                        kUseAbstractNamespace);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
 
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   EXPECT_FALSE(accepted_socket);
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
 
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
   EXPECT_TRUE(client_socket.IsConnected());
   // Server has not yet been notified of the connection.
   EXPECT_FALSE(accepted_socket);
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket);
   EXPECT_TRUE(accepted_socket->IsConnected());
 }
 
 TEST_F(UnixDomainClientSocketTest, ConnectWithSocketDescriptor) {
   const bool kUseAbstractNamespace = false;
 
   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
                                        kUseAbstractNamespace);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
 
   SocketDescriptor accepted_socket_fd = kInvalidSocket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.AcceptSocketDescriptor(&accepted_socket_fd,
                                                  accept_callback.callback()));
   EXPECT_EQ(kInvalidSocket, accepted_socket_fd);
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
 
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
   EXPECT_TRUE(client_socket.IsConnected());
   // Server has not yet been notified of the connection.
   EXPECT_EQ(kInvalidSocket, accepted_socket_fd);
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_NE(kInvalidSocket, accepted_socket_fd);
 
   SocketDescriptor client_socket_fd = client_socket.ReleaseConnectedSocket();
   EXPECT_NE(kInvalidSocket, client_socket_fd);
 
   // Now, re-wrap client_socket_fd in a UnixDomainClientSocket and try a read
   // to be sure it hasn't gotten accidentally closed.
   SockaddrStorage addr;
   ASSERT_TRUE(UnixDomainClientSocket::FillAddress(socket_path_, false, &addr));
   std::unique_ptr<SocketPosix> adopter(new SocketPosix);
@@ skipping 14 matching lines @@
 
 TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) {
   const bool kUseAbstractNamespace = true;
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
 
 #if defined(OS_ANDROID) || defined(OS_LINUX)
   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
                                        kUseAbstractNamespace);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
 
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   EXPECT_FALSE(accepted_socket);
 
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
   EXPECT_TRUE(client_socket.IsConnected());
   // Server has not yet beend notified of the connection.
   EXPECT_FALSE(accepted_socket);
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket);
   EXPECT_TRUE(accepted_socket->IsConnected());
 #else
-  EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket),
+              IsError(ERR_ADDRESS_INVALID));
 #endif
 }
 
 TEST_F(UnixDomainClientSocketTest, ConnectToNonExistentSocket) {
   const bool kUseAbstractNamespace = false;
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
-  EXPECT_EQ(ERR_FILE_NOT_FOUND, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket),
+              IsError(ERR_FILE_NOT_FOUND));
 }
 
 TEST_F(UnixDomainClientSocketTest,
        ConnectToNonExistentSocketWithAbstractNamespace) {
   const bool kUseAbstractNamespace = true;
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
 
   TestCompletionCallback connect_callback;
 #if defined(OS_ANDROID) || defined(OS_LINUX)
-  EXPECT_EQ(ERR_CONNECTION_REFUSED, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket),
+              IsError(ERR_CONNECTION_REFUSED));
 #else
-  EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket),
+              IsError(ERR_ADDRESS_INVALID));
 #endif
 }
 
 TEST_F(UnixDomainClientSocketTest, DisconnectFromClient) {
   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   UnixDomainClientSocket client_socket(socket_path_, false);
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Try to read data.
   const int kReadDataSize = 10;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
   TestCompletionCallback read_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             accepted_socket->Read(
                 read_buffer.get(), kReadDataSize, read_callback.callback()));
 
   // Disconnect from client side.
   client_socket.Disconnect();
   EXPECT_FALSE(client_socket.IsConnected());
   EXPECT_FALSE(accepted_socket->IsConnected());
 
   // Connection closed by peer.
   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
   // Note that read callback won't be called when the connection is closed
   // locally before the peer closes it. SocketPosix just clears callbacks.
 }
 
 TEST_F(UnixDomainClientSocketTest, DisconnectFromServer) {
   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   UnixDomainClientSocket client_socket(socket_path_, false);
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Try to read data.
   const int kReadDataSize = 10;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
   TestCompletionCallback read_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             client_socket.Read(
                 read_buffer.get(), kReadDataSize, read_callback.callback()));
 
   // Disconnect from server side.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 
   // Connection closed by peer.
   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
   // Note that read callback won't be called when the connection is closed
   // locally before the peer closes it. SocketPosix just clears callbacks.
 }
 
 TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   UnixDomainClientSocket client_socket(socket_path_, false);
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Send data from client to server.
   const int kWriteDataSize = 10;
   scoped_refptr<IOBuffer> write_buffer(
       new StringIOBuffer(std::string(kWriteDataSize, 'd')));
   EXPECT_EQ(
       kWriteDataSize,
       WriteSynchronously(&client_socket, write_buffer.get(), kWriteDataSize));
@@ skipping 40 matching lines @@
       ReadSynchronously(&client_socket, read_buffer.get(), kReadBufferSize, 0));
 
   // Disconnect from server side after read-write.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 }
 
 TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) {
   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
-  EXPECT_EQ(OK, server_socket.BindAndListen(socket_path_, /*backlog=*/1));
+  EXPECT_THAT(server_socket.BindAndListen(socket_path_, /*backlog=*/1), IsOk());
   std::unique_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   UnixDomainClientSocket client_socket(socket_path_, false);
-  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_THAT(ConnectSynchronously(&client_socket), IsOk());
 
-  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_THAT(accept_callback.WaitForResult(), IsOk());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Wait for data from client.
   const int kWriteDataSize = 10;
   const int kReadBufferSize = kWriteDataSize * 2;
   const int kSmallReadBufferSize = kWriteDataSize / 3;
   // Read smaller than write data size first.
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   TestCompletionCallback read_callback;
@@ skipping 27 matching lines @@
                 accepted_socket.get(), read_buffer.get(), kReadBufferSize, 0));
 
   // Disconnect from server side after read-write.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 }
 
 }  // namespace
 }  // namespace net