Roll Chrome into Mojo.

net/base/net_util_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/base/net_util.h"
 
 #include <string.h>
 
 #include <ostream>
 
@@ skipping 43 matching lines @@
 #endif  // OS_WIN
 
 using base::ASCIIToUTF16;
 using base::WideToUTF16;
 
 namespace net {
 
 namespace {
 
 struct HeaderCase {
-  const char* header_name;
-  const char* expected;
+  const char* const header_name;
+  const char* const expected;
 };
 
 // Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
 void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
   memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
   storage->addr_len = sizeof(struct sockaddr_in);
   struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
   addr4->sin_family = AF_INET;
@@ skipping 71 matching lines @@
   interfaces->ifa_netmask = reinterpret_cast<sockaddr*>(&sock_addrs[1]);
 
   return true;
 }
 #endif  // OS_MACOSX
 
 }  // anonymous namespace
 
 TEST(NetUtilTest, GetIdentityFromURL) {
   struct {
-    const char* input_url;
-    const char* expected_username;
-    const char* expected_password;
+    const char* const input_url;
+    const char* const expected_username;
+    const char* const expected_password;
   } tests[] = {
     {
       "http://username:password@google.com",
       "username",
       "password",
     },
     { // Test for http://crbug.com/19200
       "http://username:p@ssword@google.com",
       "username",
       "p@ssword",
@@ skipping 47 matching lines @@
   // Extract the unescaped identity.
   base::string16 username, password;
   GetIdentityFromURL(url, &username, &password);
 
   // Verify that it was decoded as UTF8.
   EXPECT_EQ(ASCIIToUTF16("foo"), username);
   EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password);
 }
 
 // Just a bunch of fake headers.
-const char* google_headers =
+const char google_headers[] =
     "HTTP/1.1 200 OK\n"
     "Content-TYPE: text/html; charset=utf-8\n"
     "Content-disposition: attachment; filename=\"download.pdf\"\n"
     "Content-Length: 378557\n"
     "X-Google-Google1: 314159265\n"
     "X-Google-Google2: aaaa2:7783,bbb21:9441\n"
     "X-Google-Google4: home\n"
     "Transfer-Encoding: chunked\n"
     "Set-Cookie: HEHE_AT=6666x66beef666x6-66xx6666x66; Path=/mail\n"
     "Set-Cookie: HEHE_HELP=owned:0;Path=/\n"
@@ skipping 26 matching lines @@
 
   // Test again with empty headers.
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
     EXPECT_EQ(result, std::string());
   }
 }
 
 TEST(NetUtilTest, CompliantHost) {
   struct CompliantHostCase {
-    const char* host;
+    const char* const host;
     bool expected_output;
   };
 
   const CompliantHostCase compliant_host_cases[] = {
     {"", false},
     {"a", true},
     {"-", false},
     {".", false},
     {"9", true},
     {"9a", true},
@@ skipping 16 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(compliant_host_cases); ++i) {
     EXPECT_EQ(compliant_host_cases[i].expected_output,
               IsCanonicalizedHostCompliant(compliant_host_cases[i].host));
   }
 }
 
 TEST(NetUtilTest, ParseHostAndPort) {
   const struct {
-    const char* input;
+    const char* const input;
     bool success;
-    const char* expected_host;
+    const char* const expected_host;
     int expected_port;
   } tests[] = {
     // Valid inputs:
     {"foo:10", true, "foo", 10},
     {"foo", true, "foo", -1},
     {
       "[1080:0:0:0:8:800:200C:4171]:11",
       true,
       "1080:0:0:0:8:800:200C:4171",
       11
@@ skipping 36 matching lines @@
     if (tests[i].success) {
       EXPECT_EQ(tests[i].expected_host, host);
       EXPECT_EQ(tests[i].expected_port, port);
     }
   }
 }
 
 TEST(NetUtilTest, GetHostAndPort) {
   const struct {
     GURL url;
-    const char* expected_host_and_port;
+    const char* const expected_host_and_port;
   } tests[] = {
     { GURL("http://www.foo.com/x"), "www.foo.com:80"},
     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
     // For IPv6 literals should always include the brackets.
     { GURL("http://[1::2]/x"), "[1::2]:80"},
     { GURL("http://[::a]:33/x"), "[::a]:33"},
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host_and_port = GetHostAndPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, GetHostAndOptionalPort) {
   const struct {
     GURL url;
-    const char* expected_host_and_port;
+    const char* const expected_host_and_port;
   } tests[] = {
     { GURL("http://www.foo.com/x"), "www.foo.com"},
     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
     // For IPv6 literals should always include the brackets.
     { GURL("http://[1::2]/x"), "[1::2]"},
     { GURL("http://[::a]:33/x"), "[::a]:33"},
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
@@ skipping 21 matching lines @@
             IPAddressToStringWithPort(addr2, sizeof(addr2), 99));
 
   uint8 addr3[16] = {0xFE, 0xDC, 0xBA, 0x98};
   EXPECT_EQ("[fedc:ba98::]:8080",
             IPAddressToStringWithPort(addr3, sizeof(addr3), 8080));
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv4) {
   const struct {
     uint8 addr[4];
-    const char* result;
+    const char* const result;
   } tests[] = {
     {{0, 0, 0, 0}, "0.0.0.0"},
     {{127, 0, 0, 1}, "127.0.0.1"},
     {{192, 168, 0, 1}, "192.168.0.1"},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv4Address(tests[i].addr, 80, &storage);
     std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv6) {
   const struct {
     uint8 addr[16];
-    const char* result;
+    const char* const result;
   } tests[] = {
     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10},
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv6Address(tests[i].addr, 80, &storage);
     EXPECT_EQ(std::string(tests[i].result),
@@ skipping 28 matching lines @@
 TEST(NetUtilTest, GetHostName) {
   // We can't check the result of GetHostName() directly, since the result
   // will differ across machines. Our goal here is to simply exercise the
   // code path, and check that things "look about right".
   std::string hostname = GetHostName();
   EXPECT_FALSE(hostname.empty());
 }
 
 TEST(NetUtilTest, SimplifyUrlForRequest) {
   struct {
-    const char* input_url;
-    const char* expected_simplified_url;
+    const char* const input_url;
+    const char* const expected_simplified_url;
   } tests[] = {
     {
       // Reference section should be stripped.
       "http://www.google.com:78/foobar?query=1#hash",
       "http://www.google.com:78/foobar?query=1",
     },
     {
       // Reference section can itself contain #.
       "http://192.168.0.1?query=1#hash#10#11#13#14",
       "http://192.168.0.1?query=1",
@@ skipping 145 matching lines @@
   IPAddressNumber ipv4mapped_number;
   EXPECT_TRUE(ParseIPLiteralToNumber("::ffff:0101:1", &ipv4mapped_number));
   IPAddressNumber expected;
   EXPECT_TRUE(ParseIPLiteralToNumber("1.1.0.1", &expected));
   IPAddressNumber result = ConvertIPv4MappedToIPv4(ipv4mapped_number);
   EXPECT_EQ(expected, result);
 }
 
 // Test parsing invalid CIDR notation literals.
 TEST(NetUtilTest, ParseCIDRBlock_Invalid) {
-  const char* bad_literals[] = {
+  const char* const bad_literals[] = {
       "foobar",
       "",
       "192.168.0.1",
       "::1",
       "/",
       "/1",
       "1",
       "192.168.1.1/-1",
       "192.168.1.1/33",
       "::1/-3",
@@ skipping 20 matching lines @@
   EXPECT_TRUE(ParseCIDRBlock("192.168.0.1/11",
                                   &ip_number,
                                   &prefix_length_in_bits));
 
   EXPECT_EQ("192,168,0,1", DumpIPNumber(ip_number));
   EXPECT_EQ(11u, prefix_length_in_bits);
 }
 
 TEST(NetUtilTest, IPNumberMatchesPrefix) {
   struct {
-    const char* cidr_literal;
-    const char* ip_literal;
+    const char* const cidr_literal;
+    const char* const ip_literal;
     bool expected_to_match;
   } tests[] = {
     // IPv4 prefix with IPv4 inputs.
     {
       "10.10.1.32/27",
       "10.10.1.44",
       true
     },
     {
       "10.10.1.32/27",
@@ skipping 693 matching lines @@
 TEST(NetUtilTest, SetWifiOptionsTest) {
   TryChangeWifiOptions(0);
   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN);
   TryChangeWifiOptions(WIFI_OPTIONS_MEDIA_STREAMING_MODE);
   TryChangeWifiOptions(WIFI_OPTIONS_DISABLE_SCAN |
                        WIFI_OPTIONS_MEDIA_STREAMING_MODE);
 }
 
 struct NonUniqueNameTestData {
   bool is_unique;
-  const char* hostname;
+  const char* const hostname;
 };
 
 // Google Test pretty-printer.
 void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) {
   ASSERT_TRUE(data.hostname);
   *os << " hostname: " << testing::PrintToString(data.hostname)
       << "; is_unique: " << testing::PrintToString(data.is_unique);
 }
 
 const NonUniqueNameTestData kNonUniqueNameTestData[] = {
@@ skipping 58 matching lines @@
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net