Fixed UDP tests for MacOS X 10.7

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"
@@ skipping 113 matching lines @@
     return;
   *address = IPEndPoint(ip_number, port);
 }
 
 TEST_F(UDPSocketTest, Connect) {
   const int kPort = 9999;
   std::string simple_message("hello world!");
 
   // Setup the server to listen.
   IPEndPoint bind_address;
-  CreateUDPAddress("0.0.0.0", kPort, &bind_address);
+  CreateUDPAddress("127.0.0.1", kPort, &bind_address);
   CapturingNetLog server_log;
   scoped_ptr<UDPServerSocket> server(
       new UDPServerSocket(&server_log, NetLog::Source()));
+  server->AllowAddressReuse();
   int rv = server->Listen(bind_address);
   EXPECT_EQ(OK, rv);
 
   // Setup the client.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort, &server_address);
   CapturingNetLog client_log;
   scoped_ptr<UDPClientSocket> client(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
                           RandIntCallback(),
@@ skipping 46 matching lines @@
   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));
 }
 
+#if !defined(OS_MACOSX)
+
+// TODO (ygorshenin): crbug.com/145487

[Sergey Ulanov, 2012/09/04 21:27:32]

It's better to keep the test but just skip this test when not running as root,
e.g.
#if !defined(OS_MACOSX)
  if (getuid() != 0) {
    LOG(ERROR) << "Skipping Broadcast test because it requires root permissions
on OSX";
    return;
  }
#endif  // !defined (OS_MAXOSX)

[ygorshenin1, 2012/09/05 13:25:45]

Done.

 TEST_F(UDPSocketTest, Broadcast) {
   const int kPort = 9999;
   std::string first_message("first message"), second_message("second message");
 
   IPEndPoint broadcast_address;
   CreateUDPAddress("255.255.255.255", kPort, &broadcast_address);
   IPEndPoint listen_address;
   CreateUDPAddress("0.0.0.0", kPort, &listen_address);
 
   CapturingNetLog server1_log, server2_log;
@@ skipping 19 matching lines @@
   ASSERT_EQ(first_message, str);
 
   rv = SendToSocket(server2.get(), second_message, broadcast_address);
   EXPECT_EQ(static_cast<int>(second_message.size()), rv);
   str = RecvFromSocket(server1.get());
   ASSERT_EQ(second_message, str);
   str = RecvFromSocket(server2.get());
   ASSERT_EQ(second_message, str);
 }
 
+#endif

[Sergey Ulanov, 2012/09/04 21:27:32]

add  // !defined (OS_MAXOSX)

[ygorshenin1, 2012/09/05 13:25:45]

Done.

+
 // In this test, we verify that random binding logic works, which attempts
 // to bind to a random port and returns if succeeds, otherwise retries for
 // |kBindRetries| number of times.
 
 // To generate the scenario, we first create |kBindRetries| number of
 // UDPClientSockets with default binding policy and connect to the same
 // peer and save the used port numbers.  Then we get rid of the last
 // socket, making sure that the local port it was bound to is available.
 // Finally, we create a socket with random binding policy, passing it a
 // test PRNG that would serve used port numbers in the array, one after
@@ skipping 75 matching lines @@
 // 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 int kPort1 = 9999;
   const int 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("0.0.0.0", kPort1, &bind_address);
+  CreateUDPAddress("127.0.0.1", kPort1, &bind_address);
   UDPServerSocket server1(NULL, NetLog::Source());
+  server1.AllowAddressReuse();
   int rv = server1.Listen(bind_address);
   EXPECT_EQ(OK, rv);
 
   // Setup the second server to listen.
-  CreateUDPAddress("0.0.0.0", kPort2, &bind_address);
+  CreateUDPAddress("127.0.0.1", kPort2, &bind_address);
   UDPServerSocket server2(NULL, NetLog::Source());
+  server2.AllowAddressReuse();
   rv = server2.Listen(bind_address);
   EXPECT_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());
@@ skipping 122 matching lines @@
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
 
   EXPECT_FALSE(callback.have_result());
 }
 
 }  // namespace
 
 }  // namespace net