clang-format again

oss-internship-2020/libtiff/example/main_sandboxed.cc

@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
 #include <array>
 #include <cstdint>
+#include <cstdlib>
+#include <cstring>
 
 #include "../sandboxed.h"
 #include "sandboxed_api/sandbox2/util/fileops.h"
@@ -47,21 +46,11 @@ absl::Status CheckCluster(int cluster, const sapi::v::Array<uint8_t>& buffer,
     return absl::OkStatus();
   }
 
-  std::cerr << "Cluster " << cluster << " did not match expected results.\n"
+  return absl::InternalError(
-            << "Expect: " << expected_cluster[0] << "\t" << expected_cluster[1]
+      absl::StrCat("Cluster ", cluster, " did not match expected results.\n",
-            << "\t" << expected_cluster[4] << "\t" << expected_cluster[5]
+                   "Expect: ", expected_cluster[0], "\t", expected_cluster[1],
-            << "\t" << expected_cluster[2] << "\t" << expected_cluster[3]
+                   "\t", expected_cluster[4], "\t", expected_cluster[5], "\t",
-            << "\n"
+                   expected_cluster[2], "\t", expected_cluster[3], "\n"));
-            << "Got: " << target[0] << "\t" << target[1] << "\t" << target[4]
-            << "\t" << target[5] << "\t" << target[2] << "\t" << target[3]
-            << '\n';
-
-  return absl::InternalError(absl::StrCat(
-    "Cluster ", cluster, " did not match expected results.\n", "Expect: ",
-    expected_cluster[0], "\t", expected_cluster[1], "\t", expected_cluster[4],
-    "\t", expected_cluster[5], "\t", expected_cluster[2], "\t",
-    expected_cluster[3], "\n"
-  ));
 }
 
 absl::Status CheckRgbPixel(int pixel, int min_red, int max_red, int min_green,
@@ -77,9 +66,8 @@ absl::Status CheckRgbPixel(int pixel, int min_red, int max_red, int min_green,
   return absl::InternalError(absl::StrCat(
       "Pixel ", pixel, " did not match expected results.\n", "Got R=", rgb[0],
       " (expected ", min_red, "..", max_red, "), G=", rgb[1], " (expected ",
-    min_green, "..", max_green, "), B=", rgb[2], " (expected ", min_blue, "..",
+      min_green, "..", max_green, "), B=", rgb[2], " (expected ", min_blue,
-    max_blue, ")\n"
+      "..", max_blue, ")\n"));
-  ));
 }
 
 absl::Status CheckRgbaPixel(int pixel, int min_red, int max_red, int min_green,
@@ -101,12 +89,11 @@ absl::Status CheckRgbaPixel(int pixel, int min_red, int max_red, int min_green,
   }
 
   return absl::InternalError(absl::StrCat(
-    "Pixel ", pixel, " did not match expected results.\n", "Got R=",
+      "Pixel ", pixel, " did not match expected results.\n",
-    TIFFGetR(rgba), " (expected ", min_red, "..", max_red, "), G=",
+      "Got R=", TIFFGetR(rgba), " (expected ", min_red, "..", max_red,
-    TIFFGetG(rgba), " (expected ", min_green, "..", max_green, "), B=",
+      "), G=", TIFFGetG(rgba), " (expected ", min_green, "..", max_green,
-    TIFFGetB(rgba), " (expected ", min_blue, "..", max_blue, "), A=",
+      "), B=", TIFFGetB(rgba), " (expected ", min_blue, "..", max_blue, "), A=",
-    TIFFGetA(rgba), " (expected ", min_alpha, "..", max_alpha, ")\n"
+      TIFFGetA(rgba), " (expected ", min_alpha, "..", max_alpha, ")\n"));
-  ));
 }
 
 }  // namespace
@@ -163,19 +150,17 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
     return absl::InternalError(absl::StrCat("Could not open ", srcfile));
   }
 
