Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(251)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/socket/ssl_client_socket_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
« no previous file with comments | « net/socket/ssl_client_socket_pool_unittest.cc ('k') | net/socket/ssl_server_socket_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/socket/ssl_client_socket_unittest.cc
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index 2ac6959c9bd57772f8510b37a2581649e9b0ad2d..a05baff371b1642d99f8753f142b5666691d490a 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -54,12 +54,16 @@
#include "net/ssl/ssl_info.h"
#include "net/ssl/test_ssl_private_key.h"
#include "net/test/cert_test_util.h"
+#include "net/test/gtest_util.h"
#include "net/test/spawned_test_server/spawned_test_server.h"
#include "net/test/test_data_directory.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
+using net::test::IsError;
+using net::test::IsOk;
+
using testing::_;
using testing::Return;
using testing::Truly;
@@ -860,7 +864,7 @@ class SSLClientSocketCertRequestInfoTest : public SSLClientSocketTest {
std::unique_ptr<StreamSocket> transport(
new TCPClientSocket(addr, NULL, &log, NetLog::Source()));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server.host_port_pair(),
@@ -868,7 +872,7 @@ class SSLClientSocketCertRequestInfoTest : public SSLClientSocketTest {
EXPECT_FALSE(sock->IsConnected());
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
scoped_refptr<SSLCertRequestInfo> request_info = new SSLCertRequestInfo();
sock->GetSSLCertRequestInfo(request_info.get());
@@ -908,7 +912,7 @@ class SSLClientSocketFalseStartTest : public SSLClientSocketTest {
std::unique_ptr<FakeBlockingStreamSocket> transport(
new FakeBlockingStreamSocket(std::move(real_transport)));
int rv = callback->GetResult(transport->Connect(callback->callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
FakeBlockingStreamSocket* raw_transport = transport.get();
std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
@@ -919,7 +923,7 @@ class SSLClientSocketFalseStartTest : public SSLClientSocketTest {
// (ServerHello, etc.)
raw_transport->BlockReadResult();
rv = sock->Connect(callback->callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
raw_transport->WaitForReadResult();
// Release the ServerHello and wait for the client to write
@@ -958,7 +962,7 @@ class SSLClientSocketFalseStartTest : public SSLClientSocketTest {
// state machine sometimes lives on a separate thread, so this thread may
// not yet have processed the signal that the handshake has completed.
int rv = callback.WaitForResult();
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
@@ -1025,7 +1029,7 @@ TEST_F(SSLClientSocketTest, Connect) {
std::unique_ptr<StreamSocket> transport(
new TCPClientSocket(addr(), NULL, &log, NetLog::Source()));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
@@ -1040,7 +1044,7 @@ TEST_F(SSLClientSocketTest, Connect) {
EXPECT_TRUE(LogContainsBeginEvent(entries, 5, NetLog::TYPE_SSL_CONNECT));
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
log.GetEntries(&entries);
EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLog::TYPE_SSL_CONNECT));
@@ -1058,7 +1062,7 @@ TEST_F(SSLClientSocketTest, ConnectExpired) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(ERR_CERT_DATE_INVALID, rv);
+ EXPECT_THAT(rv, IsError(ERR_CERT_DATE_INVALID));
// Rather than testing whether or not the underlying socket is connected,
// test that the handshake has finished. This is because it may be
@@ -1078,7 +1082,7 @@ TEST_F(SSLClientSocketTest, ConnectMismatched) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, rv);
+ EXPECT_THAT(rv, IsError(ERR_CERT_COMMON_NAME_INVALID));
// Rather than testing whether or not the underlying socket is connected,
// test that the handshake has finished. This is because it may be
@@ -1101,7 +1105,7 @@ TEST_F(SSLClientSocketTest, ConnectBadValidity) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_SERVER_CERT_BAD_FORMAT, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_SERVER_CERT_BAD_FORMAT));
EXPECT_FALSE(IsCertificateError(rv));
SSLInfo ssl_info;
@@ -1119,7 +1123,7 @@ TEST_F(SSLClientSocketTest, ConnectClientAuthCertRequested) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
TestNetLogEntry::List entries;
log_.GetEntries(&entries);
@@ -1144,7 +1148,7 @@ TEST_F(SSLClientSocketTest, ConnectClientAuthSendNullCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// We responded to the server's certificate request with a Certificate
// message with no client certificate in it. ssl_info.client_cert_sent
@@ -1173,7 +1177,7 @@ TEST_F(SSLClientSocketTest, Read) {
EXPECT_EQ(0, transport->GetTotalReceivedBytes());
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
@@ -1181,7 +1185,7 @@ TEST_F(SSLClientSocketTest, Read) {
EXPECT_EQ(0, sock->GetTotalReceivedBytes());
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Number of network bytes received should increase because of SSL socket
// establishment.
@@ -1230,7 +1234,7 @@ TEST_F(SSLClientSocketTest, Connect_WithSynchronousError) {
std::unique_ptr<SynchronousErrorStreamSocket> transport(
new SynchronousErrorStreamSocket(std::move(real_transport)));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1244,7 +1248,7 @@ TEST_F(SSLClientSocketTest, Connect_WithSynchronousError) {
raw_transport->SetNextWriteError(ERR_CONNECTION_RESET);
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
EXPECT_FALSE(sock->IsConnected());
}
@@ -1261,7 +1265,7 @@ TEST_F(SSLClientSocketTest, Read_WithSynchronousError) {
std::unique_ptr<SynchronousErrorStreamSocket> transport(
new SynchronousErrorStreamSocket(std::move(real_transport)));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1273,7 +1277,7 @@ TEST_F(SSLClientSocketTest, Read_WithSynchronousError) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
@@ -1295,7 +1299,7 @@ TEST_F(SSLClientSocketTest, Read_WithSynchronousError) {
// rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING is a legitimate
// result when using a dedicated task runner for NSS.
rv = callback.GetResult(sock->Read(buf.get(), 4096, callback.callback()));
- EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
}
// Tests that the SSLClientSocket properly handles when the underlying transport
@@ -1317,7 +1321,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousError) {
new FakeBlockingStreamSocket(std::move(error_socket)));
FakeBlockingStreamSocket* raw_transport = transport.get();
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1328,7 +1332,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousError) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
@@ -1352,7 +1356,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousError) {
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
rv = sock->Read(buf.get(), 4096, callback.callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Now unblock the outgoing request, having it fail with the connection
// being reset.
@@ -1362,7 +1366,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousError) {
// checking that rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING
// is a legitimate result when using a dedicated task runner for NSS.
rv = callback.GetResult(rv);
- EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
}
// If there is a Write failure at the transport with no follow-up Read, although
@@ -1384,7 +1388,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousErrorNoRead) {
new CountingStreamSocket(std::move(error_socket)));
CountingStreamSocket* raw_counting_socket = counting_socket.get();
int rv = callback.GetResult(counting_socket->Connect(callback.callback()));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1395,7 +1399,7 @@ TEST_F(SSLClientSocketTest, Write_WithSynchronousErrorNoRead) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
ASSERT_TRUE(sock->IsConnected());
// Simulate an unclean/forcible shutdown on the underlying socket.
@@ -1434,14 +1438,14 @@ TEST_F(SSLClientSocketTest, Read_FullDuplex) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Issue a "hanging" Read first.
TestCompletionCallback callback;
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
rv = sock_->Read(buf.get(), 4096, callback.callback());
// We haven't written the request, so there should be no response yet.
- ASSERT_EQ(ERR_IO_PENDING, rv);
+ ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
// Write the request.
// The request is padded with a User-Agent header to a size that causes the
@@ -1485,7 +1489,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
FakeBlockingStreamSocket* raw_transport = transport.get();
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1496,7 +1500,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
ssl_config);
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
std::string request_text = "GET / HTTP/1.1\r\nUser-Agent: long browser name ";
@@ -1521,7 +1525,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
rv = raw_sock->Read(read_buf.get(), 4096, read_callback.callback());
// Ensure things didn't complete synchronously, otherwise |sock| is invalid.
- ASSERT_EQ(ERR_IO_PENDING, rv);
+ ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
ASSERT_FALSE(read_callback.have_result());
// Attempt to write the remaining data. OpenSSL will return that its blocked
@@ -1529,7 +1533,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
rv = raw_sock->Write(request_buffer.get(),
request_buffer->BytesRemaining(),
callback.callback());
- ASSERT_EQ(ERR_IO_PENDING, rv);
+ ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
ASSERT_FALSE(callback.have_result());
// Now unblock Write(), which will invoke OnSendComplete and (eventually)
@@ -1538,7 +1542,7 @@ TEST_F(SSLClientSocketTest, Read_DeleteWhilePendingFullDuplex) {
raw_transport->UnblockWrite();
rv = read_callback.WaitForResult();
- EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
// The Write callback should not have been called.
EXPECT_FALSE(callback.have_result());
@@ -1564,7 +1568,7 @@ TEST_F(SSLClientSocketTest, Read_WithWriteError) {
FakeBlockingStreamSocket* raw_transport = transport.get();
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to avoid handshake non-determinism.
SSLConfig ssl_config;
@@ -1575,7 +1579,7 @@ TEST_F(SSLClientSocketTest, Read_WithWriteError) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
// Send a request so there is something to read from the socket.
@@ -1594,7 +1598,7 @@ TEST_F(SSLClientSocketTest, Read_WithWriteError) {
raw_transport->BlockReadResult();
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
rv = sock->Read(buf.get(), 4096, read_callback.callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Perform another write, but have it fail. Write a request larger than the
// internal socket buffers so that the request hits the underlying transport
@@ -1626,7 +1630,7 @@ TEST_F(SSLClientSocketTest, Read_WithWriteError) {
}
} while (rv > 0);
- EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
// Release the read.
raw_transport->UnblockReadResult();
@@ -1647,7 +1651,7 @@ TEST_F(SSLClientSocketTest, Connect_WithZeroReturn) {
std::unique_ptr<SynchronousErrorStreamSocket> transport(
new SynchronousErrorStreamSocket(std::move(real_transport)));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SynchronousErrorStreamSocket* raw_transport = transport.get();
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
@@ -1657,7 +1661,7 @@ TEST_F(SSLClientSocketTest, Connect_WithZeroReturn) {
raw_transport->SetNextReadError(0);
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
+ EXPECT_THAT(rv, IsError(ERR_CONNECTION_CLOSED));
EXPECT_FALSE(sock->IsConnected());
}
@@ -1673,7 +1677,7 @@ TEST_F(SSLClientSocketTest, Read_WithZeroReturn) {
std::unique_ptr<SynchronousErrorStreamSocket> transport(
new SynchronousErrorStreamSocket(std::move(real_transport)));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to ensure the handshake has completed.
SSLConfig ssl_config;
@@ -1685,7 +1689,7 @@ TEST_F(SSLClientSocketTest, Read_WithZeroReturn) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
raw_transport->SetNextReadError(0);
@@ -1710,7 +1714,7 @@ TEST_F(SSLClientSocketTest, Read_WithAsyncZeroReturn) {
new FakeBlockingStreamSocket(std::move(error_socket)));
FakeBlockingStreamSocket* raw_transport = transport.get();
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Disable TLS False Start to ensure the handshake has completed.
SSLConfig ssl_config;
@@ -1721,14 +1725,14 @@ TEST_F(SSLClientSocketTest, Read_WithAsyncZeroReturn) {
ssl_config));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
raw_error_socket->SetNextReadError(0);
raw_transport->BlockReadResult();
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
rv = sock->Read(buf.get(), 4096, callback.callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
raw_transport->UnblockReadResult();
rv = callback.GetResult(rv);
@@ -1744,7 +1748,7 @@ TEST_F(SSLClientSocketTest, Read_WithFatalAlert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// Receive the fatal alert.
TestCompletionCallback callback;
@@ -1758,7 +1762,7 @@ TEST_F(SSLClientSocketTest, Read_SmallChunks) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
scoped_refptr<IOBuffer> request_buffer(
@@ -1788,14 +1792,14 @@ TEST_F(SSLClientSocketTest, Read_ManySmallRecords) {
new ReadBufferingStreamSocket(std::move(real_transport)));
ReadBufferingStreamSocket* raw_transport = transport.get();
int rv = callback.GetResult(transport->Connect(callback.callback()));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
SSLConfig()));
rv = callback.GetResult(sock->Connect(callback.callback()));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
ASSERT_TRUE(sock->IsConnected());
const char request_text[] = "GET /ssl-many-small-records HTTP/1.0\r\n\r\n";
@@ -1829,7 +1833,7 @@ TEST_F(SSLClientSocketTest, Read_Interrupted) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
scoped_refptr<IOBuffer> request_buffer(
@@ -1856,14 +1860,14 @@ TEST_F(SSLClientSocketTest, Read_FullLogging) {
std::unique_ptr<StreamSocket> transport(
new TCPClientSocket(addr(), NULL, &log, NetLog::Source()));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
SSLConfig()));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock->IsConnected());
const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
@@ -1925,14 +1929,14 @@ TEST_F(SSLClientSocketTest, PrematureApplicationData) {
std::unique_ptr<StreamSocket> transport(
new MockTCPClientSocket(addr(), NULL, &data));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
SSLConfig()));
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
}
TEST_F(SSLClientSocketTest, CipherSuiteDisables) {
@@ -1956,7 +1960,7 @@ TEST_F(SSLClientSocketTest, CipherSuiteDisables) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
}
// When creating an SSLClientSocket, it is allowed to pass in a
@@ -1970,7 +1974,7 @@ TEST_F(SSLClientSocketTest, ClientSocketHandleNotFromPool) {
std::unique_ptr<StreamSocket> transport(
new TCPClientSocket(addr(), NULL, NULL, NetLog::Source()));
int rv = callback.GetResult(transport->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::unique_ptr<ClientSocketHandle> socket_handle(new ClientSocketHandle());
socket_handle->SetSocket(std::move(transport));
@@ -1981,7 +1985,7 @@ TEST_F(SSLClientSocketTest, ClientSocketHandleNotFromPool) {
EXPECT_FALSE(sock->IsConnected());
rv = callback.GetResult(sock->Connect(callback.callback()));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
}
// Verifies that SSLClientSocket::ExportKeyingMaterial return a success
@@ -1991,7 +1995,7 @@ TEST_F(SSLClientSocketTest, ExportKeyingMaterial) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
const int kKeyingMaterialSize = 32;
@@ -2074,7 +2078,7 @@ TEST_F(SSLClientSocketTest, VerifyServerChainProperlyOrdered) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(ERR_CERT_INVALID, rv);
+ EXPECT_THAT(rv, IsError(ERR_CERT_INVALID));
EXPECT_TRUE(sock_->IsConnected());
// When given option CERT_CHAIN_WRONG_ROOT, SpawnedTestServer will present
@@ -2167,7 +2171,7 @@ TEST_F(SSLClientSocketTest, VerifyReturnChainProperlyOrdered) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
TestNetLogEntry::List entries;
@@ -2287,7 +2291,7 @@ TEST_F(SSLClientSocketTest, ConnectSignedCertTimestampsEnabledTLSExtension) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->signed_cert_timestamps_received_);
}
@@ -2305,7 +2309,7 @@ TEST_F(SSLClientSocketTest, EVCertStatusMaintainedNoCTVerifier) {
// No verifier to skip CT and policy checks.
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo result;
ASSERT_TRUE(sock_->GetSSLInfo(&result));
@@ -2341,7 +2345,7 @@ TEST_F(SSLClientSocketTest, EVCertStatusMaintainedForCompliantCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo result;
ASSERT_TRUE(sock_->GetSSLInfo(&result));
@@ -2377,7 +2381,7 @@ TEST_F(SSLClientSocketTest, EVCertStatusRemovedForNonCompliantCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo result;
ASSERT_TRUE(sock_->GetSSLInfo(&result));
@@ -2430,7 +2434,7 @@ TEST_F(SSLClientSocketTest, ConnectSignedCertTimestampsEnabledOCSP) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->stapled_ocsp_response_received_);
}
@@ -2446,7 +2450,7 @@ TEST_F(SSLClientSocketTest, ConnectSignedCertTimestampsDisabled) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_FALSE(sock_->signed_cert_timestamps_received_);
}
@@ -2496,12 +2500,13 @@ TEST_F(SSLClientSocketTest, ReusableAfterWrite) {
std::unique_ptr<FakeBlockingStreamSocket> transport(
new FakeBlockingStreamSocket(std::move(real_transport)));
FakeBlockingStreamSocket* raw_transport = transport.get();
- ASSERT_EQ(OK, callback.GetResult(transport->Connect(callback.callback())));
+ ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
+ IsOk());
std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
std::move(transport), spawned_test_server()->host_port_pair(),
SSLConfig()));
- ASSERT_EQ(OK, callback.GetResult(sock->Connect(callback.callback())));
+ ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())), IsOk());
// Block any application data from reaching the network.
raw_transport->BlockWrite();
@@ -2534,14 +2539,14 @@ TEST_F(SSLClientSocketTest, SessionResumption) {
SSLConfig ssl_config;
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
// The next connection should resume.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
sock_.reset();
@@ -2550,10 +2555,11 @@ TEST_F(SSLClientSocketTest, SessionResumption) {
std::unique_ptr<StreamSocket> transport(
new TCPClientSocket(addr(), NULL, &log_, NetLog::Source()));
TestCompletionCallback callback;
- ASSERT_EQ(OK, callback.GetResult(transport->Connect(callback.callback())));
+ ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
+ IsOk());
std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
std::move(transport), HostPortPair("example.com", 443), ssl_config);
- ASSERT_EQ(OK, callback.GetResult(sock->Connect(callback.callback())));
+ ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())), IsOk());
ASSERT_TRUE(sock->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
sock.reset();
@@ -2562,7 +2568,7 @@ TEST_F(SSLClientSocketTest, SessionResumption) {
// After clearing the session cache, the next handshake doesn't resume.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
}
@@ -2578,13 +2584,13 @@ TEST_F(SSLClientSocketTest, CertificateErrorNoResume) {
SSLConfig ssl_config;
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- ASSERT_EQ(ERR_CERT_COMMON_NAME_INVALID, rv);
+ ASSERT_THAT(rv, IsError(ERR_CERT_COMMON_NAME_INVALID));
cert_verifier_->set_default_result(OK);
// The next connection should perform a full handshake.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- ASSERT_EQ(OK, rv);
+ ASSERT_THAT(rv, IsOk());
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
@@ -2605,7 +2611,7 @@ TEST_F(SSLClientSocketTest, FallbackShardSessionCache) {
// session cache.
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(fallback_ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo ssl_info;
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
@@ -2614,7 +2620,7 @@ TEST_F(SSLClientSocketTest, FallbackShardSessionCache) {
// A non-fallback connection needs a full handshake.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1_2,
@@ -2627,7 +2633,7 @@ TEST_F(SSLClientSocketTest, FallbackShardSessionCache) {
// The non-fallback connection added a > TLS 1.0 entry to the session cache.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
// This does not check for equality because TLS 1.2 support is conditional on
@@ -2639,7 +2645,7 @@ TEST_F(SSLClientSocketTest, FallbackShardSessionCache) {
// offer the > TLS 1.0 session, so this must have been the session from the
// first fallback connection.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(fallback_ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1,
@@ -2658,22 +2664,22 @@ TEST_F(SSLClientSocketTest, DHE) {
SSLConfig ssl_config;
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
ssl_config.dhe_enabled = true;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
// Enabling deprecated ciphers gives DHE a dedicated error code.
ssl_config.dhe_enabled = false;
ssl_config.deprecated_cipher_suites_enabled = true;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_OBSOLETE_CIPHER, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_OBSOLETE_CIPHER));
// Enabling both deprecated ciphers and DHE restores it.
ssl_config.dhe_enabled = true;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
}
// Tests that enabling deprecated ciphers shards the session cache.
@@ -2688,20 +2694,20 @@ TEST_F(SSLClientSocketTest, DeprecatedShardSessionCache) {
// Connect with deprecated ciphers enabled to warm the session cache cache.
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(deprecated_ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo ssl_info;
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
// Test that re-connecting with deprecated ciphers enabled still resumes.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(deprecated_ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
// However, a normal connection needs a full handshake.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
@@ -2710,19 +2716,19 @@ TEST_F(SSLClientSocketTest, DeprecatedShardSessionCache) {
// Now make a normal connection to prime the session cache.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
// A normal connection should be able to resume.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
// However, enabling deprecated ciphers connects fresh.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(deprecated_ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
}
@@ -2737,7 +2743,7 @@ TEST_F(SSLClientSocketTest, RequireECDHE) {
config.require_ecdhe = true;
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
- EXPECT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
}
TEST_F(SSLClientSocketTest, TokenBindingEnabled) {
@@ -2750,7 +2756,7 @@ TEST_F(SSLClientSocketTest, TokenBindingEnabled) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo info;
EXPECT_TRUE(sock_->GetSSLInfo(&info));
EXPECT_TRUE(info.token_binding_negotiated);
@@ -2768,7 +2774,7 @@ TEST_F(SSLClientSocketTest, TokenBindingFailsWithEmsDisabled) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
}
TEST_F(SSLClientSocketTest, TokenBindingEnabledWithoutServerSupport) {
@@ -2780,7 +2786,7 @@ TEST_F(SSLClientSocketTest, TokenBindingEnabledWithoutServerSupport) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
SSLInfo info;
EXPECT_TRUE(sock_->GetSSLInfo(&info));
EXPECT_FALSE(info.token_binding_negotiated);
@@ -2879,7 +2885,7 @@ TEST_F(SSLClientSocketFalseStartTest, SessionResumption) {
// Make a second connection.
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// It should resume the session.
SSLInfo ssl_info;
@@ -2910,7 +2916,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBeforeFinished) {
client_config, &callback, &raw_transport1, &sock1));
// Although raw_transport1 has the server Finished blocked, the handshake
// still completes.
- EXPECT_EQ(OK, callback.WaitForResult());
+ EXPECT_THAT(callback.WaitForResult(), IsOk());
// Continue to block the client (|sock1|) from processing the Finished
// message, but allow it to arrive on the socket. This ensures that, from the
@@ -2923,7 +2929,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBeforeFinished) {
// doesn't come in one Read.
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
int rv = sock1->Read(buf.get(), 4096, callback.callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
raw_transport1->WaitForReadResult();
// Drop the old socket. This is needed because the Python test server can't
@@ -2932,7 +2938,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBeforeFinished) {
// Start a second connection.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// No session resumption because the first connection never received a server
// Finished message.
@@ -2964,7 +2970,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBadFinished) {
client_config, &callback, &raw_transport1, &sock1));
// Although raw_transport1 has the server Finished blocked, the handshake
// still completes.
- EXPECT_EQ(OK, callback.WaitForResult());
+ EXPECT_THAT(callback.WaitForResult(), IsOk());
// Continue to block the client (|sock1|) from processing the Finished
// message, but allow it to arrive on the socket. This ensures that, from the
@@ -2976,7 +2982,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBadFinished) {
// the socket.
scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
int rv = sock1->Read(buf.get(), 4096, callback.callback());
- EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
raw_transport1->WaitForReadResult();
// The server's second leg, or part of it, is now received but not yet sent to
@@ -2987,7 +2993,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBadFinished) {
// Unblock the Finished message. |sock1->Read| should now fail.
raw_transport1->UnblockReadResult();
- EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.GetResult(rv));
+ EXPECT_THAT(callback.GetResult(rv), IsError(ERR_SSL_PROTOCOL_ERROR));
// Drop the old socket. This is needed because the Python test server can't
// service two sockets in parallel.
@@ -2995,7 +3001,7 @@ TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBadFinished) {
// Start a second connection.
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
// No session resumption because the first connection never received a server
// Finished message.
@@ -3017,7 +3023,7 @@ TEST_F(SSLClientSocketChannelIDTest, SendChannelID) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
@@ -3063,7 +3069,7 @@ TEST_F(SSLClientSocketChannelIDTest, FailingChannelIDAsync) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(ERR_UNEXPECTED, rv);
+ EXPECT_THAT(rv, IsError(ERR_UNEXPECTED));
EXPECT_FALSE(sock_->IsConnected());
}
@@ -3105,7 +3111,7 @@ TEST_F(SSLClientSocketTest, NPN) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::string proto;
EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, sock_->GetNextProto(&proto));
@@ -3125,7 +3131,7 @@ TEST_F(SSLClientSocketTest, NPNNoOverlap) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::string proto;
EXPECT_EQ(SSLClientSocket::kNextProtoNoOverlap, sock_->GetNextProto(&proto));
@@ -3146,7 +3152,7 @@ TEST_F(SSLClientSocketTest, NPNServerPreference) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::string proto;
EXPECT_EQ(SSLClientSocket::kNextProtoNegotiated, sock_->GetNextProto(&proto));
@@ -3166,7 +3172,7 @@ TEST_F(SSLClientSocketTest, NPNClientDisabled) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::string proto;
EXPECT_EQ(SSLClientSocket::kNextProtoUnsupported,
@@ -3182,7 +3188,7 @@ TEST_F(SSLClientSocketTest, NPNServerDisabled) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
std::string proto;
EXPECT_EQ(SSLClientSocket::kNextProtoUnsupported,
@@ -3228,7 +3234,7 @@ TEST_F(SSLClientSocketTest, NoCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
- EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
EXPECT_FALSE(sock_->IsConnected());
}
@@ -3250,7 +3256,7 @@ TEST_F(SSLClientSocketTest, SendEmptyCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
SSLInfo ssl_info;
@@ -3281,7 +3287,7 @@ TEST_F(SSLClientSocketTest, SendGoodCert) {
int rv;
ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
SSLInfo ssl_info;
@@ -3329,7 +3335,7 @@ TEST_F(SSLClientSocketTest, PKPBypassedSet) {
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
- EXPECT_EQ(OK, rv);
+ EXPECT_THAT(rv, IsOk());
EXPECT_TRUE(sock_->IsConnected());
EXPECT_TRUE(ssl_info.pkp_bypassed);
@@ -3363,7 +3369,7 @@ TEST_F(SSLClientSocketTest, PKPEnforced) {
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
- EXPECT_EQ(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN));
EXPECT_TRUE(ssl_info.cert_status & CERT_STATUS_PINNED_KEY_MISSING);
EXPECT_TRUE(sock_->IsConnected());
@@ -3407,7 +3413,7 @@ TEST_F(SSLClientSocketTest, CTIsRequired) {
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
- EXPECT_EQ(ERR_CERTIFICATE_TRANSPARENCY_REQUIRED, rv);
+ EXPECT_THAT(rv, IsError(ERR_CERTIFICATE_TRANSPARENCY_REQUIRED));
EXPECT_TRUE(ssl_info.cert_status &
CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
EXPECT_TRUE(sock_->IsConnected());
@@ -3458,7 +3464,7 @@ TEST_F(SSLClientSocketTest, PKPMoreImportantThanCT) {
SSLInfo ssl_info;
ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
- EXPECT_EQ(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN, rv);
+ EXPECT_THAT(rv, IsError(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN));
EXPECT_TRUE(ssl_info.cert_status & CERT_STATUS_PINNED_KEY_MISSING);
EXPECT_TRUE(ssl_info.cert_status &
CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
« no previous file with comments | « net/socket/ssl_client_socket_pool_unittest.cc ('k') | net/socket/ssl_server_socket_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698