Multicast socket API

chrome/browser/extensions/api/socket/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 "chrome/browser/extensions/api/socket/udp_socket.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 // UDPSocketUnitTest exists solely to make it easier to pass a specific
 // gtest_filter argument during development.
 class UDPSocketUnitTest : public BrowserWithTestWindowTest {
 };
 
 static void OnConnected(int result) {
-  DCHECK(result == 0);
+  EXPECT_EQ(0, result);
 }
 
 static void OnCompleted(int bytes_read,
                         scoped_refptr<net::IOBuffer> io_buffer,
                         const std::string& address,
                         int port) {
   // Do nothing; don't care.
 }
 
+static const char test_message[] = "$$TESTMESSAGETESTMESSAGETESTMESSAGETEST$$";
+static const int test_message_length = ARRAYSIZE_UNSAFE(test_message);
+
+static void OnSendCompleted(int result) {
+  EXPECT_EQ(test_message_length, result);
+}
+
 TEST(UDPSocketUnitTest, TestUDPSocketRecvFrom) {
-  MessageLoopForIO io_loop;  // for RecvFrom to do its threaded work.
+  MessageLoopForIO io_loop;  // For RecvFrom to do its threaded work.
   UDPSocket socket("abcdefghijklmnopqrst");
 
   // Confirm that we can call two RecvFroms in quick succession without
   // triggering crbug.com/146606.
   socket.Connect("127.0.0.1", 40000, base::Bind(&OnConnected));
   socket.RecvFrom(4096, base::Bind(&OnCompleted));
   socket.RecvFrom(4096, base::Bind(&OnCompleted));
 }
 
+TEST(UDPSocketUnitTest, TestUDPMulticastJoinGroup) {
+  const char* kGroup = "237.132.100.17";
+  UDPSocket src("abcdefghijklmnopqrst");
+  UDPSocket dest("abcdefghijklmnopqrst");
+
+  EXPECT_EQ(0, dest.Bind("0.0.0.0", 13333));
+  EXPECT_EQ(0, dest.JoinGroup(kGroup));
+  base::hash_set<std::string> groups;
+  dest.GetJoinedGroups(&groups);
+  EXPECT_EQ(static_cast<size_t>(1), groups.size());
+  EXPECT_EQ(kGroup, *groups.begin());
+  EXPECT_NE(0, dest.LeaveGroup("237.132.100.13"));
+  EXPECT_EQ(0, dest.LeaveGroup(kGroup));
+  dest.GetJoinedGroups(&groups);
+  EXPECT_EQ(static_cast<size_t>(0), groups.size());
+}
+
+TEST(UDPSocketUnitTest, TestUDPMulticastTimeToLive) {
+  const char* kGroup = "237.132.100.17";
+  UDPSocket socket("abcdefghijklmnopqrst");
+  EXPECT_NE(0, socket.SetMulticastTimeToLive(-1));  // Negative TTL shall fail.
+  EXPECT_EQ(0, socket.SetMulticastTimeToLive(3));
+  socket.Connect(kGroup, 13333, base::Bind(&OnConnected));
+}
+
+TEST(UDPSocketUnitTest, TestUDPMulticastLoopbackMode) {
+  const char* kGroup = "237.132.100.17";
+  UDPSocket socket("abcdefghijklmnopqrst");
+  EXPECT_EQ(0, socket.SetMulticastLoopbackMode(false));
+  socket.Connect(kGroup, 13333, base::Bind(&OnConnected));
+}
+
+static void QuitMessageLoop() {
+  MessageLoopForIO::current()->QuitNow();
+}
+
+static void SendMulticastPacket(UDPSocket* src,

[wtc, 2013/04/23 18:01:07]

This method should be documented. It is not obvious from
the name "SendMulticastPacket" that you are just sending a
test packet, and that you are sending it repeatedly every
one second until it is received.

[Bei Zhang, 2013/04/23 20:36:39]

Done.

+                                const char* group,

[wtc, 2013/04/23 18:01:07]

The |group| argument is not used. Can we remove it?

[Bei Zhang, 2013/04/23 20:36:39]

Done.

+                                int result) {
+  if (result == 0) {
+    scoped_refptr<net::IOBuffer> data = new net::WrappedIOBuffer(test_message);
+    src->Write(data, test_message_length, base::Bind(&OnSendCompleted));
+    MessageLoopForIO::current()->PostDelayedTask(FROM_HERE,
+          base::Bind(&SendMulticastPacket, src, group, result),
+          base::TimeDelta::FromSeconds(1));

[wtc, 2013/04/23 18:01:07]

Do we need to cancel this delayed task if it is no longer
necessary?

[Bei Zhang, 2013/04/23 20:36:39]

We do not need to cancel the task.
It will not be invoked once we call QuitNow().

On 2013/04/23 18:01:07, wtc wrote:

+  } else {
+    QuitMessageLoop();
+    FAIL() << "Failed to connect to multicast address. Error code: " << result;
+  }
+}
+
+static void OnMulticastReadCompleted(bool *packet_received,

[wtc, 2013/04/23 18:01:07]

|packet_received| is an output argument. Our Style Guide
recommends that we list it after the input arguments.

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Function_Param...

[Bei Zhang, 2013/04/23 20:36:39]

Unfortunately we cannot bind argument to the end of the arguments list of a
closure. Would you like to make it a static global variable?

On 2013/04/23 18:01:07, wtc wrote:

[wtc, 2013/04/23 22:15:26]

Thank you for the explanation. (I am not familiar with
closures.) You don't need to change this to a static global
variable.

+                                     int count,
+                                     scoped_refptr<net::IOBuffer> io_buffer) {
+  EXPECT_EQ(test_message_length, count);
+  EXPECT_EQ(0, strncmp(io_buffer->data(), test_message, test_message_length));
+  *packet_received = true;
+  QuitMessageLoop();
+}
+
+TEST(UDPSocketUnitTest, TestUDPMulticastRecv) {
+  const int kPort = 9999;
+  const char* const kGroup = "237.132.100.17";
+  bool packet_received = false;
+  MessageLoopForIO io_loop;  // For Read to do its threaded work.
+  UDPSocket dest("abcdefghijklmnopqrst");
+  UDPSocket src("abcdefghijklmnopqrst");
+
+  // Receiver
+  EXPECT_EQ(0, dest.Bind("0.0.0.0", kPort));
+  EXPECT_EQ(0, dest.JoinGroup(kGroup));
+  dest.Read(1024, base::Bind(&OnMulticastReadCompleted, &packet_received));
+
+  // Sender
+  EXPECT_EQ(0, src.SetMulticastTimeToLive(0));
+  src.Connect(kGroup, kPort, base::Bind(&SendMulticastPacket, &src, kGroup));
+
+  // If not received in 4 seconds quit the message loop.

[wtc, 2013/04/23 18:01:07]

This should be increased to a very large number, such as 30
seconds or 60 seconds. You may want to consult the maintainer
of try bots to find out how long they allow each unit test to
take. Then, use a timeout equal or close to that timeout.

[Bei Zhang, 2013/04/23 20:36:39]

Done. I found out that there is no per tests case time limit. So you were right
the 75 second should be a system limit.

On 2013/04/23 18:01:07, wtc wrote:

+  io_loop.PostDelayedTask(FROM_HERE,
+                          base::Bind(&QuitMessageLoop),
+                          base::TimeDelta::FromSeconds(4));
+
+  io_loop.Run();
+
+  EXPECT_TRUE(packet_received) << "Failed to receive from multicast address";
+}
+
 }  // namespace extensions