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

net/proxy/mojo_proxy_resolver_impl_unittest.cc

 // Copyright 2015 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/proxy/mojo_proxy_resolver_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_v8_tracing.h"
 #include "net/proxy/proxy_server.h"
 #include "net/test/event_waiter.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 {
 
 class TestRequestClient : public interfaces::ProxyResolverRequestClient {
  public:
   enum Event {
     RESULT_RECEIVED,
     CONNECTION_ERROR,
   };
 
@@ skipping 169 matching lines @@
   request.results->UsePacString(
       "PROXY proxy.example.com:1; "
       "SOCKS4 socks4.example.com:2; "
       "SOCKS5 socks5.example.com:3; "
       "HTTPS https.example.com:4; "
       "QUIC quic.example.com:65000; "
       "DIRECT");
   request.callback.Run(OK);
   client.WaitForResult();
 
-  EXPECT_EQ(OK, client.error());
+  EXPECT_THAT(client.error(), IsOk());
   std::vector<ProxyServer> servers =
       client.results().To<std::vector<ProxyServer>>();
   ASSERT_EQ(6u, servers.size());
   EXPECT_EQ(ProxyServer::SCHEME_HTTP, servers[0].scheme());
   EXPECT_EQ("proxy.example.com", servers[0].host_port_pair().host());
   EXPECT_EQ(1, servers[0].host_port_pair().port());
 
   EXPECT_EQ(ProxyServer::SCHEME_SOCKS4, servers[1].scheme());
   EXPECT_EQ("socks4.example.com", servers[1].host_port_pair().host());
   EXPECT_EQ(2, servers[1].host_port_pair().port());
@@ skipping 18 matching lines @@
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request.url);
   request.callback.Run(ERR_FAILED);
   client.WaitForResult();
 
-  EXPECT_EQ(ERR_FAILED, client.error());
+  EXPECT_THAT(client.error(), IsError(ERR_FAILED));
   std::vector<ProxyServer> proxy_servers =
       client.results().To<std::vector<ProxyServer>>();
   EXPECT_TRUE(proxy_servers.empty());
 }
 
 TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
   interfaces::ProxyResolverRequestClientPtr client_ptr1;
   TestRequestClient client1(mojo::GetProxy(&client_ptr1));
   interfaces::ProxyResolverRequestClientPtr client_ptr2;
   TestRequestClient client2(mojo::GetProxy(&client_ptr2));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr1));
   resolver_->GetProxyForUrl(GURL("https://example.com"),
                             std::move(client_ptr2));
   ASSERT_EQ(2u, mock_proxy_resolver_->pending_requests().size());
   const MockProxyResolverV8Tracing::Request& request1 =
       mock_proxy_resolver_->pending_requests()[0];
   EXPECT_EQ(GURL("http://example.com"), request1.url);
   const MockProxyResolverV8Tracing::Request& request2 =
       mock_proxy_resolver_->pending_requests()[1];
   EXPECT_EQ(GURL("https://example.com"), request2.url);
   request1.results->UsePacString("HTTPS proxy.example.com:12345");
   request1.callback.Run(OK);
   request2.results->UsePacString("SOCKS5 another-proxy.example.com:6789");
   request2.callback.Run(OK);
   client1.WaitForResult();
   client2.WaitForResult();
 
-  EXPECT_EQ(OK, client1.error());
+  EXPECT_THAT(client1.error(), IsOk());
   std::vector<ProxyServer> proxy_servers1 =
       client1.results().To<std::vector<ProxyServer>>();
   ASSERT_EQ(1u, proxy_servers1.size());
   ProxyServer& server1 = proxy_servers1[0];
   EXPECT_EQ(ProxyServer::SCHEME_HTTPS, server1.scheme());
   EXPECT_EQ("proxy.example.com", server1.host_port_pair().host());
   EXPECT_EQ(12345, server1.host_port_pair().port());
 
-  EXPECT_EQ(OK, client2.error());
+  EXPECT_THAT(client2.error(), IsOk());
   std::vector<ProxyServer> proxy_servers2 =
       client2.results().To<std::vector<ProxyServer>>();
   ASSERT_EQ(1u, proxy_servers1.size());
   ProxyServer& server2 = proxy_servers2[0];
   EXPECT_EQ(ProxyServer::SCHEME_SOCKS5, server2.scheme());
   EXPECT_EQ("another-proxy.example.com", server2.host_port_pair().host());
   EXPECT_EQ(6789, server2.host_port_pair().port());
 }
 
 TEST_F(MojoProxyResolverImplTest, DestroyClient) {
@@ skipping 15 matching lines @@
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl(GURL("http://example.com"), std::move(client_ptr));
   ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   resolver_impl_.reset();
   client.event_waiter().WaitForEvent(TestRequestClient::CONNECTION_ERROR);
 }
 
 }  // namespace net