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

net/url_request/url_fetcher_impl_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/url_request/url_fetcher_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 21 matching lines @@
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_element_reader.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/gtest_util.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS_CERTS)
 #include "net/cert_net/nss_ocsp.h"
 #endif
 
 namespace net {
 
 using base::Time;
 using base::TimeDelta;
+using net::test::IsError;
+using net::test::IsOk;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 // TODO(akalin): Move all the test data to somewhere under net/.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("net/data/url_fetcher_impl_unittest");
 const char kTestServerFilePrefix[] = "/";
 
@@ skipping 490 matching lines @@
   ASSERT_FALSE(delegate.did_complete());
 
   // A network change notification aborts the connect job.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   delegate.WaitForComplete();
   EXPECT_FALSE(mock_resolver->has_pending_requests());
 
   // And the owner of the fetcher gets the ERR_NETWORK_CHANGED error.
   EXPECT_EQ(hanging_url(), delegate.fetcher()->GetOriginalURL());
   ASSERT_FALSE(delegate.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(),
+              IsError(ERR_NETWORK_CHANGED));
 }
 
 TEST_F(URLFetcherTest, RetryOnNetworkChangedAndFail) {
   EXPECT_EQ(0, GetNumFetcherCores());
 
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
   // Force context creation.
   context_getter->GetURLRequestContext();
   MockHostResolver* mock_resolver = context_getter->context()->mock_resolver();
@@ skipping 26 matching lines @@
 
   // A 4th failure doesn't trigger another retry, and propagates the error
   // to the owner of the fetcher.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   delegate.WaitForComplete();
   EXPECT_FALSE(mock_resolver->has_pending_requests());
 
   // And the owner of the fetcher gets the ERR_NETWORK_CHANGED error.
   EXPECT_EQ(hanging_url(), delegate.fetcher()->GetOriginalURL());
   ASSERT_FALSE(delegate.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_NETWORK_CHANGED, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(),
+              IsError(ERR_NETWORK_CHANGED));
 }
 
 TEST_F(URLFetcherTest, RetryOnNetworkChangedAndSucceed) {
   EXPECT_EQ(0, GetNumFetcherCores());
 
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
   // Force context creation.
   context_getter->GetURLRequestContext();
   MockHostResolver* mock_resolver = context_getter->context()->mock_resolver();
@@ skipping 205 matching lines @@
   base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
 
   // Try to append data.
   delegate.fetcher()->AppendChunkToUpload("kCreateUploadStreamBody", false);
   delegate.fetcher()->AppendChunkToUpload("kCreateUploadStreamBody", true);
 
   delegate.WaitForComplete();
 
   // Make sure the request failed, as expected.
   EXPECT_FALSE(delegate.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_UNSAFE_PORT, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(),
+              IsError(ERR_UNSAFE_PORT));
 }
 
 // Checks that upload progress increases over time, never exceeds what's already
 // been sent, and adds a chunk whenever all previously appended chunks have
 // been uploaded.
 class CheckUploadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CheckUploadProgressDelegate()
       : chunk_(1 << 16, 'a'), num_chunks_appended_(0), last_seen_progress_(0) {}
   ~CheckUploadProgressDelegate() override {}
@@ skipping 216 matching lines @@
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(
       test_server_->GetURL(std::string("/server-redirect?") + kRedirectTarget),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.fetcher()->SetStopOnRedirect(true);
   delegate.StartFetcherAndWait();
 
   EXPECT_EQ(GURL(kRedirectTarget), delegate.fetcher()->GetURL());
   EXPECT_EQ(URLRequestStatus::CANCELED,
             delegate.fetcher()->GetStatus().status());
-  EXPECT_EQ(ERR_ABORTED, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(), IsError(ERR_ABORTED));
   EXPECT_EQ(301, delegate.fetcher()->GetResponseCode());
 }
 
 TEST_F(URLFetcherTest, ThrottleOnRepeatedFetches) {
   base::Time start_time = Time::Now();
   GURL url(test_server_->GetURL(kDefaultResponsePath));
 
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateSameThreadContextGetter());
 
