UDP sockets implementation for windows.

net/udp/udp_socket_unittest.cc

 // Copyright (c) 2011 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/metrics/histogram.h"
 #include "net/base/io_buffer.h"
@@ skipping 89 matching lines @@
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
- private:
+ protected:
   static const int kMaxRead = 1024;
   scoped_refptr<IOBufferWithSize> buffer_;
   IPEndPoint recv_from_address_;
 };
 
 // Creates and address from an ip/port and returns it in |address|.
 void CreateUDPAddress(std::string ip_str, int port, IPEndPoint* address) {
   IPAddressNumber ip_number;
   bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
   if (!rv)
@@ skipping 95 matching lines @@
 
   // 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 is_ipv6;
+    bool may_fail;
   } tests[] = {
     { "127.0.00.1", "127.0.0.1", false },
     { "192.168.1.1", "127.0.0.1", false },
-    { "::1", "::1", true },
+    { "::1", "::1", false },
     { "2001:db8:0::42", "::1", true },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
+    SCOPED_TRACE(std::string("Connecting from ") +  tests[i].local_address +
+                 std::string(" to ") + tests[i].remote_address);
+
     net::IPAddressNumber ip_number;
     net::ParseIPLiteralToNumber(tests[i].remote_address, &ip_number);
     net::IPEndPoint remote_address(ip_number, 80);
     net::ParseIPLiteralToNumber(tests[i].local_address, &ip_number);
     net::IPEndPoint local_address(ip_number, 80);
 
     UDPClientSocket client(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());
 
     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) {
-  // TODO(mbelshe): implement me
+  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);
+
+  IPEndPoint local_address;
+  rv = server.GetLocalAddress(&local_address);
+  EXPECT_EQ(rv, 0);
+
+  // Verify that port was allocated.
+  EXPECT_GE(local_address.port(), 0);
+  EXPECT_EQ(local_address.address(), bind_address.address());
 }
 
 TEST_F(UDPSocketTest, ServerGetPeerAddress) {
-  // TODO(mbelshe): implement me
+  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);
+
+  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);
+
+  TestCompletionCallback callback;
+  IPEndPoint from;
+  rv = server.RecvFrom(buffer_, kMaxRead, &from, &callback);
+  EXPECT_EQ(rv, ERR_IO_PENDING);
+
+  server.Close();
+
+  EXPECT_TRUE(callback.have_result());
+  EXPECT_EQ(callback.GetResult(rv), ERR_ABORTED);
 }
 
 }  // namespace
 
 }  // namespace net
-
-int main(int argc, char** argv) {
-  // Record histograms, so we can get histograms data in tests.
-  base::StatisticsRecorder recorder;
-  NetTestSuite test_suite(argc, argv);
-
-  return test_suite.Run();
-}