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

net/proxy/proxy_script_decider_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 <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/mock_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_decider.h"
 #include "net/proxy/proxy_script_fetcher.h"
+#include "net/test/gtest_util.h"
 #include "net/url_request/url_request_context.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 {
 
 enum Error {
   kFailedDownloading = -100,
   kFailedParsing = ERR_PAC_SCRIPT_FAILED,
 };
 
 class Rules {
  public:
@@ skipping 296 matching lines @@
 
  private:
   URLRequestContext request_context_;
 };
 
 // Fails if a synchronous DNS lookup success for wpad causes QuickCheck to fail.
 TEST_F(ProxyScriptDeciderQuickCheckTest, SyncSuccess) {
   resolver_.set_synchronous_mode(true);
   resolver_.rules()->AddRule("wpad", "1.2.3.4");
 
-  EXPECT_EQ(OK, StartDecider());
+  EXPECT_THAT(StartDecider(), IsOk());
   EXPECT_EQ(rule_.text(), decider_->script_data()->utf16());
 
   EXPECT_TRUE(decider_->effective_config().has_pac_url());
   EXPECT_EQ(rule_.url, decider_->effective_config().pac_url());
 }
 
 // Fails if an asynchronous DNS lookup success for wpad causes QuickCheck to
 // fail.
 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncSuccess) {
   resolver_.set_ondemand_mode(true);
   resolver_.rules()->AddRule("wpad", "1.2.3.4");
 
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   ASSERT_TRUE(resolver_.has_pending_requests());
   resolver_.ResolveAllPending();
   callback_.WaitForResult();
   EXPECT_FALSE(resolver_.has_pending_requests());
   EXPECT_EQ(rule_.text(), decider_->script_data()->utf16());
   EXPECT_TRUE(decider_->effective_config().has_pac_url());
   EXPECT_EQ(rule_.url, decider_->effective_config().pac_url());
 }
 
 // Fails if an asynchronous DNS lookup failure (i.e. an NXDOMAIN) still causes
 // ProxyScriptDecider to yield a PAC URL.
 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncFail) {
   resolver_.set_ondemand_mode(true);
   resolver_.rules()->AddSimulatedFailure("wpad");
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   ASSERT_TRUE(resolver_.has_pending_requests());
   resolver_.ResolveAllPending();
   callback_.WaitForResult();
   EXPECT_FALSE(decider_->effective_config().has_pac_url());
 }
 
 // Fails if a DNS lookup timeout either causes ProxyScriptDecider to yield a PAC
 // URL or causes ProxyScriptDecider not to cancel its pending resolution.
 TEST_F(ProxyScriptDeciderQuickCheckTest, AsyncTimeout) {
   resolver_.set_ondemand_mode(true);
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   ASSERT_TRUE(resolver_.has_pending_requests());
   callback_.WaitForResult();
   EXPECT_FALSE(resolver_.has_pending_requests());
   EXPECT_FALSE(decider_->effective_config().has_pac_url());
 }
 
 // Fails if DHCP check doesn't take place before QuickCheck.
 TEST_F(ProxyScriptDeciderQuickCheckTest, QuickCheckInhibitsDhcp) {
   MockDhcpProxyScriptFetcher dhcp_fetcher;
   const char *kPac = "function FindProxyForURL(u,h) { return \"DIRECT\"; }";
   base::string16 pac_contents = base::UTF8ToUTF16(kPac);
   GURL url("http://foobar/baz");
   dhcp_fetcher.SetPacURL(url);
   decider_.reset(new ProxyScriptDecider(&fetcher_, &dhcp_fetcher, NULL));
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   dhcp_fetcher.CompleteRequests(OK, pac_contents);
   EXPECT_TRUE(decider_->effective_config().has_pac_url());
   EXPECT_EQ(decider_->effective_config().pac_url(), url);
 }
 
 // Fails if QuickCheck still happens when disabled. To ensure QuickCheck is not
 // happening, we add a synchronous failing resolver, which would ordinarily
 // mean a QuickCheck failure, then ensure that our ProxyScriptFetcher is still
 // asked to fetch.
 TEST_F(ProxyScriptDeciderQuickCheckTest, QuickCheckDisabled) {
   const char *kPac = "function FindProxyForURL(u,h) { return \"DIRECT\"; }";
   resolver_.set_synchronous_mode(true);
   resolver_.rules()->AddSimulatedFailure("wpad");
   MockProxyScriptFetcher fetcher;
   decider_.reset(new ProxyScriptDecider(&fetcher, &dhcp_fetcher_, NULL));
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   EXPECT_TRUE(fetcher.has_pending_request());
   fetcher.NotifyFetchCompletion(OK, kPac);
 }
 
 TEST_F(ProxyScriptDeciderQuickCheckTest, ExplicitPacUrl) {
   const char *kCustomUrl = "http://custom/proxy.pac";
   config_.set_pac_url(GURL(kCustomUrl));
   Rules::Rule rule = rules_.AddSuccessRule(kCustomUrl);
   resolver_.rules()->AddSimulatedFailure("wpad");
   resolver_.rules()->AddRule("custom", "1.2.3.4");
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   callback_.WaitForResult();
   EXPECT_TRUE(decider_->effective_config().has_pac_url());
   EXPECT_EQ(rule.url, decider_->effective_config().pac_url());
 }
 
 // Regression test for http://crbug.com/409698.
 // This test lets the state machine get into state QUICK_CHECK_COMPLETE, then
 // destroys the decider, causing a cancel.
 TEST_F(ProxyScriptDeciderQuickCheckTest, CancelPartway) {
   resolver_.set_synchronous_mode(false);
   resolver_.set_ondemand_mode(true);
-  EXPECT_EQ(ERR_IO_PENDING, StartDecider());
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   decider_.reset(NULL);
 }
 
 // Fails at WPAD (downloading), but succeeds in choosing the custom PAC.
 TEST(ProxyScriptDeciderTest, AutodetectFailCustomSuccess1) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
@@ skipping 331 matching lines @@
 
   // Run the message loop to let the DHCP fetch complete and post the results
   // back. Before the fix linked to above, this would try to invoke on
   // the callback object provided by ProxyScriptDecider after it was
   // no longer valid.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace net