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

net/server/http_server_unittest.cc

 // Copyright 2013 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/server/http_server.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 22 matching lines @@
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
 #include "net/server/http_server_request_info.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_server_socket.h"
+#include "net/test/gtest_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 const int kMaxExpectedResponseLength = 2048;
 
 void SetTimedOutAndQuitLoop(const base::WeakPtr<bool> timed_out,
                             const base::Closure& quit_loop_func) {
   if (timed_out) {
     *timed_out = true;
@@ skipping 124 matching lines @@
 class HttpServerTest : public testing::Test,
                        public HttpServer::Delegate {
  public:
   HttpServerTest() : quit_after_request_count_(0) {}
 
   void SetUp() override {
     std::unique_ptr<ServerSocket> server_socket(
         new TCPServerSocket(NULL, NetLog::Source()));
     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
     server_.reset(new HttpServer(std::move(server_socket), this));
-    ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
+    ASSERT_THAT(server_->GetLocalAddress(&server_address_), IsOk());
   }
 
   void OnConnect(int connection_id) override {}
 
   void OnHttpRequest(int connection_id,
                      const HttpServerRequestInfo& info) override {
     requests_.push_back(std::make_pair(info, connection_id));
     if (requests_.size() == quit_after_request_count_)
       run_loop_quit_func_.Run();
   }
@@ skipping 56 matching lines @@
                           const HttpServerRequestInfo& info) override {
     HttpServerTest::OnHttpRequest(connection_id, info);
   }
 
   void OnWebSocketMessage(int connection_id, const std::string& data) override {
   }
 };
 
 TEST_F(HttpServerTest, Request) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("GET", GetRequest(0).method);
   ASSERT_EQ("/test", GetRequest(0).path);
   ASSERT_EQ("", GetRequest(0).data);
   ASSERT_EQ(0u, GetRequest(0).headers.size());
   ASSERT_TRUE(base::StartsWith(GetRequest(0).peer.ToString(), "127.0.0.1",
                                base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, RequestWithHeaders) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   const char* const kHeaders[][3] = {
       {"Header", ": ", "1"},
       {"HeaderWithNoWhitespace", ":", "1"},
       {"HeaderWithWhitespace", "   :  \t   ", "1 1 1 \t  "},
       {"HeaderWithColon", ": ", "1:1"},
       {"EmptyHeader", ":", ""},
       {"EmptyHeaderWithWhitespace", ":  \t  ", ""},
       {"HeaderWithNonASCII", ":  ", "\xf7"},
   };
   std::string headers;
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     headers +=
         std::string(kHeaders[i][0]) + kHeaders[i][1] + kHeaders[i][2] + "\r\n";
   }
 
   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("", GetRequest(0).data);
 
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     std::string field = base::ToLowerASCII(std::string(kHeaders[i][0]));
     std::string value = kHeaders[i][2];
     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
   }
 }
 
 TEST_F(HttpServerTest, RequestWithDuplicateHeaders) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   const char* const kHeaders[][3] = {
       {"FirstHeader", ": ", "1"},
       {"DuplicateHeader", ": ", "2"},
       {"MiddleHeader", ": ", "3"},
       {"DuplicateHeader", ": ", "4"},
       {"LastHeader", ": ", "5"},
   };
   std::string headers;
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     headers +=
         std::string(kHeaders[i][0]) + kHeaders[i][1] + kHeaders[i][2] + "\r\n";
   }
 
   client.Send("GET /test HTTP/1.1\r\n" + headers + "\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("", GetRequest(0).data);
 
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
     std::string field = base::ToLowerASCII(std::string(kHeaders[i][0]));
     std::string value = (field == "duplicateheader") ? "2,4" : kHeaders[i][2];
     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
   }
 }
 
 TEST_F(HttpServerTest, HasHeaderValueTest) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   const char* const kHeaders[] = {
       "Header: Abcd",
       "HeaderWithNoWhitespace:E",
       "HeaderWithWhitespace   :  \t   f \t  ",
       "DuplicateHeader: g",
       "HeaderWithComma: h, i ,j",
       "DuplicateHeader: k",
       "EmptyHeader:",
       "EmptyHeaderWithWhitespace:  \t  ",
       "HeaderWithNonASCII:  \xf7",
@@ skipping 16 matching lines @@
   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithcomma", "i"));
   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithcomma", "j"));
   ASSERT_TRUE(GetRequest(0).HasHeaderValue("duplicateheader", "k"));
   ASSERT_FALSE(GetRequest(0).HasHeaderValue("emptyheader", "x"));
   ASSERT_FALSE(GetRequest(0).HasHeaderValue("emptyheaderwithwhitespace", "x"));
   ASSERT_TRUE(GetRequest(0).HasHeaderValue("headerwithnonascii", "\xf7"));
 }
 
 TEST_F(HttpServerTest, RequestWithBody) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   std::string body = "a" + std::string(1 << 10, 'b') + "c";
   client.Send(base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "SomeHeader: 1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str()));
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ(2u, GetRequest(0).headers.size());
   ASSERT_EQ(body.length(), GetRequest(0).data.length());
   ASSERT_EQ('a', body[0]);
   ASSERT_EQ('c', *body.rbegin());
 }
 
 TEST_F(WebSocketTest, RequestWebSocket) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   client.Send(
       "GET /test HTTP/1.1\r\n"
       "Upgrade: WebSocket\r\n"
       "Connection: SomethingElse, Upgrade\r\n"
       "Sec-WebSocket-Version: 8\r\n"
       "Sec-WebSocket-Key: key\r\n"
       "\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
 }
 