@@ skipping 289 matching lines @@
   delegate2.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
   delegate2.fetcher()->Start();
 
   // Check that shutting down the getter cancels the request synchronously,
   // allowing the context to be destroyed.
   context_getter->Shutdown();
 
   // Wait for the first fetcher, make sure it failed.
   delegate1.WaitForComplete();
   EXPECT_FALSE(delegate1.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, delegate1.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate1.fetcher()->GetStatus().error(),
+              IsError(ERR_CONTEXT_SHUT_DOWN));
 
   // Wait for the second fetcher, make sure it failed.
   delegate2.WaitForComplete();
   EXPECT_FALSE(delegate2.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, delegate2.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate2.fetcher()->GetStatus().error(),
+              IsError(ERR_CONTEXT_SHUT_DOWN));
 
   // New fetchers should automatically fail without making new requests. This
   // should follow the same path as the second fetcher, but best to be safe.
   WaitingURLFetcherDelegate delegate3;
   delegate3.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
   delegate3.fetcher()->Start();
   delegate3.WaitForComplete();
   EXPECT_FALSE(delegate3.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, delegate3.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate3.fetcher()->GetStatus().error(),
+              IsError(ERR_CONTEXT_SHUT_DOWN));
 }
 
 TEST_F(URLFetcherTest, ShutdownCrossThread) {
   scoped_refptr<FetcherTestURLRequestContextGetter> context_getter(
       CreateCrossThreadContextGetter());
 
   WaitingURLFetcherDelegate delegate1;
   delegate1.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
   delegate1.fetcher()->Start();
   // Check that shutting the context getter lets the context be destroyed safely
   // and cancels the request.
   context_getter->Shutdown();
   delegate1.WaitForComplete();
   EXPECT_FALSE(delegate1.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, delegate1.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate1.fetcher()->GetStatus().error(),
+              IsError(ERR_CONTEXT_SHUT_DOWN));
 
   // New requests should automatically fail without making new requests.
   WaitingURLFetcherDelegate delegate2;
   delegate2.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
   delegate2.StartFetcherAndWait();
   EXPECT_FALSE(delegate2.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, delegate2.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate2.fetcher()->GetStatus().error(),
+              IsError(ERR_CONTEXT_SHUT_DOWN));
 }
 
 // Get a small file.
 TEST_F(URLFetcherTest, FileTestSmallGet) {
   const char kFileToFetch[] = "simple.html";
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath out_path = temp_dir.path().AppendASCII(kFileToFetch);
   SaveFileTest(kFileToFetch, false, out_path, false);
@@ skipping 51 matching lines @@
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(
       test_server_->GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.fetcher()->SaveResponseToFileAtPath(
       out_path, scoped_refptr<base::SingleThreadTaskRunner>(
                     base::ThreadTaskRunnerHandle::Get()));
   delegate.StartFetcherAndWait();
 
   EXPECT_FALSE(delegate.fetcher()->GetStatus().is_success());
-  EXPECT_EQ(ERR_ACCESS_DENIED, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(),
+              IsError(ERR_ACCESS_DENIED));
 }
 
 // Get a small file and save it to a temp file.
 TEST_F(URLFetcherTest, TempFileTestSmallGet) {
   SaveFileTest("simple.html", true, base::FilePath(), false);
 }
 
 // Get a file large enough to require more than one read into URLFetcher::Core's
 // IOBuffer and save it to a temp file.
 TEST_F(URLFetcherTest, TempFileTestLargeGet) {
   SaveFileTest("animate1.gif", true, base::FilePath(), false);
 }
 
 // If the caller takes the ownership of the temp file, check that the file
 // persists even after URLFetcher is gone.
 TEST_F(URLFetcherTest, TempFileTestTakeOwnership) {
   SaveFileTest("simple.html", true, base::FilePath(), true);
 }
 
 TEST_F(URLFetcherBadHTTPSTest, BadHTTPS) {
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL(kDefaultResponsePath),
                          URLFetcher::GET, CreateSameThreadContextGetter());
   delegate.StartFetcherAndWait();
 
   EXPECT_EQ(URLRequestStatus::CANCELED,
             delegate.fetcher()->GetStatus().status());
-  EXPECT_EQ(ERR_ABORTED, delegate.fetcher()->GetStatus().error());
+  EXPECT_THAT(delegate.fetcher()->GetStatus().error(), IsError(ERR_ABORTED));
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_FALSE(delegate.fetcher()->GetResponseHeaders());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net