net/socket/transport_client_socket_pool_unittest.cc - Issue 2109503009: Refactor net tests to use GMock matchers for checking net::Error results

Unified Diff: net/socket/transport_client_socket_pool_unittest.cc

Issue 2109503009: Refactor net tests to use GMock matchers for checking net::Error results (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Revert changes to contents.txt files Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/socket/transport_client_socket_pool_unittest.cc

diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/transport_client_socket_pool_unittest.cc

index ddfe941e6c8ba8945cff8e0f31ab3a7c69d5cab2..3bbc2d0b28c8d30b22936489fe512e80b3662758 100644

--- a/net/socket/transport_client_socket_pool_unittest.cc

+++ b/net/socket/transport_client_socket_pool_unittest.cc

@@ -23,8 +23,13 @@

#include "net/socket/socket_test_util.h"

#include "net/socket/stream_socket.h"

#include "net/socket/transport_client_socket_pool_test_util.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 {

using internal::ClientSocketPoolBaseHelper;

@@ -178,11 +183,11 @@ TEST_F(TransportClientSocketPoolTest, Basic) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

TestLoadTimingInfoConnectedNotReused(handle);

@@ -216,10 +221,11 @@ TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {

handle.Init("a", dest, kDefaultPriority,

ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog()));

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));

ASSERT_EQ(1u, handle.connection_attempts().size());

EXPECT_TRUE(handle.connection_attempts()[0].endpoint.address().empty());

- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, handle.connection_attempts()[0].result);

+ EXPECT_THAT(handle.connection_attempts()[0].result,

+ IsError(ERR_NAME_NOT_RESOLVED));

}

TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {

@@ -231,11 +237,12 @@ TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {

handle.Init("a", params_, kDefaultPriority,

ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog()));

- EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));

ASSERT_EQ(1u, handle.connection_attempts().size());

EXPECT_EQ("127.0.0.1:80",

handle.connection_attempts()[0].endpoint.ToString());

- EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);

+ EXPECT_THAT(handle.connection_attempts()[0].result,

+ IsError(ERR_CONNECTION_FAILED));

// Make the host resolutions complete synchronously this time.

host_resolver_->set_synchronous_mode(true);

@@ -246,35 +253,36 @@ TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {

ASSERT_EQ(1u, handle.connection_attempts().size());

EXPECT_EQ("127.0.0.1:80",

handle.connection_attempts()[0].endpoint.ToString());

- EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);

+ EXPECT_THAT(handle.connection_attempts()[0].result,

+ IsError(ERR_CONNECTION_FAILED));

}

TEST_F(TransportClientSocketPoolTest, PendingRequests) {

// First request finishes asynchronously.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

- EXPECT_EQ(OK, (*requests())[0]->WaitForResult());

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

+ EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());

// Make all subsequent host resolutions complete synchronously.

host_resolver_->set_synchronous_mode(true);

// Rest of them finish synchronously, until we reach the per-group limit.

- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());

// The rest are pending since we've used all active sockets.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));

+ EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));

ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);

@@ -309,34 +317,34 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests) {

TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {

// First request finishes asynchronously.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

- EXPECT_EQ(OK, (*requests())[0]->WaitForResult());

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

+ EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());

// Make all subsequent host resolutions complete synchronously.

host_resolver_->set_synchronous_mode(true);

// Rest of them finish synchronously, until we reach the per-group limit.

- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());

// The rest are pending since we've used all active sockets.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);

// The pending requests should finish successfully.

- EXPECT_EQ(OK, (*requests())[6]->WaitForResult());

- EXPECT_EQ(OK, (*requests())[7]->WaitForResult());

- EXPECT_EQ(OK, (*requests())[8]->WaitForResult());

- EXPECT_EQ(OK, (*requests())[9]->WaitForResult());

- EXPECT_EQ(OK, (*requests())[10]->WaitForResult());

+ EXPECT_THAT((*requests())[6]->WaitForResult(), IsOk());

+ EXPECT_THAT((*requests())[7]->WaitForResult(), IsOk());

+ EXPECT_THAT((*requests())[8]->WaitForResult(), IsOk());

+ EXPECT_THAT((*requests())[9]->WaitForResult(), IsOk());

