Clang format slam.

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"
 
 namespace net {
 
 TEST(MimeUtilTest, ExtensionTest) {
   const struct {
     const base::FilePath::CharType* extension;
     const char* 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 },
-    { FILE_PATH_LITERAL("not an extension / for sure"), "", false },
-  };
+        {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},
+        {FILE_PATH_LITERAL("not an extension / for sure"), "", false},
+    };

[mmenke, 2014/10/10 18:12:39]

This (And all cases like it) are pretty hideous.  I'd say we should get rid of
all cases of this, if we reformat files that do it.

 
   std::string mime_type;
   bool rv;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(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;
     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 },
-  };
+        {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},
+    };
 
   std::string mime_type;
   bool rv;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    rv = GetMimeTypeFromFile(base::FilePath(tests[i].file_path),
-                                  &mime_type);
+    rv = GetMimeTypeFromFile(base::FilePath(tests[i].file_path), &mime_type);
     EXPECT_EQ(tests[i].valid, rv);
     if (rv)
       EXPECT_EQ(tests[i].mime_type, mime_type);
   }
 }
 
 TEST(MimeUtilTest, LookupTypes) {
   EXPECT_FALSE(IsUnsupportedTextMimeType("text/banana"));
   EXPECT_TRUE(IsUnsupportedTextMimeType("text/vcard"));
 
@@ skipping 56 matching lines @@
   EXPECT_FALSE(IsStrictMediaMimeType("audio/unknown"));
   EXPECT_FALSE(IsStrictMediaMimeType("application/unknown"));
   EXPECT_FALSE(IsStrictMediaMimeType("unknown/unknown"));
 }
 
 TEST(MimeUtilTest, MatchesMimeType) {
   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/*"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg"));
-  EXPECT_TRUE(MatchesMimeType("application/*+xml",
-                                   "application/html+xml"));
+  EXPECT_TRUE(MatchesMimeType("application/*+xml", "application/html+xml"));
   EXPECT_TRUE(MatchesMimeType("application/*+xml", "application/+xml"));
-  EXPECT_TRUE(MatchesMimeType("application/*+json",
-                                   "application/x-myformat+json"));
+  EXPECT_TRUE(
+      MatchesMimeType("application/*+json", "application/x-myformat+json"));
   EXPECT_TRUE(MatchesMimeType("aaa*aaa", "aaaaaa"));
   EXPECT_TRUE(MatchesMimeType("*", std::string()));
   EXPECT_FALSE(MatchesMimeType("video/", "video/x-mpeg"));
   EXPECT_FALSE(MatchesMimeType(std::string(), "video/x-mpeg"));
   EXPECT_FALSE(MatchesMimeType(std::string(), std::string()));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg", std::string()));
   EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/xml"));
-  EXPECT_FALSE(MatchesMimeType("application/*+xml",
-                                    "application/html+xmlz"));
-  EXPECT_FALSE(MatchesMimeType("application/*+xml",
-                                    "applcation/html+xml"));
+  EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/html+xmlz"));
+  EXPECT_FALSE(MatchesMimeType("application/*+xml", "applcation/html+xml"));
   EXPECT_FALSE(MatchesMimeType("aaa*aaa", "aaaaa"));
 
   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg;param=val"));
   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg;param=val"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg"));
   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg;param=other"));
   EXPECT_TRUE(MatchesMimeType("video/*;param=val", "video/mpeg;param=val"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg;param=val"));
-  EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
-                              "video/x-mpeg;param=val"));
-  EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
-                               "video/x-mpeg;param=val"));
-  EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
-                               "video/x-mpeg;param2=val"));
+  EXPECT_TRUE(
+      MatchesMimeType("video/x-mpeg;param=val", "video/x-mpeg;param=val"));
+  EXPECT_FALSE(
+      MatchesMimeType("video/x-mpeg;param2=val2", "video/x-mpeg;param=val"));
+  EXPECT_FALSE(
+      MatchesMimeType("video/x-mpeg;param2=val2", "video/x-mpeg;param2=val"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
                               "video/x-mpeg;param=val;param2=val2"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val;param2=val2",
                               "video/x-mpeg;param=val;param2=val2"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param2=val2;param=val",
                               "video/x-mpeg;param=val;param2=val2"));
   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param3=val3;param=val",
                                "video/x-mpeg;param=val;param2=val2"));
   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val ;param2=val2 ",
                               "video/x-mpeg;param=val;param2=val2"));
@@ skipping 17 matching lines @@
 }
 
 // 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;
     size_t expected_size;
     const char* 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, { }                    },
-    { ",",                          2, { "", "" }             },
-  };
+        {"\"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, {}},
+        {",", 2, {"", ""}},
+    };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::vector<std::string> codecs_out;
     ParseCodecString(tests[i].original, &codecs_out, true);
     ASSERT_EQ(tests[i].expected_size, codecs_out.size());
     for (size_t j = 0; j < tests[i].expected_size; ++j)
       EXPECT_EQ(tests[i].results[j], codecs_out[j]);
   }
 
   // Test without stripping the codec type.
@@ skipping 57 matching lines @@
   EXPECT_EQ("text", GetIANAMediaType("text/plain"));
   EXPECT_EQ("video", GetIANAMediaType("video/H261"));
 }
 
 TEST(MimeUtilTest, TestGetExtensionsForMimeType) {
   const struct {
     const char* mime_type;
     size_t min_expected_size;
     const char* contained_result;
   } tests[] = {
-    { "text/plain", 2, "txt" },
-    { "*",          0, NULL  },
-    { "message/*",  1, "eml" },
-    { "MeSsAge/*",  1, "eml" },
-    { "image/bmp",  1, "bmp" },
-    { "video/*",    6, "mp4" },
+    {"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" },
+    {"video/*", 6, "mpg"},
 #else
-    { "video/*",    6, "mpeg" },
+    {"video/*", 6, "mpeg"},
 #endif
-    { "audio/*",    6, "oga" },
-    { "aUDIo/*",    6, "wav" },
+    {"audio/*", 6, "oga"},
+    {"aUDIo/*", 6, "wav"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     std::vector<base::FilePath::StringType> extensions;
     GetExtensionsForMimeType(tests[i].mime_type, &extensions);
     ASSERT_TRUE(tests[i].min_expected_size <= extensions.size());
 
     if (!tests[i].contained_result)
       continue;
 
@@ skipping 25 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);
+  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