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