Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/basictypes.h"
      6 #include "base/strings/string_split.h"
      7 #include "base/strings/utf_string_conversions.h"
      8 #include "net/base/mime_util.h"
      9 #include "testing/gtest/include/gtest/gtest.h"
     10 
     11 #if defined(OS_ANDROID)
     12 #include "base/android/build_info.h"
     13 #endif
     14 
     15 namespace net {
     16 
     17 TEST(MimeUtilTest, ExtensionTest) {
     18   const struct {
     19     const base::FilePath::CharType* extension;
     20     const char* mime_type;
     21     bool valid;
     22   } tests[] = {
     23     { FILE_PATH_LITERAL("png"), "image/png", true },
     24     { FILE_PATH_LITERAL("css"), "text/css", true },
     25     { FILE_PATH_LITERAL("pjp"), "image/jpeg", true },
     26     { FILE_PATH_LITERAL("pjpeg"), "image/jpeg", true },
     27     { FILE_PATH_LITERAL("not an extension / for sure"), "", false },
     28   };
     29 
     30   std::string mime_type;
     31   bool rv;
     32 
     33   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     34     rv = GetMimeTypeFromExtension(tests[i].extension, &mime_type);
     35     EXPECT_EQ(tests[i].valid, rv);
     36     if (rv)
     37       EXPECT_EQ(tests[i].mime_type, mime_type);
     38   }
     39 }
     40 
     41 TEST(MimeUtilTest, FileTest) {
     42   const struct {
     43     const base::FilePath::CharType* file_path;
     44     const char* mime_type;
     45     bool valid;
     46   } tests[] = {
     47     { FILE_PATH_LITERAL("c:\\foo\\bar.css"), "text/css", true },
     48     { FILE_PATH_LITERAL("c:\\blah"), "", false },
     49     { FILE_PATH_LITERAL("/usr/local/bin/mplayer"), "", false },
     50     { FILE_PATH_LITERAL("/home/foo/bar.css"), "text/css", true },
     51     { FILE_PATH_LITERAL("/blah."), "", false },
     52     { FILE_PATH_LITERAL("c:\\blah."), "", false },
     53   };
     54 
     55   std::string mime_type;
     56   bool rv;
     57 
     58   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     59     rv = GetMimeTypeFromFile(base::FilePath(tests[i].file_path),
     60                                   &mime_type);
     61     EXPECT_EQ(tests[i].valid, rv);
     62     if (rv)
     63       EXPECT_EQ(tests[i].mime_type, mime_type);
     64   }
     65 }
     66 
     67 TEST(MimeUtilTest, LookupTypes) {
     68   EXPECT_FALSE(IsUnsupportedTextMimeType("text/banana"));
     69   EXPECT_TRUE(IsUnsupportedTextMimeType("text/vcard"));
     70 
     71   EXPECT_TRUE(IsSupportedImageMimeType("image/jpeg"));
     72   EXPECT_FALSE(IsSupportedImageMimeType("image/lolcat"));
     73   EXPECT_TRUE(IsSupportedNonImageMimeType("text/html"));
     74   EXPECT_TRUE(IsSupportedNonImageMimeType("text/css"));
     75   EXPECT_TRUE(IsSupportedNonImageMimeType("text/"));
     76   EXPECT_TRUE(IsSupportedNonImageMimeType("text/banana"));
     77   EXPECT_FALSE(IsSupportedNonImageMimeType("text/vcard"));
     78   EXPECT_FALSE(IsSupportedNonImageMimeType("application/virus"));
     79   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-x509-user-cert"));
     80   EXPECT_TRUE(IsSupportedNonImageMimeType("application/json"));
     81   EXPECT_TRUE(IsSupportedNonImageMimeType("application/+json"));
     82   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-suggestions+json"));
     83   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-s+json;x=2"));
     84 #if defined(OS_ANDROID)
     85   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-x509-ca-cert"));
     86   EXPECT_TRUE(IsSupportedNonImageMimeType("application/x-pkcs12"));
     87   EXPECT_TRUE(IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
     88   EXPECT_TRUE(IsSupportedMediaMimeType("application/x-mpegurl"));
     89 #endif
     90 
     91   EXPECT_TRUE(IsSupportedMimeType("image/jpeg"));
     92   EXPECT_FALSE(IsSupportedMimeType("image/lolcat"));
     93   EXPECT_TRUE(IsSupportedMimeType("text/html"));
     94   EXPECT_TRUE(IsSupportedMimeType("text/banana"));
     95   EXPECT_FALSE(IsSupportedMimeType("text/vcard"));
     96   EXPECT_FALSE(IsSupportedMimeType("application/virus"));
     97   EXPECT_FALSE(IsSupportedMimeType("application/x-json"));
     98   EXPECT_FALSE(IsSupportedNonImageMimeType("application/vnd.doc;x=y+json"));
     99 }
    100 
    101 TEST(MimeUtilTest, StrictMediaMimeType) {
    102   EXPECT_TRUE(IsStrictMediaMimeType("video/webm"));
    103   EXPECT_TRUE(IsStrictMediaMimeType("audio/webm"));
    104 
    105   EXPECT_TRUE(IsStrictMediaMimeType("audio/wav"));
    106   EXPECT_TRUE(IsStrictMediaMimeType("audio/x-wav"));
    107 
    108   EXPECT_TRUE(IsStrictMediaMimeType("video/ogg"));
    109   EXPECT_TRUE(IsStrictMediaMimeType("audio/ogg"));
    110   EXPECT_TRUE(IsStrictMediaMimeType("application/ogg"));
    111 
    112   EXPECT_TRUE(IsStrictMediaMimeType("audio/mpeg"));
    113   EXPECT_TRUE(IsStrictMediaMimeType("audio/mp3"));
    114   EXPECT_TRUE(IsStrictMediaMimeType("audio/x-mp3"));
    115 
    116   // TODO(amogh.bihani): These will be fixed http://crbug.com/53193
    117   EXPECT_FALSE(IsStrictMediaMimeType("video/mp4"));
    118   EXPECT_FALSE(IsStrictMediaMimeType("video/x-m4v"));
    119   EXPECT_FALSE(IsStrictMediaMimeType("audio/mp4"));
    120   EXPECT_FALSE(IsStrictMediaMimeType("audio/x-m4a"));
    121 
    122   EXPECT_FALSE(IsStrictMediaMimeType("application/x-mpegurl"));
    123   EXPECT_FALSE(IsStrictMediaMimeType("application/vnd.apple.mpegurl"));
    124   // ---------------------------------------------------------------------------
    125 
    126   EXPECT_FALSE(IsStrictMediaMimeType("video/unknown"));
    127   EXPECT_FALSE(IsStrictMediaMimeType("audio/unknown"));
    128   EXPECT_FALSE(IsStrictMediaMimeType("application/unknown"));
    129   EXPECT_FALSE(IsStrictMediaMimeType("unknown/unknown"));
    130 }
    131 
    132 TEST(MimeUtilTest, MatchesMimeType) {
    133   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg"));
    134   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg"));
    135   EXPECT_TRUE(MatchesMimeType("video/*", "video/*"));
    136   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg"));
    137   EXPECT_TRUE(MatchesMimeType("application/*+xml",
    138                                    "application/html+xml"));
    139   EXPECT_TRUE(MatchesMimeType("application/*+xml", "application/+xml"));
    140   EXPECT_TRUE(MatchesMimeType("application/*+json",
    141                                    "application/x-myformat+json"));
    142   EXPECT_TRUE(MatchesMimeType("aaa*aaa", "aaaaaa"));
    143   EXPECT_TRUE(MatchesMimeType("*", std::string()));
    144   EXPECT_FALSE(MatchesMimeType("video/", "video/x-mpeg"));
    145   EXPECT_FALSE(MatchesMimeType(std::string(), "video/x-mpeg"));
    146   EXPECT_FALSE(MatchesMimeType(std::string(), std::string()));
    147   EXPECT_FALSE(MatchesMimeType("video/x-mpeg", std::string()));
    148   EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/xml"));
    149   EXPECT_FALSE(MatchesMimeType("application/*+xml",
    150                                     "application/html+xmlz"));
    151   EXPECT_FALSE(MatchesMimeType("application/*+xml",
    152                                     "applcation/html+xml"));
    153   EXPECT_FALSE(MatchesMimeType("aaa*aaa", "aaaaa"));
    154 
    155   EXPECT_TRUE(MatchesMimeType("*", "video/x-mpeg;param=val"));
    156   EXPECT_TRUE(MatchesMimeType("video/*", "video/x-mpeg;param=val"));
    157   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg"));
    158   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/mpeg;param=other"));
    159   EXPECT_TRUE(MatchesMimeType("video/*;param=val", "video/mpeg;param=val"));
    160   EXPECT_TRUE(MatchesMimeType("video/x-mpeg", "video/x-mpeg;param=val"));
    161   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
    162                               "video/x-mpeg;param=val"));
    163   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
    164                                "video/x-mpeg;param=val"));
    165   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param2=val2",
    166                                "video/x-mpeg;param2=val"));
    167   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val",
    168                               "video/x-mpeg;param=val;param2=val2"));
    169   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val;param2=val2",
    170                               "video/x-mpeg;param=val;param2=val2"));
    171   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param2=val2;param=val",
    172                               "video/x-mpeg;param=val;param2=val2"));
    173   EXPECT_FALSE(MatchesMimeType("video/x-mpeg;param3=val3;param=val",
    174                                "video/x-mpeg;param=val;param2=val2"));
    175   EXPECT_TRUE(MatchesMimeType("video/x-mpeg;param=val ;param2=val2 ",
    176                               "video/x-mpeg;param=val;param2=val2"));
    177 
    178   EXPECT_TRUE(MatchesMimeType("*/*;param=val", "video/x-mpeg;param=val"));
    179   EXPECT_FALSE(MatchesMimeType("*/*;param=val", "video/x-mpeg;param=val2"));
    180 
    181   EXPECT_TRUE(MatchesMimeType("*", "*"));
    182   EXPECT_TRUE(MatchesMimeType("*", "*/*"));
    183   EXPECT_TRUE(MatchesMimeType("*/*", "*/*"));
    184   EXPECT_TRUE(MatchesMimeType("*/*", "*"));
    185   EXPECT_TRUE(MatchesMimeType("video/*", "video/*"));
    186   EXPECT_FALSE(MatchesMimeType("video/*", "*/*"));
    187   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/*"));
    188   EXPECT_TRUE(MatchesMimeType("video/*;param=val", "video/*;param=val"));
    189   EXPECT_FALSE(MatchesMimeType("video/*;param=val", "video/*;param=val2"));
    190 
    191   EXPECT_TRUE(MatchesMimeType("ab*cd", "abxxxcd"));
    192   EXPECT_TRUE(MatchesMimeType("ab*cd", "abx/xcd"));
    193   EXPECT_TRUE(MatchesMimeType("ab/*cd", "ab/xxxcd"));
    194 }
    195 
    196 TEST(MimeUtilTest, CommonMediaMimeType) {
    197 #if defined(OS_ANDROID)
    198   bool HLSSupported;
    199   if (base::android::BuildInfo::GetInstance()->sdk_int() < 14)
    200     HLSSupported = false;
    201   else
    202     HLSSupported = true;
    203 #endif
    204 
    205   EXPECT_TRUE(IsSupportedMediaMimeType("audio/webm"));
    206   EXPECT_TRUE(IsSupportedMediaMimeType("video/webm"));
    207 
    208   EXPECT_TRUE(IsSupportedMediaMimeType("audio/wav"));
    209   EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-wav"));
    210 
    211   EXPECT_TRUE(IsSupportedMediaMimeType("audio/ogg"));
    212   EXPECT_TRUE(IsSupportedMediaMimeType("application/ogg"));
    213 #if defined(OS_ANDROID)
    214   EXPECT_FALSE(IsSupportedMediaMimeType("video/ogg"));
    215   EXPECT_EQ(HLSSupported, IsSupportedMediaMimeType("application/x-mpegurl"));
    216   EXPECT_EQ(HLSSupported,
    217             IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
    218 #else
    219   EXPECT_TRUE(IsSupportedMediaMimeType("video/ogg"));
    220   EXPECT_FALSE(IsSupportedMediaMimeType("application/x-mpegurl"));
    221   EXPECT_FALSE(IsSupportedMediaMimeType("application/vnd.apple.mpegurl"));
    222 #endif  // OS_ANDROID
    223 
    224 #if defined(USE_PROPRIETARY_CODECS)
    225   EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp4"));
    226   EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-m4a"));
    227   EXPECT_TRUE(IsSupportedMediaMimeType("video/mp4"));
    228   EXPECT_TRUE(IsSupportedMediaMimeType("video/x-m4v"));
    229 
    230   EXPECT_TRUE(IsSupportedMediaMimeType("audio/mp3"));
    231   EXPECT_TRUE(IsSupportedMediaMimeType("audio/x-mp3"));
    232   EXPECT_TRUE(IsSupportedMediaMimeType("audio/mpeg"));
    233 #else
    234   EXPECT_FALSE(IsSupportedMediaMimeType("audio/mp4"));
    235   EXPECT_FALSE(IsSupportedMediaMimeType("audio/x-m4a"));
    236   EXPECT_FALSE(IsSupportedMediaMimeType("video/mp4"));
    237   EXPECT_FALSE(IsSupportedMediaMimeType("video/x-m4v"));
    238 
    239   EXPECT_FALSE(IsSupportedMediaMimeType("audio/mp3"));
    240   EXPECT_FALSE(IsSupportedMediaMimeType("audio/x-mp3"));
    241   EXPECT_FALSE(IsSupportedMediaMimeType("audio/mpeg"));
    242 #endif  // USE_PROPRIETARY_CODECS
    243   EXPECT_FALSE(IsSupportedMediaMimeType("video/mp3"));
    244 
    245   EXPECT_FALSE(IsSupportedMediaMimeType("video/unknown"));
    246   EXPECT_FALSE(IsSupportedMediaMimeType("audio/unknown"));
    247   EXPECT_FALSE(IsSupportedMediaMimeType("unknown/unknown"));
    248 }
    249 
    250 // Note: codecs should only be a list of 2 or fewer; hence the restriction of
    251 // results' length to 2.
    252 TEST(MimeUtilTest, ParseCodecString) {
    253   const struct {
    254     const char* original;
    255     size_t expected_size;
    256     const char* results[2];
    257   } tests[] = {
    258     { "\"bogus\"",                  1, { "bogus" }            },
    259     { "0",                          1, { "0" }                },
    260     { "avc1.42E01E, mp4a.40.2",     2, { "avc1",   "mp4a" }   },
    261     { "\"mp4v.20.240, mp4a.40.2\"", 2, { "mp4v",   "mp4a" }   },
    262     { "mp4v.20.8, samr",            2, { "mp4v",   "samr" }   },
    263     { "\"theora, vorbis\"",         2, { "theora", "vorbis" } },
    264     { "",                           0, { }                    },
    265     { "\"\"",                       0, { }                    },
    266     { "\"   \"",                    0, { }                    },
    267     { ",",                          2, { "", "" }             },
    268   };
    269 
    270   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
    271     std::vector<std::string> codecs_out;
    272     ParseCodecString(tests[i].original, &codecs_out, true);
    273     ASSERT_EQ(tests[i].expected_size, codecs_out.size());
    274     for (size_t j = 0; j < tests[i].expected_size; ++j)
    275       EXPECT_EQ(tests[i].results[j], codecs_out[j]);
    276   }
    277 
    278   // Test without stripping the codec type.
    279   std::vector<std::string> codecs_out;
    280   ParseCodecString("avc1.42E01E, mp4a.40.2", &codecs_out, false);
    281   ASSERT_EQ(2u, codecs_out.size());
    282   EXPECT_EQ("avc1.42E01E", codecs_out[0]);
    283   EXPECT_EQ("mp4a.40.2", codecs_out[1]);
    284 }
    285 
    286 TEST(MimeUtilTest, TestParseMimeTypeWithoutParameter) {
    287   std::string nonAscii("application/nonutf8");
    288   EXPECT_TRUE(ParseMimeTypeWithoutParameter(nonAscii, NULL, NULL));
    289 #if defined(OS_WIN)
    290   nonAscii.append(base::WideToUTF8(std::wstring(L"\u2603")));
    291 #else
    292   nonAscii.append("\u2603");  // unicode snowman
    293 #endif
    294   EXPECT_FALSE(ParseMimeTypeWithoutParameter(nonAscii, NULL, NULL));
    295 
    296   std::string top_level_type;
    297   std::string subtype;
    298   EXPECT_TRUE(ParseMimeTypeWithoutParameter(
    299       "application/mime", &top_level_type, &subtype));
    300   EXPECT_EQ("application", top_level_type);
    301   EXPECT_EQ("mime", subtype);
    302 
    303   // Various allowed subtype forms.
    304   EXPECT_TRUE(ParseMimeTypeWithoutParameter("application/json", NULL, NULL));
    305   EXPECT_TRUE(ParseMimeTypeWithoutParameter(
    306       "application/x-suggestions+json", NULL, NULL));
    307   EXPECT_TRUE(ParseMimeTypeWithoutParameter("application/+json", NULL, NULL));
    308 
    309   // Upper case letters are allowed.
    310   EXPECT_TRUE(ParseMimeTypeWithoutParameter("text/mime", NULL, NULL));
    311   EXPECT_TRUE(ParseMimeTypeWithoutParameter("TEXT/mime", NULL, NULL));
    312   EXPECT_TRUE(ParseMimeTypeWithoutParameter("Text/mime", NULL, NULL));
    313   EXPECT_TRUE(ParseMimeTypeWithoutParameter("TeXt/mime", NULL, NULL));
    314 
    315   // Experimental types are also considered to be valid.
    316   EXPECT_TRUE(ParseMimeTypeWithoutParameter("x-video/mime", NULL, NULL));
    317   EXPECT_TRUE(ParseMimeTypeWithoutParameter("X-Video/mime", NULL, NULL));
    318 
    319   EXPECT_FALSE(ParseMimeTypeWithoutParameter("text", NULL, NULL));
    320   EXPECT_FALSE(ParseMimeTypeWithoutParameter("text/", NULL, NULL));
    321   EXPECT_FALSE(ParseMimeTypeWithoutParameter("text/ ", NULL, NULL));
    322   EXPECT_FALSE(ParseMimeTypeWithoutParameter("te(xt/ ", NULL, NULL));
    323   EXPECT_FALSE(ParseMimeTypeWithoutParameter("text/()plain", NULL, NULL));
    324 
    325   EXPECT_FALSE(ParseMimeTypeWithoutParameter("x-video", NULL, NULL));
    326   EXPECT_FALSE(ParseMimeTypeWithoutParameter("x-video/", NULL, NULL));
    327 
    328   EXPECT_FALSE(ParseMimeTypeWithoutParameter("application/a/b/c", NULL, NULL));
    329 
    330   //EXPECT_TRUE(ParseMimeTypeWithoutParameter("video/mime;parameter"));
    331 }
    332 
    333 TEST(MimeUtilTest, TestIsValidTopLevelMimeType) {
    334   EXPECT_TRUE(IsValidTopLevelMimeType("application"));
    335   EXPECT_TRUE(IsValidTopLevelMimeType("audio"));
    336   EXPECT_TRUE(IsValidTopLevelMimeType("example"));
    337   EXPECT_TRUE(IsValidTopLevelMimeType("image"));
    338   EXPECT_TRUE(IsValidTopLevelMimeType("message"));
    339   EXPECT_TRUE(IsValidTopLevelMimeType("model"));
    340   EXPECT_TRUE(IsValidTopLevelMimeType("multipart"));
    341   EXPECT_TRUE(IsValidTopLevelMimeType("text"));
    342   EXPECT_TRUE(IsValidTopLevelMimeType("video"));
    343 
    344   EXPECT_TRUE(IsValidTopLevelMimeType("TEXT"));
    345   EXPECT_TRUE(IsValidTopLevelMimeType("Text"));
    346   EXPECT_TRUE(IsValidTopLevelMimeType("TeXt"));
    347 
    348   EXPECT_FALSE(IsValidTopLevelMimeType("mime"));
    349   EXPECT_FALSE(IsValidTopLevelMimeType(""));
    350   EXPECT_FALSE(IsValidTopLevelMimeType("/"));
    351   EXPECT_FALSE(IsValidTopLevelMimeType(" "));
    352 
    353   EXPECT_TRUE(IsValidTopLevelMimeType("x-video"));
    354   EXPECT_TRUE(IsValidTopLevelMimeType("X-video"));
    355 
    356   EXPECT_FALSE(IsValidTopLevelMimeType("x-"));
    357 }
    358 
    359 TEST(MimeUtilTest, TestToIANAMediaType) {
    360   EXPECT_EQ("", GetIANAMediaType("texting/driving"));
    361   EXPECT_EQ("", GetIANAMediaType("ham/sandwich"));
    362   EXPECT_EQ("", GetIANAMediaType(std::string()));
    363   EXPECT_EQ("", GetIANAMediaType("/application/hamsandwich"));
    364 
    365   EXPECT_EQ("application", GetIANAMediaType("application/poodle-wrestler"));
    366   EXPECT_EQ("audio", GetIANAMediaType("audio/mpeg"));
    367   EXPECT_EQ("example", GetIANAMediaType("example/yomomma"));
    368   EXPECT_EQ("image", GetIANAMediaType("image/png"));
    369   EXPECT_EQ("message", GetIANAMediaType("message/sipfrag"));
    370   EXPECT_EQ("model", GetIANAMediaType("model/vrml"));
    371   EXPECT_EQ("multipart", GetIANAMediaType("multipart/mixed"));
    372   EXPECT_EQ("text", GetIANAMediaType("text/plain"));
    373   EXPECT_EQ("video", GetIANAMediaType("video/H261"));
    374 }
    375 
    376 TEST(MimeUtilTest, TestGetExtensionsForMimeType) {
    377   const struct {
    378     const char* mime_type;
    379     size_t min_expected_size;
    380     const char* contained_result;
    381   } tests[] = {
    382     { "text/plain", 2, "txt" },
    383     { "*",          0, NULL  },
    384     { "message/*",  1, "eml" },
    385     { "MeSsAge/*",  1, "eml" },
    386     { "image/bmp",  1, "bmp" },
    387     { "video/*",    6, "mp4" },
    388 #if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_IOS)
    389     { "video/*",    6, "mpg" },
    390 #else
    391     { "video/*",    6, "mpeg" },
    392 #endif
    393     { "audio/*",    6, "oga" },
    394     { "aUDIo/*",    6, "wav" },
    395   };
    396 
    397   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
    398     std::vector<base::FilePath::StringType> extensions;
    399     GetExtensionsForMimeType(tests[i].mime_type, &extensions);
    400     ASSERT_TRUE(tests[i].min_expected_size <= extensions.size());
    401 
    402     if (!tests[i].contained_result)
    403       continue;
    404 
    405     bool found = false;
    406     for (size_t j = 0; !found && j < extensions.size(); ++j) {
    407 #if defined(OS_WIN)
    408       if (extensions[j] == base::UTF8ToWide(tests[i].contained_result))
    409         found = true;
    410 #else
    411       if (extensions[j] == tests[i].contained_result)
    412         found = true;
    413 #endif
    414     }
    415     ASSERT_TRUE(found) << "Must find at least the contained result within "
    416                        << tests[i].mime_type;
    417   }
    418 }
    419 
    420 TEST(MimeUtilTest, TestGetCertificateMimeTypeForMimeType) {
    421   EXPECT_EQ(CERTIFICATE_MIME_TYPE_X509_USER_CERT,
    422             GetCertificateMimeTypeForMimeType("application/x-x509-user-cert"));
    423 #if defined(OS_ANDROID)
    424   // Only Android supports CA Certs and PKCS12 archives.
    425   EXPECT_EQ(CERTIFICATE_MIME_TYPE_X509_CA_CERT,
    426             GetCertificateMimeTypeForMimeType("application/x-x509-ca-cert"));
    427   EXPECT_EQ(CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE,
    428             GetCertificateMimeTypeForMimeType("application/x-pkcs12"));
    429 #else
    430   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
    431             GetCertificateMimeTypeForMimeType("application/x-x509-ca-cert"));
    432   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
    433             GetCertificateMimeTypeForMimeType("application/x-pkcs12"));
    434 #endif
    435   EXPECT_EQ(CERTIFICATE_MIME_TYPE_UNKNOWN,
    436             GetCertificateMimeTypeForMimeType("text/plain"));
    437 }
    438 
    439 TEST(MimeUtilTest, TestAddMultipartValueForUpload) {
    440   const char* ref_output = "--boundary\r\nContent-Disposition: form-data;"
    441                            " name=\"value name\"\r\nContent-Type: content type"
    442                            "\r\n\r\nvalue\r\n"
    443                            "--boundary\r\nContent-Disposition: form-data;"
    444                            " name=\"value name\"\r\n\r\nvalue\r\n"
    445                            "--boundary--\r\n";
    446   std::string post_data;
    447   AddMultipartValueForUpload("value name", "value", "boundary",
    448                              "content type", &post_data);
    449   AddMultipartValueForUpload("value name", "value", "boundary",
    450                              "", &post_data);
    451   AddMultipartFinalDelimiterForUpload("boundary", &post_data);
    452   EXPECT_STREQ(ref_output, post_data.c_str());
    453 }
    454 
    455 }  // namespace net
    456