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

net/spdy/spdy_http_stream_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/spdy/spdy_http_stream.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 10 matching lines @@
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/ssl/default_channel_id_store.h"
+#include "net/test/gtest_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 {
 
 enum TestCase {
   // Test using the SPDY/3.1 protocol.
   kTestCaseSPDY31,
 
   // Test using the HTTP/2 protocol, without specifying a stream
   // dependency based on the RequestPriority.
@@ skipping 336 matching lines @@
   const int kFirstChunkSize = kUploadDataSize/2;
   upload_stream.AppendData(kUploadData, kFirstChunkSize, false);
   upload_stream.AppendData(kUploadData + kFirstChunkSize,
                             kUploadDataSize - kFirstChunkSize, true);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(
       OK,
       http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                    net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream.SendRequest(
       headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + body->size()),
             http_stream.GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(resp->size() + body->size()),
             http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, we there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
@@ skipping 21 matching lines @@
   EXPECT_EQ(spdy_util_.spdy_version(), session_->GetProtocolVersion());
 
   ChunkedUploadDataStream upload_stream(0);
   upload_stream.AppendData(nullptr, 0, true);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
   EXPECT_EQ(ERR_IO_PENDING,
             http_stream.SendRequest(headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk->size()),
             http_stream.GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk->size()),
             http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
@@ skipping 21 matching lines @@
 
   ChunkedUploadDataStream upload_stream(0);
   // Append first chunk.
   upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING,
             http_stream.SendRequest(headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + body->size()),
             http_stream.GetTotalSentBytes());
   EXPECT_EQ(0, http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, we there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Appending a second chunk now should not result in a crash.
@@ skipping 39 matching lines @@
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
   upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   std::unique_ptr<SpdyHttpStream> http_stream(
       new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   TestCompletionCallback callback;
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete the initial request write and the first chunk.
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
   // Now append the final two chunks which will enqueue two more writes.
   upload_stream.AppendData(kUploadData1, kUploadData1Size, false);
   upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   // Finish writing all the chunks and do all reads.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size() + chunk2->size() +
                                  chunk3->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk1->size() +
                                  chunk2->size() + chunk3->size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
-  ASSERT_EQ(OK, http_stream->ReadResponseHeaders(callback.callback()));
+  ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Check |chunk2| response.
   scoped_refptr<IOBuffer> buf2(new IOBuffer(kUploadData1Size));
@@ skipping 38 matching lines @@
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
   upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   std::unique_ptr<SpdyHttpStream> http_stream(
       new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   TestCompletionCallback callback;
   HttpRequestHeaders headers;
@@ skipping 11 matching lines @@
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(0, http_stream->GetTotalReceivedBytes());
 
   // Now end the stream with an empty data frame and the FIN set.
   upload_stream.AppendData(nullptr, 0, true);
 
   // Finish writing the final frame, and perform all reads.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Check response headers.
-  ASSERT_EQ(OK, http_stream->ReadResponseHeaders(callback.callback()));
+  ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size() + chunk2->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(
       static_cast<int64_t>(resp->size() + chunk1->size() + chunk2->size()),
       http_stream->GetTotalReceivedBytes());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
@@ skipping 31 matching lines @@
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
   upload_stream.AppendData("", 0, true);
 
   BoundNetLog net_log;
   std::unique_ptr<SpdyHttpStream> http_stream(
       new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   TestCompletionCallback callback;
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete writing request, followed by a FIN.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk->size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
-  ASSERT_EQ(OK, http_stream->ReadResponseHeaders(callback.callback()));
+  ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk| response.
   scoped_refptr<IOBuffer> buf(new IOBuffer(1));
   ASSERT_EQ(0,
             http_stream->ReadResponseBody(
                 buf.get(), 1, callback.callback()));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
@@ skipping 70 matching lines @@
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   BoundNetLog net_log;
   std::unique_ptr<SpdyHttpStream> http_stream(
       new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete the initial request write and first chunk.
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
   EXPECT_EQ(static_cast<int64_t>(req->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(0, http_stream->GetTotalReceivedBytes());
 
   upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   ASSERT_TRUE(callback.have_result());
-  EXPECT_EQ(OK, callback.WaitForResult());
+  EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Verify that the window size has decreased.
   ASSERT_TRUE(http_stream->stream() != nullptr);
   EXPECT_NE(static_cast<int>(
                 SpdySession::GetDefaultInitialWindowSize(session_->protocol())),
             http_stream->stream()->send_window_size());
 
   // Read window update.
   base::RunLoop().RunUntilIdle();
 
@@ skipping 11 matching lines @@
   // Read rest of data.
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk1->size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
-  ASSERT_EQ(OK, http_stream->ReadResponseHeaders(callback.callback()));
+  ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
@@ skipping 19 matching lines @@
 
   MockRead reads[] = {
       CreateMockRead(*resp, 2), MockRead(SYNCHRONOUS, 0, 3),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
   EXPECT_EQ(spdy_util_.spdy_version(), session_->GetProtocolVersion());
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::SYNC);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_data_stream;
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
 
   int result = http_stream.SendRequest(headers, &response, callback.callback());
-  EXPECT_EQ(ERR_FAILED, callback.GetResult(result));
+  EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
   // Because the server has not closed the connection yet, there shouldn't be
   // a stream but a session in the pool
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 TEST_P(SpdyHttpStreamTest, DataReadErrorAsynchronous) {
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
 
@@ skipping 13 matching lines @@
 
   MockRead reads[] = {
       MockRead(ASYNC, 0, 2),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
   EXPECT_EQ(spdy_util_.spdy_version(), session_->GetProtocolVersion());
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::ASYNC);
-  ASSERT_EQ(OK, upload_data_stream.Init(TestCompletionCallback().callback()));
+  ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
+              IsOk());
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_data_stream;
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
 
   int result = http_stream.SendRequest(headers, &response, callback.callback());
-  EXPECT_EQ(ERR_IO_PENDING, result);
-  EXPECT_EQ(ERR_FAILED, callback.GetResult(result));
+  EXPECT_THAT(result, IsError(ERR_IO_PENDING));
+  EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
   // Because the server has closed the connection, there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net