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

net/proxy/dhcp_proxy_script_adapter_fetcher_win_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/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/timer/timer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/mock_proxy_script_fetcher.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/gtest_util.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::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 const char kPacUrl[] = "http://pacserver/script.pac";
 
 // In net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc there are a few
 // tests that exercise DhcpProxyScriptAdapterFetcher end-to-end along with
 // DhcpProxyScriptFetcherWin, i.e. it tests the end-to-end usage of Win32
 // APIs and the network.  In this file we test only by stubbing out
@@ skipping 138 matching lines @@
   std::unique_ptr<MockDhcpProxyScriptAdapterFetcher> fetcher_;
   base::string16 pac_text_;
 };
 
 TEST(DhcpProxyScriptAdapterFetcher, NormalCaseURLNotInDhcp) {
   FetcherClient client;
   client.fetcher_->configured_url_ = "";
   client.RunTest();
   client.WaitForResult(ERR_PAC_NOT_IN_DHCP);
   ASSERT_TRUE(client.fetcher_->DidFinish());
-  EXPECT_EQ(ERR_PAC_NOT_IN_DHCP, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsError(ERR_PAC_NOT_IN_DHCP));
   EXPECT_EQ(base::string16(L""), client.fetcher_->GetPacScript());
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, NormalCaseURLInDhcp) {
   FetcherClient client;
   client.RunTest();
   client.WaitForResult(OK);
   ASSERT_TRUE(client.fetcher_->DidFinish());
-  EXPECT_EQ(OK, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsOk());
   EXPECT_EQ(base::string16(L"bingo"), client.fetcher_->GetPacScript());
   EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL());
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, TimeoutDuringDhcp) {
   // Does a Fetch() with a long enough delay on accessing DHCP that the
   // fetcher should time out.  This is to test a case manual testing found,
   // where under certain circumstances (e.g. adapter enabled for DHCP and
   // needs to retrieve its configuration from DHCP, but no DHCP server
   // present on the network) accessing DHCP can take on the order of tens
   // of seconds.
   FetcherClient client;
   client.fetcher_->dhcp_delay_ = TestTimeouts::action_max_timeout();
   client.fetcher_->timeout_ = base::TimeDelta::FromMilliseconds(25);
 
   base::ElapsedTimer timer;
   client.RunTest();
   // An error different from this would be received if the timeout didn't
   // kick in.
   client.WaitForResult(ERR_TIMED_OUT);
 
   ASSERT_TRUE(client.fetcher_->DidFinish());
-  EXPECT_EQ(ERR_TIMED_OUT, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsError(ERR_TIMED_OUT));
   EXPECT_EQ(base::string16(L""), client.fetcher_->GetPacScript());
   EXPECT_EQ(GURL(), client.fetcher_->GetPacURL());
   client.FinishTestAllowCleanup();
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, CancelWhileDhcp) {
   FetcherClient client;
   client.RunTest();
   client.fetcher_->Cancel();
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(client.fetcher_->DidFinish());
   ASSERT_TRUE(client.fetcher_->WasCancelled());
-  EXPECT_EQ(ERR_ABORTED, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsError(ERR_ABORTED));
   EXPECT_EQ(base::string16(L""), client.fetcher_->GetPacScript());
   EXPECT_EQ(GURL(), client.fetcher_->GetPacURL());
   client.FinishTestAllowCleanup();
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, CancelWhileFetcher) {
   FetcherClient client;
   // This causes the mock fetcher not to pretend the
   // fetcher finishes after a timeout.
   client.fetcher_->fetcher_delay_ms_ = -1;
   client.RunTest();
   int max_loops = 4;
   while (!client.fetcher_->IsWaitingForFetcher() && max_loops--) {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     base::RunLoop().RunUntilIdle();
   }
   client.fetcher_->Cancel();
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(client.fetcher_->DidFinish());
   ASSERT_TRUE(client.fetcher_->WasCancelled());
-  EXPECT_EQ(ERR_ABORTED, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsError(ERR_ABORTED));
   EXPECT_EQ(base::string16(L""), client.fetcher_->GetPacScript());
   // GetPacURL() still returns the URL fetched in this case.
   EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL());
   client.FinishTestAllowCleanup();
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, CancelAtCompletion) {
   FetcherClient client;
   client.RunTest();
   client.WaitForResult(OK);
   client.fetcher_->Cancel();
   // Canceling after you're done should have no effect, so these
   // are identical expectations to the NormalCaseURLInDhcp test.
   ASSERT_TRUE(client.fetcher_->DidFinish());
-  EXPECT_EQ(OK, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsOk());
   EXPECT_EQ(base::string16(L"bingo"), client.fetcher_->GetPacScript());
   EXPECT_EQ(GURL(kPacUrl), client.fetcher_->GetPacURL());
   client.FinishTestAllowCleanup();
 }
 
 // Does a real fetch on a mock DHCP configuration.
 class MockDhcpRealFetchProxyScriptAdapterFetcher
     : public MockDhcpProxyScriptAdapterFetcher {
  public:
   explicit MockDhcpRealFetchProxyScriptAdapterFetcher(
@@ skipping 26 matching lines @@
   scoped_refptr<base::TaskRunner> runner =
       client.worker_pool_->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   client.fetcher_.reset(
       new MockDhcpRealFetchProxyScriptAdapterFetcher(
           &url_request_context, runner));
   client.fetcher_->configured_url_ = configured_url.spec();
   client.RunTest();
   client.WaitForResult(OK);
   ASSERT_TRUE(client.fetcher_->DidFinish());
-  EXPECT_EQ(OK, client.fetcher_->GetResult());
+  EXPECT_THAT(client.fetcher_->GetResult(), IsOk());
   EXPECT_EQ(base::string16(L"-downloadable.pac-\n"),
             client.fetcher_->GetPacScript());
   EXPECT_EQ(configured_url,
             client.fetcher_->GetPacURL());
 }
 
 #define BASE_URL "http://corpserver/proxy.pac"
 
 TEST(DhcpProxyScriptAdapterFetcher, SanitizeDhcpApiString) {
   const size_t kBaseUrlLen = strlen(BASE_URL);
@@ skipping 12 matching lines @@
   EXPECT_EQ(BASE_URL,
             DhcpProxyScriptAdapterFetcher::SanitizeDhcpApiString(
                 BASE_URL "\0foo\0blat", kBaseUrlLen + 9));
 }
 
 #undef BASE_URL
 
 }  // namespace
 
 }  // namespace net