-  SAPI_ASSIGN_OR_RETURN(
+  SAPI_ASSIGN_OR_RETURN(status_or_int,
-    status_or_int, api.TIFFGetField2(&tif, TIFFTAG_YCBCRSUBSAMPLING,
+                        api.TIFFGetField2(&tif, TIFFTAG_YCBCRSUBSAMPLING,
                                           h.PtrBoth(), v.PtrBoth()));
   if (status_or_int.value() == 0 || h.GetValue() != 2 || v.GetValue() != 2) {
     return absl::InternalError("Could not retrieve subsampling tag");
   }
 
-  SAPI_ASSIGN_OR_RETURN(
+  SAPI_ASSIGN_OR_RETURN(status_or_long, api.TIFFTileSize(&tif));
-    status_or_long, api.TIFFTileSize(&tif));
   if (status_or_long.value() != 24576) {
-    return absl::InternalError(absl::StrCat("tiles are ",
+    return absl::InternalError(
-                                            status_or_long.value(),
+        absl::StrCat("tiles are ", status_or_long.value(), " bytes\n"));
-                                            " bytes\n"));
   }
   tsize_t sz = status_or_long.value();
 
@@ -185,8 +170,7 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
   if (status_or_long.value() != sz) {
     return absl::InternalError(absl::StrCat(
         "Did not get expected result code from TIFFReadEncodedTile(): ",
-      status_or_long.value(), " instead of ", sz
+        status_or_long.value(), " instead of ", sz));
-    ));
   }
 
   unsigned pixel_status = 1;
@@ -210,18 +194,16 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
   }
 
   SAPI_ASSIGN_OR_RETURN(
-    status_or_int, api.TIFFSetFieldU1(&tif, TIFFTAG_JPEGCOLORMODE,
+      status_or_int,
-                                      JPEGCOLORMODE_RGB));
+      api.TIFFSetFieldU1(&tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB));
   if (!status_or_int.value()) {
     return absl::InternalError("TIFFSetFieldU1 not available");
   }
 
-  SAPI_ASSIGN_OR_RETURN(
+  SAPI_ASSIGN_OR_RETURN(status_or_long, api.TIFFTileSize(&tif));
-    status_or_long, api.TIFFTileSize(&tif));
   if (status_or_long.value() != 128 * 128 * 3) {
-    return absl::InternalError(absl::StrCat("tiles are ",
+    return absl::InternalError(
-                                            status_or_long.value(),
+        absl::StrCat("tiles are ", status_or_long.value(), " bytes"));
-                                            " bytes"));
   }
   sz = status_or_long.value();
 
@@ -232,13 +214,11 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
   if (status_or_long.value() != sz) {
     return absl::InternalError(absl::StrCat(
         "Did not get expected result code from TIFFReadEncodedTile(): ",
-      status_or_long.value(), " instead of ", sz
+        status_or_long.value(), " instead of ", sz));
-    ));
   }
 
   pixel_status = 1;