+ EXPECT_THAT((*requests())[10]->WaitForResult(), IsOk());

EXPECT_EQ(static_cast<int>(requests()->size()),

client_socket_factory_.allocation_count());

@@ -375,7 +383,7 @@ TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {

handle.Reset();

- EXPECT_EQ(OK, callback2.WaitForResult());

+ EXPECT_THAT(callback2.WaitForResult(), IsOk());

handle2.Reset();

}

@@ -407,7 +415,7 @@ TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {

// If the first one is not cancelled, it will advance the load state, and

// then the second one will crash.

- EXPECT_EQ(OK, callback2.WaitForResult());

+ EXPECT_THAT(callback2.WaitForResult(), IsOk());

EXPECT_FALSE(callback.have_result());

handle.Reset();

@@ -415,29 +423,29 @@ TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {

TEST_F(TransportClientSocketPoolTest, CancelRequest) {

// First request finishes asynchronously.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

- EXPECT_EQ(OK, (*requests())[0]->WaitForResult());

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

+ EXPECT_THAT((*requests())[0]->WaitForResult(), IsOk());

// Make all subsequent host resolutions complete synchronously.

host_resolver_->set_synchronous_mode(true);

- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsOk());

// Reached per-group limit, queue up requests.

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));

+ EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));

+ EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));

// Cancel a request.

size_t index_to_cancel = kMaxSocketsPerGroup + 2;

@@ -490,7 +498,7 @@ class RequestSocketCallback : public TestCompletionCallbackBase {

private:

void OnComplete(int result) {

SetResult(result);

- ASSERT_EQ(OK, result);

+ ASSERT_THAT(result, IsOk());

if (!within_callback_) {

// Don't allow reuse of the socket. Disconnect it and then release it and

@@ -509,7 +517,7 @@ class RequestSocketCallback : public TestCompletionCallbackBase {

int rv = handle_->Init("a", dest, LOWEST,

ClientSocketPool::RespectLimits::ENABLED,

callback(), pool_, BoundNetLog());

- EXPECT_EQ(OK, rv);

+ EXPECT_THAT(rv, IsOk());

}

@@ -530,13 +538,13 @@ TEST_F(TransportClientSocketPoolTest, RequestTwice) {

int rv =

handle.Init("a", dest, LOWEST, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- ASSERT_EQ(ERR_IO_PENDING, rv);

+ ASSERT_THAT(rv, IsError(ERR_IO_PENDING));

// The callback is going to request "www.google.com". We want it to complete

// synchronously this time.

host_resolver_->set_synchronous_mode(true);

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

handle.Reset();

}

@@ -548,15 +556,15 @@ TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {

MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);

// Queue up all the requests

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

// Now, kMaxSocketsPerGroup requests should be active. Let's cancel them.

ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size()));

@@ -565,7 +573,7 @@ TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {

// Let's wait for the rest to complete now.

for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) {

- EXPECT_EQ(OK, (*requests())[i]->WaitForResult());

+ EXPECT_THAT((*requests())[i]->WaitForResult(), IsOk());

(*requests())[i]->handle()->Reset();

}

@@ -582,10 +590,11 @@ TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {

// Queue up all the requests

for (int i = 0; i < kNumRequests; i++)

- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));

+ EXPECT_THAT(StartRequest("a", kDefaultPriority), IsError(ERR_IO_PENDING));

for (int i = 0; i < kNumRequests; i++)

- EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult());

+ EXPECT_THAT((*requests())[i]->WaitForResult(),

+ IsError(ERR_CONNECTION_FAILED));

}

TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {

@@ -594,11 +603,11 @@ TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

TestLoadTimingInfoConnectedNotReused(handle);

@@ -612,7 +621,7 @@ TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {

rv = handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(OK, rv);

+ EXPECT_THAT(rv, IsOk());

EXPECT_EQ(0, pool_.IdleSocketCount());

TestLoadTimingInfoConnectedReused(handle);

}

@@ -623,11 +632,11 @@ TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

@@ -680,7 +689,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {

int rv =

handle.Init("b", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

@@ -694,7 +703,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {

// Let the appropriate socket connect.

base::RunLoop().RunUntilIdle();

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

@@ -723,7 +732,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {

int rv =

handle.Init("c", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

@@ -770,7 +779,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {

int rv =

handle.Init("b", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

@@ -788,11 +797,12 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {

// Let the appropriate socket connect.

base::RunLoop().RunUntilIdle();

- EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

ASSERT_EQ(1u, handle.connection_attempts().size());

- EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);

+ EXPECT_THAT(handle.connection_attempts()[0].result,

+ IsError(ERR_CONNECTION_FAILED));

EXPECT_EQ(0, pool_.IdleSocketCount());

handle.Reset();

@@ -821,7 +831,7 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {

int rv =

handle.Init("b", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool_, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

@@ -839,11 +849,12 @@ TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {

// Let the appropriate socket connect.

base::RunLoop().RunUntilIdle();

- EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

ASSERT_EQ(1u, handle.connection_attempts().size());

- EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);

+ EXPECT_THAT(handle.connection_attempts()[0].result,

+ IsError(ERR_CONNECTION_FAILED));

handle.Reset();

// Reset for the next case.

@@ -877,11 +888,11 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

IPEndPoint endpoint;

@@ -892,7 +903,7 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) {

ConnectionAttempts attempts;

handle.socket()->GetConnectionAttempts(&attempts);

ASSERT_EQ(1u, attempts.size());

- EXPECT_EQ(ERR_CONNECTION_FAILED, attempts[0].result);

+ EXPECT_THAT(attempts[0].result, IsError(ERR_CONNECTION_FAILED));

EXPECT_TRUE(attempts[0].endpoint.address().IsIPv6());

EXPECT_EQ(2, client_socket_factory_.allocation_count());

@@ -928,11 +939,11 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

IPEndPoint endpoint;

@@ -944,7 +955,7 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) {

ConnectionAttempts attempts;

handle.socket()->GetConnectionAttempts(&attempts);

ASSERT_EQ(1u, attempts.size());

- EXPECT_EQ(ERR_CONNECTION_FAILED, attempts[0].result);

+ EXPECT_THAT(attempts[0].result, IsError(ERR_CONNECTION_FAILED));

EXPECT_TRUE(attempts[0].endpoint.address().IsIPv4());

EXPECT_EQ(2, client_socket_factory_.allocation_count());

@@ -969,11 +980,11 @@ TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

IPEndPoint endpoint;

@@ -1001,11 +1012,11 @@ TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) {

int rv =

handle.Init("a", params_, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(ERR_IO_PENDING, rv);

+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));

EXPECT_FALSE(handle.is_initialized());

EXPECT_FALSE(handle.socket());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(handle.is_initialized());

EXPECT_TRUE(handle.socket());

IPEndPoint endpoint;

@@ -1034,7 +1045,7 @@ TEST_F(TransportClientSocketPoolTest, TCPFastOpenOnIPv4WithNoFallback) {

scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen();

handle.Init("a", params, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(socket_data.IsUsingTCPFastOpen());

}

@@ -1060,7 +1071,7 @@ TEST_F(TransportClientSocketPoolTest, TCPFastOpenOnIPv6WithNoFallback) {

scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen();

handle.Init("a", params, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

EXPECT_TRUE(socket_data.IsUsingTCPFastOpen());

}

@@ -1090,7 +1101,7 @@ TEST_F(TransportClientSocketPoolTest,

scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen();

handle.Init("a", params, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

// Verify that the socket used is connected to the fallback IPv4 address.

IPEndPoint endpoint;

handle.socket()->GetPeerAddress(&endpoint);

@@ -1122,7 +1133,7 @@ TEST_F(TransportClientSocketPoolTest,

scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen();

handle.Init("a", params, LOW, ClientSocketPool::RespectLimits::ENABLED,

callback.callback(), &pool, BoundNetLog());

- EXPECT_EQ(OK, callback.WaitForResult());

+ EXPECT_THAT(callback.WaitForResult(), IsOk());

IPEndPoint endpoint;

handle.socket()->GetPeerAddress(&endpoint);

// Verify that the socket used is connected to the IPv6 address.

« no previous file with comments | « net/socket/tcp_socket_unittest.cc ('k') | net/socket/transport_client_socket_unittest.cc » ('j') | no next file with comments »