blob: 89970fb093f9f09e488af5d66d1ee57e0d2ce81d [file] [log] [blame]
// Copyright (c) 2011 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 "net/base/mime_sniffer.h"
#include "starboard/common/string.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
namespace net {
namespace {
using ::testing::Range;
using ::testing::Values;
using ::net::SniffMimeType; // It is shadowed by SniffMimeType(), below.
// Turn |str|, a constant string with one or more embedded NULs, along with
// a NUL terminator, into an std::string() containing just that data.
// Turn |str|, a string with one or more embedded NULs, into an std::string()
template <size_t N>
std::string MakeConstantString(const char (&str)[N]) {
return std::string(str, N - 1);
}
static std::string SniffMimeType(const std::string& content,
const std::string& url,
const std::string& mime_type_hint) {
std::string mime_type;
SniffMimeType(content.data(), content.size(), GURL(url), mime_type_hint,
ForceSniffFileUrlsForHtml::kDisabled, &mime_type);
return mime_type;
}
TEST(MimeSnifferTest, BoundaryConditionsTest) {
std::string mime_type;
std::string type_hint;
char buf[] = {
'd', '\x1f', '\xFF'
};
GURL url;
SniffMimeType(buf, 0, url, type_hint, ForceSniffFileUrlsForHtml::kDisabled,
&mime_type);
EXPECT_EQ("text/plain", mime_type);
SniffMimeType(buf, 1, url, type_hint, ForceSniffFileUrlsForHtml::kDisabled,
&mime_type);
EXPECT_EQ("text/plain", mime_type);
SniffMimeType(buf, 2, url, type_hint, ForceSniffFileUrlsForHtml::kDisabled,
&mime_type);
EXPECT_EQ("application/octet-stream", mime_type);
}
TEST(MimeSnifferTest, BasicSniffingTest) {
EXPECT_EQ("text/html",
SniffMimeType(MakeConstantString("<!DOCTYPE html PUBLIC"),
"http://www.example.com/", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("<HtMl><Body></body></htMl>"),
"http://www.example.com/foo.gif",
"application/octet-stream"));
EXPECT_EQ("image/gif",
SniffMimeType(MakeConstantString("GIF89a\x1F\x83\x94"),
"http://www.example.com/foo", "text/plain"));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Gif87a\x1F\x83\x94"),
"http://www.example.com/foo?param=tt.gif", ""));
EXPECT_EQ("text/plain",
SniffMimeType(MakeConstantString("%!PS-Adobe-3.0"),
"http://www.example.com/foo", "text/plain"));
EXPECT_EQ(
"application/octet-stream",
SniffMimeType(MakeConstantString("\x89"
"PNG\x0D\x0A\x1A\x0A"),
"http://www.example.com/foo", "application/octet-stream"));
EXPECT_EQ("image/jpeg",
SniffMimeType(MakeConstantString("\xFF\xD8\xFF\x23\x49\xAF"),
"http://www.example.com/foo", ""));
}
TEST(MimeSnifferTest, ChromeExtensionsTest) {
// schemes
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx", ""));
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"https://www.example.com/foo.crx", ""));
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"ftp://www.example.com/foo.crx", ""));
// some other mimetypes that should get converted
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx", "text/plain"));
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx",
"application/octet-stream"));
// success edge cases
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx?query=string", ""));
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo..crx", ""));
EXPECT_EQ("application/x-chrome-extension",
SniffMimeType(MakeConstantString("Cr24\x03\x00\x00\x00"),
"http://www.example.com/foo..crx", ""));
// wrong file extension
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.bin", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.bin?monkey", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"invalid-url", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foocrx", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx.blech", ""));
// wrong magic
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Cr24\x02\x00\x00\x01"),
"http://www.example.com/foo.crx?monkey", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("PADDING_Cr24\x02\x00\x00\x00"),
"http://www.example.com/foo.crx?monkey", ""));
}
TEST(MimeSnifferTest, MozillaCompatibleTest) {
EXPECT_EQ("text/html", SniffMimeType(MakeConstantString(" \n <hTmL>\n <hea"),
"http://www.example.com/", ""));
EXPECT_EQ("text/plain",
SniffMimeType(MakeConstantString(" \n <hTmL>\n <hea"),
"http://www.example.com/", "text/plain"));
EXPECT_EQ("image/bmp", SniffMimeType(MakeConstantString("BMjlakdsfk"),
"http://www.example.com/foo", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("\x00\x00\x30\x00"),
"http://www.example.com/favicon.ico", ""));
EXPECT_EQ("text/plain", SniffMimeType(MakeConstantString("#!/bin/sh\nls /\n"),
"http://www.example.com/foo", ""));
EXPECT_EQ("text/plain",
SniffMimeType(MakeConstantString("From: Fred\nTo: Bob\n\nHi\n.\n"),
"http://www.example.com/foo", ""));
EXPECT_EQ("text/xml",
SniffMimeType(MakeConstantString(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"),
"http://www.example.com/foo", ""));
EXPECT_EQ(
"application/octet-stream",
SniffMimeType(
MakeConstantString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"),
"http://www.example.com/foo", "application/octet-stream"));
}
TEST(MimeSnifferTest, DontAllowPrivilegeEscalationTest) {
EXPECT_EQ(
"image/gif",
SniffMimeType(MakeConstantString("GIF87a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo", ""));
EXPECT_EQ(
"image/gif",
SniffMimeType(MakeConstantString("GIF87a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo?q=ttt.html", ""));
EXPECT_EQ(
"image/gif",
SniffMimeType(MakeConstantString("GIF87a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo#ttt.html", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString("a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString("a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo?q=ttt.html", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString("a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo#ttt.html", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString("a\n<html>\n<body>"
"<script>alert('haxorzed');\n</script>"
"</body></html>\n"),
"http://www.example.com/foo.html", ""));
}
TEST(MimeSnifferTest, SniffFilesAsHtml) {
const std::string kContent = "<html><body>text</body></html>";
const GURL kUrl("file:///C/test.unusualextension");
std::string mime_type;
SniffMimeType(kContent.c_str(), kContent.length(), kUrl, "" /* type_hint */,
ForceSniffFileUrlsForHtml::kDisabled, &mime_type);
EXPECT_EQ("text/plain", mime_type);
SniffMimeType(kContent.c_str(), kContent.length(), kUrl, "" /* type_hint */,
ForceSniffFileUrlsForHtml::kEnabled, &mime_type);
EXPECT_EQ("text/html", mime_type);
}
TEST(MimeSnifferTest, UnicodeTest) {
EXPECT_EQ("text/plain", SniffMimeType(MakeConstantString("\xEF\xBB\xBF"
"Hi there"),
"http://www.example.com/foo", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString("\xEF\xBB\xBF\xED\x7A\xAD\x7A\x0D\x79"),
"http://www.example.com/foo", ""));
EXPECT_EQ(
"text/plain",
SniffMimeType(MakeConstantString(
"\xFE\xFF\xD0\xA5\xD0\xBE\xD0\xBB\xD1\x83\xD0\xB9"),
"http://www.example.com/foo", ""));
EXPECT_EQ("text/plain",
SniffMimeType(
MakeConstantString(
"\xFE\xFF\x00\x41\x00\x20\xD8\x00\xDC\x00\xD8\x00\xDC\x01"),
"http://www.example.com/foo", ""));
}
TEST(MimeSnifferTest, FlashTest) {
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("CWSdd\x00\xB3"),
"http://www.example.com/foo", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("FLVjdkl*(#)0sdj\x00"),
"http://www.example.com/foo?q=ttt.swf", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("FWS3$9\r\b\x00"),
"http://www.example.com/foo#ttt.swf", ""));
EXPECT_EQ("text/plain", SniffMimeType(MakeConstantString("FLVjdkl*(#)0sdj"),
"http://www.example.com/foo.swf", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("FLVjdkl*(#)0s\x01dj"),
"http://www.example.com/foo/bar.swf", ""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("FWS3$9\r\b\x1A"),
"http://www.example.com/foo.swf?clickTAG=http://"
"www.adnetwork.com/bar",
""));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("FWS3$9\r\x1C\b"),
"http://www.example.com/foo.swf?clickTAG=http://"
"www.adnetwork.com/bar",
"text/plain"));
}
TEST(MimeSnifferTest, XMLTest) {
// An easy feed to identify.
EXPECT_EQ("application/atom+xml",
SniffMimeType("<?xml?><feed", "", "text/xml"));
// Don't sniff out of plain text.
EXPECT_EQ("text/plain", SniffMimeType("<?xml?><feed", "", "text/plain"));
// Simple RSS.
EXPECT_EQ("application/rss+xml",
SniffMimeType("<?xml version='1.0'?>\r\n<rss", "", "text/xml"));
// The top of CNN's RSS feed, which we'd like to recognize as RSS.
static const char kCNNRSS[] =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<?xml-stylesheet href=\"http://rss.cnn.com/~d/styles/rss2full.xsl\" "
"type=\"text/xsl\" media=\"screen\"?>"
"<?xml-stylesheet href=\"http://rss.cnn.com/~d/styles/itemcontent.css\" "
"type=\"text/css\" media=\"screen\"?>"
"<rss xmlns:feedburner=\"http://rssnamespace.org/feedburner/ext/1.0\" "
"version=\"2.0\">";
// CNN's RSS
EXPECT_EQ("application/rss+xml", SniffMimeType(kCNNRSS, "", "text/xml"));
EXPECT_EQ("text/plain", SniffMimeType(kCNNRSS, "", "text/plain"));
// Don't sniff random XML as something different.
EXPECT_EQ("text/xml", SniffMimeType("<?xml?><notafeed", "", "text/xml"));
// Don't sniff random plain-text as something different.
EXPECT_EQ("text/plain", SniffMimeType("<?xml?><notafeed", "", "text/plain"));
// We never upgrade to application/xhtml+xml.
EXPECT_EQ("text/xml",
SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", "",
"text/xml"));
EXPECT_EQ("application/xml",
SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", "",
"application/xml"));
EXPECT_EQ("text/plain",
SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", "",
"text/plain"));
EXPECT_EQ("application/rss+xml",
SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", "",
"application/rss+xml"));
EXPECT_EQ("text/xml", SniffMimeType("<html><head>", "", "text/xml"));
EXPECT_EQ("text/xml",
SniffMimeType("<foo><rss "
"xmlns:feedburner=\"http://rssnamespace.org/"
"feedburner/ext/1.0\" version=\"2.0\">",
"", "text/xml"));
}
// Test content which is >= 1024 bytes, and includes no open angle bracket.
// http://code.google.com/p/chromium/issues/detail?id=3521
TEST(MimeSnifferTest, XMLTestLargeNoAngledBracket) {
// Make a large input, with 1024 bytes of "x".
std::string content;
content.resize(1024);
std::fill(content.begin(), content.end(), 'x');
// content.size() >= 1024 so the sniff is unambiguous.
std::string mime_type;
EXPECT_TRUE(SniffMimeType(content.data(), content.size(), GURL(), "text/xml",
ForceSniffFileUrlsForHtml::kDisabled, &mime_type));
EXPECT_EQ("text/xml", mime_type);
}
// Test content which is >= 1024 bytes, and includes a binary looking byte.
// http://code.google.com/p/chromium/issues/detail?id=15314
TEST(MimeSnifferTest, LooksBinary) {
// Make a large input, with 1024 bytes of "x" and 1 byte of 0x01.
std::string content;
content.resize(1024);
std::fill(content.begin(), content.end(), 'x');
content[1000] = 0x01;
// content.size() >= 1024 so the sniff is unambiguous.
std::string mime_type;
EXPECT_TRUE(SniffMimeType(content.data(), content.size(), GURL(),
"text/plain", ForceSniffFileUrlsForHtml::kDisabled,
&mime_type));
EXPECT_EQ("application/octet-stream", mime_type);
}
TEST(MimeSnifferTest, OfficeTest) {
// Check for URLs incorrectly reported as Microsoft Office files.
EXPECT_EQ(
"application/octet-stream",
SniffMimeType(MakeConstantString("Hi there"),
"http://www.example.com/foo.doc", "application/msword"));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Hi there"),
"http://www.example.com/foo.xls",
"application/vnd.ms-excel"));
EXPECT_EQ("application/octet-stream",
SniffMimeType(MakeConstantString("Hi there"),
"http://www.example.com/foo.ppt",
"application/vnd.ms-powerpoint"));
// Check for Microsoft Office files incorrectly reported as text.
EXPECT_EQ(
"application/msword",
SniffMimeType(MakeConstantString("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
"Hi there"),
"http://www.example.com/foo.doc", "text/plain"));
EXPECT_EQ(
"application/vnd.openxmlformats-officedocument."
"wordprocessingml.document",
SniffMimeType(MakeConstantString(
"PK\x03\x04"
"Hi there"),
"http://www.example.com/foo.doc", "text/plain"));
EXPECT_EQ(
"application/vnd.ms-excel",
SniffMimeType(MakeConstantString("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
"Hi there"),
"http://www.example.com/foo.xls", "text/plain"));
EXPECT_EQ(
"application/vnd.openxmlformats-officedocument."
"spreadsheetml.sheet",
SniffMimeType(MakeConstantString("PK\x03\x04"
"Hi there"),
"http://www.example.com/foo.xls", "text/plain"));
EXPECT_EQ(
"application/vnd.ms-powerpoint",
SniffMimeType(MakeConstantString("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1"
"Hi there"),
"http://www.example.com/foo.ppt", "text/plain"));
EXPECT_EQ(
"application/vnd.openxmlformats-officedocument."
"presentationml.presentation",
SniffMimeType(MakeConstantString("PK\x03\x04"
"Hi there"),
"http://www.example.com/foo.ppt", "text/plain"));
}
// TODO(thestig) Add more tests for other AV formats. Add another test case for
// RAW images.
TEST(MimeSnifferTest, AudioVideoTest) {
std::string mime_type;
const char kOggTestData[] = "OggS\x00";
EXPECT_TRUE(SniffMimeTypeFromLocalData(kOggTestData, sizeof(kOggTestData) - 1,
&mime_type));
EXPECT_EQ("audio/ogg", mime_type);
mime_type.clear();
// Check ogg header requires the terminal '\0' to be sniffed.
EXPECT_FALSE(SniffMimeTypeFromLocalData(
kOggTestData, sizeof(kOggTestData) - 2, &mime_type));
EXPECT_EQ("", mime_type);
mime_type.clear();
const char kFlacTestData[] =
"fLaC\x00\x00\x00\x22\x12\x00\x12\x00\x00\x00\x00\x00";
EXPECT_TRUE(SniffMimeTypeFromLocalData(
kFlacTestData, sizeof(kFlacTestData) - 1, &mime_type));
EXPECT_EQ("audio/x-flac", mime_type);
mime_type.clear();
const char kWMATestData[] =
"\x30\x26\xb2\x75\x8e\x66\xcf\x11\xa6\xd9\x00\xaa\x00\x62\xce\x6c";
EXPECT_TRUE(SniffMimeTypeFromLocalData(kWMATestData, sizeof(kWMATestData) - 1,
&mime_type));
EXPECT_EQ("video/x-ms-asf", mime_type);
mime_type.clear();
// mp4a, m4b, m4p, and alac extension files which share the same container
// format.
const char kMP4TestData[] =
"\x00\x00\x00\x20\x66\x74\x79\x70\x4d\x34\x41\x20\x00\x00\x00\x00";
EXPECT_TRUE(SniffMimeTypeFromLocalData(kMP4TestData, sizeof(kMP4TestData) - 1,
&mime_type));
EXPECT_EQ("video/mp4", mime_type);
mime_type.clear();
const char kAACTestData[] =
"\xff\xf1\x50\x80\x02\x20\xb0\x23\x0a\x83\x20\x7d\x61\x90\x3e\xb1";
EXPECT_TRUE(SniffMimeTypeFromLocalData(kAACTestData, sizeof(kAACTestData) - 1,
&mime_type));
EXPECT_EQ("audio/mpeg", mime_type);
mime_type.clear();
}
TEST(MimeSnifferTest, ImageTest) {
std::string mime_type;
const char kWebPSimpleFormat[] = "RIFF\xee\x81\x00\x00WEBPVP8 ";
EXPECT_TRUE(SniffMimeTypeFromLocalData(
kWebPSimpleFormat, sizeof(kWebPSimpleFormat) - 1, &mime_type));
EXPECT_EQ("image/webp", mime_type);
mime_type.clear();
const char kWebPLosslessFormat[] = "RIFF\xee\x81\x00\x00WEBPVP8L";
EXPECT_TRUE(SniffMimeTypeFromLocalData(
kWebPLosslessFormat, sizeof(kWebPLosslessFormat) - 1, &mime_type));
EXPECT_EQ("image/webp", mime_type);
mime_type.clear();
const char kWebPExtendedFormat[] = "RIFF\xee\x81\x00\x00WEBPVP8X";
EXPECT_TRUE(SniffMimeTypeFromLocalData(
kWebPExtendedFormat, sizeof(kWebPExtendedFormat) - 1, &mime_type));
EXPECT_EQ("image/webp", mime_type);
mime_type.clear();
}
// The tests need char parameters, but the ranges to test include 0xFF, and some
// platforms have signed chars and are noisy about it. Using an int parameter
// and casting it to char inside the test case solves both these problems.
class MimeSnifferBinaryTest : public ::testing::TestWithParam<int> {};
// From https://mimesniff.spec.whatwg.org/#binary-data-byte :
// A binary data byte is a byte in the range 0x00 to 0x08 (NUL to BS), the byte
// 0x0B (VT), a byte in the range 0x0E to 0x1A (SO to SUB), or a byte in the
// range 0x1C to 0x1F (FS to US).
TEST_P(MimeSnifferBinaryTest, IsBinaryControlCode) {
char param = static_cast<char>(GetParam());
EXPECT_TRUE(LooksLikeBinary(&param, 1));
}
// ::testing::Range(a, b) tests an open-ended range, ie. "b" is not included.
INSTANTIATE_TEST_CASE_P(MimeSnifferBinaryTestRange1,
MimeSnifferBinaryTest,
Range(0x00, 0x09));
INSTANTIATE_TEST_CASE_P(MimeSnifferBinaryTestByte0x0B,
MimeSnifferBinaryTest,
Values(0x0B));
INSTANTIATE_TEST_CASE_P(MimeSnifferBinaryTestRange2,
MimeSnifferBinaryTest,
Range(0x0E, 0x1B));
INSTANTIATE_TEST_CASE_P(MimeSnifferBinaryTestRange3,
MimeSnifferBinaryTest,
Range(0x1C, 0x20));
class MimeSnifferPlainTextTest : public ::testing::TestWithParam<int> {};
TEST_P(MimeSnifferPlainTextTest, NotBinaryControlCode) {
char param = static_cast<char>(GetParam());
EXPECT_FALSE(LooksLikeBinary(&param, 1));
}
INSTANTIATE_TEST_CASE_P(MimeSnifferPlainTextTestPlainTextControlCodes,
MimeSnifferPlainTextTest,
Values(0x09, 0x0A, 0x0C, 0x0D, 0x1B));
INSTANTIATE_TEST_CASE_P(MimeSnifferPlainTextTestNotControlCodeRange,
MimeSnifferPlainTextTest,
Range(0x20, 0x100));
class MimeSnifferControlCodesEdgeCaseTest
: public ::testing::TestWithParam<const char*> {};
TEST_P(MimeSnifferControlCodesEdgeCaseTest, EdgeCase) {
const char* param = GetParam();
EXPECT_TRUE(LooksLikeBinary(param, SbStringGetLength(param)));
}
INSTANTIATE_TEST_CASE_P(MimeSnifferControlCodesEdgeCaseTest,
MimeSnifferControlCodesEdgeCaseTest,
Values("\x01__", // first byte is binary
"__\x03", // last byte is binary
"_\x02_" // a byte in the middle is binary
));
} // namespace
} // namespace net