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

net/quic/quic_end_to_end_unittest.cc

 // Copyright 2013 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 <memory>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 15 matching lines @@
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/http/transport_security_state.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/test/cert_test_util.h"
+#include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "net/tools/quic/test_tools/server_thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::StringPiece;
 
 namespace net {
 
+using test::IsOk;
 using test::QuicInMemoryCachePeer;
 using test::ServerThread;
 
 namespace test {
 
 namespace {
 
 const char kResponseBody[] = "some arbitrary response body";
 
 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
@@ skipping 169 matching lines @@
   void InitializePostRequest(size_t length) {
     GenerateBody(length);
     std::vector<std::unique_ptr<UploadElementReader>> element_readers;
     element_readers.push_back(base::WrapUnique(new UploadBytesElementReader(
         request_body_.data(), request_body_.length())));
     upload_data_stream_.reset(
         new ElementsUploadDataStream(std::move(element_readers), 0));
     request_.method = "POST";
     request_.url = GURL("https://test.example.com/");
     request_.upload_data_stream = upload_data_stream_.get();
-    ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+    ASSERT_THAT(request_.upload_data_stream->Init(CompletionCallback()),
+                IsOk());
   }
 
   // Checks that |consumer| completed and received |status_line| and |body|.
   void CheckResponse(const TestTransactionConsumer& consumer,
                      const std::string& status_line,
                      const std::string& body) {
     ASSERT_TRUE(consumer.is_done());
-    ASSERT_EQ(OK, consumer.error());
+    ASSERT_THAT(consumer.error(), IsOk());
     EXPECT_EQ(status_line, consumer.response_info()->headers->GetStatusLine());
     EXPECT_EQ(body, consumer.content());
   }
 
   std::unique_ptr<MockHostResolver> host_resolver_impl_;
   MappedHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   std::unique_ptr<ChannelIDService> channel_id_service_;
   TransportSecurityState transport_security_state_;
   std::unique_ptr<CTVerifier> cert_transparency_verifier_;
@@ skipping 121 matching lines @@
   base::MessageLoop::current()->Run();
 
   for (size_t i = 0; i < num_requests; ++i) {
     CheckResponse(*consumers[i], "HTTP/1.1 200", kResponseBody);
   }
   STLDeleteElements(&consumers);
 }
 
 }  // namespace test
 }  // namespace net