@@ skipping 26 matching lines @@
   fetcher->AddExtraRequestHeader(
       base::StringPrintf("content-length:%d", 1 << 30));
   fetcher->Start();
 
   ASSERT_TRUE(RunLoopWithTimeout(&run_loop));
   ASSERT_EQ(0u, requests_.size());
 }
 
 TEST_F(HttpServerTest, Send200) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   server_->Send200(GetConnectionId(0), "Response!", "text/plain");
 
   std::string response;
   ASSERT_TRUE(client.ReadResponse(&response));
   ASSERT_TRUE(base::StartsWith(response, "HTTP/1.1 200 OK",
                                base::CompareCase::SENSITIVE));
   ASSERT_TRUE(
       base::EndsWith(response, "Response!", base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, SendRaw) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   server_->SendRaw(GetConnectionId(0), "Raw Data ");
   server_->SendRaw(GetConnectionId(0), "More Data");
   server_->SendRaw(GetConnectionId(0), "Third Piece of Data");
 
   const std::string expected_response("Raw Data More DataThird Piece of Data");
   std::string response;
   ASSERT_TRUE(client.Read(&response, expected_response.length()));
   ASSERT_EQ(expected_response, response);
@@ skipping 113 matching lines @@
   ASSERT_EQ(0u, requests_.size());
   socket->DidRead(request_text.c_str() + request_text.length() - 2, 2);
   ASSERT_EQ(1u, requests_.size());
   ASSERT_EQ(body, GetRequest(0).data);
 }
 
 TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
   // The idea behind this test is that requests with or without bodies should
   // not break parsing of the next request.
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   std::string body = "body";
   client.Send(base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str()));
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ(body, GetRequest(0).data);
 
   int client_connection_id = GetConnectionId(0);
@@ skipping 36 matching lines @@
     connection_ids_.push_back(connection_id);
     server_->Close(connection_id);
   }
 
  protected:
   std::vector<int> connection_ids_;
 };
 
 TEST_F(CloseOnConnectHttpServerTest, ServerImmediatelyClosesConnection) {
   TestHttpClient client;
-  ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
+  ASSERT_THAT(client.ConnectAndWait(server_address_), IsOk());
   client.Send("GET / HTTP/1.1\r\n\r\n");
   ASSERT_FALSE(RunUntilRequestsReceived(1));
   ASSERT_EQ(1ul, connection_ids_.size());
   ASSERT_EQ(0ul, requests_.size());
 }
 
 }  // namespace
 
 }  // namespace net