-  if (status = CheckRgbPixel(0, 15, 18, 0, 0, 18, 41, buffer2_);
+  if (status = CheckRgbPixel(0, 15, 18, 0, 0, 18, 41, buffer2_); !status.ok()) {
-      !status.ok()) {
     LOG(ERROR) << "CheckRgbPixel failed:\n" << status.ToString();
   }
   pixel_status &= status.ok();
@@ -266,7 +246,8 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
 
   sapi::v::Array<uint32> rgba_buffer_(128 * 128);
 
-  SAPI_ASSIGN_OR_RETURN(status_or_int,
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_int,
       api.TIFFReadRGBATile(&tif2, 1 * 128, 2 * 128, rgba_buffer_.PtrBoth()));
   if (!status_or_int.value()) {
     return absl::InternalError("TIFFReadRGBATile() returned failure code");
@@ -284,8 +265,9 @@ absl::Status LibTIFFMain(const std::string& srcfile) {
   }
   pixel_status &= status.ok();
 
-  if (status = CheckRgbaPixel(512, 5, 6, 34, 36, 182, 196, 255, 255,
+  if (status =
-                              rgba_buffer_); !status.ok()) {
+          CheckRgbaPixel(512, 5, 6, 34, 36, 182, 196, 255, 255, rgba_buffer_);
+      !status.ok()) {
     LOG(ERROR) << "CheckRgbaPixel failed:\n" << status.ToString();
   }
   pixel_status &= status.ok();
@@ -314,8 +296,8 @@ int main(int argc, char** argv) {
 
   auto status = LibTIFFMain(srcfile);
   if (!status.ok()) {
-    LOG(ERROR)
+    LOG(ERROR) << "LibTIFFMain failed with error:\n"
-      << "LibTIFFMain failed with error:\n" << status.ToString() << '\n';
+               << status.ToString() << '\n';
     return EXIT_FAILURE;
   }
 

oss-internship-2020/libtiff/formated.cc

@@ -0,0 +1,305 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+#include "../sandboxed.h"
+#include "sandboxed_api/sandbox2/util/fileops.h"
+#include "sandboxed_api/sandbox2/util/path.h"
+#include "sandboxed_api/vars.h"
+#include "tiffio.h"  // NOLINT(build/include)
+
+// sapi functions:
+//  TIFFTileSize
+//  TIFFOpen
+//  TIFFReadEncodedTile
+//  TIFFSetField
+//  TIFFClose
+//  TIFFReadRGBATile
+//  TIFFGetField
+
+constexpr std::array<uint8_t, 6> kCluster0 = {0, 0, 2, 0, 138, 139};
+constexpr std::array<uint8_t, 6> kCluster64 = {0, 0, 9, 6, 134, 119};
+constexpr std::array<uint8_t, 6> kCluster128 = {44, 40, 63, 59, 230, 95};
+
+namespace {
+
+absl::Status CheckCluster(int cluster, const sapi::v::Array<uint8_t>& buffer,
+                          const std::array<uint8_t, 6>& expected_cluster) {
+  uint8_t* target = buffer.GetData() + cluster * 6;
+
+  if (!std::memcmp(target, expected_cluster.data(), 6)) {
+    return absl::OkStatus();
+  }
+
+  return absl::InternalError(
+      absl::StrCat("Cluster ", cluster, " did not match expected results.\n",
+                   "Expect: ", expected_cluster[0], "\t", expected_cluster[1],
+                   "\t", expected_cluster[4], "\t", expected_cluster[5], "\t",
+                   expected_cluster[2], "\t", expected_cluster[3], "\n"));
+}
+
+absl::Status CheckRgbPixel(int pixel, int min_red, int max_red, int min_green,
+                           int max_green, int min_blue, int max_blue,
+                           const sapi::v::Array<uint8_t>& buffer) {
+  uint8_t* rgb = buffer.GetData() + 3 * pixel;
+
+  if (rgb[0] >= min_red && rgb[0] <= max_red && rgb[1] >= min_green &&
+      rgb[1] <= max_green && rgb[2] >= min_blue && rgb[2] <= max_blue) {
+    return absl::OkStatus();
+  }
+
+  return absl::InternalError(absl::StrCat(
+      "Pixel ", pixel, " did not match expected results.\n", "Got R=", rgb[0],
+      " (expected ", min_red, "..", max_red, "), G=", rgb[1], " (expected ",
+      min_green, "..", max_green, "), B=", rgb[2], " (expected ", min_blue,
+      "..", max_blue, ")\n"));
+}
+
+absl::Status CheckRgbaPixel(int pixel, int min_red, int max_red, int min_green,
+                            int max_green, int min_blue, int max_blue,
+                            int min_alpha, int max_alpha,
+                            const sapi::v::Array<unsigned>& buffer) {
+  // RGBA images are upside down - adjust for normal ordering
+  int adjusted_pixel = pixel % 128 + (127 - (pixel / 128)) * 128;
+  uint32 rgba = buffer[adjusted_pixel];
+
+  if (TIFFGetR(rgba) >= (uint32)min_red && TIFFGetR(rgba) <= (uint32)max_red &&
+      TIFFGetG(rgba) >= (uint32)min_green &&
+      TIFFGetG(rgba) <= (uint32)max_green &&
+      TIFFGetB(rgba) >= (uint32)min_blue &&
+      TIFFGetB(rgba) <= (uint32)max_blue &&
+      TIFFGetA(rgba) >= (uint32)min_alpha &&
+      TIFFGetA(rgba) <= (uint32)max_alpha) {
+    return absl::OkStatus();
+  }
+
+  return absl::InternalError(absl::StrCat(
+      "Pixel ", pixel, " did not match expected results.\n",
+      "Got R=", TIFFGetR(rgba), " (expected ", min_red, "..", max_red,
+      "), G=", TIFFGetG(rgba), " (expected ", min_green, "..", max_green,
+      "), B=", TIFFGetB(rgba), " (expected ", min_blue, "..", max_blue, "), A=",
+      TIFFGetA(rgba), " (expected ", min_alpha, "..", max_alpha, ")\n"));
+}
+
+}  // namespace
+
+std::string GetFilePath(const std::string& dir, const std::string& filename) {
+  return sandbox2::file::JoinPath(dir, "test", "images", filename);
+}
+
+std::string GetFilePath(const std::string filename) {
+  std::string cwd = sandbox2::file_util::fileops::GetCWD();
+  auto find = cwd.rfind("build");
+
+  std::string project_path;
+  if (find == std::string::npos) {
+    LOG(ERROR) << "Something went wrong: CWD don't contain build dir. "
+               << "Please run tests from build dir or send project dir as a "
+               << "parameter: ./sandboxed /absolute/path/to/project/dir \n";
+    project_path = cwd;
+  } else {
+    project_path = cwd.substr(0, find);
+  }
+
+  return sandbox2::file::JoinPath(project_path, "test", "images", filename);
+}
+
+absl::Status LibTIFFMain(const std::string& srcfile) {
+  // without addDir to sandbox. to add dir use
+  // sandbox(absolute_path_to_dir, srcfile) or
+  // sandbox(absolute_path_to_dir). file and dir should be exists.
+  // srcfile must also be absolute_path_to_file
+  TiffSapiSandbox sandbox("", srcfile);
+
+  // initialize sapi vars after constructing TiffSapiSandbox
+  sapi::v::UShort h, v;
+  sapi::StatusOr<TIFF*> status_or_tif;
+  sapi::StatusOr<int> status_or_int;
+  sapi::StatusOr<tmsize_t> status_or_long;
+  absl::Status status;
+
+  status = sandbox.Init();
+
+  SAPI_RETURN_IF_ERROR(sandbox.Init());
+
+  TiffApi api(&sandbox);
+  sapi::v::ConstCStr srcfile_var(srcfile.c_str());
+  sapi::v::ConstCStr r_var("r");
+
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_tif, api.TIFFOpen(srcfile_var.PtrBefore(), r_var.PtrBefore()));
+
+  sapi::v::RemotePtr tif(status_or_tif.value());
+  if (!tif.GetValue()) {
+    // tif is NULL
+    return absl::InternalError(absl::StrCat("Could not open ", srcfile));
+  }
+
+  SAPI_ASSIGN_OR_RETURN(status_or_int,
+                        api.TIFFGetField2(&tif, TIFFTAG_YCBCRSUBSAMPLING,
+                                          h.PtrBoth(), v.PtrBoth()));
+  if (status_or_int.value() == 0 || h.GetValue() != 2 || v.GetValue() != 2) {
+    return absl::InternalError("Could not retrieve subsampling tag");
+  }
+
+  SAPI_ASSIGN_OR_RETURN(status_or_long, api.TIFFTileSize(&tif));
+  if (status_or_long.value() != 24576) {
+    return absl::InternalError(
+        absl::StrCat("tiles are ", status_or_long.value(), " bytes\n"));
+  }
+  tsize_t sz = status_or_long.value();
+
+  sapi::v::Array<uint8_t> buffer_(sz);
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_long, api.TIFFReadEncodedTile(&tif, 9, buffer_.PtrBoth(), sz));
+  if (status_or_long.value() != sz) {
+    return absl::InternalError(absl::StrCat(
+        "Did not get expected result code from TIFFReadEncodedTile(): ",
+        status_or_long.value(), " instead of ", sz));
+  }
+
+  unsigned pixel_status = 1;
+  if (status = CheckCluster(0, buffer_, kCluster0); !status.ok()) {
+    LOG(ERROR) << "CheckCluster failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status = CheckCluster(64, buffer_, kCluster64); !status.ok()) {
+    LOG(ERROR) << "CheckCluster failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status = CheckCluster(128, buffer_, kCluster128); !status.ok()) {
+    LOG(ERROR) << "CheckCluster failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (!pixel_status) {
+    return absl::InternalError("unexpected pixel_status value");
+  }
+
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_int,
+      api.TIFFSetFieldU1(&tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB));
+  if (!status_or_int.value()) {
+    return absl::InternalError("TIFFSetFieldU1 not available");
+  }
+
+  SAPI_ASSIGN_OR_RETURN(status_or_long, api.TIFFTileSize(&tif));
+  if (status_or_long.value() != 128 * 128 * 3) {
+    return absl::InternalError(
+        absl::StrCat("tiles are ", status_or_long.value(), " bytes"));
+  }
+  sz = status_or_long.value();
+
+  sapi::v::Array<uint8_t> buffer2_(sz);
+
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_long, api.TIFFReadEncodedTile(&tif, 9, buffer2_.PtrBoth(), sz));
+  if (status_or_long.value() != sz) {
+    return absl::InternalError(absl::StrCat(
+        "Did not get expected result code from TIFFReadEncodedTile(): ",
+        status_or_long.value(), " instead of ", sz));
+  }
+
+  pixel_status = 1;
+  if (status = CheckRgbPixel(0, 15, 18, 0, 0, 18, 41, buffer2_); !status.ok()) {
+    LOG(ERROR) << "CheckRgbPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status = CheckRgbPixel(64, 0, 0, 0, 0, 0, 2, buffer2_); !status.ok()) {
+    LOG(ERROR) << "CheckRgbPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status = CheckRgbPixel(512, 5, 6, 34, 36, 182, 196, buffer2_);
+      !status.ok()) {
+    LOG(ERROR) << "CheckRgbPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  SAPI_RETURN_IF_ERROR(api.TIFFClose(&tif));
+
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_tif, api.TIFFOpen(srcfile_var.PtrBefore(), r_var.PtrBefore()));
+
+  sapi::v::RemotePtr tif2(status_or_tif.value());
+  if (!tif2.GetValue()) {  // tif is NULL
+    return absl::InternalError(absl::StrCat("Could not reopen ", srcfile));
+  }
+
+  sapi::v::Array<uint32> rgba_buffer_(128 * 128);
+
+  SAPI_ASSIGN_OR_RETURN(
+      status_or_int,
+      api.TIFFReadRGBATile(&tif2, 1 * 128, 2 * 128, rgba_buffer_.PtrBoth()));
+  if (!status_or_int.value()) {
+    return absl::InternalError("TIFFReadRGBATile() returned failure code");
+  }
+
+  if (status = CheckRgbaPixel(0, 15, 18, 0, 0, 18, 41, 255, 255, rgba_buffer_);
+      !status.ok()) {
+    LOG(ERROR) << "CheckRgbaPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status = CheckRgbaPixel(64, 0, 0, 0, 0, 0, 2, 255, 255, rgba_buffer_);
+      !status.ok()) {
+    LOG(ERROR) << "CheckRgbaPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  if (status =
+          CheckRgbaPixel(512, 5, 6, 34, 36, 182, 196, 255, 255, rgba_buffer_);
+      !status.ok()) {
+    LOG(ERROR) << "CheckRgbaPixel failed:\n" << status.ToString();
+  }
+  pixel_status &= status.ok();
+
+  SAPI_RETURN_IF_ERROR(api.TIFFClose(&tif2));
+
+  if (!pixel_status) {
+    return absl::InternalError("unexpected pixel_status value");
+  }
+
+  return absl::OkStatus();
+}
+
+int main(int argc, char** argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+  std::string srcfile;
+  // "test/images/quad-tile.jpg.tiff"
+  std::string srcfilerel = "quad-tile.jpg.tiff";
+
+  if (argc < 2) {
+    srcfile = GetFilePath(srcfilerel);
+  } else {
+    srcfile = GetFilePath(argv[1], srcfilerel);
+  }
+
+  auto status = LibTIFFMain(srcfile);
+  if (!status.ok()) {
+    LOG(ERROR) << "LibTIFFMain failed with error:\n"
+               << status.ToString() << '\n';
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}

oss-internship-2020/libtiff/test/check_tag.h

@@ -15,7 +15,7 @@
 #include <cstring>
 
 #include "helper.h"
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 void CheckShortField(TiffApi&, sapi::v::RemotePtr& tif, const ttag_t field,
                      const uint16_t value);

oss-internship-2020/libtiff/test/defer_strile_writing.cc

@@ -15,7 +15,7 @@
 #include <cstdint>
 
 #include "helper.h"
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 // sapi functions:
 //  TIFFOpen

oss-internship-2020/libtiff/test/helper.cc

@@ -14,15 +14,13 @@
 
 #include "helper.h"
 
-#include <iostream>
-
 static auto* g_in_dir = new std::string();
 
 std::string GetImagesDir() {
   std::string cwd = sandbox2::file_util::fileops::GetCWD();
   auto find = cwd.rfind("/build");
   if (find == std::string::npos) {
-    std::cerr << "Something went wrong: CWD don't contain build dir. "
+    LOG(ERROR) << "Something went wrong: CWD don't contain build dir. "
                << "Please run tests from build dir, path might be incorrect\n";
 
     return cwd + "/test/images";

oss-internship-2020/libtiff/test/long_tag.cc

@@ -13,10 +13,9 @@
 // limitations under the License.
 
 #include <array>
-#include <vector>
 
 #include "check_tag.h"
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 // sapi functions:
 //  TIFFWriteScanline
@@ -34,7 +33,8 @@ struct LongTag {
 };
 
 constexpr std::array<LongTag, 1> kLongTags = {
-	{TIFFTAG_SUBFILETYPE, 1, FILETYPE_REDUCEDIMAGE | FILETYPE_PAGE | FILETYPE_MASK}};
+    {TIFFTAG_SUBFILETYPE, 1,
+     FILETYPE_REDUCEDIMAGE | FILETYPE_PAGE | FILETYPE_MASK}};
 #define SPP 3  // kSamplePerPixel
 constexpr unsigned kWidth = 1;
 constexpr unsigned kLength = 1;

oss-internship-2020/libtiff/test/raw_decode.cc

@@ -17,7 +17,7 @@
 
 #include "gtest/gtest.h"
 #include "helper.h"
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 // sapi functions:
 //  TIFFOpen
@@ -34,8 +34,8 @@ constexpr std::array<uint8_t, 6> kCluster0 = {0, 0, 2, 0, 138, 139};
 constexpr std::array<uint8_t, 6> kCluster64 = {0, 0, 9, 6, 134, 119};
 constexpr std::array<uint8_t, 6> kCluster128 = {44, 40, 63, 59, 230, 95};
 
-int CheckCluster(int cluster, const sapi::v::Array<uint8_t> &buffer,
+int CheckCluster(int cluster, const sapi::v::Array<uint8_t>& buffer,
-                 const std::array<uint8_t, 6> &expected_cluster) {
+                 const std::array<uint8_t, 6>& expected_cluster) {
   uint8_t* target = buffer.GetData() + cluster * 6;
 
   bool comp = !(std::memcmp(target, expected_cluster.data(), 6) == 0);
@@ -53,7 +53,7 @@ int CheckCluster(int cluster, const sapi::v::Array<uint8_t> &buffer,
 
 int CheckRgbPixel(int pixel, int min_red, int max_red, int min_green,
                   int max_green, int min_blue, int max_blue,
-                  const sapi::v::Array<uint8_t> &buffer) {
+                  const sapi::v::Array<uint8_t>& buffer) {
   uint8_t* rgb = buffer.GetData() + 3 * pixel;
 
   bool comp =
@@ -71,7 +71,7 @@ int CheckRgbPixel(int pixel, int min_red, int max_red, int min_green,
 
 int CheckRgbaPixel(int pixel, int min_red, int max_red, int min_green,
                    int max_green, int min_blue, int max_blue, int min_alpha,
-                   int max_alpha, const sapi::v::Array<unsigned> &buffer) {
+                   int max_alpha, const sapi::v::Array<unsigned>& buffer) {
   // RGBA images are upside down - adjust for normal ordering
   int adjusted_pixel = pixel % 128 + (127 - (pixel / 128)) * 128;
   unsigned rgba = buffer[adjusted_pixel];

oss-internship-2020/libtiff/test/short_tag.cc

@@ -14,10 +14,9 @@
 
 #include <array>
 #include <cstdint>
-#include <vector>
 
 #include "check_tag.h"
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 // sapi functions:
 //  TIFFWriteScanline
@@ -46,8 +45,8 @@ struct PairedTag {
   const std::array<uint16_t, 2> values;
 };
 
-constexpr std::array<SingleTag, 9> kShortSingleTags = {{
+constexpr std::array<SingleTag, 9> kShortSingleTags = {
-    {TIFFTAG_COMPRESSION, COMPRESSION_NONE},
+    {{TIFFTAG_COMPRESSION, COMPRESSION_NONE},
      {TIFFTAG_FILLORDER, FILLORDER_MSB2LSB},
      {TIFFTAG_ORIENTATION, ORIENTATION_BOTRIGHT},
      {TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH},
@@ -57,8 +56,8 @@ constexpr std::array<SingleTag, 9> kShortSingleTags = {{
      {TIFFTAG_NUMBEROFINKS, SPP},
      {TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT}}};
 
-constexpr std::array<PairedTag, 4> kShortPairedTags = {{
+constexpr std::array<PairedTag, 4> kShortPairedTags = {
-    {TIFFTAG_PAGENUMBER, {1, 1}},
+    {{TIFFTAG_PAGENUMBER, {1, 1}},
      {TIFFTAG_HALFTONEHINTS, {0, 255}},
      {TIFFTAG_DOTRANGE, {8, 16}},
      {TIFFTAG_YCBCRSUBSAMPLING, {2, 1}}}};

oss-internship-2020/libtiff/wrapper/func.h

@@ -15,7 +15,7 @@
 #ifndef LIBTIFF_WRAPPER_FUNC_H
 #define LIBTIFF_WRAPPER_FUNC_H
 
-#include "tiffio.h"
+#include "tiffio.h"  // NOLINT(build/include)
 
 // wrapper for variadic functions TIFFGetField and TIFFSetField
 // s - signed