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

net/socket/ssl_server_socket_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.
 
 // This test suite uses SSLClientSocket to test the implementation of
 // SSLServerSocket. In order to establish connections between the sockets
 // we need two additional classes:
 // 1. FakeSocket
 //    Connects SSL socket to FakeDataChannel. This class is just a stub.
 //
@@ skipping 51 matching lines @@
 #include "net/socket/stream_socket.h"
 #include "net/ssl/scoped_openssl_types.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_info.h"
 #include "net/ssl/ssl_private_key.h"
 #include "net/ssl/ssl_server_config.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/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;
+
 namespace net {
 
 namespace {
 
 const char kClientCertFileName[] = "client_1.pem";
 const char kClientPrivateKeyFileName[] = "client_1.pk8";
 const char kWrongClientCertFileName[] = "client_2.pem";
 const char kWrongClientPrivateKeyFileName[] = "client_2.pk8";
 const char kClientCertCAFileName[] = "client_1_ca.pem";
 
@@ skipping 448 matching lines @@
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(OK, client_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(client_ret, IsOk());
+  ASSERT_THAT(server_ret, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
 
   // The default cipher suite should be ECDHE and, unless on NSS and the
   // platform doesn't support it, an AEAD.
   uint16_t cipher_suite =
       SSLConnectionStatusToCipherSuite(ssl_info.connection_status);
@@ skipping 13 matching lines @@
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(OK, client_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(client_ret, IsOk());
+  ASSERT_THAT(server_ret, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
   EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
   SSLInfo ssl_server_info;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
   EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
 
   // Make sure the second connection is cached.
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
   TestCompletionCallback handshake_callback2;
   int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
 
   TestCompletionCallback connect_callback2;
   int client_ret2 = client_socket_->Connect(connect_callback2.callback());
 
   client_ret2 = connect_callback2.GetResult(client_ret2);
   server_ret2 = handshake_callback2.GetResult(server_ret2);
 
-  ASSERT_EQ(OK, client_ret2);
-  ASSERT_EQ(OK, server_ret2);
+  ASSERT_THAT(client_ret2, IsOk());
+  ASSERT_THAT(server_ret2, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info2;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
   EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
   SSLInfo ssl_server_info2;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
   EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
 }
 
 // This test makes sure the session cache separates out by server context.
 TEST_F(SSLServerSocketTest, HandshakeCachedContextSwitch) {
   ASSERT_NO_FATAL_FAILURE(CreateContext());
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(OK, client_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(client_ret, IsOk());
+  ASSERT_THAT(server_ret, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
   EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
   SSLInfo ssl_server_info;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
   EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
 
   // Make sure the second connection is NOT cached when using a new context.
   ASSERT_NO_FATAL_FAILURE(CreateContext());
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
 
   TestCompletionCallback handshake_callback2;
   int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
 
   TestCompletionCallback connect_callback2;
   int client_ret2 = client_socket_->Connect(connect_callback2.callback());
 
   client_ret2 = connect_callback2.GetResult(client_ret2);
   server_ret2 = handshake_callback2.GetResult(server_ret2);
 
-  ASSERT_EQ(OK, client_ret2);
-  ASSERT_EQ(OK, server_ret2);
+  ASSERT_THAT(client_ret2, IsOk());
+  ASSERT_THAT(server_ret2, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info2;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
   EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_FULL);
   SSLInfo ssl_server_info2;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
   EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_FULL);
 }
 
@@ skipping 11 matching lines @@
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(OK, client_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(client_ret, IsOk());
+  ASSERT_THAT(server_ret, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   client_socket_->GetSSLInfo(&ssl_info);
   EXPECT_EQ(CERT_STATUS_AUTHORITY_INVALID, ssl_info.cert_status);
   server_socket_->GetSSLInfo(&ssl_info);
   ASSERT_TRUE(ssl_info.cert.get());
   EXPECT_TRUE(client_cert->Equals(ssl_info.cert.get()));
 }
 
@@ skipping 12 matching lines @@
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(OK, client_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(client_ret, IsOk());
+  ASSERT_THAT(server_ret, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info));
   EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
   SSLInfo ssl_server_info;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info));
   ASSERT_TRUE(ssl_server_info.cert.get());
   EXPECT_TRUE(client_cert->Equals(ssl_server_info.cert.get()));
   EXPECT_EQ(ssl_server_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
   server_socket_->Disconnect();
   client_socket_->Disconnect();
 
   // Create the connection again.
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
   TestCompletionCallback handshake_callback2;
   int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
 
   TestCompletionCallback connect_callback2;
   int client_ret2 = client_socket_->Connect(connect_callback2.callback());
 
   client_ret2 = connect_callback2.GetResult(client_ret2);
   server_ret2 = handshake_callback2.GetResult(server_ret2);
 
-  ASSERT_EQ(OK, client_ret2);
-  ASSERT_EQ(OK, server_ret2);
+  ASSERT_THAT(client_ret2, IsOk());
+  ASSERT_THAT(server_ret2, IsOk());
 
   // Make sure the cert status is expected.
   SSLInfo ssl_info2;
   ASSERT_TRUE(client_socket_->GetSSLInfo(&ssl_info2));
   EXPECT_EQ(ssl_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
   SSLInfo ssl_server_info2;
   ASSERT_TRUE(server_socket_->GetSSLInfo(&ssl_server_info2));
   ASSERT_TRUE(ssl_server_info2.cert.get());
   EXPECT_TRUE(client_cert->Equals(ssl_server_info2.cert.get()));
   EXPECT_EQ(ssl_server_info2.handshake_type, SSLInfo::HANDSHAKE_RESUME);
@@ skipping 22 matching lines @@
 
   // Check that the authority name that arrived in the CertificateRequest
   // handshake message is as expected.
   scoped_refptr<X509Certificate> client_cert =
       ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
   ASSERT_TRUE(client_cert);
   EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info->cert_authorities));
 
   client_socket_->Disconnect();
 
-  EXPECT_EQ(ERR_FAILED, handshake_callback.GetResult(server_ret));
+  EXPECT_THAT(handshake_callback.GetResult(server_ret), IsError(ERR_FAILED));
 }
 
 TEST_F(SSLServerSocketTest, HandshakeWithClientCertRequiredNotSuppliedCached) {
   ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
   ASSERT_NO_FATAL_FAILURE(CreateContext());
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
   // Use the default setting for the client socket, which is to not send
   // a client certificate. This will cause the client to receive an
   // ERR_SSL_CLIENT_AUTH_CERT_NEEDED error, and allow for inspecting the
   // requested cert_authorities from the CertificateRequest sent by the
@@ skipping 12 matching lines @@
 
   // Check that the authority name that arrived in the CertificateRequest
   // handshake message is as expected.
   scoped_refptr<X509Certificate> client_cert =
       ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
   ASSERT_TRUE(client_cert);
   EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info->cert_authorities));
 
   client_socket_->Disconnect();
 
-  EXPECT_EQ(ERR_FAILED, handshake_callback.GetResult(server_ret));
+  EXPECT_THAT(handshake_callback.GetResult(server_ret), IsError(ERR_FAILED));
   server_socket_->Disconnect();
 
   // Below, check that the cache didn't store the result of a failed handshake.
   ASSERT_NO_FATAL_FAILURE(CreateSockets());
   TestCompletionCallback handshake_callback2;
   int server_ret2 = server_socket_->Handshake(handshake_callback2.callback());
 
   TestCompletionCallback connect_callback2;
   EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED,
             connect_callback2.GetResult(
                 client_socket_->Connect(connect_callback2.callback())));
 
   scoped_refptr<SSLCertRequestInfo> request_info2 = new SSLCertRequestInfo();
   client_socket_->GetSSLCertRequestInfo(request_info2.get());
 
   // Check that the authority name that arrived in the CertificateRequest
   // handshake message is as expected.
   EXPECT_TRUE(client_cert->IsIssuedByEncoded(request_info2->cert_authorities));
 
   client_socket_->Disconnect();
 
-  EXPECT_EQ(ERR_FAILED, handshake_callback2.GetResult(server_ret2));
+  EXPECT_THAT(handshake_callback2.GetResult(server_ret2), IsError(ERR_FAILED));
 }
 
 TEST_F(SSLServerSocketTest, HandshakeWithWrongClientCertSupplied) {
   scoped_refptr<X509Certificate> client_cert =
       ImportCertFromFile(GetTestCertsDirectory(), kClientCertFileName);
   ASSERT_TRUE(client_cert);
 
   ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForClient(
       kWrongClientCertFileName, kWrongClientPrivateKeyFileName));
   ASSERT_NO_FATAL_FAILURE(ConfigureClientCertsForServer());
@@ skipping 58 matching lines @@
   // Establish connection.
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
   ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
   ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
 
   client_ret = connect_callback.GetResult(client_ret);
-  ASSERT_EQ(OK, client_ret);
+  ASSERT_THAT(client_ret, IsOk());
   server_ret = handshake_callback.GetResult(server_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(server_ret, IsOk());
 
   const int kReadBufSize = 1024;
   scoped_refptr<StringIOBuffer> write_buf =
       new StringIOBuffer("testing123");
   scoped_refptr<DrainableIOBuffer> read_buf =
       new DrainableIOBuffer(new IOBuffer(kReadBufSize), kReadBufSize);
 
   // Write then read.
   TestCompletionCallback write_callback;
   TestCompletionCallback read_callback;
@@ skipping 61 matching lines @@
   // Establish connection.
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
   ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
   ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
 
   client_ret = connect_callback.GetResult(client_ret);
-  ASSERT_EQ(OK, client_ret);
+  ASSERT_THAT(client_ret, IsOk());
   server_ret = handshake_callback.GetResult(server_ret);
-  ASSERT_EQ(OK, server_ret);
+  ASSERT_THAT(server_ret, IsOk());
 
   scoped_refptr<StringIOBuffer> write_buf = new StringIOBuffer("testing123");
 
   // The server closes the connection. The server needs to write some
   // data first so that the client's Read() calls from the transport
   // socket won't return ERR_IO_PENDING.  This ensures that the client
   // will call Read() on the transport socket again.
   TestCompletionCallback write_callback;
   server_ret = server_socket_->Write(write_buf.get(), write_buf->size(),
                                      write_callback.callback());
@@ skipping 27 matching lines @@
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
   ASSERT_TRUE(client_ret == OK || client_ret == ERR_IO_PENDING);
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
   ASSERT_TRUE(server_ret == OK || server_ret == ERR_IO_PENDING);
 
   if (client_ret == ERR_IO_PENDING) {
-    ASSERT_EQ(OK, connect_callback.WaitForResult());
+    ASSERT_THAT(connect_callback.WaitForResult(), IsOk());
   }
   if (server_ret == ERR_IO_PENDING) {
-    ASSERT_EQ(OK, handshake_callback.WaitForResult());
+    ASSERT_THAT(handshake_callback.WaitForResult(), IsOk());
   }
 
   const int kKeyingMaterialSize = 32;
   const char kKeyingLabel[] = "EXPERIMENTAL-server-socket-test";
   const char kKeyingContext[] = "";
   unsigned char server_out[kKeyingMaterialSize];
   int rv = server_socket_->ExportKeyingMaterial(
       kKeyingLabel, false, kKeyingContext, server_out, sizeof(server_out));
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
 
   unsigned char client_out[kKeyingMaterialSize];
   rv = client_socket_->ExportKeyingMaterial(kKeyingLabel, false, kKeyingContext,
                                             client_out, sizeof(client_out));
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
   EXPECT_EQ(0, memcmp(server_out, client_out, sizeof(server_out)));
 
   const char kKeyingLabelBad[] = "EXPERIMENTAL-server-socket-test-bad";
   unsigned char client_bad[kKeyingMaterialSize];
   rv = client_socket_->ExportKeyingMaterial(
       kKeyingLabelBad, false, kKeyingContext, client_bad, sizeof(client_bad));
   ASSERT_EQ(rv, OK);
   EXPECT_NE(0, memcmp(server_out, client_bad, sizeof(server_out)));
 }
 
@@ skipping 23 matching lines @@
 
   TestCompletionCallback connect_callback;
   int client_ret = client_socket_->Connect(connect_callback.callback());
 
   TestCompletionCallback handshake_callback;
   int server_ret = server_socket_->Handshake(handshake_callback.callback());
 
   client_ret = connect_callback.GetResult(client_ret);
   server_ret = handshake_callback.GetResult(server_ret);
 
-  ASSERT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, client_ret);
-  ASSERT_EQ(ERR_SSL_VERSION_OR_CIPHER_MISMATCH, server_ret);
+  ASSERT_THAT(client_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
+  ASSERT_THAT(server_ret, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
 }
 
 }  // namespace net