Roll Chrome into Mojo.

net/base/mime_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 "base/basictypes.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace net {
 
 TEST(MimeUtilTest, ExtensionTest) {
   const struct {
     const base::FilePath::CharType* extension;
-    const char* mime_type;
+    const char* const mime_type;
     bool valid;
   } tests[] = {
     { FILE_PATH_LITERAL("png"), "image/png", true },
     { FILE_PATH_LITERAL("css"), "text/css", true },
     { FILE_PATH_LITERAL("pjp"), "image/jpeg", true },
     { FILE_PATH_LITERAL("pjpeg"), "image/jpeg", true },
 #if defined(OS_ANDROID)
     { FILE_PATH_LITERAL("m3u8"), "application/x-mpegurl", true },
 #endif
     { FILE_PATH_LITERAL("not an extension / for sure"), "", false },
   };
 
   std::string mime_type;
   bool rv;
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     rv = GetMimeTypeFromExtension(tests[i].extension, &mime_type);
     EXPECT_EQ(tests[i].valid, rv);
     if (rv)
       EXPECT_EQ(tests[i].mime_type, mime_type);
   }
 }
 
 TEST(MimeUtilTest, FileTest) {
   const struct {
     const base::FilePath::CharType* file_path;
-    const char* mime_type;
+    const char* const mime_type;
     bool valid;
   } tests[] = {
     { FILE_PATH_LITERAL("c:\\foo\\bar.css"), "text/css", true },
     { FILE_PATH_LITERAL("c:\\blah"), "", false },
     { FILE_PATH_LITERAL("/usr/local/bin/mplayer"), "", false },
     { FILE_PATH_LITERAL("/home/foo/bar.css"), "text/css", true },
     { FILE_PATH_LITERAL("/blah."), "", false },
     { FILE_PATH_LITERAL("c:\\blah."), "", false },
   };
 
@@ skipping 193 matching lines @@
 
   EXPECT_FALSE(IsSupportedMediaMimeType("video/unknown"));
   EXPECT_FALSE(IsSupportedMediaMimeType("audio/unknown"));
   EXPECT_FALSE(IsSupportedMediaMimeType("unknown/unknown"));
 }
 
 // Note: codecs should only be a list of 2 or fewer; hence the restriction of
 // results' length to 2.
 TEST(MimeUtilTest, ParseCodecString) {
   const struct {
-    const char* original;
+    const char* const original;
     size_t expected_size;
-    const char* results[2];
+    const char* const results[2];
   } tests[] = {
     { "\"bogus\"",                  1, { "bogus" }            },
     { "0",                          1, { "0" }                },
     { "avc1.42E01E, mp4a.40.2",     2, { "avc1",   "mp4a" }   },
     { "\"mp4v.20.240, mp4a.40.2\"", 2, { "mp4v",   "mp4a" }   },
     { "mp4v.20.8, samr",            2, { "mp4v",   "samr" }   },
     { "\"theora, vorbis\"",         2, { "theora", "vorbis" } },
     { "",                           0, { }                    },
     { "\"\"",                       0, { }                    },
     { "\"   \"",                    0, { }                    },
@@ skipping 84 matching lines @@
   EXPECT_FALSE(IsValidTopLevelMimeType(" "));
 
   EXPECT_TRUE(IsValidTopLevelMimeType("x-video"));
   EXPECT_TRUE(IsValidTopLevelMimeType("X-video"));
 
   EXPECT_FALSE(IsValidTopLevelMimeType("x-"));
 }
 
 TEST(MimeUtilTest, TestGetExtensionsForMimeType) {
   const struct {
-    const char* mime_type;
+    const char* const mime_type;
     size_t min_expected_size;
-    const char* contained_result;
+    const char* const contained_result;
   } tests[] = {
     { "text/plain", 2, "txt" },
     { "*",          0, NULL  },
     { "message/*",  1, "eml" },
     { "MeSsAge/*",  1, "eml" },
     { "image/bmp",  1, "bmp" },
     { "video/*",    6, "mp4" },
 #if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_IOS)
     { "video/*",    6, "mpg" },
 #else
@@ skipping 39 matching lines @@
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
             GetCertificateMimeTypeForMimeType("application/x-x509-ca-cert"));
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
             GetCertificateMimeTypeForMimeType("application/x-pkcs12"));
 #endif
   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
             GetCertificateMimeTypeForMimeType("text/plain"));
 }
 
 TEST(MimeUtilTest, TestAddMultipartValueForUpload) {
-  const char* ref_output = "--boundary\r\nContent-Disposition: form-data;"
-                           " name=\"value name\"\r\nContent-Type: content type"
-                           "\r\n\r\nvalue\r\n"
-                           "--boundary\r\nContent-Disposition: form-data;"
-                           " name=\"value name\"\r\n\r\nvalue\r\n"
-                           "--boundary--\r\n";
+  const char ref_output[] =
+      "--boundary\r\nContent-Disposition: form-data;"
+      " name=\"value name\"\r\nContent-Type: content type"
+      "\r\n\r\nvalue\r\n"
+      "--boundary\r\nContent-Disposition: form-data;"
+      " name=\"value name\"\r\n\r\nvalue\r\n"
+      "--boundary--\r\n";
   std::string post_data;
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "content type", &post_data);
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "", &post_data);
   AddMultipartFinalDelimiterForUpload("boundary", &post_data);
   EXPECT_STREQ(ref_output, post_data.c_str());
 }
 
 }  // namespace net