ParseHosts: Allow commas as separators on Mac OS X

net/dns/dns_hosts_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/dns/dns_hosts.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
@@ skipping 46 matching lines @@
     ASSERT_TRUE(ip.empty());
     ASSERT_TRUE(ParseIPLiteralToNumber(entries[i].ip, &ip));
     ASSERT_EQ(ip.size(), (entries[i].family == ADDRESS_FAMILY_IPV4) ? 4u : 16u);
   }
 
   DnsHosts hosts;
   ParseHosts(contents, &hosts);
   ASSERT_EQ(expected, hosts);
 }
 
+TEST(DnsHostsTest, ParseHosts_CommaIsToken) {

[mmenke, 2014/07/24 21:32:30]

Bit of a pain, but should probably have one that makes sure it's used as a token
only on Mac - it's a trivial test, given these two, but it's often the trivial,
but untested, things that end up breaking. 

[Deprecated (see juliatuttle), 2014/07/25 19:34:44]

So make one that's conditional on Mac and tests that the behavior of ParseHosts
actually uses the right mode depending whether it's on Mac or not?

[mmenke, 2014/07/25 19:38:46]

What I suggest is run the test everywhere, but have two different expected hosts
structs, with an ifdef to select the correct one.  Basically just these two
tests combined (I'm fine with just merging the tests, but also fine with keeping
the existing one and adding a new one).

+  std::string contents =
+      "127.0.0.1 comma1,comma2";

[mmenke, 2014/07/24 21:32:30]

This fits on one line.

[mmenke, 2014/07/24 21:32:30]

Also should probably make it const and use kConstNamingScheme.

[Deprecated (see juliatuttle), 2014/07/25 19:34:44]

Done.

[Deprecated (see juliatuttle), 2014/07/25 19:34:44]

Done.

+
+  const struct {
+    const char* host;
+    AddressFamily family;
+    const char* ip;
+  } entries[] = {

[mmenke, 2014/07/24 21:32:30]

Should also probably use const naming scheme here.

[Deprecated (see juliatuttle), 2014/07/25 19:34:44]

Done.

+    { "comma1,comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" },
+  };
+
+  DnsHosts expected;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(entries); ++i) {
+    DnsHostsKey key(entries[i].host, entries[i].family);
+    IPAddressNumber& ip = expected[key];
+    ASSERT_TRUE(ip.empty());
+    ASSERT_TRUE(ParseIPLiteralToNumber(entries[i].ip, &ip));
+    ASSERT_EQ(ip.size(), (entries[i].family == ADDRESS_FAMILY_IPV4) ? 4u : 16u);
+  }

[mmenke, 2014/07/24 21:32:30]

Suggest making this block a function.

[Deprecated (see juliatuttle), 2014/07/25 19:34:44]

Done.

+
+  DnsHosts hosts;
+  ParseHostsWithCommaMode(contents, &hosts, PARSE_HOSTS_COMMA_IS_TOKEN);
+  ASSERT_EQ(expected, hosts);
+}
+
+TEST(DnsHostsTest, ParseHosts_CommaIsWhitespace) {
+  std::string contents =
+      "127.0.0.1 comma1,comma2";
+
+  const struct {
+    const char* host;
+    AddressFamily family;
+    const char* ip;
+  } entries[] = {
+    { "comma1", ADDRESS_FAMILY_IPV4, "127.0.0.1" },
+    { "comma2", ADDRESS_FAMILY_IPV4, "127.0.0.1" },
+  };
+
+  DnsHosts expected;
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(entries); ++i) {
+    DnsHostsKey key(entries[i].host, entries[i].family);
+    IPAddressNumber& ip = expected[key];
+    ASSERT_TRUE(ip.empty());
+    ASSERT_TRUE(ParseIPLiteralToNumber(entries[i].ip, &ip));
+    ASSERT_EQ(ip.size(), (entries[i].family == ADDRESS_FAMILY_IPV4) ? 4u : 16u);
+  }
+
+  DnsHosts hosts;
+  ParseHostsWithCommaMode(contents, &hosts, PARSE_HOSTS_COMMA_IS_WHITESPACE);
+  ASSERT_EQ(expected, hosts);
+}
+
 TEST(DnsHostsTest, HostsParser_Empty) {
   DnsHosts hosts;
   ParseHosts("", &hosts);
   EXPECT_EQ(0u, hosts.size());
 }
 
 TEST(DnsHostsTest, HostsParser_OnlyWhitespace) {
   DnsHosts hosts;
   ParseHosts(" ", &hosts);
   EXPECT_EQ(0u, hosts.size());
@@ skipping 38 matching lines @@
 TEST(DnsHostsTest, HostsParser_EndsWithNewlineAndToken) {
   DnsHosts hosts;
   ParseHosts("127.0.0.1 localhost\ntoken", &hosts);
   EXPECT_EQ(1u, hosts.size());
 }
 
 }  // namespace
 
 }  // namespace net