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

net/quic/quic_chromium_client_stream_test.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/quic/quic_chromium_client_stream.h"
 
 #include <string>
 
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/quic/quic_chromium_client_session.h"
 #include "net/quic/quic_client_session_base.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
+#include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 
+using net::test::IsError;
+using net::test::IsOk;
+
 using testing::AnyNumber;
 using testing::CreateFunctor;
 using testing::Invoke;
 using testing::Return;
 using testing::StrEq;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
@@ skipping 361 matching lines @@
           testing::Invoke(CreateFunctor(
               &QuicChromiumClientStreamTest::ReadData, base::Unretained(this),
               StringPiece(data, arraysize(data) - 1))),
           testing::Invoke([&run_loop]() { run_loop.Quit(); })));
 
   // Wait for the read to complete.
   run_loop.Run();
 
   // Read again, and it will be pending.
   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->Read(buffer.get(), 1));
+  EXPECT_THAT(stream_->Read(buffer.get(), 1), IsError(ERR_IO_PENDING));
 
   SpdyHeaderBlock trailers;
   trailers["bar"] = "foo";
   trailers[kFinalOffsetHeaderKey] = base::IntToString(strlen(data));
   std::string uncompressed_trailers =
       SpdyUtils::SerializeUncompressedHeaders(trailers);
 
   stream_->OnStreamHeaders(uncompressed_trailers);
   stream_->OnStreamHeadersComplete(true, uncompressed_trailers.length());
   EXPECT_FALSE(stream_->IsDoneReading());
@@ skipping 59 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->WriteStreamData(base::StringPiece(kData1, kDataLen), true,
                                      callback.callback()));
   ASSERT_FALSE(callback.have_result());
 
   // All data written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 TEST_P(QuicChromiumClientStreamTest, WritevStreamData) {
   EXPECT_CALL(delegate_, OnClose());
 
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer("hello world!"));
   scoped_refptr<StringIOBuffer> buf2(
       new StringIOBuffer("Just a small payload"));
 
   // All data written.
@@ skipping 25 matching lines @@
             stream_->WritevStreamData({buf1.get(), buf2.get()},
                                       {buf1->size(), buf2->size()}, true,
                                       callback.callback()));
   ASSERT_FALSE(callback.have_result());
 
   // The second piece of data is written.
   EXPECT_CALL(session_, WritevData(stream_, stream_->id(), _, _, _, _))
       .WillOnce(Return(QuicConsumedData(buf2->size(), true)));
   stream_->OnCanWrite();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 TEST_P(QuicChromiumClientStreamTest, HeadersBeforeDelegate) {
   // We don't use stream_ because we want an incoming server push
   // stream.
   QuicChromiumClientStream* stream = new QuicChromiumClientStream(
       kServerDataStreamId1, &session_, BoundNetLog());
   session_.ActivateStream(stream);
 
   InitializeHeaders();
   std::string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream->OnStreamHeaders(uncompressed_headers);
   stream->OnStreamHeadersComplete(false, uncompressed_headers.length());
   EXPECT_TRUE(stream->decompressed_headers().empty());
 
   EXPECT_CALL(delegate_,
               OnHeadersAvailableMock(_, uncompressed_headers.length()));
   stream->SetDelegate(&delegate_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(headers_, delegate_.headers_);
 
   // Times(2) because OnClose will be called for stream and stream_.
   EXPECT_CALL(delegate_, OnClose()).Times(2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net