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

net/http/http_network_layer_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/http/http_network_layer.h"
 
 #include <utility>
 
 #include "base/strings/stringprintf.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/ssl/ssl_config_service_defaults.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 {
 
 class HttpNetworkLayerTest : public PlatformTest {
  protected:
   HttpNetworkLayerTest() : ssl_config_service_(new SSLConfigServiceDefaults) {}
 
   void SetUp() override {
     ConfigureTestDependencies(ProxyService::CreateDirect());
@@ skipping 23 matching lines @@
                                                const std::string& value) {
     TestCompletionCallback callback;
 
     HttpRequestInfo request_info;
     request_info.url = GURL("http://www.google.com/");
     request_info.method = method;
     request_info.load_flags = LOAD_NORMAL;
 
     std::unique_ptr<HttpTransaction> trans;
     int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-    EXPECT_EQ(OK, rv);
+    EXPECT_THAT(rv, IsOk());
 
     rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
-    ASSERT_EQ(OK, rv);
+    ASSERT_THAT(rv, IsOk());
 
     std::string contents;
     rv = ReadTransaction(trans.get(), &contents);
-    EXPECT_EQ(OK, rv);
+    EXPECT_THAT(rv, IsOk());
     EXPECT_EQ(content, contents);
 
     if (!header.empty()) {
       // We also have a server header here that isn't set by the proxy.
       EXPECT_TRUE(trans->GetResponseInfo()->headers->HasHeaderValue(
           header, value));
     }
   }
 
   // Check that |proxy_count| proxies are in the retry list.
@@ skipping 177 matching lines @@
   std::unique_ptr<ProxyService> proxy_service_;
   const scoped_refptr<SSLConfigService> ssl_config_service_;
   std::unique_ptr<HttpNetworkSession> network_session_;
   std::unique_ptr<HttpNetworkLayer> factory_;
   HttpServerPropertiesImpl http_server_properties_;
 };
 
 TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
   std::unique_ptr<HttpTransaction> trans;
   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   EXPECT_TRUE(trans.get() != NULL);
 }
 
 TEST_F(HttpNetworkLayerTest, Suspend) {
   std::unique_ptr<HttpTransaction> trans;
   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   trans.reset();
 
   factory_->OnSuspend();
 
   rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, rv);
+  EXPECT_THAT(rv, IsError(ERR_NETWORK_IO_SUSPENDED));
 
   ASSERT_TRUE(trans == NULL);
 
   factory_->OnResume();
 
   rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 }
 
 TEST_F(HttpNetworkLayerTest, GET) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "User-Agent: Foo/1.0\r\n\r\n"),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   mock_socket_factory_.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   HttpRequestInfo request_info;
   request_info.url = GURL("http://www.google.com/");
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                        "Foo/1.0");
   request_info.load_flags = LOAD_NORMAL;
 
   std::unique_ptr<HttpTransaction> trans;
   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
   rv = callback.GetResult(rv);
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
 
   std::string contents;
   rv = ReadTransaction(trans.get(), &contents);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   EXPECT_EQ("hello world", contents);
 }
 
 TEST_F(HttpNetworkLayerTest, NetworkVerified) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   MockWrite data_writes[] = {
@@ skipping 10 matching lines @@
 
   HttpRequestInfo request_info;
   request_info.url = GURL("http://www.google.com/");
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                        "Foo/1.0");
   request_info.load_flags = LOAD_NORMAL;
 
   std::unique_ptr<HttpTransaction> trans;
   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
-  ASSERT_EQ(OK, callback.GetResult(rv));
+  ASSERT_THAT(callback.GetResult(rv), IsOk());
 
   EXPECT_TRUE(trans->GetResponseInfo()->network_accessed);
 }
 
 TEST_F(HttpNetworkLayerTest, NetworkUnVerified) {
   MockRead data_reads[] = {
     MockRead(ASYNC, ERR_CONNECTION_RESET),
   };
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "User-Agent: Foo/1.0\r\n\r\n"),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
                                 data_writes, arraysize(data_writes));
   mock_socket_factory_.AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   HttpRequestInfo request_info;
   request_info.url = GURL("http://www.google.com/");
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                        "Foo/1.0");
   request_info.load_flags = LOAD_NORMAL;
 
   std::unique_ptr<HttpTransaction> trans;
   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
-  ASSERT_EQ(ERR_CONNECTION_RESET, callback.GetResult(rv));
+  ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_RESET));
 
   // network_accessed is true; the HTTP stack did try to make a connection.
   EXPECT_TRUE(trans->GetResponseInfo()->network_accessed);
 }
 
 }  // namespace
 
 }  // namespace net