Roll Chrome into Mojo.

net/http/http_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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::HttpUtil;
 
 namespace {
 class HttpUtilTest : public testing::Test {};
 }
 
 TEST(HttpUtilTest, IsSafeHeader) {
-  static const char* unsafe_headers[] = {
+  static const char* const unsafe_headers[] = {
     "sec-",
     "sEc-",
     "sec-foo",
     "sEc-FoO",
     "proxy-",
     "pRoXy-",
     "proxy-foo",
     "pRoXy-FoO",
     "accept-charset",
     "accept-encoding",
@@ skipping 16 matching lines @@
     "upgrade",
     "user-agent",
     "via",
   };
   for (size_t i = 0; i < arraysize(unsafe_headers); ++i) {
     EXPECT_FALSE(HttpUtil::IsSafeHeader(unsafe_headers[i]))
       << unsafe_headers[i];
     EXPECT_FALSE(HttpUtil::IsSafeHeader(StringToUpperASCII(std::string(
         unsafe_headers[i])))) << unsafe_headers[i];
   }
-  static const char* safe_headers[] = {
+  static const char* const safe_headers[] = {
     "foo",
     "x-",
     "x-foo",
     "content-disposition",
     "update",
     "accept-charseta",
     "accept_charset",
     "accept-encodinga",
     "accept_encoding",
     "access-control-request-headersa",
@@ skipping 28 matching lines @@
   };
   for (size_t i = 0; i < arraysize(safe_headers); ++i) {
     EXPECT_TRUE(HttpUtil::IsSafeHeader(safe_headers[i])) << safe_headers[i];
     EXPECT_TRUE(HttpUtil::IsSafeHeader(StringToUpperASCII(std::string(
         safe_headers[i])))) << safe_headers[i];
   }
 }
 
 TEST(HttpUtilTest, HasHeader) {
   static const struct {
-    const char* headers;
-    const char* name;
+    const char* const headers;
+    const char* const name;
     bool expected_result;
   } tests[] = {
     { "", "foo", false },
     { "foo\r\nbar", "foo", false },
     { "ffoo: 1", "foo", false },
     { "foo: 1", "foo", true },
     { "foo: 1\r\nbar: 2", "foo", true },
     { "fOO: 1\r\nbar: 2", "foo", true },
     { "g: 0\r\nfoo: 1\r\nbar: 2", "foo", true },
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     bool result = HttpUtil::HasHeader(tests[i].headers, tests[i].name);
     EXPECT_EQ(tests[i].expected_result, result);
   }
 }
 
 TEST(HttpUtilTest, StripHeaders) {
-  static const char* headers =
+  static const char* const headers =
       "Origin: origin\r\n"
       "Content-Type: text/plain\r\n"
       "Cookies: foo1\r\n"
       "Custom: baz\r\n"
       "COOKIES: foo2\r\n"
       "Server: Apache\r\n"
       "OrIGin: origin2\r\n";
 
-  static const char* header_names[] = {
+  static const char* const header_names[] = {
     "origin", "content-type", "cookies"
   };
 
-  static const char* expected_stripped_headers =
+  static const char* const expected_stripped_headers =
       "Custom: baz\r\n"
       "Server: Apache\r\n";
 
   EXPECT_EQ(expected_stripped_headers,
             HttpUtil::StripHeaders(headers, header_names,
                                    arraysize(header_names)));
 }
 
 TEST(HttpUtilTest, HeadersIterator) {
   std::string headers = "foo: 1\t\r\nbar: hello world\r\nbaz: 3 \r\n";
@@ skipping 107 matching lines @@
 
   // Replace <backslash> <backslash> with <backslash>
   EXPECT_STREQ("\"xyz\\\\abc\"", HttpUtil::Quote("xyz\\abc").c_str());
 
   // Replace <backslash> X with X
   EXPECT_STREQ("\"xyzXabc\"", HttpUtil::Quote("xyzXabc").c_str());
 }
 
 TEST(HttpUtilTest, LocateEndOfHeaders) {
   struct {
-    const char* input;
+    const char* const input;
     int expected_result;
   } tests[] = {
     { "foo\r\nbar\r\n\r\n", 12 },
     { "foo\nbar\n\n", 9 },
     { "foo\r\nbar\r\n\r\njunk", 12 },
     { "foo\nbar\n\njunk", 9 },
     { "foo\nbar\n\r\njunk", 10 },
     { "foo\nbar\r\n\njunk", 10 },
   };
   for (size_t i = 0; i < arraysize(tests); ++i) {
     int input_len = static_cast<int>(strlen(tests[i].input));
     int eoh = HttpUtil::LocateEndOfHeaders(tests[i].input, input_len);
     EXPECT_EQ(tests[i].expected_result, eoh);
   }
 }
 
 TEST(HttpUtilTest, AssembleRawHeaders) {
   struct {
-    const char* input;  // with '|' representing '\0'
-    const char* expected_result;  // with '\0' changed to '|'
+    const char* const input;  // with '|' representing '\0'
+    const char* const expected_result;  // with '\0' changed to '|'
   } tests[] = {
     { "HTTP/1.0 200 OK\r\nFoo: 1\r\nBar: 2\r\n\r\n",
       "HTTP/1.0 200 OK|Foo: 1|Bar: 2||" },
 
     { "HTTP/1.0 200 OK\nFoo: 1\nBar: 2\n\n",
       "HTTP/1.0 200 OK|Foo: 1|Bar: 2||" },
 
     // Valid line continuation (single SP).
     {
       "HTTP/1.0 200 OK\n"
@@ skipping 291 matching lines @@
     std::replace(input.begin(), input.end(), '|', '\0');
     std::string raw = HttpUtil::AssembleRawHeaders(input.data(), input.size());
     std::replace(raw.begin(), raw.end(), '\0', '|');
     EXPECT_EQ(tests[i].expected_result, raw);
   }
 }
 
 // Test SpecForRequest() and PathForRequest().
 TEST(HttpUtilTest, RequestUrlSanitize) {
   struct {
-    const char* url;
-    const char* expected_spec;
-    const char* expected_path;
+    const char* const url;
+    const char* const expected_spec;
+    const char* const expected_path;
   } tests[] = {
     { // Check that #hash is removed.
       "http://www.google.com:78/foobar?query=1#hash",
       "http://www.google.com:78/foobar?query=1",
       "/foobar?query=1"
     },
     { // The reference may itself contain # -- strip all of it.
       "http://192.168.0.1?query=1#hash#10#11#13#14",
       "http://192.168.0.1/?query=1",
       "/?query=1"
@@ skipping 40 matching lines @@
   EXPECT_EQ(std::string("en-US,fr;q=0.8,de;q=0.6"),
             HttpUtil::GenerateAcceptLanguageHeader("en-US,fr,de"));
   EXPECT_EQ(std::string("en-US,fr;q=0.8,de;q=0.6,ko;q=0.4,zh-CN;q=0.2,"
                         "ja;q=0.2"),
             HttpUtil::GenerateAcceptLanguageHeader("en-US,fr,de,ko,zh-CN,ja"));
 }
 
 // HttpResponseHeadersTest.GetMimeType also tests ParseContentType.
 TEST(HttpUtilTest, ParseContentType) {
   const struct {
-    const char* content_type;
-    const char* expected_mime_type;
-    const char* expected_charset;
+    const char* const content_type;
+    const char* const expected_mime_type;
+    const char* const expected_charset;
     const bool expected_had_charset;
-    const char* expected_boundary;
+    const char* const expected_boundary;
   } tests[] = {
     { "text/html; charset=utf-8",
       "text/html",
       "utf-8",
       true,
       ""
     },
     { "text/html; charset =utf-8",
       "text/html",
       "utf-8",
@@ skipping 59 matching lines @@
                                     &charset, &had_charset, &boundary);
     EXPECT_EQ(tests[i].expected_mime_type, mime_type) << "i=" << i;
     EXPECT_EQ(tests[i].expected_charset, charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_had_charset, had_charset) << "i=" << i;
     EXPECT_EQ(tests[i].expected_boundary, boundary) << "i=" << i;
   }
 }
 
 TEST(HttpUtilTest, ParseRanges) {
   const struct {
-    const char* headers;
+    const char* const headers;
     bool expected_return_value;
     size_t expected_ranges_size;
     const struct {
       int64 expected_first_byte_position;
       int64 expected_last_byte_position;
       int64 expected_suffix_length;
     } expected_ranges[10];
   } tests[] = {
     { "Range: bytes=0-10",
       true,
@@ skipping 352 matching lines @@
 TEST(HttpUtilTest, NameValuePairsIteratorMissingEndQuote) {
   std::string data = "name='value";
   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
   EXPECT_TRUE(parser.valid());
 
   ASSERT_NO_FATAL_FAILURE(
       CheckNextNameValuePair(&parser, true, true, "name", "value"));
   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
       &parser, false, true, std::string(), std::string()));
 }