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

net/udp/udp_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.
 
 #include "net/udp/udp_socket.h"
 
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
+#include "net/test/gtest_util.h"
 #include "net/test/net_test_suite.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if defined(OS_IOS)
 #include <TargetConditionals.h>
 #endif
 
+using net::test::IsError;
+using net::test::IsOk;
+
 namespace net {
 
 namespace {
 
 class UDPSocketTest : public PlatformTest {
  public:
   UDPSocketTest() : buffer_(new IOBufferWithSize(kMaxRead)) {}
 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
@@ skipping 116 matching lines @@
   CreateUDPAddress("127.0.0.1", kPort, &bind_address);
   TestNetLog server_log;
   std::unique_ptr<UDPServerSocket> server(
       new UDPServerSocket(&server_log, NetLog::Source()));
 #if defined(OS_WIN)
   if (use_nonblocking_io)
     server->UseNonBlockingIO();
 #endif
   server->AllowAddressReuse();
   int rv = server->Listen(bind_address);
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
 
   // Setup the client.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort, &server_address);
   TestNetLog client_log;
   std::unique_ptr<UDPClientSocket> client(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &client_log, NetLog::Source()));
 #if defined(OS_WIN)
   if (use_nonblocking_io)
     client->UseNonBlockingIO();
 #endif
 
   rv = client->Connect(server_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Client sends to the server.
   rv = WriteSocket(client.get(), simple_message);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
 
   // Server waits for message.
   std::string str = RecvFromSocket(server.get());
   DCHECK(simple_message == str);
 
   // Server echoes reply.
   rv = SendToSocket(server.get(), simple_message);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
 
   // Client waits for response.
   str = ReadSocket(client.get());
   DCHECK(simple_message == str);
 
   // Test asynchronous read. Server waits for message.
   base::RunLoop run_loop;
   int read_result = 0;
   rv = server->RecvFrom(
       buffer_.get(), kMaxRead, &recv_from_address_,
       base::Bind(&ReadCompleteCallback, &read_result, run_loop.QuitClosure()));
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Client sends to the server.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&UDPSocketTest::WriteSocketIgnoreResult,
                  base::Unretained(this), client.get(), simple_message));
   run_loop.Run();
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(read_result));
   EXPECT_EQ(simple_message, std::string(buffer_->data(), read_result));
 
