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

net/socket/socks_client_socket_pool_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 "net/socket/socks_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.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 int kMaxSockets = 32;
 const int kMaxSocketsPerGroup = 6;
 
 // Make sure |handle|'s load times are set correctly.  Only connect times should
 // be set.
 void TestLoadTimingInfo(const ClientSocketHandle& handle) {
@@ skipping 95 matching lines @@
 
 TEST_F(SOCKSClientSocketPoolTest, Simple) {
   SOCKS5MockData data(SYNCHRONOUS);
   data.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
 
   ClientSocketHandle handle;
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        CompletionCallback(), &pool_, BoundNetLog());
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 // Make sure that SOCKSConnectJob passes on its priority to its
 // socket request on Init.
 TEST_F(SOCKSClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
@@ skipping 34 matching lines @@
 
 TEST_F(SOCKSClientSocketPoolTest, Async) {
   SOCKS5MockData data(ASYNC);
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), &pool_, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 TEST_F(SOCKSClientSocketPoolTest, TransportConnectError) {
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS,
                                            ERR_CONNECTION_REFUSED));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   ClientSocketHandle handle;
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        CompletionCallback(), &pool_, BoundNetLog());
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
+  EXPECT_THAT(rv, IsError(ERR_PROXY_CONNECTION_FAILED));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, AsyncTransportConnectError) {
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), &pool_, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
-  EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_CONNECTION_FAILED));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, SOCKSConnectError) {
   MockRead failed_read[] = {
     MockRead(SYNCHRONOUS, 0),
   };
   StaticSocketDataProvider socket_data(
       failed_read, arraysize(failed_read), NULL, 0);
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   ClientSocketHandle handle;
   EXPECT_EQ(0, transport_socket_pool_.release_count());
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        CompletionCallback(), &pool_, BoundNetLog());
-  EXPECT_EQ(ERR_SOCKS_CONNECTION_FAILED, rv);
+  EXPECT_THAT(rv, IsError(ERR_SOCKS_CONNECTION_FAILED));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_EQ(1, transport_socket_pool_.release_count());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, AsyncSOCKSConnectError) {
   MockRead failed_read[] = {
     MockRead(ASYNC, 0),
   };
   StaticSocketDataProvider socket_data(
         failed_read, arraysize(failed_read), NULL, 0);
   socket_data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   EXPECT_EQ(0, transport_socket_pool_.release_count());
   int rv = handle.Init("a", CreateSOCKSv5Params(), LOW,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), &pool_, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
-  EXPECT_EQ(ERR_SOCKS_CONNECTION_FAILED, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SOCKS_CONNECTION_FAILED));
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_EQ(1, transport_socket_pool_.release_count());
 }
 
 TEST_F(SOCKSClientSocketPoolTest, CancelDuringTransportConnect) {
   SOCKS5MockData data(SYNCHRONOUS);
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
   // We need two connections because the pool base lets one cancelled
   // connect job proceed for potential future use.
   SOCKS5MockData data2(SYNCHRONOUS);
   transport_client_socket_factory_.AddSocketDataProvider(data2.data_provider());
 
   EXPECT_EQ(0, transport_socket_pool_.cancel_count());
   int rv = StartRequestV5("a", LOW);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = StartRequestV5("a", LOW);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   pool_.CancelRequest("a", (*requests())[0]->handle());
   pool_.CancelRequest("a", (*requests())[1]->handle());
   // Requests in the connect phase don't actually get cancelled.
   EXPECT_EQ(0, transport_socket_pool_.cancel_count());
 
   // Now wait for the TCP sockets to connect.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, GetOrderOfRequest(1));
@@ skipping 11 matching lines @@
   transport_client_socket_factory_.AddSocketDataProvider(data.data_provider());
   // We need two connections because the pool base lets one cancelled
   // connect job proceed for potential future use.
   SOCKS5MockData data2(ASYNC);
   data2.data_provider()->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   transport_client_socket_factory_.AddSocketDataProvider(data2.data_provider());
 
   EXPECT_EQ(0, transport_socket_pool_.cancel_count());
   EXPECT_EQ(0, transport_socket_pool_.release_count());
   int rv = StartRequestV5("a", LOW);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   rv = StartRequestV5("a", LOW);
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   pool_.CancelRequest("a", (*requests())[0]->handle());
   pool_.CancelRequest("a", (*requests())[1]->handle());
   EXPECT_EQ(0, transport_socket_pool_.cancel_count());
   // Requests in the connect phase don't actually get cancelled.
   EXPECT_EQ(0, transport_socket_pool_.release_count());
 
   // Now wait for the async data to reach the SOCKS connect jobs.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, GetOrderOfRequest(1));
   EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, GetOrderOfRequest(2));
   EXPECT_EQ(0, transport_socket_pool_.cancel_count());
   EXPECT_EQ(0, transport_socket_pool_.release_count());
   EXPECT_EQ(2, pool_.IdleSocketCount());
 
   (*requests())[0]->handle()->Reset();
   (*requests())[1]->handle()->Reset();
 }
 
 // It would be nice to also test the timeouts in SOCKSClientSocketPool.
 
 }  // namespace
 
 }  // namespace net