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 OnReadCompleted(int count,

[Bei Zhang, 2013/04/23 17:26:53]

Renamed to OnMulticastReadCompleted at line 102.

+                            scoped_refptr<net::IOBuffer> io_buffer) {
+  EXPECT_EQ(static_cast<int>(test_message_length), count);

[wtc, 2013/04/22 19:19:53]

The static_cast<int> can be removed because you declare
test_message_length as an int.

Similarly for line 44.

[Bei Zhang, 2013/04/23 17:26:53]

Done.

+  EXPECT_EQ(0, strncmp(io_buffer->data(), test_message, test_message_length));
+  MessageLoopForIO::current()->QuitWhenIdle();
+}
+
+static void OnSendCompleted(int result) {
+  EXPECT_EQ(static_cast<int>(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));
+}
+
+void OnMulticastSenderConnected(UDPSocket* src,
+                                const char* group, int result) {

[wtc, 2013/04/22 19:19:53]

It may be better to list one parameter per line.

[Bei Zhang, 2013/04/23 17:26:53]

Done.
Renamed to SendMulticastPacket at line 87.

+  if (result == 0) {
+    scoped_refptr<net::IOBuffer> data = new net::WrappedIOBuffer(test_message);
+    src->Write(data, test_message_length, base::Bind(&OnSendCompleted));

[wtc, 2013/04/22 19:19:53]

Should we check the return value of src->Write()?

Same question for the dest->SendTo() call on lines 103-104.

[Bei Zhang, 2013/04/23 17:26:53]

extensions::Socket::Write and extensions::Socket::Read does not have a return
value. The error code is return in the callback which is checked on line 44.

On 2013/04/22 19:19:53, wtc wrote:

+  } else {
+    FAIL() << "Failed to connect to multicast address. Error code: " << result;
+  }
+}
+
+void Timeout(UDPSocket* dest, const char* loopback_addr, int port) {

[Bei Zhang, 2013/04/23 17:26:53]

Renamed to QuitMessageLoop at line 83.

+  FAIL() << "Failed to recveive from multicast address";

[wtc, 2013/04/22 19:19:53]

Typo: recveive => receive

[Bei Zhang, 2013/04/23 17:26:53]

Done.

+  scoped_refptr<net::IOBuffer> data = new net::WrappedIOBuffer(test_message);
+  dest->SendTo(data, test_message_length, loopback_addr,
+               port, base::Bind(&OnSendCompleted));
+}
+
+TEST(UDPSocketUnitTest, TestUDPMulticastRecv) {
+  const int kPort = 9999;
+  const char* const kGroup = "237.132.100.17";
+
+  MessageLoopForIO io_loop;  // For Read to do its threaded work.
+  UDPSocket dest("abcdefghijklmnopqrst");
+  UDPSocket src("abcdefghijklmnopqrst");
+
+  EXPECT_EQ(0, src.SetMulticastTimeToLive(0));
+  EXPECT_EQ(0, dest.Bind("0.0.0.0", kPort));
+  EXPECT_EQ(0, dest.JoinGroup(kGroup));
+  dest.Read(1024, base::Bind(&OnReadCompleted));
+
+  // Wait for 2 seconds for the JoinGroup to take effect.

[wtc, 2013/04/22 19:19:53]

This comment says "2 seconds", but you seem to wait for 4
seconds (see line 125).

IMPORTANT: this can be a source of flaky tests. Is there a
way to wait until JoinGroup has taken effect, rather than
waiting for a fixed time interval and hoping that JoinGroup
has taken effect?

[Bei Zhang, 2013/04/23 17:26:53]

Done.

On 2013/04/22 19:19:53, wtc wrote:

+  src.Connect(kGroup, kPort, base::Bind(
+      &OnMulticastSenderConnected, &src, kGroup));
+  MessageLoopForIO::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&Timeout, &dest, "0.0.0.0", kPort),
+      base::TimeDelta::FromSeconds(4));
+  MessageLoopForIO::current()->Run();
+}
+
 }  // namespace extensions