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

net/proxy/multi_threaded_proxy_resolver_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/multi_threaded_proxy_resolver.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.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/mock_proxy_resolver.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_factory.h"
+#include "net/test/gtest_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 using base::ASCIIToUTF16;
 
 namespace net {
 
 namespace {
 
 // A synchronous mock ProxyResolver implementation, which can be used in
 // conjunction with MultiThreadedProxyResolver.
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
@@ skipping 158 matching lines @@
         new BlockableProxyResolverFactory);
     factory_ = factory_owner.get();
     resolver_factory_.reset(new SingleShotMultiThreadedProxyResolverFactory(
         num_threads, std::move(factory_owner)));
     TestCompletionCallback ready_callback;
     std::unique_ptr<ProxyResolverFactory::Request> request;
     resolver_factory_->CreateProxyResolver(
         ProxyResolverScriptData::FromUTF8("pac script bytes"), &resolver_,
         ready_callback.callback(), &request);
     EXPECT_TRUE(request);
-    ASSERT_EQ(OK, ready_callback.WaitForResult());
+    ASSERT_THAT(ready_callback.WaitForResult(), IsOk());
 
     // Verify that the script data reaches the synchronous resolver factory.
     ASSERT_EQ(1u, factory_->script_data().size());
     EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
               factory_->script_data()[0]->utf16());
   }
 
   void ClearResolver() { resolver_.reset(); }
 
   BlockableProxyResolverFactory& factory() {
@@ skipping 16 matching lines @@
   const size_t kNumThreads = 1u;
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   // Start request 0.
   int rv;
   TestCompletionCallback callback0;
   BoundTestNetLog log0;
   ProxyInfo results0;
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                  callback0.callback(), NULL, log0.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait for request 0 to finish.
   rv = callback0.WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
 
   // The mock proxy resolver should have written 1 log entry. And
   // on completion, this should have been copied into |log0|.
   // We also have 1 log entry that was emitted by the
   // MultiThreadedProxyResolver.
   TestNetLogEntry::List entries0;
   log0.GetEntries(&entries0);
 
   ASSERT_EQ(2u, entries0.size());
   EXPECT_EQ(NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD, entries0[0].type);
 
   // Start 3 more requests (request1 to request3).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                  callback1.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback2;
   ProxyInfo results2;
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                  callback2.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback3;
   ProxyInfo results3;
   rv = resolver().GetProxyForURL(GURL("http://request3"), &results3,
                                  callback3.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait for the requests to finish (they must finish in the order they were
   // started, which is what we check for from their magic return value)
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(1, rv);
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
   rv = callback2.WaitForResult();
   EXPECT_EQ(2, rv);
@@ skipping 16 matching lines @@
   // Block the proxy resolver, so no request can complete.
   factory().resolvers()[0]->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   BoundTestNetLog log0;
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                  callback0.callback(), &request0, log0.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Start 2 more requests (request1 and request2).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   BoundTestNetLog log1;
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                  callback1.callback(), NULL, log1.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   BoundTestNetLog log2;
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                  callback2.callback(), &request2, log2.bound());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Unblock the worker thread so the requests can continue running.
   factory().resolvers()[0]->WaitUntilBlocked();
   factory().resolvers()[0]->Unblock();
 
   // Check that request 0 completed as expected.
   // The NetLog has 1 entry that came from the MultiThreadedProxyResolver, and
   // 1 entry from the mock proxy resolver.
   EXPECT_EQ(0, callback0.WaitForResult());
   EXPECT_EQ("PROXY request0:80", results0.ToPacString());
@@ skipping 47 matching lines @@
   // Block the proxy resolver, so no request can complete.
   factory().resolvers()[0]->Block();
 
   // Start request 0.
   ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv =
       resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                 callback0.callback(), &request0, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait until requests 0 reaches the worker thread.
   factory().resolvers()[0]->WaitUntilBlocked();
 
   // Start 3 more requests (request1 : request3).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                  callback1.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   rv =
       resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                 callback2.callback(), &request2, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback3;
   ProxyInfo results3;
   rv = resolver().GetProxyForURL(GURL("http://request3"), &results3,
                                  callback3.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Cancel request0 (inprogress) and request2 (pending).
   resolver().CancelRequest(request0);
   resolver().CancelRequest(request2);
 
   // Unblock the worker thread so the requests can continue running.
   factory().resolvers()[0]->Unblock();
 
   // Wait for requests 1 and 3 to finish.
 
@@ skipping 24 matching lines @@
   // Block the proxy resolver, so no request can complete.
   factory().resolvers()[0]->Block();
 
   int rv;
   // Start 3 requests.
 
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                  callback0.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                  callback1.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback2;
   ProxyInfo results2;
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                  callback2.callback(), NULL, BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait until request 0 reaches the worker thread.
   factory().resolvers()[0]->WaitUntilBlocked();
 
   // Add some latency, to improve the chance that when
   // MultiThreadedProxyResolver is deleted below we are still running inside
   // of the worker thread. The test will pass regardless, so this race doesn't
   // cause flakiness. However the destruction during execution is a more
   // interesting case to test.
   factory().resolvers()[0]->SetResolveLatency(
@@ skipping 27 matching lines @@
   int rv;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
   ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start request 0 -- this should run on thread 0 as there is nothing else
   // going on right now.
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results[0],
                                  callback[0].callback(), &request[0],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait for request 0 to finish.
   rv = callback[0].WaitForResult();
   EXPECT_EQ(0, rv);
   EXPECT_EQ("PROXY request0:80", results[0].ToPacString());
   ASSERT_EQ(1u, factory().resolvers().size());
   EXPECT_EQ(1, factory().resolvers()[0]->request_count());
 
   base::RunLoop().RunUntilIdle();
 
   // We now block the first resolver to ensure a request is sent to the second
   // thread.
   factory().resolvers()[0]->Block();
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results[1],
                                  callback[1].callback(), &request[1],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   factory().resolvers()[0]->WaitUntilBlocked();
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results[2],
                                  callback[2].callback(), &request[2],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ(0, callback[2].WaitForResult());
   ASSERT_EQ(2u, factory().resolvers().size());
 
   // We now block the second resolver as well to ensure a request is sent to the
   // third thread.
   factory().resolvers()[1]->Block();
   rv = resolver().GetProxyForURL(GURL("http://request3"), &results[3],
                                  callback[3].callback(), &request[3],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   factory().resolvers()[1]->WaitUntilBlocked();
   rv = resolver().GetProxyForURL(GURL("http://request4"), &results[4],
                                  callback[4].callback(), &request[4],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_EQ(0, callback[4].WaitForResult());
 
   // We should now have a total of 3 threads, each with its own ProxyResolver
   // that will get initialized with the same data.
   ASSERT_EQ(3u, factory().resolvers().size());
 
   ASSERT_EQ(3u, factory().script_data().size());
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
               factory().script_data()[i]->utf16())
         << "i=" << i;
   }
 
   // Start and cancel two requests. Since the first two threads are still
   // blocked, they'll both be serviced by the third thread. The first request
   // will reach the resolver, but the second will still be queued when canceled.
   // Start a third request so we can be sure the resolver has completed running
   // the first request.
   rv = resolver().GetProxyForURL(GURL("http://request5"), &results[5],
                                  callback[5].callback(), &request[5],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = resolver().GetProxyForURL(GURL("http://request6"), &results[6],
                                  callback[6].callback(), &request[6],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = resolver().GetProxyForURL(GURL("http://request7"), &results[7],
                                  callback[7].callback(), &request[7],
                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   resolver().CancelRequest(request[5]);
   resolver().CancelRequest(request[6]);
 
   EXPECT_EQ(2, callback[7].WaitForResult());
 
   // Check that the cancelled requests never invoked their callback.
   EXPECT_FALSE(callback[5].have_result());
   EXPECT_FALSE(callback[6].have_result());
 
   // Unblock the first two threads and wait for their requests to complete.
@@ skipping 27 matching lines @@
   ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start a request that will block the first thread.
 
   factory().resolvers()[0]->Block();
 
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results[0],
                                  callback[0].callback(), &request[0],
                                  BoundNetLog());
 
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   factory().resolvers()[0]->WaitUntilBlocked();
 
   // Start 3 more requests -- they should all be serviced by thread #2
   // since thread #1 is blocked.
 
   for (int i = 1; i < kNumRequests; ++i) {
     rv = resolver().GetProxyForURL(
         GURL(base::StringPrintf("http://request%d", i)), &results[i],
         callback[i].callback(), &request[i], BoundNetLog());
-    EXPECT_EQ(ERR_IO_PENDING, rv);
+    EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   }
 
   // Wait for the three requests to complete (they should complete in FIFO
   // order).
   for (int i = 1; i < kNumRequests; ++i) {
     EXPECT_EQ(i - 1, callback[i].WaitForResult());
   }
 
   // Unblock the first thread.
   factory().resolvers()[0]->Unblock();
@@ skipping 27 matching lines @@
   SingleShotMultiThreadedProxyResolverFactory resolver_factory(
       kNumThreads, base::WrapUnique(new FailingProxyResolverFactory));
   TestCompletionCallback ready_callback;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   std::unique_ptr<ProxyResolver> resolver;
   EXPECT_EQ(ERR_IO_PENDING,
             resolver_factory.CreateProxyResolver(
                 ProxyResolverScriptData::FromUTF8("pac script bytes"),
                 &resolver, ready_callback.callback(), &request));
   EXPECT_TRUE(request);
-  EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, ready_callback.WaitForResult());
+  EXPECT_THAT(ready_callback.WaitForResult(), IsError(ERR_PAC_SCRIPT_FAILED));
   EXPECT_FALSE(resolver);
 }
 
 void Fail(int error) {
   FAIL() << "Unexpected callback with error " << error;
 }
 
 // Test that cancelling an in-progress create request works correctly.
 TEST_F(MultiThreadedProxyResolverTest, CancelCreate) {
   const size_t kNumThreads = 1u;
@@ skipping 30 matching lines @@
   std::unique_ptr<ProxyResolverFactory::Request> request;
   std::unique_ptr<ProxyResolver> resolver;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             resolver_factory.CreateProxyResolver(
                 ProxyResolverScriptData::FromUTF8("pac script bytes"),
                 &resolver, base::Bind(&DeleteRequest, callback.callback(),
                                       base::Unretained(&request)),
                 &request));
   EXPECT_TRUE(request);
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Test that deleting the factory with a request in-progress works correctly.
 TEST_F(MultiThreadedProxyResolverTest, DestroyFactoryWithRequestsInProgress) {
   const size_t kNumThreads = 1u;
   std::unique_ptr<ProxyResolverFactory::Request> request;
   std::unique_ptr<ProxyResolver> resolver;
   {
     SingleShotMultiThreadedProxyResolverFactory resolver_factory(
         kNumThreads, base::WrapUnique(new BlockableProxyResolverFactory));
     EXPECT_EQ(ERR_IO_PENDING,
               resolver_factory.CreateProxyResolver(
                   ProxyResolverScriptData::FromUTF8("pac script bytes"),
                   &resolver, base::Bind(&Fail), &request));
     EXPECT_TRUE(request);
   }
   // The factory destructor will block until the worker thread stops, but it may
   // post tasks to the origin message loop which are still pending. Run them
   // now to ensure it works as expected.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net