Clang format slam.

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_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/test/net_test_suite.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class UDPSocketTest : public PlatformTest {
  public:
-  UDPSocketTest()
-      : buffer_(new IOBufferWithSize(kMaxRead)) {
-  }
+  UDPSocketTest() : buffer_(new IOBufferWithSize(kMaxRead)) {}
 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
     TestCompletionCallback callback;
 
     int rv = socket->RecvFrom(
         buffer_.get(), kMaxRead, &recv_from_address_, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ skipping 127 matching lines @@
   DCHECK(simple_message == str);
 
   // Delete sockets so they log their final events.
   server.reset();
   client.reset();
 
   // Check the server's log.
   CapturingNetLog::CapturedEntryList server_entries;
   server_log.GetEntries(&server_entries);
   EXPECT_EQ(4u, server_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
   EXPECT_TRUE(LogContainsEvent(
       server_entries, 1, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
       server_entries, 2, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsEndEvent(server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
 
   // Check the client's log.
   CapturingNetLog::CapturedEntryList client_entries;
   client_log.GetEntries(&client_entries);
   EXPECT_EQ(6u, client_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 1, NetLog::TYPE_UDP_CONNECT));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 2, NetLog::TYPE_UDP_CONNECT));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(client_entries, 1, NetLog::TYPE_UDP_CONNECT));
+  EXPECT_TRUE(LogContainsEndEvent(client_entries, 2, NetLog::TYPE_UDP_CONNECT));
   EXPECT_TRUE(LogContainsEvent(
       client_entries, 3, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
       client_entries, 4, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsEndEvent(client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
 }
 
 #if defined(OS_MACOSX)
 // UDPSocketPrivate_Broadcast is disabled for OSX because it requires
 // root permissions on OSX 10.7+.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
 #elif defined(OS_ANDROID)
 // It is also disabled for Android because it is extremely flaky.
 // The first call to SendToSocket returns -109 (Address not reachable)
 // in some unpredictable cases. crbug.com/139144.
@@ skipping 60 matching lines @@
 
 class TestPrng {
  public:
   explicit TestPrng(const std::deque<int>& numbers) : numbers_(numbers) {}
   int GetNext(int /* min */, int /* max */) {
     DCHECK(!numbers_.empty());
     int rv = numbers_.front();
     numbers_.pop_front();
     return rv;
   }
+
  private:
   std::deque<int> numbers_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPrng);
 };
 
 #if defined(OS_ANDROID)
 // Disabled on Android for lack of 192.168.1.13. crbug.com/161245
 TEST_F(UDPSocketTest, DISABLED_ConnectRandomBind) {
 #else
 TEST_F(UDPSocketTest, ConnectRandomBind) {
 #endif
   std::vector<UDPClientSocket*> sockets;
   IPEndPoint peer_address;
   CreateUDPAddress("192.168.1.13", 53, &peer_address);
 
   // 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());
+    UDPClientSocket* socket = new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                  RandIntCallback(),
+                                                  NULL,
+                                                  NetLog::Source());
     sockets.push_back(socket);
     EXPECT_EQ(OK, socket->Connect(peer_address));
 
     IPEndPoint client_address;
     EXPECT_EQ(OK, socket->GetLocalAddress(&client_address));
     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.
-  scoped_ptr<UDPClientSocket> test_socket(
-      new UDPClientSocket(DatagramSocket::RANDOM_BIND,
-                          rand_int_cb,
-                          NULL,
-                          NetLog::Source()));
+  scoped_ptr<UDPClientSocket> test_socket(new UDPClientSocket(
+      DatagramSocket::RANDOM_BIND, rand_int_cb, NULL, NetLog::Source()));
   EXPECT_EQ(OK, test_socket->Connect(peer_address));
 
   // 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_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;
 }
 
 TEST_F(UDPSocketTest, ConnectFail) {
   IPEndPoint peer_address;
   CreateUDPAddress("0.0.0.0", 53, &peer_address);
 
-  scoped_ptr<UDPSocket> socket(
-      new UDPSocket(DatagramSocket::RANDOM_BIND,
-                    base::Bind(&PrivilegedRand),
-                    NULL,
-                    NetLog::Source()));
+  scoped_ptr<UDPSocket> socket(new UDPSocket(DatagramSocket::RANDOM_BIND,
+                                             base::Bind(&PrivilegedRand),
+                                             NULL,
+                                             NetLog::Source()));
   int 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.
@@ skipping 19 matching lines @@
   // 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);
 
   // 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());
+  UDPClientSocket client(
+      DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLog::Source());
   rv = client.Connect(server_address);
   EXPECT_EQ(OK, rv);
 
   // 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);
 
   // Server2 sends reply.
-  rv = SendToSocket(&server2, foreign_message,
-                    client_address);
+  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);
+  rv = SendToSocket(&server1, simple_message, client_address);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
 
   // Client waits for response.
   str = ReadSocket(&client);
   DCHECK(simple_message == str);
 }
 
 TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) {
   struct TestData {
     std::string remote_address;
     std::string local_address;
     bool may_fail;
   } tests[] = {
-    { "127.0.00.1", "127.0.0.1", false },
-    { "::1", "::1", true },
+    {"127.0.00.1", "127.0.0.1", false},
+    {"::1", "::1", true},
 #if !defined(OS_ANDROID)
     // Addresses below are disabled on Android. See crbug.com/161248
-    { "192.168.1.1", "127.0.0.1", false },
-    { "2001:db8:0::42", "::1", true },
+    {"192.168.1.1", "127.0.0.1", false},
+    {"2001:db8:0::42", "::1", true},
 #endif
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
-    SCOPED_TRACE(std::string("Connecting from ") +  tests[i].local_address +
+    SCOPED_TRACE(std::string("Connecting from ") + tests[i].local_address +
                  std::string(" to ") + tests[i].remote_address);
 
     IPAddressNumber ip_number;
     ParseIPLiteralToNumber(tests[i].remote_address, &ip_number);
     IPEndPoint remote_address(ip_number, 80);
     ParseIPLiteralToNumber(tests[i].local_address, &ip_number);
     IPEndPoint local_address(ip_number, 80);
 
     UDPClientSocket client(DatagramSocket::DEFAULT_BIND,
                            RandIntCallback(),
                            NULL,
                            NetLog::Source());
     int rv = client.Connect(remote_address);
     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);
 
     // 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());
+    // EXPECT_EQ(local_address.address(), fetched_local_address.address());
 
     IPEndPoint fetched_remote_address;
     rv = client.GetPeerAddress(&fetched_remote_address);
     EXPECT_EQ(OK, rv);
 
     EXPECT_EQ(remote_address, fetched_remote_address);
   }
 }
 
 TEST_F(UDPSocketTest, ServerGetLocalAddress) {
@@ skipping 53 matching lines @@
 
 TEST_F(UDPSocketTest, MAYBE_JoinMulticastGroup) {
   const int kPort = 9999;
   const char* const kGroup = "237.132.100.17";
 
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
   IPAddressNumber group_ip;
   EXPECT_TRUE(ParseIPLiteralToNumber(kGroup, &group_ip));
 
-  UDPSocket socket(DatagramSocket::DEFAULT_BIND,
-                   RandIntCallback(),
-                   NULL,
-                   NetLog::Source());
+  UDPSocket socket(
+      DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLog::Source());
   EXPECT_EQ(OK, socket.Bind(bind_address));
   EXPECT_EQ(OK, socket.JoinGroup(group_ip));
   // Joining group multiple times.
   EXPECT_NE(OK, socket.JoinGroup(group_ip));
   EXPECT_EQ(OK, socket.LeaveGroup(group_ip));
   // Leaving group multiple times.
   EXPECT_NE(OK, socket.LeaveGroup(group_ip));
 
   socket.Close();
 }
 
 TEST_F(UDPSocketTest, MulticastOptions) {
   const int kPort = 9999;
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
 
-  UDPSocket socket(DatagramSocket::DEFAULT_BIND,
-                   RandIntCallback(),
-                   NULL,
-                   NetLog::Source());
+  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_NE(OK, socket.SetMulticastTimeToLive(-1));
   EXPECT_EQ(OK, socket.SetMulticastInterface(0));
 
   EXPECT_EQ(OK, socket.Bind(bind_address));
 
   EXPECT_NE(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(0));
   EXPECT_NE(OK, socket.SetMulticastInterface(0));
 
   socket.Close();
 }
 
 }  // namespace
 
 }  // namespace net