Add gtest wrapper for djpeg tests

Add gtests to test JPEG decompression code paths.

Bug: 993876
Change-Id: I8ff99a8e4f81cacb80cdcaff5bcab318eabc96cd

3 files changed, 942 insertions, 2 deletions

diff --git a/BUILD.gn b/BUILD.gn
index cf0b000..1ef1efc 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -326,15 +326,18 @@ test("libjpeg_turbo_unittests") {
     "cdjpeg.c",
     "cjpeg-gtest-wrapper.cpp",
     "cjpeg.c",
+    "djpeg-gtest-wrapper.cpp",
+    "djpeg.c",
     "jpegtran-gtest-wrapper.cpp",
     "jpegtran.c",
+    "md5/md5.c",
+    "md5/md5hl.c",
     "tjbench-gtest-wrapper.cpp",
     "tjbench.c",
     "tjunittest-gtest-wrapper.cpp",
     "tjunittest.c",
     "tjutil.c",
-    "md5/md5.c",
-    "md5/md5hl.c",
+    "rdcolmap.c",
     "rdgif.c",
     "rdswitch.c",
   ]
@@ -352,6 +355,7 @@ test("libjpeg_turbo_unittests") {
 
   defines = [
     "GTEST",
+    "BMP_SUPPORTED",
     "PPM_SUPPORTED",
   ]
 
diff --git a/README.chromium b/README.chromium
index 1a3fe63..1831dae 100644
--- a/README.chromium
+++ b/README.chromium
@@ -86,6 +86,7 @@ following changes which are not merged to upstream:
   - Add input JPEG images for djpeg and jpegtran tests
   - Add gtest wrapper for jpegtran tests
   - Refactor djpeg.c to provide test interface
+  - Add gtest wrapper for djpeg tests
 
 Refer to working-with-nested-repos [1] for details of how to setup your git
 svn client to update the code (for making local changes, cherry picking from
diff --git a/djpeg-gtest-wrapper.cpp b/djpeg-gtest-wrapper.cpp
new file mode 100644
index 0000000..9e14f0f
--- /dev/null
+++ b/djpeg-gtest-wrapper.cpp
@@ -0,0 +1,935 @@
+/*
+ * Copyright 2020 The Chromium Authors. All Rights Reserved.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+#include "base/files/file.h"
+#include "base/files/file_util.h"
+#include "base/hash/md5.h"
+#include "base/path_service.h"
+
+#include <gtest/gtest.h>
+#include <string>
+
+extern "C" int djpeg(int argc, char *argv[]);
+
+static std::string GetTargetDirectory() {
+#if defined(ANDROID)
+  return "/sdcard";
+#else
+  base::FilePath path;
+  base::PathService::Get(base::DIR_CURRENT, &path);
+  return path.MaybeAsASCII();
+#endif
+}
+
+static void GetTestFilePath(base::FilePath* path, std::string filename) {
+  ASSERT_TRUE(base::PathService::Get(base::DIR_SOURCE_ROOT, path));
+  *path = path->AppendASCII("third_party");
+  *path = path->AppendASCII("libjpeg_turbo");
+  *path = path->AppendASCII("testimages");
+  *path = path->AppendASCII(filename);
+  ASSERT_TRUE(base::PathExists(*path));
+}
+
+static bool CompareFileAndMD5(const base::FilePath& path,
+                              const std::string expected_md5) {
+  // Read the output file and compute the MD5.
+  std::string output;
+  if (!base::ReadFileToString(path, &output)) {
+    return false;
+  }
+  const std::string md5 = base::MD5String(output);
+  return expected_md5 == md5;
+}
+
+const static std::vector<std::tuple<const std::string,
+                                    const std::string,
+                                    const std::string>> SCALE_IMAGE_MD5 = {
+  std::make_tuple("2/1", "testout_420m_islow_2_1.ppm",
+                  "9f9de8c0612f8d06869b960b05abf9c9"),
+  std::make_tuple("15/8", "testout_420m_islow_15_8.ppm",
+                  "b6875bc070720b899566cc06459b63b7"),
+  std::make_tuple("13/8", "testout_420m_islow_13_8.ppm",
+                  "bc3452573c8152f6ae552939ee19f82f"),
+  std::make_tuple("11/8", "testout_420m_islow_11_8.ppm",
+                  "d8cc73c0aaacd4556569b59437ba00a5"),
+  std::make_tuple("9/8", "testout_420m_islow_9_8.ppm",
+                  "d25e61bc7eac0002f5b393aa223747b6"),
+  std::make_tuple("7/8", "testout_420m_islow_7_8.ppm",
+                  "ddb564b7c74a09494016d6cd7502a946"),
+  std::make_tuple("3/4", "testout_420m_islow_3_4.ppm",
+                  "8ed8e68808c3fbc4ea764fc9d2968646"),
+  std::make_tuple("5/8", "testout_420m_islow_5_8.ppm",
+                  "a3363274999da2366a024efae6d16c9b"),
+  std::make_tuple("1/2", "testout_420m_islow_1_2.ppm",
+                  "e692a315cea26b988c8e8b29a5dbcd81"),
+  std::make_tuple("3/8", "testout_420m_islow_3_8.ppm",
+                  "79eca9175652ced755155c90e785a996"),
+  std::make_tuple("1/4", "testout_420m_islow_1_4.ppm",
+                  "79cd778f8bf1a117690052cacdd54eca"),
+  std::make_tuple("1/8", "testout_420m_islow_1_8.ppm",
+                  "391b3d4aca640c8567d6f8745eb2142f")
+};
+
+class DJPEGTestScalingDCT : public
+  ::testing::TestWithParam<std::tuple<const std::string,
+                                      const std::string,
+                                      const std::string>> {};
+
+TEST_P(DJPEGTestScalingDCT, Test) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(std::get<1>(GetParam()));
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-scale";
+  std::string arg4 = std::get<0>(GetParam());
+  std::string arg5 = "-nosmooth";
+  std::string arg6 = "-ppm";
+  std::string arg7 = "-outfile";
+  std::string arg8 = output_path.MaybeAsASCII();
+  std::string arg9 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(10, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  EXPECT_TRUE(CompareFileAndMD5(output_path, std::get<2>(GetParam())));
+}
+
+INSTANTIATE_TEST_SUITE_P(TestScalingDCT,
+                         DJPEGTestScalingDCT,
+                         ::testing::ValuesIn(SCALE_IMAGE_MD5));
+
+TEST(DJPEGTest, ISlow420256) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420_islow_256.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-colors";
+  std::string arg4 = "256";
+  std::string arg5 = "-bmp";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "4980185e3776e89bd931736e1cddeee6";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420565) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420_islow_565.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-dither";
+  std::string arg5 = "none";
+  std::string arg6 = "-bmp";
+  std::string arg7 = "-outfile";
+  std::string arg8 = output_path.MaybeAsASCII();
+  std::string arg9 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(10, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "bf9d13e16c4923b92e1faa604d7922cb";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420565D) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420_islow_565D.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-bmp";
+  std::string arg5 = "-outfile";
+  std::string arg6 = output_path.MaybeAsASCII();
+  std::string arg7 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(8, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "6bde71526acc44bcff76f696df8638d2";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420M565) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420m_islow_565.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-rgb565";
+  std::string arg5 = "-dither";
+  std::string arg6 = "none";
+  std::string arg7 = "-bmp";
+  std::string arg8 = "-outfile";
+  std::string arg9 = output_path.MaybeAsASCII();
+  std::string arg10 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0], &arg10[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(11, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "8dc0185245353cfa32ad97027342216f";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420M565D) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420m_islow_565D.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-rgb565";
+  std::string arg5 = "-bmp";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "ce034037d212bc403330df6f915c161b";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420Skip1531) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testorig.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420_islow_skip15_31.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-skip";
+  std::string arg4 = "15,31";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "c4c65c1e43d7275cd50328a61e6534f0";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+#ifdef C_ARITH_CODING_SUPPORTED
+TEST(DJPEGTest, ISlow420AriSkip16139) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testimgari.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(
+                              "testout_420_islow_ari_skip16_139.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-skip";
+  std::string arg4 = "16,139";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "087c6b123db16ac00cb88c5b590bb74a";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow420AriCrop53x5344) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testimgari.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(
+                              "testout_420_islow_ari_crop53x53_4_4.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-crop";
+  std::string arg4 = "53x53+4+4";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "886c6775af22370257122f8b16207e6d";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFast420MAri) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testimgari.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420m_ifast_ari.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-fast";
+  std::string arg2 = "-ppm";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "72b59a99bcf1de24c5b27d151bde2437";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow444AriCrop37x3700) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_444_islow_ari.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(
+                              "testout_444_islow_ari_crop37x37_0_0.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-crop";
+  std::string arg4 = "37x37+0+0";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "cb57b32bd6d03e35432362f7bf184b6d";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+#endif
+
+TEST(DJPEGTest, RGBISlow) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_rgb_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_rgb_islow.ppm");
+  base::FilePath output_icc_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_icc_path = output_icc_path.AppendASCII("testout_rgb_islow.icc");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-ppm";
+  std::string arg4 = "-icc";
+  std::string arg5 = output_icc_path.MaybeAsASCII();
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "00a257f5393fef8821f2b88ac7421291";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+  const std::string ICC_EXPECTED_MD5 = "b06a39d730129122e85c1363ed1bbc9e";
+  EXPECT_TRUE(CompareFileAndMD5(output_icc_path, ICC_EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, RGBISlow565) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_rgb_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_rgb_islow_565.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-dither";
+  std::string arg5 = "none";
+  std::string arg6 = "-bmp";
+  std::string arg7 = "-outfile";
+  std::string arg8 = output_path.MaybeAsASCII();
+  std::string arg9 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(10, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "f07d2e75073e4bb10f6c6f4d36e2e3be";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, RGBISlow565D) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_rgb_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_rgb_islow_565D.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-bmp";
+  std::string arg5 = "-outfile";
+  std::string arg6 = output_path.MaybeAsASCII();
+  std::string arg7 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(8, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "4cfa0928ef3e6bb626d7728c924cfda4";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFast422) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_422_ifast_opt.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_422_ifast.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "fast";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "35bd6b3f833bad23de82acea847129fa";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFast422M) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_422_ifast_opt.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_422m_ifast.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "fast";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-outfile";
+  std::string arg5 = output_path.MaybeAsASCII();
+  std::string arg6 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(7, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "8dbc65323d62cca7c91ba02dd1cfa81d";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFast422M565) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_422_ifast_opt.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_422m_ifast_565.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-rgb565";
+  std::string arg5 = "-dither";
+  std::string arg6 = "none";
+  std::string arg7 = "-bmp";
+  std::string arg8 = "-outfile";
+  std::string arg9 = output_path.MaybeAsASCII();
+  std::string arg10 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0], &arg10[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(11, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "3294bd4d9a1f2b3d08ea6020d0db7065";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFast422M565D) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_422_ifast_opt.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_422m_ifast_565D.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-rgb565";
+  std::string arg5 = "-bmp";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "da98c9c7b6039511be4a79a878a9abc1";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFastProg420Q100) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_420_q100_ifast_prog.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420_q100_ifast.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "fast";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "5a732542015c278ff43635e473a8a294";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFastProg420MQ100) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_420_q100_ifast_prog.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_420m_q100_ifast.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "fast";
+  std::string arg3 = "-nosmooth";
+  std::string arg4 = "-outfile";
+  std::string arg5 = output_path.MaybeAsASCII();
+  std::string arg6 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(7, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "ff692ee9323a3b424894862557c092f1";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, GrayISlow) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_gray_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_gray_islow.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "8d3596c56eace32f205deccc229aa5ed";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, GrayISlowRGB) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_gray_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_gray_islow_rgb.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb";
+  std::string arg4 = "-outfile";
+  std::string arg5 = output_path.MaybeAsASCII();
+  std::string arg6 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(7, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "116424ac07b79e5e801f00508eab48ec";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, GrayISlow565) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_gray_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_gray_islow_565.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-dither";
+  std::string arg5 = "none";
+  std::string arg6 = "-bmp";
+  std::string arg7 = "-outfile";
+  std::string arg8 = output_path.MaybeAsASCII();
+  std::string arg9 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0], &arg9[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(10, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "12f78118e56a2f48b966f792fedf23cc";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, GrayISlow565D) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_gray_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_gray_islow_565D.bmp");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-rgb565";
+  std::string arg4 = "-bmp";
+  std::string arg5 = "-outfile";
+  std::string arg6 = output_path.MaybeAsASCII();
+  std::string arg7 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(8, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "bdbbd616441a24354c98553df5dc82db";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, FloatProg3x2) {
+
+  base::FilePath input_image_path;
+#if defined(__arm__) || defined(__aarch64__)
+  GetTestFilePath(&input_image_path, "testout_3x2_float_prog_arm.jpg");
+#elif defined(__i386__) || defined(__x86_64__)
+  GetTestFilePath(&input_image_path, "testout_3x2_float_prog_intel.jpg");
+#else
+#error "Unknown platform."
+#endif
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_3x2_float.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "float";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+#if defined(__arm__) || defined(__aarch64__)
+  const std::string EXPECTED_MD5 = "f6bfab038438ed8f5522fbd33595dcdc";
+#elif defined(__i386__) || defined(__x86_64__)
+  const std::string EXPECTED_MD5 = "1a75f36e5904d6fc3a85a43da9ad89bb";
+#else
+#error "Unknown platform."
+#endif
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, IFastProg3x2) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_3x2_ifast_prog.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_3x2_ifast.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "fast";
+  std::string arg3 = "-outfile";
+  std::string arg4 = output_path.MaybeAsASCII();
+  std::string arg5 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(6, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "fd283664b3b49127984af0a7f118fccd";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlowProgCrop62x627171) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_420_islow_prog.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(
+                              "testout_420_islow_prog_crop62x62_71_71.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-crop";
+  std::string arg4 = "62x62+71+71";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "26eb36ccc7d1f0cb80cdabb0ac8b5d99";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlow444Skip16) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_444_islow.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII("testout_444_islow_skip1_6.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-skip";
+  std::string arg4 = "1,6";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "5606f86874cf26b8fcee1117a0a436a6";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}
+
+TEST(DJPEGTest, ISlowProg444Crop98x981313) {
+
+  base::FilePath input_image_path;
+  GetTestFilePath(&input_image_path, "testout_444_islow_prog.jpg");
+  base::FilePath output_path(FILE_PATH_LITERAL(GetTargetDirectory()));
+  output_path = output_path.AppendASCII(
+                              "testout_444_islow_prog_crop98x98_13_13.ppm");
+
+  std::string prog_name = "djpeg";
+  std::string arg1 = "-dct";
+  std::string arg2 = "int";
+  std::string arg3 = "-crop";
+  std::string arg4 = "98x98+13+13";
+  std::string arg5 = "-ppm";
+  std::string arg6 = "-outfile";
+  std::string arg7 = output_path.MaybeAsASCII();
+  std::string arg8 = input_image_path.MaybeAsASCII();
+
+  char *command_line[] = { &prog_name[0],
+                           &arg1[0], &arg2[0], &arg3[0], &arg4[0], &arg5[0],
+                           &arg6[0], &arg7[0], &arg8[0]
+                         };
+  // Generate test image file.
+  EXPECT_EQ(djpeg(9, command_line), 0);
+
+  // Compare expected MD5 sum against that of test image.
+  const std::string EXPECTED_MD5 = "db87dc7ce26bcdc7a6b56239ce2b9d6c";
+  EXPECT_TRUE(CompareFileAndMD5(output_path, EXPECTED_MD5));
+}