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

net/ftp/ftp_network_transaction_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/ftp/ftp_network_transaction.h"
 
 #include "build/build_config.h"
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/ftp/ftp_request_info.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"
 #include "testing/platform_test.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace {
 
 // Size we use for IOBuffers used to receive data from the test data socket.
 const int kBufferSize = 128;
 
 }  // namespace
 
 namespace net {
 
 class FtpSocketDataProvider : public SocketDataProvider {
@@ skipping 905 matching lines @@
   FtpRequestInfo request_info = GetRequestInfo("ftp://badhost");
   scoped_refptr<RuleBasedHostResolverProc> rules(
       new RuleBasedHostResolverProc(NULL));
   rules->AddSimulatedFailure("badhost");
   host_resolver_->set_rules(rules.get());
 
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, callback_.callback(),
                                BoundNetLog()));
-  ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
+  ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
 }
 
 // Check that when determining the host, the square brackets decorating IPv6
 // literals in URLs are stripped.
 TEST_P(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) {
   // This test only makes sense for IPv6 connections.
   if (GetFamily() != AF_INET6)
     return;
 
@@ skipping 210 matching lines @@
                                         NULL, 0);
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
   mock_socket_factory_.AddSocketDataProvider(&data_socket1);
   mock_socket_factory_.AddSocketDataProvider(&data_socket2);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, callback_.callback(),
                                BoundNetLog()));
-  ASSERT_EQ(OK, callback_.WaitForResult());
+  ASSERT_THAT(callback_.WaitForResult(), IsOk());
 
   // The transaction fires the callback when we can start reading data. That
   // means that the data socket should be open.
   MockTCPClientSocket* data_socket =
       static_cast<MockTCPClientSocket*>(transaction_.data_socket_.get());
   ASSERT_TRUE(data_socket);
   ASSERT_TRUE(data_socket->IsConnected());
 
   // Even if the PASV response specified some other address, we connect
   // to the address we used for control connection (which could be 127.0.0.1
@@ skipping 164 matching lines @@
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, callback_.callback(),
                                BoundNetLog()));
-  ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
+  ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_FTP_FAILED));
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("QUIT\r\n"),
   };
   StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
                                         ctrl_writes, arraysize(ctrl_writes));
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
                 AuthCredentials(
                     base::ASCIIToUTF16("foo\nownz0red"),
                     base::ASCIIToUTF16("innocent")),
                 callback_.callback()));
-  EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_MALFORMED_IDENTITY));
 }
 
 TEST_P(FtpNetworkTransactionTest, EvilRestartPassword) {
   FtpSocketDataProvider ctrl_socket1;
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.Start(&request_info, callback_.callback(),
                                BoundNetLog()));
-  ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
+  ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_FTP_FAILED));
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("331 User okay, send password\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("USER innocent\r\n"),
     MockWrite("QUIT\r\n"),
   };
   StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
                                         ctrl_writes, arraysize(ctrl_writes));
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
                 AuthCredentials(base::ASCIIToUTF16("innocent"),
                                 base::ASCIIToUTF16("foo\nownz0red")),
                 callback_.callback()));
-  EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
+  EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_MALFORMED_IDENTITY));
 }
 
 TEST_P(FtpNetworkTransactionTest, Escaping) {
   FtpSocketDataProviderEscaping ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81",
                      OK);
 }
 
 // Test for http://crbug.com/23794.
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) {
@@ skipping 224 matching lines @@
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 INSTANTIATE_TEST_CASE_P(FTP,
                         FtpNetworkTransactionTest,
                         ::testing::Values(AF_INET, AF_INET6));
 
 }  // namespace net