@@ skipping 70 matching lines @@
   std::unique_ptr<UDPServerSocket> server1(
       new UDPServerSocket(&server1_log, NetLog::Source()));
   std::unique_ptr<UDPServerSocket> server2(
       new UDPServerSocket(&server2_log, NetLog::Source()));
   server1->AllowAddressReuse();
   server1->AllowBroadcast();
   server2->AllowAddressReuse();
   server2->AllowBroadcast();
 
   int rv = server1->Listen(listen_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   rv = server2->Listen(listen_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = SendToSocket(server1.get(), first_message, broadcast_address);
   ASSERT_EQ(static_cast<int>(first_message.size()), rv);
   std::string str = RecvFromSocket(server1.get());
   ASSERT_EQ(first_message, str);
   str = RecvFromSocket(server2.get());
   ASSERT_EQ(first_message, str);
 
   rv = SendToSocket(server2.get(), second_message, broadcast_address);
   ASSERT_EQ(static_cast<int>(second_message.size()), rv);
@@ skipping 44 matching lines @@
 
   // Create and connect sockets and save port numbers.
   std::deque<int> used_ports;
   for (int i = 0; i < kBindRetries; ++i) {
     UDPClientSocket* socket =
         new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
                             RandIntCallback(),
                             NULL,
                             NetLog::Source());
     sockets.push_back(socket);
-    EXPECT_EQ(OK, socket->Connect(peer_address));
+    EXPECT_THAT(socket->Connect(peer_address), IsOk());
 
     IPEndPoint client_address;
-    EXPECT_EQ(OK, socket->GetLocalAddress(&client_address));
+    EXPECT_THAT(socket->GetLocalAddress(&client_address), IsOk());
     used_ports.push_back(client_address.port());
   }
 
   // Free the last socket, its local port is still in |used_ports|.
   delete sockets.back();
   sockets.pop_back();
 
   TestPrng test_prng(used_ports);
   RandIntCallback rand_int_cb =
       base::Bind(&TestPrng::GetNext, base::Unretained(&test_prng));
 
   // Create a socket with random binding policy and connect.
   std::unique_ptr<UDPClientSocket> test_socket(new UDPClientSocket(
       DatagramSocket::RANDOM_BIND, rand_int_cb, NULL, NetLog::Source()));
-  EXPECT_EQ(OK, test_socket->Connect(peer_address));
+  EXPECT_THAT(test_socket->Connect(peer_address), IsOk());
 
   // Make sure that the last port number in the |used_ports| was used.
   IPEndPoint client_address;
-  EXPECT_EQ(OK, test_socket->GetLocalAddress(&client_address));
+  EXPECT_THAT(test_socket->GetLocalAddress(&client_address), IsOk());
   EXPECT_EQ(used_ports.back(), client_address.port());
 
   STLDeleteElements(&sockets);
 }
 
 // Return a privileged port (under 1024) so binding will fail.
 int PrivilegedRand(int min, int max) {
   // Chosen by fair dice roll.  Guaranteed to be random.
   return 4;
 }
 
 #if defined(OS_IOS) && !TARGET_IPHONE_SIMULATOR
 // TODO(droger): On iOS this test fails on device (but passes on simulator).
 // See http://crbug.com/227760.
 #define MAYBE_ConnectFail DISABLED_ConnectFail
 #else
 #define MAYBE_ConnectFail ConnectFail
 #endif
 TEST_F(UDPSocketTest, MAYBE_ConnectFail) {
   IPEndPoint peer_address;
   CreateUDPAddress("0.0.0.0", 53, &peer_address);
 
   std::unique_ptr<UDPSocket> socket(new UDPSocket(DatagramSocket::RANDOM_BIND,
                                                   base::Bind(&PrivilegedRand),
                                                   NULL, NetLog::Source()));
   int rv = socket->Open(peer_address.GetFamily());
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
   rv = socket->Connect(peer_address);
   // Connect should have failed since we couldn't bind to that port,
   EXPECT_NE(OK, rv);
   // Make sure that UDPSocket actually closed the socket.
   EXPECT_FALSE(socket->is_connected());
 }
 
 // In this test, we verify that connect() on a socket will have the effect
 // of filtering reads on this socket only to data read from the destination
 // we connected to.
 //
 // The purpose of this test is that some documentation indicates that connect
 // binds the client's sends to send to a particular server endpoint, but does
 // not bind the client's reads to only be from that endpoint, and that we need
 // to always use recvfrom() to disambiguate.
 TEST_F(UDPSocketTest, VerifyConnectBindsAddr) {
   const uint16_t kPort1 = 9999;
   const uint16_t kPort2 = 10000;
   std::string simple_message("hello world!");
   std::string foreign_message("BAD MESSAGE TO GET!!");
 
   // Setup the first server to listen.
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", kPort1, &bind_address);
   UDPServerSocket server1(NULL, NetLog::Source());
   server1.AllowAddressReuse();
   int rv = server1.Listen(bind_address);
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
 
   // Setup the second server to listen.
   CreateUDPAddress("127.0.0.1", kPort2, &bind_address);
   UDPServerSocket server2(NULL, NetLog::Source());
   server2.AllowAddressReuse();
   rv = server2.Listen(bind_address);
-  ASSERT_EQ(OK, rv);
+  ASSERT_THAT(rv, IsOk());
 
   // Setup the client, connected to server 1.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort1, &server_address);
   UDPClientSocket client(DatagramSocket::DEFAULT_BIND,
                          RandIntCallback(),
                          NULL,
                          NetLog::Source());
   rv = client.Connect(server_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Client sends to server1.
   rv = WriteSocket(&client, simple_message);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
 
   // Server1 waits for message.
   std::string str = RecvFromSocket(&server1);
   DCHECK(simple_message == str);
 
   // Get the client's address.
   IPEndPoint client_address;
   rv = client.GetLocalAddress(&client_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   // Server2 sends reply.
   rv = SendToSocket(&server2, foreign_message,
                     client_address);
   EXPECT_EQ(foreign_message.length(), static_cast<size_t>(rv));
 
   // Server1 sends reply.
   rv = SendToSocket(&server1, simple_message,
                     client_address);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
@@ skipping 36 matching lines @@
     if (tests[i].may_fail && rv == ERR_ADDRESS_UNREACHABLE) {
       // Connect() may return ERR_ADDRESS_UNREACHABLE for IPv6
       // addresses if IPv6 is not configured.
       continue;
     }
 
     EXPECT_LE(ERR_IO_PENDING, rv);
 
     IPEndPoint fetched_local_address;
     rv = client.GetLocalAddress(&fetched_local_address);
-    EXPECT_EQ(OK, rv);
+    EXPECT_THAT(rv, IsOk());
 
     // TODO(mbelshe): figure out how to verify the IP and port.
     //                The port is dynamically generated by the udp stack.
     //                The IP is the real IP of the client, not necessarily
     //                loopback.
     //EXPECT_EQ(local_address.address(), fetched_local_address.address());
 
     IPEndPoint fetched_remote_address;
     rv = client.GetPeerAddress(&fetched_remote_address);
-    EXPECT_EQ(OK, rv);
+    EXPECT_THAT(rv, IsOk());
 
     EXPECT_EQ(remote_address, fetched_remote_address);
   }
 }
 
 TEST_F(UDPSocketTest, ServerGetLocalAddress) {
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", 0, &bind_address);
   UDPServerSocket server(NULL, NetLog::Source());
   int rv = server.Listen(bind_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   IPEndPoint local_address;
   rv = server.GetLocalAddress(&local_address);
   EXPECT_EQ(rv, 0);
 
   // Verify that port was allocated.
   EXPECT_GT(local_address.port(), 0);
   EXPECT_EQ(local_address.address(), bind_address.address());
 }
 
 TEST_F(UDPSocketTest, ServerGetPeerAddress) {
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", 0, &bind_address);
   UDPServerSocket server(NULL, NetLog::Source());
   int rv = server.Listen(bind_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   IPEndPoint peer_address;
   rv = server.GetPeerAddress(&peer_address);
   EXPECT_EQ(rv, ERR_SOCKET_NOT_CONNECTED);
 }
 
 // Close the socket while read is pending.
 TEST_F(UDPSocketTest, CloseWithPendingRead) {
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", 0, &bind_address);
   UDPServerSocket server(NULL, NetLog::Source());
   int rv = server.Listen(bind_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback callback;
   IPEndPoint from;
   rv = server.RecvFrom(buffer_.get(), kMaxRead, &from, callback.callback());
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
 
   EXPECT_FALSE(callback.have_result());
 }
@@ skipping 13 matching lines @@
 
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
   IPAddress group_ip;
   EXPECT_TRUE(group_ip.AssignFromIPLiteral(kGroup));
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
-  EXPECT_EQ(OK, socket.Open(bind_address.GetFamily()));
-  EXPECT_EQ(OK, socket.Bind(bind_address));
-  EXPECT_EQ(OK, socket.JoinGroup(group_ip));
+  EXPECT_THAT(socket.Open(bind_address.GetFamily()), IsOk());
+  EXPECT_THAT(socket.Bind(bind_address), IsOk());
+  EXPECT_THAT(socket.JoinGroup(group_ip), IsOk());
   // Joining group multiple times.
   EXPECT_NE(OK, socket.JoinGroup(group_ip));
-  EXPECT_EQ(OK, socket.LeaveGroup(group_ip));
+  EXPECT_THAT(socket.LeaveGroup(group_ip), IsOk());
   // Leaving group multiple times.
   EXPECT_NE(OK, socket.LeaveGroup(group_ip));
 
   socket.Close();
 }
 
 TEST_F(UDPSocketTest, MulticastOptions) {
   const uint16_t kPort = 9999;
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   // Before binding.
-  EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(false));
-  EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(true));
-  EXPECT_EQ(OK, socket.SetMulticastTimeToLive(0));
-  EXPECT_EQ(OK, socket.SetMulticastTimeToLive(3));
+  EXPECT_THAT(socket.SetMulticastLoopbackMode(false), IsOk());
+  EXPECT_THAT(socket.SetMulticastLoopbackMode(true), IsOk());
+  EXPECT_THAT(socket.SetMulticastTimeToLive(0), IsOk());
+  EXPECT_THAT(socket.SetMulticastTimeToLive(3), IsOk());
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(-1));
-  EXPECT_EQ(OK, socket.SetMulticastInterface(0));
+  EXPECT_THAT(socket.SetMulticastInterface(0), IsOk());
 
-  EXPECT_EQ(OK, socket.Open(bind_address.GetFamily()));
-  EXPECT_EQ(OK, socket.Bind(bind_address));
+  EXPECT_THAT(socket.Open(bind_address.GetFamily()), IsOk());
+  EXPECT_THAT(socket.Bind(bind_address), IsOk());
 
   EXPECT_NE(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(0));
   EXPECT_NE(OK, socket.SetMulticastInterface(0));
 
   socket.Close();
 }
 
 // Checking that DSCP bits are set correctly is difficult,
 // but let's check that the code doesn't crash at least.
 TEST_F(UDPSocketTest, SetDSCP) {
   // Setup the server to listen.
   IPEndPoint bind_address;
   UDPSocket client(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   // We need a real IP, but we won't actually send anything to it.
   CreateUDPAddress("8.8.8.8", 9999, &bind_address);
   int rv = client.Open(bind_address.GetFamily());
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = client.Connect(bind_address);
   if (rv != OK) {
     // Let's try localhost then..
     CreateUDPAddress("127.0.0.1", 9999, &bind_address);
     rv = client.Connect(bind_address);
   }
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   client.SetDiffServCodePoint(DSCP_NO_CHANGE);
   client.SetDiffServCodePoint(DSCP_AF41);
   client.SetDiffServCodePoint(DSCP_DEFAULT);
   client.SetDiffServCodePoint(DSCP_CS2);
   client.SetDiffServCodePoint(DSCP_NO_CHANGE);
   client.SetDiffServCodePoint(DSCP_DEFAULT);
   client.Close();
 }
 
@@ skipping 79 matching lines @@
 TEST_F(UDPSocketTest, SetDSCPFake) {
   // Setup the server to listen.
   IPEndPoint bind_address;
   // We need a real IP, but we won't actually send anything to it.
   CreateUDPAddress("8.8.8.8", 9999, &bind_address);
   UDPSocket client(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   int rv = client.SetDiffServCodePoint(DSCP_AF41);
-  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, rv);
+  EXPECT_THAT(rv, IsError(ERR_SOCKET_NOT_CONNECTED));
 
   rv = client.Open(bind_address.GetFamily());
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   rv = client.Connect(bind_address);
-  EXPECT_EQ(OK, rv);
+  EXPECT_THAT(rv, IsOk());
 
   QwaveAPI& qos(QwaveAPI::Get());
   qos.create_handle_func_ = FakeQOSCreateHandleFAIL;
   qos.close_handle_func_ = FakeQOSCloseHandle;
   qos.add_socket_to_flow_func_ = FakeQOSAddSocketToFlow;
   qos.remove_socket_from_flow_func_ = FakeQOSRemoveSocketFromFlow;
   qos.set_flow_func_ = FakeQOSSetFlow;
   qos.qwave_supported_ = true;
 
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_NO_CHANGE), IsOk());
   EXPECT_EQ(ERROR_NOT_SUPPORTED, client.SetDiffServCodePoint(DSCP_AF41));
   qos.create_handle_func_ = FakeQOSCreateHandle;
   g_expected_dscp = DSCP_AF41;
   g_expected_traffic_type = QOSTrafficTypeAudioVideo;
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_AF41));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_AF41), IsOk());
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_DEFAULT), IsOk());
   g_expected_dscp = DSCP_CS2;
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_CS2));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_CS2), IsOk());
   g_expected_dscp = DSCP_CS3;
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_NO_CHANGE), IsOk());
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
-  EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
+  EXPECT_THAT(client.SetDiffServCodePoint(DSCP_DEFAULT), IsOk());
   client.Close();
 }
 #endif
 
 }  // namespace net