Mime sniffer: reduce table from 256 bytes to 4

net/base/mime_sniffer_unittest.cc

 // 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 "base/basictypes.h"
 #include "net/base/mime_sniffer.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.
 
 struct SnifferTest {
   const char* content;
   size_t content_len;
   std::string url;
   std::string type_hint;
   const char* mime_type;
 };
 
 static void TestArray(SnifferTest* tests, size_t count) {
@@ skipping 456 matching lines @@
 
   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),
                                          &mime_type));
   EXPECT_EQ("audio/mpeg", 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(ContainsControlCodes(&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(ContainsControlCodes(&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(ContainsControlCodes(param, strlen(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