Roll Chrome into Mojo.

net/proxy/proxy_server_unittest.cc

 // Copyright (c) 2010 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 "base/basictypes.h"
 #include "net/proxy/proxy_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Test the creation of ProxyServer using ProxyServer::FromURI, which parses
 // inputs of the form [<scheme>"://"]<host>[":"<port>]. Verify that each part
 // was labelled correctly, and the accessors all give the right data.
 TEST(ProxyServerTest, FromURI) {
   const struct {
-    const char* input_uri;
-    const char* expected_uri;
+    const char* const input_uri;
+    const char* const expected_uri;
     net::ProxyServer::Scheme expected_scheme;
-    const char* expected_host;
+    const char* const expected_host;
     int expected_port;
-    const char* expected_pac_string;
+    const char* const expected_pac_string;
   } tests[] = {
     // HTTP proxy URIs:
     {
        "foopy:10",  // No scheme.
        "foopy:10",
        net::ProxyServer::SCHEME_HTTP,
        "foopy",
        10,
        "PROXY foopy:10"
     },
@@ skipping 154 matching lines @@
   net::ProxyServer uri =
       net::ProxyServer::FromURI("direct://", net::ProxyServer::SCHEME_HTTP);
   EXPECT_TRUE(uri.is_valid());
   EXPECT_TRUE(uri.is_direct());
   EXPECT_EQ("direct://", uri.ToURI());
   EXPECT_EQ("DIRECT", uri.ToPacString());
 }
 
 // Test parsing some invalid inputs.
 TEST(ProxyServerTest, Invalid) {
-  const char* tests[] = {
+  const char* const tests[] = {
     "",
     "   ",
     "dddf:",   // not a valid port
     "dddd:d",  // not a valid port
     "http://",  // not a valid host/port.
     "direct://xyz",  // direct is not allowed a host/port.
     "http:/",  // ambiguous, but will fail because of bad port.
     "http:",  // ambiguous, but will fail because of bad port.
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri =
         net::ProxyServer::FromURI(tests[i], net::ProxyServer::SCHEME_HTTP);
     EXPECT_FALSE(uri.is_valid());
     EXPECT_FALSE(uri.is_direct());
     EXPECT_FALSE(uri.is_http());
     EXPECT_FALSE(uri.is_socks());
   }
 }
 
 // Test that LWS (SP | HT) is disregarded from the ends.
 TEST(ProxyServerTest, Whitespace) {
-  const char* tests[] = {
+  const char* const tests[] = {
     "  foopy:80",
     "foopy:80   \t",
     "  \tfoopy:80  ",
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri =
         net::ProxyServer::FromURI(tests[i], net::ProxyServer::SCHEME_HTTP);
     EXPECT_EQ("foopy:80", uri.ToURI());
   }
 }
 
 // Test parsing a ProxyServer from a PAC representation.
 TEST(ProxyServerTest, FromPACString) {
   const struct {
-    const char* input_pac;
-    const char* expected_uri;
+    const char* const input_pac;
+    const char* const expected_uri;
   } tests[] = {
     {
        "PROXY foopy:10",
        "foopy:10",
     },
     {
        "   PROXY    foopy:10   ",
        "foopy:10",
     },
     {
@@ skipping 36 matching lines @@
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri = net::ProxyServer::FromPacString(tests[i].input_pac);
     EXPECT_TRUE(uri.is_valid());
     EXPECT_EQ(tests[i].expected_uri, uri.ToURI());
   }
 }
 
 // Test parsing a ProxyServer from an invalid PAC representation.
 TEST(ProxyServerTest, FromPACStringInvalid) {
-  const char* tests[] = {
+  const char* const tests[] = {
     "PROXY",  // missing host/port.
     "HTTPS",  // missing host/port.
     "SOCKS",  // missing host/port.
     "DIRECT foopy:10",  // direct cannot have host/port.
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri = net::ProxyServer::FromPacString(tests[i]);
     EXPECT_FALSE(uri.is_valid());
   }
 }
 
 TEST(ProxyServerTest, ComparatorAndEquality) {
   struct {
     // Inputs.
-    const char* server1;
-    const char* server2;
+    const char* const server1;
+    const char* const server2;
 
     // Expectation.
     //   -1 means server1 is less than server2
     //    0 means server1 equals server2
     //    1 means server1 is greater than server2
     int expected_comparison;
   } tests[] = {
     { // Equal.
       "foo:11",
       "http://foo:11",
@@ skipping 40 matching lines @@
       case 1:
         EXPECT_FALSE(server1 < server2);
         EXPECT_TRUE(server2 < server1);
         EXPECT_FALSE(server2 == server1);
         break;
       default:
         FAIL() << "Invalid expectation. Can be only -1, 0, 1";
     }
   }
 }