src/net/base/net_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/net_util.h"
   6
   7 #include <string.h>
   8
   9 #include <ostream>
  10
  11 #include "base/files/file_path.h"
  12 #include "base/format_macros.h"
  13 #include "base/scoped_native_library.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/sys_byteorder.h"
  19 #include "base/time/time.h"
  20
  21 #if !defined(OS_NACL) && !defined(OS_WIN)
  22 #include <net/if.h>
  23 #include <netinet/in.h>
  24 #endif  // !OS_NACL && !OS_WIN
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "url/gurl.h"
  27
  28 #if defined(OS_WIN)
  29 #include <iphlpapi.h>
  30 #include <objbase.h>
  31 #include "base/win/windows_version.h"
  32 #include "net/base/net_util_win.h"
  33 #endif  // OS_WIN
  34
  35 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_WIN)
  36 #include "net/base/address_tracker_linux.h"
  37 #endif  // !OS_MACOSX && !OS_NACL && !OS_WIN
  38
  39 #if !defined(OS_WIN)
  40 #include "net/base/net_util_posix.h"
  41 #endif  // !OS_WIN
  42
  43 using base::ASCIIToUTF16;
  44 using base::WideToUTF16;
  45
  46 namespace net {
  47
  48 namespace {
  49
  50 struct HeaderCase {
  51   const char* header_name;
  52   const char* expected;
  53 };
  54
  55 // Fills in sockaddr for the given 32-bit address (IPv4.)
  56 // |bytes| should be an array of length 4.
  57 void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
  58   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
  59   storage->addr_len = sizeof(struct sockaddr_in);
  60   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
  61   addr4->sin_port = base::HostToNet16(port);
  62   addr4->sin_family = AF_INET;
  63   memcpy(&addr4->sin_addr, bytes, 4);
  64 }
  65
  66 // Fills in sockaddr for the given 128-bit address (IPv6.)
  67 // |bytes| should be an array of length 16.
  68 void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
  69   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
  70   storage->addr_len = sizeof(struct sockaddr_in6);
  71   struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
  72   addr6->sin6_port = base::HostToNet16(port);
  73   addr6->sin6_family = AF_INET6;
  74   memcpy(&addr6->sin6_addr, bytes, 16);
  75 }
  76
  77 // Helper to strignize an IP number (used to define expectations).
  78 std::string DumpIPNumber(const IPAddressNumber& v) {
  79   std::string out;
  80   for (size_t i = 0; i < v.size(); ++i) {
  81     if (i != 0)
  82       out.append(",");
  83     out.append(base::IntToString(static_cast<int>(v[i])));
  84   }
  85   return out;
  86 }
  87
  88 }  // anonymous namespace
  89
  90 TEST(NetUtilTest, GetIdentityFromURL) {
  91   struct {
  92     const char* input_url;
  93     const char* expected_username;
  94     const char* expected_password;
  95   } tests[] = {
  96     {
  97       "http://username:password@google.com",
  98       "username",
  99       "password",
 100     },
 101     { // Test for http://crbug.com/19200
 102       "http://username:p@ssword@google.com",
 103       "username",
 104       "p@ssword",
 105     },
 106     { // Special URL characters should be unescaped.
 107       "http://username:p%3fa%26s%2fs%23@google.com",
 108       "username",
 109       "p?a&s/s#",
 110     },
 111     { // Username contains %20.
 112       "http://use rname:password@google.com",
 113       "use rname",
 114       "password",
 115     },
 116     { // Keep %00 as is.
 117       "http://use%00rname:password@google.com",
 118       "use%00rname",
 119       "password",
 120     },
 121     { // Use a '+' in the username.
 122       "http://use+rname:password@google.com",
 123       "use+rname",
 124       "password",
 125     },
 126     { // Use a '&' in the password.
 127       "http://username:p&ssword@google.com",
 128       "username",
 129       "p&ssword",
 130     },
 131   };
 132   for (size_t i = 0; i < arraysize(tests); ++i) {
 133     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
 134                                     tests[i].input_url));
 135     GURL url(tests[i].input_url);
 136
 137     base::string16 username, password;
 138     GetIdentityFromURL(url, &username, &password);
 139
 140     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
 141     EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
 142   }
 143 }
 144
 145 // Try extracting a username which was encoded with UTF8.
 146 TEST(NetUtilTest, GetIdentityFromURL_UTF8) {
 147   GURL url(WideToUTF16(L"http://foo:\x4f60\x597d@blah.com"));
 148
 149   EXPECT_EQ("foo", url.username());
 150   EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password());
 151
 152   // Extract the unescaped identity.
 153   base::string16 username, password;
 154   GetIdentityFromURL(url, &username, &password);
 155
 156   // Verify that it was decoded as UTF8.
 157   EXPECT_EQ(ASCIIToUTF16("foo"), username);
 158   EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password);
 159 }
 160
 161 // Just a bunch of fake headers.
 162 const char* google_headers =
 163     "HTTP/1.1 200 OK\n"
 164     "Content-TYPE: text/html; charset=utf-8\n"
 165     "Content-disposition: attachment; filename=\"download.pdf\"\n"
 166     "Content-Length: 378557\n"
 167     "X-Google-Google1: 314159265\n"
 168     "X-Google-Google2: aaaa2:7783,bbb21:9441\n"
 169     "X-Google-Google4: home\n"
 170     "Transfer-Encoding: chunked\n"
 171     "Set-Cookie: HEHE_AT=6666x66beef666x6-66xx6666x66; Path=/mail\n"
 172     "Set-Cookie: HEHE_HELP=owned:0;Path=/\n"
 173     "Set-Cookie: S=gmail=Xxx-beefbeefbeef_beefb:gmail_yj=beefbeef000beefbee"
 174        "fbee:gmproxy=bee-fbeefbe; Domain=.google.com; Path=/\n"
 175     "X-Google-Google2: /one/two/three/four/five/six/seven-height/nine:9411\n"
 176     "Server: GFE/1.3\n"
 177     "Transfer-Encoding: chunked\n"
 178     "Date: Mon, 13 Nov 2006 21:38:09 GMT\n"
 179     "Expires: Tue, 14 Nov 2006 19:23:58 GMT\n"
 180     "X-Malformed: bla; arg=test\"\n"
 181     "X-Malformed2: bla; arg=\n"
 182     "X-Test: bla; arg1=val1; arg2=val2";
 183
 184 TEST(NetUtilTest, GetSpecificHeader) {
 185   const HeaderCase tests[] = {
 186     {"content-type", "text/html; charset=utf-8"},
 187     {"CONTENT-LENGTH", "378557"},
 188     {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
 189     {"Bad-Header", ""},
 190     {"", ""},
 191   };
 192
 193   // Test first with google_headers.
 194   for (size_t i = 0; i < arraysize(tests); ++i) {
 195     std::string result =
 196         GetSpecificHeader(google_headers, tests[i].header_name);
 197     EXPECT_EQ(result, tests[i].expected);
 198   }
 199
 200   // Test again with empty headers.
 201   for (size_t i = 0; i < arraysize(tests); ++i) {
 202     std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
 203     EXPECT_EQ(result, std::string());
 204   }
 205 }
 206
 207 TEST(NetUtilTest, CompliantHost) {
 208   struct CompliantHostCase {
 209     const char* host;
 210     bool expected_output;
 211   };
 212
 213   const CompliantHostCase compliant_host_cases[] = {
 214     {"", false},
 215     {"a", true},
 216     {"-", false},
 217     {".", false},
 218     {"9", true},
 219     {"9a", true},
 220     {"a.", true},
 221     {"a.a", true},
 222     {"9.a", true},
 223     {"a.9", true},
 224     {"_9a", false},
 225     {"-9a", false},
 226     {"a.a9", true},
 227     {"a.-a9", false},
 228     {"a+9a", false},
 229     {"-a.a9", true},
 230     {"1-.a-b", true},
 231     {"1_.a-b", false},
 232     {"1-2.a_b", true},
 233     {"a.b.c.d.e", true},
 234     {"1.2.3.4.5", true},
 235     {"1.2.3.4.5.", true},
 236   };
 237
 238   for (size_t i = 0; i < arraysize(compliant_host_cases); ++i) {
 239     EXPECT_EQ(compliant_host_cases[i].expected_output,
 240               IsCanonicalizedHostCompliant(compliant_host_cases[i].host));
 241   }
 242 }
 243
 244 TEST(NetUtilTest, ParseHostAndPort) {
 245   const struct {
 246     const char* input;
 247     bool success;
 248     const char* expected_host;
 249     int expected_port;
 250   } tests[] = {
 251     // Valid inputs:
 252     {"foo:10", true, "foo", 10},
 253     {"foo", true, "foo", -1},
 254     {
 255       "[1080:0:0:0:8:800:200C:4171]:11",
 256       true,
 257       "1080:0:0:0:8:800:200C:4171",
 258       11
 259     },
 260     {
 261       "[1080:0:0:0:8:800:200C:4171]",
 262       true,
 263       "1080:0:0:0:8:800:200C:4171",
 264       -1
 265     },
 266
 267     // Because no validation is done on the host, the following are accepted,
 268     // even though they are invalid names.
 269     {"]", true, "]", -1},
 270     {"::1", true, ":", 1},
 271     // Invalid inputs:
 272     {"foo:bar", false, "", -1},
 273     {"foo:", false, "", -1},
 274     {":", false, "", -1},
 275     {":80", false, "", -1},
 276     {"", false, "", -1},
 277     {"porttoolong:300000", false, "", -1},
 278     {"usrname@host", false, "", -1},
 279     {"usrname:password@host", false, "", -1},
 280     {":password@host", false, "", -1},
 281     {":password@host:80", false, "", -1},
 282     {":password@host", false, "", -1},
 283     {"@host", false, "", -1},
 284     {"[", false, "", -1},
 285     {"[]", false, "", -1},
 286   };
 287
 288   for (size_t i = 0; i < arraysize(tests); ++i) {
 289     std::string host;
 290     int port;
 291     bool ok = ParseHostAndPort(tests[i].input, &host, &port);
 292
 293     EXPECT_EQ(tests[i].success, ok);
 294
 295     if (tests[i].success) {
 296       EXPECT_EQ(tests[i].expected_host, host);
 297       EXPECT_EQ(tests[i].expected_port, port);
 298     }
 299   }
 300 }
 301
 302 TEST(NetUtilTest, GetHostAndPort) {
 303   const struct {
 304     GURL url;
 305     const char* expected_host_and_port;
 306   } tests[] = {
 307     { GURL("http://www.foo.com/x"), "www.foo.com:80"},
 308     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 309
 310     // For IPv6 literals should always include the brackets.
 311     { GURL("http://[1::2]/x"), "[1::2]:80"},
 312     { GURL("http://[::a]:33/x"), "[::a]:33"},
 313   };
 314   for (size_t i = 0; i < arraysize(tests); ++i) {
 315     std::string host_and_port = GetHostAndPort(tests[i].url);
 316     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
 317   }
 318 }
 319
 320 TEST(NetUtilTest, GetHostAndOptionalPort) {
 321   const struct {
 322     GURL url;
 323     const char* expected_host_and_port;
 324   } tests[] = {
 325     { GURL("http://www.foo.com/x"), "www.foo.com"},
 326     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 327
 328     // For IPv6 literals should always include the brackets.
 329     { GURL("http://[1::2]/x"), "[1::2]"},
 330     { GURL("http://[::a]:33/x"), "[::a]:33"},
 331   };
 332   for (size_t i = 0; i < arraysize(tests); ++i) {
 333     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
 334     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
 335   }
 336 }
 337
 338 TEST(NetUtilTest, IPAddressToString) {
 339   uint8 addr1[4] = {0, 0, 0, 0};
 340   EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
 341
 342   uint8 addr2[4] = {192, 168, 0, 1};
 343   EXPECT_EQ("192.168.0.1", IPAddressToString(addr2, sizeof(addr2)));
 344
 345   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
 346   EXPECT_EQ("fedc:ba98::", IPAddressToString(addr3, sizeof(addr3)));
 347 }
 348
 349 TEST(NetUtilTest, IPAddressToStringWithPort) {
 350   uint8 addr1[4] = {0, 0, 0, 0};
 351   EXPECT_EQ("0.0.0.0:3", IPAddressToStringWithPort(addr1, sizeof(addr1), 3));
 352
 353   uint8 addr2[4] = {192, 168, 0, 1};
 354   EXPECT_EQ("192.168.0.1:99",
 355             IPAddressToStringWithPort(addr2, sizeof(addr2), 99));
 356
 357   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
 358   EXPECT_EQ("[fedc:ba98::]:8080",
 359             IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
 360 }
 361
 362 TEST(NetUtilTest, NetAddressToString_IPv4) {
 363   const struct {
 364     uint8 addr[4];
 365     const char* result;
 366   } tests[] = {
 367     {{0, 0, 0, 0}, "0.0.0.0"},
 368     {{127, 0, 0, 1}, "127.0.0.1"},
 369     {{192, 168, 0, 1}, "192.168.0.1"},
 370   };
 371
 372   for (size_t i = 0; i < arraysize(tests); ++i) {
 373     SockaddrStorage storage;
 374     MakeIPv4Address(tests[i].addr, 80, &storage);
 375     std::string result = NetAddressToString(storage.addr, storage.addr_len);
 376     EXPECT_EQ(std::string(tests[i].result), result);
 377   }
 378 }
 379
 380 TEST(NetUtilTest, NetAddressToString_IPv6) {
 381   const struct {
 382     uint8 addr[16];
 383     const char* result;
 384   } tests[] = {
 385     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
 386       0x98, 0x76, 0x54, 0x32, 0x10},
 387      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
 388   };
 389
 390   for (size_t i = 0; i < arraysize(tests); ++i) {
 391     SockaddrStorage storage;
 392     MakeIPv6Address(tests[i].addr, 80, &storage);
 393     EXPECT_EQ(std::string(tests[i].result),
 394         NetAddressToString(storage.addr, storage.addr_len));
 395   }
 396 }
 397
 398 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
 399   uint8 addr[] = {127, 0, 0, 1};
 400   SockaddrStorage storage;
 401   MakeIPv4Address(addr, 166, &storage);
 402   std::string result = NetAddressToStringWithPort(storage.addr,
 403                                                   storage.addr_len);
 404   EXPECT_EQ("127.0.0.1:166", result);
 405 }
 406
 407 TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
 408   uint8 addr[] = {
 409       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
 410       0x98, 0x76, 0x54, 0x32, 0x10
 411   };
 412   SockaddrStorage storage;
 413   MakeIPv6Address(addr, 361, &storage);
 414   std::string result = NetAddressToStringWithPort(storage.addr,
 415                                                   storage.addr_len);
 416
 417   // May fail on systems that don't support IPv6.
 418   if (!result.empty())
 419     EXPECT_EQ("[fedc:ba98:7654:3210:fedc:ba98:7654:3210]:361", result);
 420 }
 421
 422 TEST(NetUtilTest, GetHostName) {
 423   // We can't check the result of GetHostName() directly, since the result
 424   // will differ across machines. Our goal here is to simply exercise the
 425   // code path, and check that things "look about right".
 426   std::string hostname = GetHostName();
 427   EXPECT_FALSE(hostname.empty());
 428 }
 429
 430 TEST(NetUtilTest, SimplifyUrlForRequest) {
 431   struct {
 432     const char* input_url;
 433     const char* expected_simplified_url;
 434   } tests[] = {
 435     {
 436       // Reference section should be stripped.
 437       "http://www.google.com:78/foobar?query=1#hash",
 438       "http://www.google.com:78/foobar?query=1",
 439     },
 440     {
 441       // Reference section can itself contain #.
 442       "http://192.168.0.1?query=1#hash#10#11#13#14",
 443       "http://192.168.0.1?query=1",
 444     },
 445     { // Strip username/password.
 446       "http://user:pass@google.com",
 447       "http://google.com/",
 448     },
 449     { // Strip both the reference and the username/password.
 450       "http://user:pass@google.com:80/sup?yo#X#X",
 451       "http://google.com/sup?yo",
 452     },
 453     { // Try an HTTPS URL -- strip both the reference and the username/password.
 454       "https://user:pass@google.com:80/sup?yo#X#X",
 455       "https://google.com:80/sup?yo",
 456     },
 457     { // Try an FTP URL -- strip both the reference and the username/password.
 458       "ftp://user:pass@google.com:80/sup?yo#X#X",
 459       "ftp://google.com:80/sup?yo",
 460     },
 461     { // Try a nonstandard URL
 462       "foobar://user:pass@google.com:80/sup?yo#X#X",
 463       "foobar://user:pass@google.com:80/sup?yo",
 464     },
 465   };
 466   for (size_t i = 0; i < arraysize(tests); ++i) {
 467     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
 468                                     tests[i].input_url));
 469     GURL input_url(GURL(tests[i].input_url));
 470     GURL expected_url(GURL(tests[i].expected_simplified_url));
 471     EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
 472   }
 473 }
 474
 475 TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
 476   std::string invalid[] = { "1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12" };
 477   std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
 478
 479   for (size_t i = 0; i < arraysize(invalid); ++i) {
 480     SetExplicitlyAllowedPorts(invalid[i]);
 481     EXPECT_EQ(0, static_cast<int>(GetCountOfExplicitlyAllowedPorts()));
 482   }
 483
 484   for (size_t i = 0; i < arraysize(valid); ++i) {
 485     SetExplicitlyAllowedPorts(valid[i]);
 486     EXPECT_EQ(i, GetCountOfExplicitlyAllowedPorts());
 487   }
 488 }
 489
 490 TEST(NetUtilTest, GetHostOrSpecFromURL) {
 491   EXPECT_EQ("example.com",
 492             GetHostOrSpecFromURL(GURL("http://example.com/test")));
 493   EXPECT_EQ("example.com",
 494             GetHostOrSpecFromURL(GURL("http://example.com./test")));
 495   EXPECT_EQ("file:///tmp/test.html",
 496             GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
 497 }
 498
 499 TEST(NetUtilTest, GetAddressFamily) {
 500   IPAddressNumber number;
 501   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
 502   EXPECT_EQ(ADDRESS_FAMILY_IPV4, GetAddressFamily(number));
 503   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
 504   EXPECT_EQ(ADDRESS_FAMILY_IPV6, GetAddressFamily(number));
 505 }
 506
 507 // Test that invalid IP literals fail to parse.
 508 TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) {
 509   IPAddressNumber number;
 510
 511   EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number));
 512   EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number));
 513   EXPECT_FALSE(ParseIPLiteralToNumber(std::string(), &number));
 514   EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number));
 515   EXPECT_FALSE(ParseIPLiteralToNumber("  192.168.0.1  ", &number));
 516   EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number));
 517 }
 518
 519 // Test parsing an IPv4 literal.
 520 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv4) {
 521   IPAddressNumber number;
 522   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
 523   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
 524   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
 525 }
 526
 527 // Test parsing an IPv6 literal.
 528 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv6) {
 529   IPAddressNumber number;
 530   EXPECT_TRUE(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number));
 531   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
 532   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 533 }
 534
 535 // Test mapping an IPv4 address to an IPv6 address.
 536 TEST(NetUtilTest, ConvertIPv4NumberToIPv6Number) {
 537   IPAddressNumber ipv4_number;
 538   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 539
 540   IPAddressNumber ipv6_number =
 541       ConvertIPv4NumberToIPv6Number(ipv4_number);
 542
 543   // ::ffff:192.168.0.1
 544   EXPECT_EQ("0,0,0,0,0,0,0,0,0,0,255,255,192,168,0,1",
 545             DumpIPNumber(ipv6_number));
 546   EXPECT_EQ("::ffff:c0a8:1", IPAddressToString(ipv6_number));
 547 }
 548
 549 TEST(NetUtilTest, ParseURLHostnameToNumber_FailParse) {
 550   IPAddressNumber number;
 551
 552   EXPECT_FALSE(ParseURLHostnameToNumber("bad value", &number));
 553   EXPECT_FALSE(ParseURLHostnameToNumber("bad:value", &number));
 554   EXPECT_FALSE(ParseURLHostnameToNumber(std::string(), &number));
 555   EXPECT_FALSE(ParseURLHostnameToNumber("192.168.0.1:30", &number));
 556   EXPECT_FALSE(ParseURLHostnameToNumber("  192.168.0.1  ", &number));
 557   EXPECT_FALSE(ParseURLHostnameToNumber("::1", &number));
 558 }
 559
 560 TEST(NetUtilTest, ParseURLHostnameToNumber_IPv4) {
 561   IPAddressNumber number;
 562   EXPECT_TRUE(ParseURLHostnameToNumber("192.168.0.1", &number));
 563   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
 564   EXPECT_EQ("192.168.0.1", IPAddressToString(number));
 565 }
 566
 567 TEST(NetUtilTest, ParseURLHostnameToNumber_IPv6) {
 568   IPAddressNumber number;
 569   EXPECT_TRUE(ParseURLHostnameToNumber("[1:abcd::3:4:ff]", &number));
 570   EXPECT_EQ("0,1,171,205,0,0,0,0,0,0,0,3,0,4,0,255", DumpIPNumber(number));
 571   EXPECT_EQ("1:abcd::3:4:ff", IPAddressToString(number));
 572 }
 573
 574 TEST(NetUtilTest, IsIPv4Mapped) {
 575   IPAddressNumber ipv4_number;
 576   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &ipv4_number));
 577   EXPECT_FALSE(IsIPv4Mapped(ipv4_number));
 578
 579   IPAddressNumber ipv6_number;
 580   EXPECT_TRUE(ParseIPLiteralToNumber("::1", &ipv4_number));
 581   EXPECT_FALSE(IsIPv4Mapped(ipv6_number));
 582
 583   IPAddressNumber ipv4mapped_number;
 584   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 585   EXPECT_TRUE(IsIPv4Mapped(ipv4mapped_number));
 586 }
 587
 588 TEST(NetUtilTest, ConvertIPv4MappedToIPv4) {
 589   IPAddressNumber ipv4mapped_number;
 590   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
 591   IPAddressNumber expected;
 592   EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
 593   IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
 594   EXPECT_EQ(expected, result);
 595 }
 596
 597 // Test parsing invalid CIDR notation literals.
 598 TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
 599   const char* bad_literals[] = {
 600       "foobar",
 601       "",
 602       "192.168.0.1",
 603       "::1",
 604       "/",
 605       "/1",
 606       "1",
 607       "192.168.1.1/-1",
 608       "192.168.1.1/33",
 609       "::1/-3",
 610       "a::3/129",
 611       "::1/x",
 612       "192.168.0.1//11"
 613   };
 614
 615   for (size_t i = 0; i < arraysize(bad_literals); ++i) {
 616     IPAddressNumber ip_number;
 617     size_t prefix_length_in_bits;
 618
 619     EXPECT_FALSE(ParseCIDRBlock(bad_literals[i],
 620                                      &ip_number,
 621                                      &prefix_length_in_bits));
 622   }
 623 }
 624
 625 // Test parsing a valid CIDR notation literal.
 626 TEST(NetUtilTest, ParseCIDRBlock_Valid) {
 627   IPAddressNumber ip_number;
 628   size_t prefix_length_in_bits;
 629
 630   EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
 631                                   &ip_number,
 632                                   &prefix_length_in_bits));
 633
 634   EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
 635   EXPECT_EQ(11u, prefix_length_in_bits);
 636 }
 637
 638 TEST(NetUtilTest, IPNumberMatchesPrefix) {
 639   struct {
 640     const char* cidr_literal;
 641     const char* ip_literal;
 642     bool expected_to_match;
 643   } tests[] = {
 644     // IPv4 prefix with IPv4 inputs.
 645     {
 646       "10.10.1.32/27",
 647       "10.10.1.44",
 648       true
 649     },
 650     {
 651       "10.10.1.32/27",
 652       "10.10.1.90",
 653       false
 654     },
 655     {
 656       "10.10.1.32/27",
 657       "10.10.1.90",
 658       false
 659     },
 660
 661     // IPv6 prefix with IPv6 inputs.
 662     {
 663       "2001:db8::/32",
 664       "2001:DB8:3:4::5",
 665       true
 666     },
 667     {
 668       "2001:db8::/32",
 669       "2001:c8::",
 670       false
 671     },
 672
 673     // IPv6 prefix with IPv4 inputs.
 674     {
 675       "2001:db8::/33",
 676       "192.168.0.1",
 677       false
 678     },
 679     {
 680       "::ffff:192.168.0.1/112",
 681       "192.168.33.77",
 682       true
 683     },
 684
 685     // IPv4 prefix with IPv6 inputs.
 686     {
 687       "10.11.33.44/16",
 688       "::ffff:0a0b:89",
 689       true
 690     },
 691     {
 692       "10.11.33.44/16",
 693       "::ffff:10.12.33.44",
 694       false
 695     },
 696   };
 697   for (size_t i = 0; i < arraysize(tests); ++i) {
 698     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
 699                                     tests[i].cidr_literal,
 700                                     tests[i].ip_literal));
 701
 702     IPAddressNumber ip_number;
 703     EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
 704
 705     IPAddressNumber ip_prefix;
 706     size_t prefix_length_in_bits;
 707
 708     EXPECT_TRUE(ParseCIDRBlock(tests[i].cidr_literal,
 709                                &ip_prefix,
 710                                &prefix_length_in_bits));
 711
 712     EXPECT_EQ(tests[i].expected_to_match,
 713               IPNumberMatchesPrefix(ip_number,
 714                                     ip_prefix,
 715                                     prefix_length_in_bits));
 716   }
 717 }
 718
 719 TEST(NetUtilTest, IsLocalhost) {
 720   EXPECT_TRUE(net::IsLocalhost("localhost"));
 721   EXPECT_TRUE(net::IsLocalhost("localhost.localdomain"));
 722   EXPECT_TRUE(net::IsLocalhost("localhost6"));
 723   EXPECT_TRUE(net::IsLocalhost("localhost6.localdomain6"));
 724   EXPECT_TRUE(net::IsLocalhost("127.0.0.1"));
 725   EXPECT_TRUE(net::IsLocalhost("127.0.1.0"));
 726   EXPECT_TRUE(net::IsLocalhost("127.1.0.0"));
 727   EXPECT_TRUE(net::IsLocalhost("127.0.0.255"));
 728   EXPECT_TRUE(net::IsLocalhost("127.0.255.0"));
 729   EXPECT_TRUE(net::IsLocalhost("127.255.0.0"));
 730   EXPECT_TRUE(net::IsLocalhost("::1"));
 731   EXPECT_TRUE(net::IsLocalhost("0:0:0:0:0:0:0:1"));
 732
 733   EXPECT_FALSE(net::IsLocalhost("localhostx"));
 734   EXPECT_FALSE(net::IsLocalhost("foo.localdomain"));
 735   EXPECT_FALSE(net::IsLocalhost("localhost6x"));
 736   EXPECT_FALSE(net::IsLocalhost("localhost.localdomain6"));
 737   EXPECT_FALSE(net::IsLocalhost("localhost6.localdomain"));
 738   EXPECT_FALSE(net::IsLocalhost("127.0.0.1.1"));
 739   EXPECT_FALSE(net::IsLocalhost(".127.0.0.255"));
 740   EXPECT_FALSE(net::IsLocalhost("::2"));
 741   EXPECT_FALSE(net::IsLocalhost("::1:1"));
 742   EXPECT_FALSE(net::IsLocalhost("0:0:0:0:1:0:0:1"));
 743   EXPECT_FALSE(net::IsLocalhost("::1:1"));
 744   EXPECT_FALSE(net::IsLocalhost("0:0:0:0:0:0:0:0:1"));
 745 }
 746
 747 // Verify GetNetworkList().
 748 TEST(NetUtilTest, GetNetworkList) {
 749   NetworkInterfaceList list;
 750   ASSERT_TRUE(GetNetworkList(&list, INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES));
 751   for (NetworkInterfaceList::iterator it = list.begin();
 752        it != list.end(); ++it) {
 753     // Verify that the names are not empty.
 754     EXPECT_FALSE(it->name.empty());
 755     EXPECT_FALSE(it->friendly_name.empty());
 756
 757     // Verify that the address is correct.
 758     EXPECT_TRUE(it->address.size() == kIPv4AddressSize ||
 759                 it->address.size() == kIPv6AddressSize)
 760         << "Invalid address of size " << it->address.size();
 761     bool all_zeroes = true;
 762     for (size_t i = 0; i < it->address.size(); ++i) {
 763       if (it->address[i] != 0) {
 764         all_zeroes = false;
 765         break;
 766       }
 767     }
 768     EXPECT_FALSE(all_zeroes);
 769     EXPECT_GT(it->network_prefix, 1u);
 770     EXPECT_LE(it->network_prefix, it->address.size() * 8);
 771
 772 #if defined(OS_WIN)
 773     // On Windows |name| is NET_LUID.
 774     base::ScopedNativeLibrary phlpapi_lib(
 775         base::FilePath(FILE_PATH_LITERAL("iphlpapi.dll")));
 776     ASSERT_TRUE(phlpapi_lib.is_valid());
 777     typedef NETIO_STATUS (WINAPI* ConvertInterfaceIndexToLuid)(NET_IFINDEX,
 778                                                                PNET_LUID);
 779     ConvertInterfaceIndexToLuid interface_to_luid =
 780         reinterpret_cast<ConvertInterfaceIndexToLuid>(
 781             phlpapi_lib.GetFunctionPointer("ConvertInterfaceIndexToLuid"));
 782
 783     typedef NETIO_STATUS (WINAPI* ConvertInterfaceLuidToGuid)(NET_LUID*,
 784                                                               GUID*);
 785     ConvertInterfaceLuidToGuid luid_to_guid =
 786         reinterpret_cast<ConvertInterfaceLuidToGuid>(
 787             phlpapi_lib.GetFunctionPointer("ConvertInterfaceLuidToGuid"));
 788
 789     if (interface_to_luid && luid_to_guid) {
 790       NET_LUID luid;
 791       EXPECT_EQ(interface_to_luid(it->interface_index, &luid), NO_ERROR);
 792       GUID guid;
 793       EXPECT_EQ(luid_to_guid(&luid, &guid), NO_ERROR);
 794       LPOLESTR name;
 795       StringFromCLSID(guid, &name);
 796       EXPECT_STREQ(base::UTF8ToWide(it->name).c_str(), name);
 797       CoTaskMemFree(name);
 798       continue;
 799     } else {
 800       EXPECT_LT(base::win::GetVersion(), base::win::VERSION_VISTA);
 801       EXPECT_LT(it->interface_index, 1u << 24u);  // Must fit 0.x.x.x.
 802       EXPECT_NE(it->interface_index, 0u);  // 0 means to use default.
 803     }
 804     if (it->type == NetworkChangeNotifier::CONNECTION_WIFI) {
 805       EXPECT_NE(WIFI_PHY_LAYER_PROTOCOL_NONE, GetWifiPHYLayerProtocol());
 806     }
 807 #elif !defined(OS_ANDROID)
 808     char name[IF_NAMESIZE];
 809     EXPECT_TRUE(if_indextoname(it->interface_index, name));
 810     EXPECT_STREQ(it->name.c_str(), name);
 811 #endif
 812   }
 813 }
 814
 815 #if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_NACL)
 816
 817 char* CopyInterfaceName(const char* ifname, int ifname_size, char* output) {
 818   EXPECT_LT(ifname_size, IF_NAMESIZE);
 819   memcpy(output, ifname, ifname_size);
 820   return output;
 821 }
 822
 823 static const char ifname_em1[] = "em1";
 824 char* GetInterfaceName(unsigned int interface_index, char* ifname) {
 825   return CopyInterfaceName(ifname_em1, arraysize(ifname_em1), ifname);
 826 }
 827
 828 static const char ifname_vm[] = "vmnet";
 829 char* GetInterfaceNameVM(unsigned int interface_index, char* ifname) {
 830   return CopyInterfaceName(ifname_vm, arraysize(ifname_vm), ifname);
 831 }
 832
 833 TEST(NetUtilTest, GetNetworkListTrimming) {
 834   NetworkInterfaceList results;
 835   ::base::hash_set<int> online_links;
 836   net::internal::AddressTrackerLinux::AddressMap address_map;
 837
 838   const unsigned char kIPv6LocalAddr[] = {
 839       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 840   const unsigned char kIPv6Addr[] =
 841     {0x24, 0x01, 0xfa, 0x00, 0x00, 0x04, 0x10, 0x00, 0xbe, 0x30, 0x5b, 0xff,
 842      0xfe, 0xe5, 0x00, 0xc3};
 843
 844   IPAddressNumber ipv6_local_address(
 845       kIPv6LocalAddr, kIPv6LocalAddr + arraysize(kIPv6LocalAddr));
 846   IPAddressNumber ipv6_address(kIPv6Addr, kIPv6Addr + arraysize(kIPv6Addr));
 847
 848   // Interface 1 is offline.
 849   struct ifaddrmsg msg = {
 850       AF_INET6,
 851       1,               /* prefix length */
 852       IFA_F_TEMPORARY, /* address flags */
 853       0,               /* link scope */
 854       1                /* link index */
 855   };
 856
 857   // Address of offline links should be ignored.
 858   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 859   EXPECT_TRUE(
 860       net::internal::GetNetworkListImpl(&results,
 861                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 862                                         online_links,
 863                                         address_map,
 864                                         GetInterfaceName));
 865   EXPECT_EQ(results.size(), 0ul);
 866
 867   // Mark interface 1 online.
 868   online_links.insert(1);
 869
 870   // Local address should be trimmed out.
 871   address_map.clear();
 872   ASSERT_TRUE(
 873       address_map.insert(std::make_pair(ipv6_local_address, msg)).second);
 874   EXPECT_TRUE(
 875       net::internal::GetNetworkListImpl(&results,
 876                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 877                                         online_links,
 878                                         address_map,
 879                                         GetInterfaceName));
 880   EXPECT_EQ(results.size(), 0ul);
 881
 882   // vmware address should return by default.
 883   address_map.clear();
 884   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 885   EXPECT_TRUE(
 886       net::internal::GetNetworkListImpl(&results,
 887                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 888                                         online_links,
 889                                         address_map,
 890                                         GetInterfaceNameVM));
 891   EXPECT_EQ(results.size(), 1ul);
 892   EXPECT_EQ(results[0].name, ifname_vm);
 893   EXPECT_EQ(results[0].network_prefix, 1ul);
 894   EXPECT_EQ(results[0].address, ipv6_address);
 895   results.clear();
 896
 897   // vmware address should be trimmed out if policy specified so.
 898   address_map.clear();
 899   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 900   EXPECT_TRUE(
 901       net::internal::GetNetworkListImpl(&results,
 902                                         EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 903                                         online_links,
 904                                         address_map,
 905                                         GetInterfaceNameVM));
 906   EXPECT_EQ(results.size(), 0ul);
 907   results.clear();
 908
 909   // Addresses with banned attributes should be ignored.
 910   address_map.clear();
 911   msg.ifa_flags = IFA_F_TENTATIVE;
 912   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 913   EXPECT_TRUE(
 914       net::internal::GetNetworkListImpl(&results,
 915                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 916                                         online_links,
 917                                         address_map,
 918                                         GetInterfaceName));
 919   EXPECT_EQ(results.size(), 0ul);
 920   results.clear();
 921
 922   // Addresses with allowed attribute IFA_F_TEMPORARY should be returned and
 923   // attributes should be translated correctly.
 924   address_map.clear();
 925   msg.ifa_flags = IFA_F_TEMPORARY;
 926   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 927   EXPECT_TRUE(
 928       net::internal::GetNetworkListImpl(&results,
 929                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 930                                         online_links,
 931                                         address_map,
 932                                         GetInterfaceName));
 933   EXPECT_EQ(results.size(), 1ul);
 934   EXPECT_EQ(results[0].name, ifname_em1);
 935   EXPECT_EQ(results[0].network_prefix, 1ul);
 936   EXPECT_EQ(results[0].address, ipv6_address);
 937   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_TEMPORARY);
 938   results.clear();
 939
 940   // Addresses with allowed attribute IFA_F_DEPRECATED should be returned and
 941   // attributes should be translated correctly.
 942   address_map.clear();
 943   msg.ifa_flags = IFA_F_DEPRECATED;
 944   ASSERT_TRUE(address_map.insert(std::make_pair(ipv6_address, msg)).second);
 945   EXPECT_TRUE(
 946       net::internal::GetNetworkListImpl(&results,
 947                                         INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES,
 948                                         online_links,
 949                                         address_map,
 950                                         GetInterfaceName));
 951   EXPECT_EQ(results.size(), 1ul);
 952   EXPECT_EQ(results[0].name, ifname_em1);
 953   EXPECT_EQ(results[0].network_prefix, 1ul);
 954   EXPECT_EQ(results[0].address, ipv6_address);
 955   EXPECT_EQ(results[0].ip_address_attributes, IP_ADDRESS_ATTRIBUTE_DEPRECATED);
 956   results.clear();
 957 }
 958
 959 #endif
 960
 961 namespace {
 962
 963 #if defined(OS_WIN)
 964 bool read_int_or_bool(DWORD data_size,
 965                       PVOID data) {
 966   switch (data_size) {
 967     case 1:
 968       return !!*reinterpret_cast<uint8*>(data);
 969     case 4:
 970       return !!*reinterpret_cast<uint32*>(data);
 971     default:
 972       LOG(FATAL) << "That is not a type I know!";
 973       return false;
 974   }
 975 }
 976
 977 int GetWifiOptions() {
 978   const internal::WlanApi& wlanapi = internal::WlanApi::GetInstance();
 979   if (!wlanapi.initialized)
 980     return -1;
 981
 982   internal::WlanHandle client;
 983   DWORD cur_version = 0;
 984   const DWORD kMaxClientVersion = 2;
 985   DWORD result = wlanapi.OpenHandle(
 986       kMaxClientVersion, &cur_version, &client);
 987   if (result != ERROR_SUCCESS)
 988     return -1;
 989
 990   WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
 991   result = wlanapi.enum_interfaces_func(client.Get(), NULL,
 992                                         &interface_list_ptr);
 993   if (result != ERROR_SUCCESS)
 994     return -1;
 995   scoped_ptr<WLAN_INTERFACE_INFO_LIST, internal::WlanApiDeleter> interface_list(
 996       interface_list_ptr);
 997
 998   for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
 999     WLAN_INTERFACE_INFO* info = &interface_list->InterfaceInfo[i];
1000     DWORD data_size;
1001     PVOID data;
1002     int options = 0;
1003     result = wlanapi.query_interface_func(
1004         client.Get(),
1005         &info->InterfaceGuid,
1006         wlan_intf_opcode_background_scan_enabled,
1007         NULL,
1008         &data_size,
1009         &data,
1010         NULL);
1011     if (result != ERROR_SUCCESS)
1012       continue;
1013     if (!read_int_or_bool(data_size, data)) {
1014       options |= WIFI_OPTIONS_DISABLE_SCAN;
1015     }
1016     internal::WlanApi::GetInstance().free_memory_func(data);
1017
1018     result = wlanapi.query_interface_func(
1019         client.Get(),
1020         &info->InterfaceGuid,
1021         wlan_intf_opcode_media_streaming_mode,
1022         NULL,
1023         &data_size,
1024         &data,
1025         NULL);
1026     if (result != ERROR_SUCCESS)
1027       continue;
1028     if (read_int_or_bool(data_size, data)) {
1029       options |= WIFI_OPTIONS_MEDIA_STREAMING_MODE;
1030     }
1031     internal::WlanApi::GetInstance().free_memory_func(data);
1032
1033     // Just the the options from the first succesful
1034     // interface.
1035     return options;
1036   }
1037
1038   // No wifi interface found.
1039   return -1;
1040 }
1041
1042 #else  // OS_WIN
1043
1044 int GetWifiOptions() {
1045   // Not supported.
1046   return -1;
1047 }
1048
1049 #endif  // OS_WIN
1050
1051 void TryChangeWifiOptions(int options) {
1052   int previous_options = GetWifiOptions();
1053   scoped_ptr<ScopedWifiOptions> scoped_options = SetWifiOptions(options);
1054   EXPECT_EQ(previous_options | options, GetWifiOptions());
1055   scoped_options.reset();
1056   EXPECT_EQ(previous_options, GetWifiOptions());
1057 }
1058
1059 };  // namespace
1060
1061 // Test SetWifiOptions().
1062 TEST(NetUtilTest, SetWifiOptionsTest) {
1063   TryChangeWifiOptions(0);
1064   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN);
1065   TryChangeWifiOptions(WIFI_OPTIONS_MEDIA_STREAMING_MODE);
1066   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN |
1067                        WIFI_OPTIONS_MEDIA_STREAMING_MODE);
1068 }
1069
1070 struct NonUniqueNameTestData {
1071   bool is_unique;
1072   const char* hostname;
1073 };
1074
1075 // Google Test pretty-printer.
1076 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
1077   ASSERT_TRUE(data.hostname);
1078   *os << " hostname: " << testing::PrintToString(data.hostname)
1079       << "; is_unique: " << testing::PrintToString(data.is_unique);
1080 }
1081
1082 const NonUniqueNameTestData kNonUniqueNameTestData[] = {
1083     // Domains under ICANN-assigned domains.
1084     { true, "google.com" },
1085     { true, "google.co.uk" },
1086     // Domains under private registries.
1087     { true, "appspot.com" },
1088     { true, "test.appspot.com" },
1089     // Unreserved IPv4 addresses (in various forms).
1090     { true, "8.8.8.8" },
1091     { true, "99.64.0.0" },
1092     { true, "212.15.0.0" },
1093     { true, "212.15" },
1094     { true, "212.15.0" },
1095     { true, "3557752832" },
1096     // Reserved IPv4 addresses (in various forms).
1097     { false, "192.168.0.0" },
1098     { false, "192.168.0.6" },
1099     { false, "10.0.0.5" },
1100     { false, "10.0" },
1101     { false, "10.0.0" },
1102     { false, "3232235526" },
1103     // Unreserved IPv6 addresses.
1104     { true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1105     { true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210" },
1106     // Reserved IPv6 addresses.
1107     { false, "::192.9.5.5" },
1108     { false, "FEED::BEEF" },
1109     { false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210" },
1110     // 'internal'/non-IANA assigned domains.
1111     { false, "intranet" },
1112     { false, "intranet." },
1113     { false, "intranet.example" },
1114     { false, "host.intranet.example" },
1115     // gTLDs under discussion, but not yet assigned.
1116     { false, "intranet.corp" },
1117     { false, "example.tech" },
1118     { false, "intranet.internal" },
1119     // Invalid host names are treated as unique - but expected to be
1120     // filtered out before then.
1121     { true, "junk)(£)$*!@~#" },
1122     { true, "w$w.example.com" },
1123     { true, "nocolonsallowed:example" },
1124     { true, "[::4.5.6.9]" },
1125 };
1126
1127 class NetUtilNonUniqueNameTest
1128     : public testing::TestWithParam<NonUniqueNameTestData> {
1129  public:
1130   virtual ~NetUtilNonUniqueNameTest() {}
1131
1132  protected:
1133   bool IsUnique(const std::string& hostname) {
1134     return !IsHostnameNonUnique(hostname);
1135   }
1136 };
1137
1138 // Test that internal/non-unique names are properly identified as such, but
1139 // that IP addresses and hosts beneath registry-controlled domains are flagged
1140 // as unique names.
1141 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
1142   const NonUniqueNameTestData& test_data = GetParam();
1143
1144   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
1145 }
1146
1147 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
1148                         testing::ValuesIn(kNonUniqueNameTestData));
1149
1150 }  // namespace net