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

net/socket/transport_client_socket_unittest.cc

 // Copyright (c) 2012 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 <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_server_socket.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 const char kServerReply[] = "HTTP/1.1 404 Not Found";
 
 enum ClientSocketTestTypes { TCP, SCTP };
 
 }  // namespace
 
 class TransportClientSocketTest
     : public ::testing::TestWithParam<ClientSocketTestTypes> {
  public:
   TransportClientSocketTest()
       : listen_port_(0),
         socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         close_server_socket_on_next_send_(false) {}
 
   virtual ~TransportClientSocketTest() {}
 
   // Testcase hooks
   void SetUp() override;
 
   void CloseServerSocket() {
     // delete the connected_sock_, which will close it.
     connected_sock_.reset();
   }
 
   void AcceptCallback(int res) {
-    ASSERT_EQ(OK, res);
+    ASSERT_THAT(res, IsOk());
     connect_loop_.Quit();
   }
 
   int DrainClientSocket(IOBuffer* buf,
                         uint32_t buf_len,
                         uint32_t bytes_to_read,
                         TestCompletionCallback* callback);
 
   // Establishes a connection to the server.
   void EstablishConnection(TestCompletionCallback* callback);
@@ skipping 25 matching lines @@
   std::unique_ptr<TCPServerSocket> listen_sock_;
   bool close_server_socket_on_next_send_;
 };
 
 void TransportClientSocketTest::SetUp() {
   ::testing::TestWithParam<ClientSocketTestTypes>::SetUp();
 
   // Open a server socket on an ephemeral port.
   listen_sock_.reset(new TCPServerSocket(NULL, NetLog::Source()));
   IPEndPoint local_address(IPAddress::IPv4Localhost(), 0);
-  ASSERT_EQ(OK, listen_sock_->Listen(local_address, 1));
+  ASSERT_THAT(listen_sock_->Listen(local_address, 1), IsOk());
   // Get the server's address (including the actual port number).
-  ASSERT_EQ(OK, listen_sock_->GetLocalAddress(&local_address));
+  ASSERT_THAT(listen_sock_->GetLocalAddress(&local_address), IsOk());
   listen_port_ = local_address.port();
   listen_sock_->Accept(&connected_sock_,
                        base::Bind(&TransportClientSocketTest::AcceptCallback,
                                   base::Unretained(this)));
 
   AddressList addr;
   // MockHostResolver resolves everything to 127.0.0.1.
   std::unique_ptr<HostResolver> resolver(new MockHostResolver());
   HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_));
   TestCompletionCallback callback;
@@ skipping 24 matching lines @@
 
   return static_cast<int>(bytes_read);
 }
 
 void TransportClientSocketTest::EstablishConnection(
     TestCompletionCallback* callback) {
   int rv = sock_->Connect(callback->callback());
   // Wait for |listen_sock_| to accept a connection.
   connect_loop_.Run();
   // Now wait for the client socket to accept the connection.
-  EXPECT_EQ(OK, callback->GetResult(rv));
+  EXPECT_THAT(callback->GetResult(rv), IsOk());
 }
 
 void TransportClientSocketTest::SendRequestAndResponse() {
   // Send client request.
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   int request_len = strlen(request_text);
   scoped_refptr<DrainableIOBuffer> request_buffer(
       new DrainableIOBuffer(new IOBuffer(request_len), request_len));
   memcpy(request_buffer->data(), request_text, request_len);
 
@@ skipping 165 matching lines @@
   scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
   uint32_t bytes_read =
       DrainClientSocket(buf.get(), 4096, strlen(kServerReply), &callback);
   ASSERT_EQ(bytes_read, strlen(kServerReply));
   ASSERT_EQ(std::string(kServerReply), std::string(buf->data(), bytes_read));
 
   // All data has been read now.  Read once more to force an ERR_IO_PENDING, and
   // then close the server socket, and note the close.
 
   int rv = sock_->Read(buf.get(), 4096, callback.callback());
-  ASSERT_EQ(ERR_IO_PENDING, rv);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   CloseServerSocket();
   EXPECT_EQ(0, callback.WaitForResult());
 }
 
 TEST_P(TransportClientSocketTest, Read_SmallChunks) {
   TestCompletionCallback callback;
   EstablishConnection(&callback);
 
   SendRequestAndResponse();
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(1));
   uint32_t bytes_read = 0;
   while (bytes_read < strlen(kServerReply)) {
     int rv = sock_->Read(buf.get(), 1, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
     rv = callback.GetResult(rv);
 
     ASSERT_EQ(1, rv);
     bytes_read += rv;
   }
 
   // All data has been read now.  Read once more to force an ERR_IO_PENDING, and
   // then close the server socket, and note the close.
 
   int rv = sock_->Read(buf.get(), 1, callback.callback());
-  ASSERT_EQ(ERR_IO_PENDING, rv);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   CloseServerSocket();
   EXPECT_EQ(0, callback.WaitForResult());
 }
 
 TEST_P(TransportClientSocketTest, Read_Interrupted) {
   TestCompletionCallback callback;
   EstablishConnection(&callback);
 
   SendRequestAndResponse();
 
   // Do a partial read and then exit.  This test should not crash!
   scoped_refptr<IOBuffer> buf(new IOBuffer(16));
   int rv = sock_->Read(buf.get(), 16, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
   rv = callback.GetResult(rv);
 
   EXPECT_NE(0, rv);
 }
 
 TEST_P(TransportClientSocketTest, FullDuplex_ReadFirst) {
   TestCompletionCallback callback;
   EstablishConnection(&callback);
 
   // Read first.  There's no data, so it should return ERR_IO_PENDING.
   const int kBufLen = 4096;
   scoped_refptr<IOBuffer> buf(new IOBuffer(kBufLen));
   int rv = sock_->Read(buf.get(), kBufLen, callback.callback());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   const int kWriteBufLen = 64 * 1024;
   scoped_refptr<IOBuffer> request_buffer(new IOBuffer(kWriteBufLen));
   char* request_data = request_buffer->data();
   memset(request_data, 'A', kWriteBufLen);
   TestCompletionCallback write_callback;
 
   int bytes_written = 0;
   while (true) {
     rv = sock_->Write(request_buffer.get(), kWriteBufLen,
@@ skipping 61 matching lines @@
 
   // It's possible the read is blocked because it's already read all the data.
   // Close the server socket, so there will at least be a 0-byte read.
   CloseServerSocket();
 
   rv = callback.WaitForResult();
   EXPECT_GE(rv, 0);
 }
 
 }  // namespace net