diff --git a/test/acm_random.h b/test/acm_random.h
index b94b6e1..c2f6b0e 100644
--- a/test/acm_random.h
+++ b/test/acm_random.h
@@ -23,9 +23,7 @@
 
   explicit ACMRandom(int seed) : random_(seed) {}
 
-  void Reset(int seed) {
-    random_.Reseed(seed);
-  }
+  void Reset(int seed) { random_.Reseed(seed); }
   uint16_t Rand16(void) {
     const uint32_t value =
         random_.Generate(testing::internal::Random::kMaxRange);
@@ -52,17 +50,11 @@
     return r < 128 ? r << 4 : r >> 4;
   }
 
-  int PseudoUniform(int range) {
-    return random_.Generate(range);
-  }
+  int PseudoUniform(int range) { return random_.Generate(range); }
 
-  int operator()(int n) {
-    return PseudoUniform(n);
-  }
+  int operator()(int n) { return PseudoUniform(n); }
 
-  static int DeterministicSeed(void) {
-    return 0xbaba;
-  }
+  static int DeterministicSeed(void) { return 0xbaba; }
 
  private:
   testing::internal::Random random_;
diff --git a/test/active_map_refresh_test.cc b/test/active_map_refresh_test.cc
index 577fe33..4e69f52 100644
--- a/test/active_map_refresh_test.cc
+++ b/test/active_map_refresh_test.cc
@@ -17,8 +17,8 @@
 namespace {
 
 // Check if any pixel in a 16x16 macroblock varies between frames.
-int CheckMb(const vpx_image_t &current, const vpx_image_t &previous,
-            int mb_r, int mb_c) {
+int CheckMb(const vpx_image_t &current, const vpx_image_t &previous, int mb_r,
+            int mb_c) {
   for (int plane = 0; plane < 3; plane++) {
     int r = 16 * mb_r;
     int c0 = 16 * mb_c;
diff --git a/test/active_map_test.cc b/test/active_map_test.cc
index f4b4605..cdf8f0b 100644
--- a/test/active_map_test.cc
+++ b/test/active_map_test.cc
@@ -39,6 +39,7 @@
       encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
     } else if (video->frame() == 3) {
       vpx_active_map_t map = vpx_active_map_t();
+      /* clang-format off */
       uint8_t active_map[9 * 13] = {
         1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
         1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
@@ -50,6 +51,7 @@
         0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1,
         1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
       };
+      /* clang-format on */
       map.cols = (kWidth + 15) / 16;
       map.rows = (kHeight + 15) / 16;
       ASSERT_EQ(map.cols, 13u);
@@ -82,15 +84,11 @@
   int cpu_used_;
 };
 
-TEST_P(ActiveMapTest, Test) {
-  DoTest();
-}
+TEST_P(ActiveMapTest, Test) { DoTest(); }
 
 class ActiveMapTestLarge : public ActiveMapTest {};
 
-TEST_P(ActiveMapTestLarge, Test) {
-  DoTest();
-}
+TEST_P(ActiveMapTestLarge, Test) { DoTest(); }
 
 VP10_INSTANTIATE_TEST_CASE(ActiveMapTestLarge,
                            ::testing::Values(::libvpx_test::kRealTime),
diff --git a/test/add_noise_test.cc b/test/add_noise_test.cc
index 35aaadf..4eff8b9 100644
--- a/test/add_noise_test.cc
+++ b/test/add_noise_test.cc
@@ -24,12 +24,9 @@
                              char bothclamp[16], unsigned int width,
                              unsigned int height, int pitch);
 
-class AddNoiseTest
-    : public ::testing::TestWithParam<AddNoiseFunc> {
+class AddNoiseTest : public ::testing::TestWithParam<AddNoiseFunc> {
  public:
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
   virtual ~AddNoiseTest() {}
 };
 
@@ -45,7 +42,7 @@
   DECLARE_ALIGNED(16, char, blackclamp[16]);
   DECLARE_ALIGNED(16, char, whiteclamp[16]);
   DECLARE_ALIGNED(16, char, bothclamp[16]);
-  const int width  = 64;
+  const int width = 64;
   const int height = 64;
   const int image_size = width * height;
   char noise[3072];
@@ -105,7 +102,7 @@
   DECLARE_ALIGNED(16, char, blackclamp[16]);
   DECLARE_ALIGNED(16, char, whiteclamp[16]);
   DECLARE_ALIGNED(16, char, bothclamp[16]);
-  const int width  = 64;
+  const int width = 64;
   const int height = 64;
   const int image_size = width * height;
   char noise[3072];
@@ -128,9 +125,8 @@
   ASM_REGISTER_STATE_CHECK(GetParam()(s, noise, blackclamp, whiteclamp,
                                       bothclamp, width, height, width));
   srand(0);
-  ASM_REGISTER_STATE_CHECK(vpx_plane_add_noise_c(d, noise, blackclamp,
-                                                 whiteclamp, bothclamp,
-                                                 width, height, width));
+  ASM_REGISTER_STATE_CHECK(vpx_plane_add_noise_c(
+      d, noise, blackclamp, whiteclamp, bothclamp, width, height, width));
 
   for (int i = 0; i < image_size; ++i) {
     EXPECT_EQ(static_cast<int>(s[i]), static_cast<int>(d[i])) << "i = " << i;
diff --git a/test/altref_test.cc b/test/altref_test.cc
index 1552488..8c7dee4 100644
--- a/test/altref_test.cc
+++ b/test/altref_test.cc
@@ -19,11 +19,8 @@
       public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   AltRefForcedKeyTestLarge()
-      : EncoderTest(GET_PARAM(0)),
-        encoding_mode_(GET_PARAM(1)),
-        cpu_used_(GET_PARAM(2)),
-        forced_kf_frame_num_(1),
-        frame_num_(0) {}
+      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
+        cpu_used_(GET_PARAM(2)), forced_kf_frame_num_(1), frame_num_(0) {}
   virtual ~AltRefForcedKeyTestLarge() {}
 
   virtual void SetUp() {
@@ -38,8 +35,8 @@
     if (video->frame() == 0) {
       encoder->Control(VP8E_SET_CPUUSED, cpu_used_);
       encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
-      // override test default for tile columns if necessary.
 #if CONFIG_VP10_ENCODER
+      // override test default for tile columns if necessary.
       if (GET_PARAM(0) == &libvpx_test::kVP10) {
         encoder->Control(VP9E_SET_TILE_COLUMNS, 6);
       }
@@ -91,9 +88,8 @@
   }
 }
 
-VP10_INSTANTIATE_TEST_CASE(
-    AltRefForcedKeyTestLarge,
-    ::testing::Values(::libvpx_test::kOnePassGood),
-    ::testing::Range(0, 9));
+VP10_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
+                           ::testing::Values(::libvpx_test::kOnePassGood),
+                           ::testing::Range(0, 9));
 
 }  // namespace
diff --git a/test/aq_segment_test.cc b/test/aq_segment_test.cc
index ee4b682..396a4fa 100644
--- a/test/aq_segment_test.cc
+++ b/test/aq_segment_test.cc
@@ -49,8 +49,8 @@
     cfg_.rc_buf_optimal_sz = 500;
     cfg_.rc_buf_sz = 1000;
     cfg_.rc_target_bitrate = 300;
-    ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv",
-                                         352, 288, 30, 1, 0, 15);
+    ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352,
+                                         288, 30, 1, 0, 15);
     ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   }
 
@@ -60,36 +60,23 @@
 
 // Validate that this AQ segmentation mode (AQ=1, variance_ap)
 // encodes and decodes without a mismatch.
-TEST_P(AqSegmentTest, TestNoMisMatchAQ1) {
-  DoTest(1);
-}
+TEST_P(AqSegmentTest, TestNoMisMatchAQ1) { DoTest(1); }
 
 // Validate that this AQ segmentation mode (AQ=2, complexity_aq)
 // encodes and decodes without a mismatch.
-TEST_P(AqSegmentTest, TestNoMisMatchAQ2) {
-  DoTest(2);
-}
+TEST_P(AqSegmentTest, TestNoMisMatchAQ2) { DoTest(2); }
 
 // Validate that this AQ segmentation mode (AQ=3, cyclic_refresh_aq)
 // encodes and decodes without a mismatch.
-TEST_P(AqSegmentTest, TestNoMisMatchAQ3) {
-  DoTest(3);
-}
+TEST_P(AqSegmentTest, TestNoMisMatchAQ3) { DoTest(3); }
 
 class AqSegmentTestLarge : public AqSegmentTest {};
 
-TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ1) {
-  DoTest(1);
-}
+TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ1) { DoTest(1); }
 
-TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ2) {
-  DoTest(2);
-}
+TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ2) { DoTest(2); }
 
-TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ3) {
-  DoTest(3);
-}
-
+TEST_P(AqSegmentTestLarge, TestNoMisMatchAQ3) { DoTest(3); }
 
 VP10_INSTANTIATE_TEST_CASE(AqSegmentTest,
                            ::testing::Values(::libvpx_test::kRealTime,
diff --git a/test/arf_freq_test.cc b/test/arf_freq_test.cc
index 4f4a75c..9c00ded 100644
--- a/test/arf_freq_test.cc
+++ b/test/arf_freq_test.cc
@@ -22,8 +22,8 @@
 const unsigned int kFrames = 100;
 const int kBitrate = 500;
 
-#define ARF_NOT_SEEN               1000001
-#define ARF_SEEN_ONCE              1000000
+#define ARF_NOT_SEEN 1000001
+#define ARF_SEEN_ONCE 1000000
 
 typedef struct {
   const char *filename;
@@ -44,24 +44,20 @@
 
 const TestVideoParam kTestVectors[] = {
   // artificially increase framerate to trigger default check
-  {"hantro_collage_w352h288.yuv", 352, 288, 5000, 1,
-    8, VPX_IMG_FMT_I420, VPX_BITS_8, 0},
-  {"hantro_collage_w352h288.yuv", 352, 288, 30, 1,
-    8, VPX_IMG_FMT_I420, VPX_BITS_8, 0},
-  {"rush_hour_444.y4m", 352, 288, 30, 1,
-    8, VPX_IMG_FMT_I444, VPX_BITS_8, 1},
+  { "hantro_collage_w352h288.yuv", 352, 288, 5000, 1, 8, VPX_IMG_FMT_I420,
+    VPX_BITS_8, 0 },
+  { "hantro_collage_w352h288.yuv", 352, 288, 30, 1, 8, VPX_IMG_FMT_I420,
+    VPX_BITS_8, 0 },
+  { "rush_hour_444.y4m", 352, 288, 30, 1, 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
 #if CONFIG_VP9_HIGHBITDEPTH
-  // Add list of profile 2/3 test videos here ...
+// Add list of profile 2/3 test videos here ...
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 };
 
 const TestEncodeParam kEncodeVectors[] = {
-  {::libvpx_test::kOnePassGood, 2},
-  {::libvpx_test::kOnePassGood, 5},
-  {::libvpx_test::kTwoPassGood, 1},
-  {::libvpx_test::kTwoPassGood, 2},
-  {::libvpx_test::kTwoPassGood, 5},
-  {::libvpx_test::kRealTime, 5},
+  { ::libvpx_test::kOnePassGood, 2 }, { ::libvpx_test::kOnePassGood, 5 },
+  { ::libvpx_test::kTwoPassGood, 1 }, { ::libvpx_test::kTwoPassGood, 2 },
+  { ::libvpx_test::kTwoPassGood, 5 }, { ::libvpx_test::kRealTime, 5 },
 };
 
 const int kMinArfVectors[] = {
@@ -80,15 +76,12 @@
 
 class ArfFreqTestLarge
     : public ::libvpx_test::EncoderTest,
-      public ::libvpx_test::CodecTestWith3Params<TestVideoParam, \
+      public ::libvpx_test::CodecTestWith3Params<TestVideoParam,
                                                  TestEncodeParam, int> {
  protected:
   ArfFreqTestLarge()
-      : EncoderTest(GET_PARAM(0)),
-        test_video_param_(GET_PARAM(1)),
-        test_encode_param_(GET_PARAM(2)),
-        min_arf_requested_(GET_PARAM(3)) {
-  }
+      : EncoderTest(GET_PARAM(0)), test_video_param_(GET_PARAM(1)),
+        test_encode_param_(GET_PARAM(2)), min_arf_requested_(GET_PARAM(3)) {}
 
   virtual ~ArfFreqTestLarge() {}
 
@@ -114,17 +107,16 @@
   }
 
   int GetNumFramesInPkt(const vpx_codec_cx_pkt_t *pkt) {
-    const uint8_t *buffer = reinterpret_cast<uint8_t*>(pkt->data.frame.buf);
+    const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
     const uint8_t marker = buffer[pkt->data.frame.sz - 1];
     const int mag = ((marker >> 3) & 3) + 1;
     int frames = (marker & 0x7) + 1;
-    const unsigned int index_sz = 2 + mag  * frames;
+    const unsigned int index_sz = 2 + mag * frames;
     // Check for superframe or not.
     // Assume superframe has only one visible frame, the rest being
     // invisible. If superframe index is not found, then there is only
     // one frame.
-    if (!((marker & 0xe0) == 0xc0 &&
-          pkt->data.frame.sz >= index_sz &&
+    if (!((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz &&
           buffer[pkt->data.frame.sz - index_sz] == marker)) {
       frames = 1;
     }
@@ -132,8 +124,7 @@
   }
 
   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
-    if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
-      return;
+    if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
     const int frames = GetNumFramesInPkt(pkt);
     if (frames == 1) {
       run_of_visible_frames_++;
@@ -167,9 +158,7 @@
     }
   }
 
-  int GetMinVisibleRun() const {
-    return min_run_;
-  }
+  int GetMinVisibleRun() const { return min_run_; }
 
   int GetMinArfDistanceRequested() const {
     if (min_arf_requested_)
@@ -178,7 +167,7 @@
       return vp10_rc_get_default_min_gf_interval(
           test_video_param_.width, test_video_param_.height,
           (double)test_video_param_.framerate_num /
-          test_video_param_.framerate_den);
+              test_video_param_.framerate_den);
   }
 
   TestVideoParam test_video_param_;
@@ -197,21 +186,18 @@
   cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
   cfg_.g_bit_depth = test_video_param_.bit_depth;
   init_flags_ = VPX_CODEC_USE_PSNR;
-  if (cfg_.g_bit_depth > 8)
-    init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
+  if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
 
   testing::internal::scoped_ptr<libvpx_test::VideoSource> video;
   if (is_extension_y4m(test_video_param_.filename)) {
-    video.reset(new libvpx_test::Y4mVideoSource(test_video_param_.filename,
-                                                0, kFrames));
+    video.reset(new libvpx_test::Y4mVideoSource(test_video_param_.filename, 0,
+                                                kFrames));
   } else {
-    video.reset(new libvpx_test::YUVVideoSource(test_video_param_.filename,
-                                                test_video_param_.fmt,
-                                                test_video_param_.width,
-                                                test_video_param_.height,
-                                                test_video_param_.framerate_num,
-                                                test_video_param_.framerate_den,
-                                                0, kFrames));
+    video.reset(new libvpx_test::YUVVideoSource(
+        test_video_param_.filename, test_video_param_.fmt,
+        test_video_param_.width, test_video_param_.height,
+        test_video_param_.framerate_num, test_video_param_.framerate_den, 0,
+        kFrames));
   }
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
@@ -235,15 +221,12 @@
     ::testing::Combine(
         ::testing::Values(static_cast<const libvpx_test::CodecFactory *>(
             &libvpx_test::kVP10)),
-        ::testing::ValuesIn(kTestVectors),
-        ::testing::ValuesIn(kEncodeVectors),
+        ::testing::ValuesIn(kTestVectors), ::testing::ValuesIn(kEncodeVectors),
         ::testing::ValuesIn(kMinArfVectors)));
 #endif  // CONFIG_VP10_ENCODER
 #else
-VP10_INSTANTIATE_TEST_CASE(
-    ArfFreqTestLarge,
-    ::testing::ValuesIn(kTestVectors),
-    ::testing::ValuesIn(kEncodeVectors),
-    ::testing::ValuesIn(kMinArfVectors));
+VP10_INSTANTIATE_TEST_CASE(ArfFreqTestLarge, ::testing::ValuesIn(kTestVectors),
+                           ::testing::ValuesIn(kEncodeVectors),
+                           ::testing::ValuesIn(kMinArfVectors));
 #endif  // CONFIG_VP9_HIGHBITDEPTH || CONFIG_EXT_REFS
 }  // namespace
diff --git a/test/avg_test.cc b/test/avg_test.cc
index 44d8dd7..4a5d325 100644
--- a/test/avg_test.cc
+++ b/test/avg_test.cc
@@ -31,7 +31,7 @@
   AverageTestBase(int width, int height) : width_(width), height_(height) {}
 
   static void SetUpTestCase() {
-    source_data_ = reinterpret_cast<uint8_t*>(
+    source_data_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kDataBlockSize));
   }
 
@@ -40,9 +40,7 @@
     source_data_ = NULL;
   }
 
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   // Handle blocks up to 4 blocks 64x64 with stride up to 128
@@ -55,47 +53,44 @@
   }
 
   // Sum Pixels
-  unsigned int ReferenceAverage8x8(const uint8_t* source, int pitch) {
+  unsigned int ReferenceAverage8x8(const uint8_t *source, int pitch) {
     unsigned int average = 0;
     for (int h = 0; h < 8; ++h)
-      for (int w = 0; w < 8; ++w)
-        average += source[h * pitch + w];
+      for (int w = 0; w < 8; ++w) average += source[h * pitch + w];
     return ((average + 32) >> 6);
   }
 
-  unsigned int ReferenceAverage4x4(const uint8_t* source, int pitch) {
+  unsigned int ReferenceAverage4x4(const uint8_t *source, int pitch) {
     unsigned int average = 0;
     for (int h = 0; h < 4; ++h)
-      for (int w = 0; w < 4; ++w)
-        average += source[h * pitch + w];
+      for (int w = 0; w < 4; ++w) average += source[h * pitch + w];
     return ((average + 8) >> 4);
   }
 
   void FillConstant(uint8_t fill_constant) {
     for (int i = 0; i < width_ * height_; ++i) {
-        source_data_[i] = fill_constant;
+      source_data_[i] = fill_constant;
     }
   }
 
   void FillRandom() {
     for (int i = 0; i < width_ * height_; ++i) {
-        source_data_[i] = rnd_.Rand8();
+      source_data_[i] = rnd_.Rand8();
     }
   }
 
   int width_, height_;
-  static uint8_t* source_data_;
+  static uint8_t *source_data_;
   int source_stride_;
 
   ACMRandom rnd_;
 };
-typedef unsigned int (*AverageFunction)(const uint8_t* s, int pitch);
+typedef unsigned int (*AverageFunction)(const uint8_t *s, int pitch);
 
 typedef std::tr1::tuple<int, int, int, int, AverageFunction> AvgFunc;
 
-class AverageTest
-    : public AverageTestBase,
-      public ::testing::WithParamInterface<AvgFunc>{
+class AverageTest : public AverageTestBase,
+                    public ::testing::WithParamInterface<AvgFunc> {
  public:
   AverageTest() : AverageTestBase(GET_PARAM(0), GET_PARAM(1)) {}
 
@@ -103,17 +98,17 @@
   void CheckAverages() {
     unsigned int expected = 0;
     if (GET_PARAM(3) == 8) {
-      expected = ReferenceAverage8x8(source_data_+ GET_PARAM(2),
-                                     source_stride_);
-    } else  if (GET_PARAM(3) == 4) {
-      expected = ReferenceAverage4x4(source_data_+ GET_PARAM(2),
-                                     source_stride_);
+      expected =
+          ReferenceAverage8x8(source_data_ + GET_PARAM(2), source_stride_);
+    } else if (GET_PARAM(3) == 4) {
+      expected =
+          ReferenceAverage4x4(source_data_ + GET_PARAM(2), source_stride_);
     }
 
-    ASM_REGISTER_STATE_CHECK(GET_PARAM(4)(source_data_+ GET_PARAM(2),
-                                          source_stride_));
-    unsigned int actual = GET_PARAM(4)(source_data_+ GET_PARAM(2),
-                                       source_stride_);
+    ASM_REGISTER_STATE_CHECK(
+        GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_));
+    unsigned int actual =
+        GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_);
 
     EXPECT_EQ(expected, actual);
   }
@@ -124,23 +119,20 @@
 
 typedef std::tr1::tuple<int, IntProRowFunc, IntProRowFunc> IntProRowParam;
 
-class IntProRowTest
-    : public AverageTestBase,
-      public ::testing::WithParamInterface<IntProRowParam> {
+class IntProRowTest : public AverageTestBase,
+                      public ::testing::WithParamInterface<IntProRowParam> {
  public:
   IntProRowTest()
-    : AverageTestBase(16, GET_PARAM(0)),
-      hbuf_asm_(NULL),
-      hbuf_c_(NULL) {
+      : AverageTestBase(16, GET_PARAM(0)), hbuf_asm_(NULL), hbuf_c_(NULL) {
     asm_func_ = GET_PARAM(1);
     c_func_ = GET_PARAM(2);
   }
 
  protected:
   virtual void SetUp() {
-    hbuf_asm_ = reinterpret_cast<int16_t*>(
+    hbuf_asm_ = reinterpret_cast<int16_t *>(
         vpx_memalign(kDataAlignment, sizeof(*hbuf_asm_) * 16));
-    hbuf_c_ = reinterpret_cast<int16_t*>(
+    hbuf_c_ = reinterpret_cast<int16_t *>(
         vpx_memalign(kDataAlignment, sizeof(*hbuf_c_) * 16));
   }
 
@@ -169,9 +161,8 @@
 
 typedef std::tr1::tuple<int, IntProColFunc, IntProColFunc> IntProColParam;
 
-class IntProColTest
-    : public AverageTestBase,
-      public ::testing::WithParamInterface<IntProColParam> {
+class IntProColTest : public AverageTestBase,
+                      public ::testing::WithParamInterface<IntProColParam> {
  public:
   IntProColTest() : AverageTestBase(GET_PARAM(0), 1), sum_asm_(0), sum_c_(0) {
     asm_func_ = GET_PARAM(1);
@@ -195,15 +186,14 @@
 typedef int (*SatdFunc)(const int16_t *coeffs, int length);
 typedef std::tr1::tuple<int, SatdFunc> SatdTestParam;
 
-class SatdTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<SatdTestParam> {
+class SatdTest : public ::testing::Test,
+                 public ::testing::WithParamInterface<SatdTestParam> {
  protected:
   virtual void SetUp() {
     satd_size_ = GET_PARAM(0);
     satd_func_ = GET_PARAM(1);
     rnd_.Reset(ACMRandom::DeterministicSeed());
-    src_ = reinterpret_cast<int16_t*>(
+    src_ = reinterpret_cast<int16_t *>(
         vpx_memalign(16, sizeof(*src_) * satd_size_));
     ASSERT_TRUE(src_ != NULL);
   }
@@ -235,7 +225,7 @@
   ACMRandom rnd_;
 };
 
-uint8_t* AverageTestBase::source_data_ = NULL;
+uint8_t *AverageTestBase::source_data_ = NULL;
 
 TEST_P(AverageTest, MinValue) {
   FillConstant(0);
@@ -286,7 +276,6 @@
   RunComparison();
 }
 
-
 TEST_P(SatdTest, MinValue) {
   const int kMin = -32640;
   const int expected = -kMin * satd_size_;
@@ -320,92 +309,86 @@
 
 INSTANTIATE_TEST_CASE_P(
     C, AverageTest,
-    ::testing::Values(
-        make_tuple(16, 16, 1, 8, &vpx_avg_8x8_c),
-        make_tuple(16, 16, 1, 4, &vpx_avg_4x4_c)));
+    ::testing::Values(make_tuple(16, 16, 1, 8, &vpx_avg_8x8_c),
+                      make_tuple(16, 16, 1, 4, &vpx_avg_4x4_c)));
 
-INSTANTIATE_TEST_CASE_P(
-    C, SatdTest,
-    ::testing::Values(
-        make_tuple(16, &vpx_satd_c),
-        make_tuple(64, &vpx_satd_c),
-        make_tuple(256, &vpx_satd_c),
-        make_tuple(1024, &vpx_satd_c)));
+INSTANTIATE_TEST_CASE_P(C, SatdTest,
+                        ::testing::Values(make_tuple(16, &vpx_satd_c),
+                                          make_tuple(64, &vpx_satd_c),
+                                          make_tuple(256, &vpx_satd_c),
+                                          make_tuple(1024, &vpx_satd_c)));
 
 #if HAVE_SSE2
 INSTANTIATE_TEST_CASE_P(
     SSE2, AverageTest,
-    ::testing::Values(
-        make_tuple(16, 16, 0, 8, &vpx_avg_8x8_sse2),
-        make_tuple(16, 16, 5, 8, &vpx_avg_8x8_sse2),
-        make_tuple(32, 32, 15, 8, &vpx_avg_8x8_sse2),
-        make_tuple(16, 16, 0, 4, &vpx_avg_4x4_sse2),
-        make_tuple(16, 16, 5, 4, &vpx_avg_4x4_sse2),
-        make_tuple(32, 32, 15, 4, &vpx_avg_4x4_sse2)));
+    ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_sse2),
+                      make_tuple(16, 16, 5, 8, &vpx_avg_8x8_sse2),
+                      make_tuple(32, 32, 15, 8, &vpx_avg_8x8_sse2),
+                      make_tuple(16, 16, 0, 4, &vpx_avg_4x4_sse2),
+                      make_tuple(16, 16, 5, 4, &vpx_avg_4x4_sse2),
+                      make_tuple(32, 32, 15, 4, &vpx_avg_4x4_sse2)));
 
 INSTANTIATE_TEST_CASE_P(
-    SSE2, IntProRowTest, ::testing::Values(
-        make_tuple(16, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
-        make_tuple(32, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
-        make_tuple(64, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c)));
+    SSE2, IntProRowTest,
+    ::testing::Values(make_tuple(16, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
+                      make_tuple(32, &vpx_int_pro_row_sse2, &vpx_int_pro_row_c),
+                      make_tuple(64, &vpx_int_pro_row_sse2,
+                                 &vpx_int_pro_row_c)));
 
 INSTANTIATE_TEST_CASE_P(
-    SSE2, IntProColTest, ::testing::Values(
-        make_tuple(16, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
-        make_tuple(32, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
-        make_tuple(64, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c)));
+    SSE2, IntProColTest,
+    ::testing::Values(make_tuple(16, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
+                      make_tuple(32, &vpx_int_pro_col_sse2, &vpx_int_pro_col_c),
+                      make_tuple(64, &vpx_int_pro_col_sse2,
+                                 &vpx_int_pro_col_c)));
 
-INSTANTIATE_TEST_CASE_P(
-    SSE2, SatdTest,
-    ::testing::Values(
-        make_tuple(16, &vpx_satd_sse2),
-        make_tuple(64, &vpx_satd_sse2),
-        make_tuple(256, &vpx_satd_sse2),
-        make_tuple(1024, &vpx_satd_sse2)));
+INSTANTIATE_TEST_CASE_P(SSE2, SatdTest,
+                        ::testing::Values(make_tuple(16, &vpx_satd_sse2),
+                                          make_tuple(64, &vpx_satd_sse2),
+                                          make_tuple(256, &vpx_satd_sse2),
+                                          make_tuple(1024, &vpx_satd_sse2)));
 #endif
 
 #if HAVE_NEON
 INSTANTIATE_TEST_CASE_P(
     NEON, AverageTest,
-    ::testing::Values(
-        make_tuple(16, 16, 0, 8, &vpx_avg_8x8_neon),
-        make_tuple(16, 16, 5, 8, &vpx_avg_8x8_neon),
-        make_tuple(32, 32, 15, 8, &vpx_avg_8x8_neon),
-        make_tuple(16, 16, 0, 4, &vpx_avg_4x4_neon),
-        make_tuple(16, 16, 5, 4, &vpx_avg_4x4_neon),
-        make_tuple(32, 32, 15, 4, &vpx_avg_4x4_neon)));
+    ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_neon),
+                      make_tuple(16, 16, 5, 8, &vpx_avg_8x8_neon),
+                      make_tuple(32, 32, 15, 8, &vpx_avg_8x8_neon),
+                      make_tuple(16, 16, 0, 4, &vpx_avg_4x4_neon),
+                      make_tuple(16, 16, 5, 4, &vpx_avg_4x4_neon),
+                      make_tuple(32, 32, 15, 4, &vpx_avg_4x4_neon)));
 
 INSTANTIATE_TEST_CASE_P(
-    NEON, IntProRowTest, ::testing::Values(
-        make_tuple(16, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
-        make_tuple(32, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
-        make_tuple(64, &vpx_int_pro_row_neon, &vpx_int_pro_row_c)));
+    NEON, IntProRowTest,
+    ::testing::Values(make_tuple(16, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
+                      make_tuple(32, &vpx_int_pro_row_neon, &vpx_int_pro_row_c),
+                      make_tuple(64, &vpx_int_pro_row_neon,
+                                 &vpx_int_pro_row_c)));
 
 INSTANTIATE_TEST_CASE_P(
-    NEON, IntProColTest, ::testing::Values(
-        make_tuple(16, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
-        make_tuple(32, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
-        make_tuple(64, &vpx_int_pro_col_neon, &vpx_int_pro_col_c)));
+    NEON, IntProColTest,
+    ::testing::Values(make_tuple(16, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
+                      make_tuple(32, &vpx_int_pro_col_neon, &vpx_int_pro_col_c),
+                      make_tuple(64, &vpx_int_pro_col_neon,
+                                 &vpx_int_pro_col_c)));
 
-INSTANTIATE_TEST_CASE_P(
-    NEON, SatdTest,
-    ::testing::Values(
-        make_tuple(16, &vpx_satd_neon),
-        make_tuple(64, &vpx_satd_neon),
-        make_tuple(256, &vpx_satd_neon),
-        make_tuple(1024, &vpx_satd_neon)));
+INSTANTIATE_TEST_CASE_P(NEON, SatdTest,
+                        ::testing::Values(make_tuple(16, &vpx_satd_neon),
+                                          make_tuple(64, &vpx_satd_neon),
+                                          make_tuple(256, &vpx_satd_neon),
+                                          make_tuple(1024, &vpx_satd_neon)));
 #endif
 
 #if HAVE_MSA
 INSTANTIATE_TEST_CASE_P(
     MSA, AverageTest,
-    ::testing::Values(
-        make_tuple(16, 16, 0, 8, &vpx_avg_8x8_msa),
-        make_tuple(16, 16, 5, 8, &vpx_avg_8x8_msa),
-        make_tuple(32, 32, 15, 8, &vpx_avg_8x8_msa),
-        make_tuple(16, 16, 0, 4, &vpx_avg_4x4_msa),
-        make_tuple(16, 16, 5, 4, &vpx_avg_4x4_msa),
-        make_tuple(32, 32, 15, 4, &vpx_avg_4x4_msa)));
+    ::testing::Values(make_tuple(16, 16, 0, 8, &vpx_avg_8x8_msa),
+                      make_tuple(16, 16, 5, 8, &vpx_avg_8x8_msa),
+                      make_tuple(32, 32, 15, 8, &vpx_avg_8x8_msa),
+                      make_tuple(16, 16, 0, 4, &vpx_avg_4x4_msa),
+                      make_tuple(16, 16, 5, 4, &vpx_avg_4x4_msa),
+                      make_tuple(32, 32, 15, 4, &vpx_avg_4x4_msa)));
 #endif
 
 }  // namespace
diff --git a/test/blend_a64_mask_1d_test.cc b/test/blend_a64_mask_1d_test.cc
index ba63afa..97608b8 100644
--- a/test/blend_a64_mask_1d_test.cc
+++ b/test/blend_a64_mask_1d_test.cc
@@ -31,7 +31,7 @@
 
 namespace {
 
-template<typename F, typename T>
+template <typename F, typename T>
 class BlendA64Mask1DTest : public FunctionEquivalenceTest<F> {
  public:
   static const int kIterations = 10000;
@@ -62,30 +62,29 @@
     T *p_src1;
 
     switch (this->rng_(3)) {
-      case 0:   // Separate sources
+      case 0:  // Separate sources
         p_src0 = src0_;
         p_src1 = src1_;
         break;
-      case 1:   // src0 == dst
+      case 1:  // src0 == dst
         p_src0 = dst_tst_;
         src0_stride_ = dst_stride_;
         src0_offset_ = dst_offset_;
         p_src1 = src1_;
         break;
-      case 2:   // src1 == dst
+      case 2:  // src1 == dst
         p_src0 = src0_;
         p_src1 = dst_tst_;
         src1_stride_ = dst_stride_;
         src1_offset_ = dst_offset_;
         break;
-      default:
-        FAIL();
+      default: FAIL();
     }
 
     Execute(p_src0, p_src1);
 
-    for (int r = 0 ; r < h_ ; ++r) {
-      for (int c = 0 ; c < w_ ; ++c) {
+    for (int r = 0; r < h_; ++r) {
+      for (int c = 0; c < w_; ++c) {
         ASSERT_EQ(dst_ref_[dst_offset_ + r * dst_stride_ + c],
                   dst_tst_[dst_offset_ + r * dst_stride_ + c]);
       }
@@ -115,28 +114,26 @@
 // 8 bit version
 //////////////////////////////////////////////////////////////////////////////
 
-typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride,
-                    const uint8_t *src0, uint32_t src0_stride,
-                    const uint8_t *src1, uint32_t src1_stride,
-                    const uint8_t *mask, int h, int w);
+typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+                    uint32_t src0_stride, const uint8_t *src1,
+                    uint32_t src1_stride, const uint8_t *mask, int h, int w);
 typedef libvpx_test::FuncParam<F8B> TestFuncs;
 
 class BlendA64Mask1DTest8B : public BlendA64Mask1DTest<F8B, uint8_t> {
  protected:
   void Execute(const uint8_t *p_src0, const uint8_t *p_src1) {
-    params_.ref_func(dst_ref_ + dst_offset_, dst_stride_,
-                     p_src0 + src0_offset_, src0_stride_,
-                     p_src1 + src1_offset_, src1_stride_, mask_, h_, w_);
-    ASM_REGISTER_STATE_CHECK(
-        params_.tst_func(dst_tst_ + dst_offset_, dst_stride_,
-                         p_src0 + src0_offset_, src0_stride_,
-                         p_src1 + src1_offset_, src1_stride_, mask_, h_, w_));
+    params_.ref_func(dst_ref_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
+                     src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_,
+                     h_, w_);
+    ASM_REGISTER_STATE_CHECK(params_.tst_func(
+        dst_tst_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
+        src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_, h_, w_));
   }
 };
 
 TEST_P(BlendA64Mask1DTest8B, RandomValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < kBufSize ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_.Rand8();
       dst_tst_[i] = rng_.Rand8();
 
@@ -144,7 +141,7 @@
       src1_[i] = rng_.Rand8();
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
 
     Common();
@@ -152,70 +149,62 @@
 }
 
 TEST_P(BlendA64Mask1DTest8B, ExtremeValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < kBufSize ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(2) + 254;
       dst_tst_[i] = rng_(2) + 254;
       src0_[i] = rng_(2) + 254;
       src1_[i] = rng_(2) + 254;
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
 
     Common();
   }
 }
 
-static void blend_a64_hmask_ref(
-    uint8_t *dst, uint32_t dst_stride,
-    const uint8_t *src0, uint32_t src0_stride,
-    const uint8_t *src1, uint32_t src1_stride,
-    const uint8_t *mask, int h, int w) {
+static void blend_a64_hmask_ref(uint8_t *dst, uint32_t dst_stride,
+                                const uint8_t *src0, uint32_t src0_stride,
+                                const uint8_t *src1, uint32_t src1_stride,
+                                const uint8_t *mask, int h, int w) {
   uint8_t mask2d[BlendA64Mask1DTest8B::kMaxMaskSize]
                 [BlendA64Mask1DTest8B::kMaxMaskSize];
 
-  for (int row = 0 ; row < h ; ++row)
-    for (int col = 0 ; col < w ; ++col)
-      mask2d[row][col] = mask[col];
+  for (int row = 0; row < h; ++row)
+    for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
 
-  vpx_blend_a64_mask_c(dst, dst_stride,
-                       src0, src0_stride,
-                       src1, src1_stride,
-                       &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize,
-                       h, w, 0, 0);
+  vpx_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
+                       &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, h, w,
+                       0, 0);
 }
 
-static void blend_a64_vmask_ref(
-    uint8_t *dst, uint32_t dst_stride,
-    const uint8_t *src0, uint32_t src0_stride,
-    const uint8_t *src1, uint32_t src1_stride,
-    const uint8_t *mask, int h, int w) {
+static void blend_a64_vmask_ref(uint8_t *dst, uint32_t dst_stride,
+                                const uint8_t *src0, uint32_t src0_stride,
+                                const uint8_t *src1, uint32_t src1_stride,
+                                const uint8_t *mask, int h, int w) {
   uint8_t mask2d[BlendA64Mask1DTest8B::kMaxMaskSize]
                 [BlendA64Mask1DTest8B::kMaxMaskSize];
 
-  for (int row = 0 ; row < h ; ++row)
-    for (int col = 0 ; col < w ; ++col)
-      mask2d[row][col] = mask[row];
+  for (int row = 0; row < h; ++row)
+    for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
 
-  vpx_blend_a64_mask_c(dst, dst_stride,
-                       src0, src0_stride,
-                       src1, src1_stride,
-                       &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize,
-                       h, w, 0, 0);
+  vpx_blend_a64_mask_c(dst, dst_stride, src0, src0_stride, src1, src1_stride,
+                       &mask2d[0][0], BlendA64Mask1DTest8B::kMaxMaskSize, h, w,
+                       0, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(
-  C, BlendA64Mask1DTest8B,
-  ::testing::Values(TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_c),
-                    TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_c)));
+    C, BlendA64Mask1DTest8B,
+    ::testing::Values(TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_c),
+                      TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_c)));
 
 #if HAVE_SSE4_1
 INSTANTIATE_TEST_CASE_P(
-  SSE4_1, BlendA64Mask1DTest8B,
-  ::testing::Values(
-      TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_sse4_1),
-      TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_sse4_1)));
+    SSE4_1, BlendA64Mask1DTest8B,
+    ::testing::Values(
+        TestFuncs(blend_a64_hmask_ref, vpx_blend_a64_hmask_sse4_1),
+        TestFuncs(blend_a64_vmask_ref, vpx_blend_a64_vmask_sse4_1)));
 #endif  // HAVE_SSE4_1
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -223,10 +212,10 @@
 // High bit-depth version
 //////////////////////////////////////////////////////////////////////////////
 
-typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride,
-                     const uint8_t *src0, uint32_t src0_stride,
-                     const uint8_t *src1, uint32_t src1_stride,
-                     const uint8_t *mask, int h, int w, int bd);
+typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+                     uint32_t src0_stride, const uint8_t *src1,
+                     uint32_t src1_stride, const uint8_t *mask, int h, int w,
+                     int bd);
 typedef libvpx_test::FuncParam<FHBD> TestFuncsHBD;
 
 class BlendA64Mask1DTestHBD : public BlendA64Mask1DTest<FHBD, uint16_t> {
@@ -239,37 +228,31 @@
     ASM_REGISTER_STATE_CHECK(params_.tst_func(
         CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
         CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
-        CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
-        mask_, h_, w_, bit_depth_));
+        CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_, mask_, h_, w_,
+        bit_depth_));
   }
 
   int bit_depth_;
 };
 
 TEST_P(BlendA64Mask1DTestHBD, RandomValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     switch (rng_(3)) {
-    case 0:
-      bit_depth_ = 8;
-      break;
-    case 1:
-      bit_depth_ = 10;
-      break;
-    default:
-      bit_depth_ = 12;
-      break;
+      case 0: bit_depth_ = 8; break;
+      case 1: bit_depth_ = 10; break;
+      default: bit_depth_ = 12; break;
     }
 
     const int hi = 1 << bit_depth_;
 
-    for (int i = 0 ; i < kBufSize ; ++i) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(hi);
       dst_tst_[i] = rng_(hi);
       src0_[i] = rng_(hi);
       src1_[i] = rng_(hi);
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
 
     Common();
@@ -277,30 +260,24 @@
 }
 
 TEST_P(BlendA64Mask1DTestHBD, ExtremeValues) {
-  for (int iter = 0 ; iter < 1000 && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < 1000 && !HasFatalFailure(); ++iter) {
     switch (rng_(3)) {
-    case 0:
-      bit_depth_ = 8;
-      break;
-    case 1:
-      bit_depth_ = 10;
-      break;
-    default:
-      bit_depth_ = 12;
-      break;
+      case 0: bit_depth_ = 8; break;
+      case 1: bit_depth_ = 10; break;
+      default: bit_depth_ = 12; break;
     }
 
     const int hi = 1 << bit_depth_;
     const int lo = hi - 2;
 
-    for (int i = 0 ; i < kBufSize ; ++i) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(hi - lo) + lo;
       dst_tst_[i] = rng_(hi - lo) + lo;
       src0_[i] = rng_(hi - lo) + lo;
       src1_[i] = rng_(hi - lo) + lo;
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
 
     Common();
@@ -308,59 +285,49 @@
 }
 
 static void highbd_blend_a64_hmask_ref(
-    uint8_t *dst, uint32_t dst_stride,
-    const uint8_t *src0, uint32_t src0_stride,
-    const uint8_t *src1, uint32_t src1_stride,
+    uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+    uint32_t src0_stride, const uint8_t *src1, uint32_t src1_stride,
     const uint8_t *mask, int h, int w, int bd) {
   uint8_t mask2d[BlendA64Mask1DTestHBD::kMaxMaskSize]
                 [BlendA64Mask1DTestHBD::kMaxMaskSize];
 
-  for (int row = 0 ; row < h ; ++row)
-    for (int col = 0 ; col < w ; ++col)
-      mask2d[row][col] = mask[col];
+  for (int row = 0; row < h; ++row)
+    for (int col = 0; col < w; ++col) mask2d[row][col] = mask[col];
 
-  vpx_highbd_blend_a64_mask_c(dst, dst_stride,
-                              src0, src0_stride,
-                              src1, src1_stride,
-                              &mask2d[0][0],
-                              BlendA64Mask1DTestHBD::kMaxMaskSize,
-                              h, w, 0, 0, bd);
+  vpx_highbd_blend_a64_mask_c(
+      dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
+      BlendA64Mask1DTestHBD::kMaxMaskSize, h, w, 0, 0, bd);
 }
 
 static void highbd_blend_a64_vmask_ref(
-    uint8_t *dst, uint32_t dst_stride,
-    const uint8_t *src0, uint32_t src0_stride,
-    const uint8_t *src1, uint32_t src1_stride,
+    uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+    uint32_t src0_stride, const uint8_t *src1, uint32_t src1_stride,
     const uint8_t *mask, int h, int w, int bd) {
   uint8_t mask2d[BlendA64Mask1DTestHBD::kMaxMaskSize]
                 [BlendA64Mask1DTestHBD::kMaxMaskSize];
 
-  for (int row = 0 ; row < h ; ++row)
-    for (int col = 0 ; col < w ; ++col)
-      mask2d[row][col] = mask[row];
+  for (int row = 0; row < h; ++row)
+    for (int col = 0; col < w; ++col) mask2d[row][col] = mask[row];
 
-  vpx_highbd_blend_a64_mask_c(dst, dst_stride,
-                              src0, src0_stride,
-                              src1, src1_stride,
-                              &mask2d[0][0],
-                              BlendA64Mask1DTestHBD::kMaxMaskSize,
-                              h, w, 0, 0, bd);
+  vpx_highbd_blend_a64_mask_c(
+      dst, dst_stride, src0, src0_stride, src1, src1_stride, &mask2d[0][0],
+      BlendA64Mask1DTestHBD::kMaxMaskSize, h, w, 0, 0, bd);
 }
 
 INSTANTIATE_TEST_CASE_P(
-  C, BlendA64Mask1DTestHBD,
-  ::testing::Values(
-      TestFuncsHBD(highbd_blend_a64_hmask_ref, vpx_highbd_blend_a64_hmask_c),
-      TestFuncsHBD(highbd_blend_a64_vmask_ref, vpx_highbd_blend_a64_vmask_c)));
+    C, BlendA64Mask1DTestHBD,
+    ::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
+                                   vpx_highbd_blend_a64_hmask_c),
+                      TestFuncsHBD(highbd_blend_a64_vmask_ref,
+                                   vpx_highbd_blend_a64_vmask_c)));
 
 #if HAVE_SSE4_1
 INSTANTIATE_TEST_CASE_P(
-  SSE4_1, BlendA64Mask1DTestHBD,
-  ::testing::Values(
-      TestFuncsHBD(highbd_blend_a64_hmask_ref,
-                   vpx_highbd_blend_a64_hmask_sse4_1),
-      TestFuncsHBD(highbd_blend_a64_vmask_ref,
-                   vpx_highbd_blend_a64_vmask_sse4_1)));
+    SSE4_1, BlendA64Mask1DTestHBD,
+    ::testing::Values(TestFuncsHBD(highbd_blend_a64_hmask_ref,
+                                   vpx_highbd_blend_a64_hmask_sse4_1),
+                      TestFuncsHBD(highbd_blend_a64_vmask_ref,
+                                   vpx_highbd_blend_a64_vmask_sse4_1)));
 #endif  // HAVE_SSE4_1
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
diff --git a/test/blend_a64_mask_test.cc b/test/blend_a64_mask_test.cc
index f6c09bb..ece3bc8 100644
--- a/test/blend_a64_mask_test.cc
+++ b/test/blend_a64_mask_test.cc
@@ -31,7 +31,7 @@
 
 namespace {
 
-template<typename F, typename T>
+template <typename F, typename T>
 class BlendA64MaskTest : public FunctionEquivalenceTest<F> {
  protected:
   static const int kIterations = 10000;
@@ -61,37 +61,36 @@
     src1_offset_ = this->rng_(33);
     src1_stride_ = this->rng_(kMaxWidth + 1 - w_) + w_;
 
-    mask_stride_ = this->rng_(kMaxWidth + 1 - w_ * (subx_ ? 2 : 1)) +
-                   w_ * (subx_ ? 2 : 1);
+    mask_stride_ =
+        this->rng_(kMaxWidth + 1 - w_ * (subx_ ? 2 : 1)) + w_ * (subx_ ? 2 : 1);
 
     T *p_src0;
     T *p_src1;
 
     switch (this->rng_(3)) {
-      case 0:   // Separate sources
+      case 0:  // Separate sources
         p_src0 = src0_;
         p_src1 = src1_;
         break;
-      case 1:   // src0 == dst
+      case 1:  // src0 == dst
         p_src0 = dst_tst_;
         src0_stride_ = dst_stride_;
         src0_offset_ = dst_offset_;
         p_src1 = src1_;
         break;
-      case 2:   // src1 == dst
+      case 2:  // src1 == dst
         p_src0 = src0_;
         p_src1 = dst_tst_;
         src1_stride_ = dst_stride_;
         src1_offset_ = dst_offset_;
         break;
-      default:
-        FAIL();
+      default: FAIL();
     }
 
     Execute(p_src0, p_src1);
 
-    for (int r = 0 ; r < h_ ; ++r) {
-      for (int c = 0 ; c < w_ ; ++c) {
+    for (int r = 0; r < h_; ++r) {
+      for (int c = 0; c < w_; ++c) {
         ASSERT_EQ(dst_ref_[dst_offset_ + r * dst_stride_ + c],
                   dst_tst_[dst_offset_ + r * dst_stride_ + c]);
       }
@@ -125,31 +124,28 @@
 // 8 bit version
 //////////////////////////////////////////////////////////////////////////////
 
-typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride,
-                    const uint8_t *src0, uint32_t src0_stride,
-                    const uint8_t *src1, uint32_t src1_stride,
-                    const uint8_t *mask, uint32_t mask_stride,
-                    int h, int w, int suby, int subx);
+typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+                    uint32_t src0_stride, const uint8_t *src1,
+                    uint32_t src1_stride, const uint8_t *mask,
+                    uint32_t mask_stride, int h, int w, int suby, int subx);
 typedef libvpx_test::FuncParam<F8B> TestFuncs;
 
 class BlendA64MaskTest8B : public BlendA64MaskTest<F8B, uint8_t> {
  protected:
   void Execute(const uint8_t *p_src0, const uint8_t *p_src1) {
-    params_.ref_func(dst_ref_ + dst_offset_, dst_stride_,
-                     p_src0 + src0_offset_, src0_stride_,
-                     p_src1 + src1_offset_, src1_stride_,
-                     mask_, kMaxMaskWidth, h_, w_, suby_, subx_);
-    ASM_REGISTER_STATE_CHECK(
-        params_.tst_func(dst_tst_ + dst_offset_, dst_stride_,
-                         p_src0 + src0_offset_, src0_stride_,
-                         p_src1 + src1_offset_, src1_stride_,
-                         mask_, kMaxMaskWidth, h_, w_, suby_, subx_));
+    params_.ref_func(dst_ref_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
+                     src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_,
+                     kMaxMaskWidth, h_, w_, suby_, subx_);
+    ASM_REGISTER_STATE_CHECK(params_.tst_func(
+        dst_tst_ + dst_offset_, dst_stride_, p_src0 + src0_offset_,
+        src0_stride_, p_src1 + src1_offset_, src1_stride_, mask_, kMaxMaskWidth,
+        h_, w_, suby_, subx_));
   }
 };
 
 TEST_P(BlendA64MaskTest8B, RandomValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < kBufSize ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_.Rand8();
       dst_tst_[i] = rng_.Rand8();
 
@@ -157,7 +153,7 @@
       src1_[i] = rng_.Rand8();
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
 
     Common();
@@ -165,15 +161,15 @@
 }
 
 TEST_P(BlendA64MaskTest8B, ExtremeValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < kBufSize ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(2) + 254;
       dst_tst_[i] = rng_(2) + 254;
       src0_[i] = rng_(2) + 254;
       src1_[i] = rng_(2) + 254;
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
 
     Common();
@@ -181,10 +177,9 @@
 }
 
 #if HAVE_SSE4_1
-INSTANTIATE_TEST_CASE_P(
-  SSE4_1_C_COMPARE, BlendA64MaskTest8B,
-  ::testing::Values(
-      TestFuncs(vpx_blend_a64_mask_c, vpx_blend_a64_mask_sse4_1)));
+INSTANTIATE_TEST_CASE_P(SSE4_1_C_COMPARE, BlendA64MaskTest8B,
+                        ::testing::Values(TestFuncs(
+                            vpx_blend_a64_mask_c, vpx_blend_a64_mask_sse4_1)));
 #endif  // HAVE_SSE4_1
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -192,11 +187,11 @@
 // High bit-depth version
 //////////////////////////////////////////////////////////////////////////////
 
-typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride,
-                     const uint8_t *src0, uint32_t src0_stride,
-                     const uint8_t *src1, uint32_t src1_stride,
-                     const uint8_t *mask, uint32_t mask_stride,
-                     int h, int w, int suby, int subx, int bd);
+typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride, const uint8_t *src0,
+                     uint32_t src0_stride, const uint8_t *src1,
+                     uint32_t src1_stride, const uint8_t *mask,
+                     uint32_t mask_stride, int h, int w, int suby, int subx,
+                     int bd);
 typedef libvpx_test::FuncParam<FHBD> TestFuncsHBD;
 
 class BlendA64MaskTestHBD : public BlendA64MaskTest<FHBD, uint16_t> {
@@ -209,37 +204,31 @@
     ASM_REGISTER_STATE_CHECK(params_.tst_func(
         CONVERT_TO_BYTEPTR(dst_tst_ + dst_offset_), dst_stride_,
         CONVERT_TO_BYTEPTR(p_src0 + src0_offset_), src0_stride_,
-        CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_,
-        mask_, kMaxMaskWidth, h_, w_, suby_, subx_, bit_depth_));
+        CONVERT_TO_BYTEPTR(p_src1 + src1_offset_), src1_stride_, mask_,
+        kMaxMaskWidth, h_, w_, suby_, subx_, bit_depth_));
   }
 
   int bit_depth_;
 };
 
 TEST_P(BlendA64MaskTestHBD, RandomValues) {
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     switch (rng_(3)) {
-    case 0:
-      bit_depth_ = 8;
-      break;
-    case 1:
-      bit_depth_ = 10;
-      break;
-    default:
-      bit_depth_ = 12;
-      break;
+      case 0: bit_depth_ = 8; break;
+      case 1: bit_depth_ = 10; break;
+      default: bit_depth_ = 12; break;
     }
 
     const int hi = 1 << bit_depth_;
 
-    for (int i = 0 ; i < kBufSize ; ++i) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(hi);
       dst_tst_[i] = rng_(hi);
       src0_[i] = rng_(hi);
       src1_[i] = rng_(hi);
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(VPX_BLEND_A64_MAX_ALPHA + 1);
 
     Common();
@@ -247,30 +236,24 @@
 }
 
 TEST_P(BlendA64MaskTestHBD, ExtremeValues) {
-  for (int iter = 0 ; iter < 1000 && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < 1000 && !HasFatalFailure(); ++iter) {
     switch (rng_(3)) {
-    case 0:
-      bit_depth_ = 8;
-      break;
-    case 1:
-      bit_depth_ = 10;
-      break;
-    default:
-      bit_depth_ = 12;
-      break;
+      case 0: bit_depth_ = 8; break;
+      case 1: bit_depth_ = 10; break;
+      default: bit_depth_ = 12; break;
     }
 
     const int hi = 1 << bit_depth_;
     const int lo = hi - 2;
 
-    for (int i = 0 ; i < kBufSize ; ++i) {
+    for (int i = 0; i < kBufSize; ++i) {
       dst_ref_[i] = rng_(hi - lo) + lo;
       dst_tst_[i] = rng_(hi - lo) + lo;
       src0_[i] = rng_(hi - lo) + lo;
       src1_[i] = rng_(hi - lo) + lo;
     }
 
-    for (int i = 0 ; i < kMaxMaskSize ; ++i)
+    for (int i = 0; i < kMaxMaskSize; ++i)
       mask_[i] = rng_(2) + VPX_BLEND_A64_MAX_ALPHA - 1;
 
     Common();
@@ -279,10 +262,9 @@
 
 #if HAVE_SSE4_1
 INSTANTIATE_TEST_CASE_P(
-  SSE4_1_C_COMPARE, BlendA64MaskTestHBD,
-  ::testing::Values(
-      TestFuncsHBD(vpx_highbd_blend_a64_mask_c,
-                   vpx_highbd_blend_a64_mask_sse4_1)));
+    SSE4_1_C_COMPARE, BlendA64MaskTestHBD,
+    ::testing::Values(TestFuncsHBD(vpx_highbd_blend_a64_mask_c,
+                                   vpx_highbd_blend_a64_mask_sse4_1)));
 #endif  // HAVE_SSE4_1
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 }  // namespace
diff --git a/test/boolcoder_test.cc b/test/boolcoder_test.cc
index c61bb4a..5dbfd5c 100644
--- a/test/boolcoder_test.cc
+++ b/test/boolcoder_test.cc
@@ -28,12 +28,13 @@
 TEST(VP9, TestBitIO) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
   for (int n = 0; n < num_tests; ++n) {
-    for (int method = 0; method <= 7; ++method) {   // we generate various proba
+    for (int method = 0; method <= 7; ++method) {  // we generate various proba
       const int kBitsToTest = 1000;
       uint8_t probas[kBitsToTest];
 
       for (int i = 0; i < kBitsToTest; ++i) {
         const int parity = i & 1;
+        /* clang-format off */
         probas[i] =
           (method == 0) ? 0 : (method == 1) ? 255 :
           (method == 2) ? 128 :
@@ -44,6 +45,7 @@
             (method == 6) ?
             (parity ? rnd(64) : 255 - rnd(64)) :
             (parity ? rnd(32) : 255 - rnd(32));
+        /* clang-format on */
       }
       for (int bit_method = 0; bit_method <= 3; ++bit_method) {
         const int random_seed = 6432;
@@ -79,8 +81,7 @@
           }
           GTEST_ASSERT_EQ(vpx_read(&br, probas[i]), bit)
               << "pos: " << i << " / " << kBitsToTest
-              << " bit_method: " << bit_method
-              << " method: " << method;
+              << " bit_method: " << bit_method << " method: " << method;
         }
       }
     }
diff --git a/test/borders_test.cc b/test/borders_test.cc
index 088b8f2..9057631 100644
--- a/test/borders_test.cc
+++ b/test/borders_test.cc
@@ -17,8 +17,9 @@
 
 namespace {
 
-class BordersTest : public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
+class BordersTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   BordersTest() : EncoderTest(GET_PARAM(0)) {}
   virtual ~BordersTest() {}
@@ -78,6 +79,6 @@
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 }
 
-VP10_INSTANTIATE_TEST_CASE(BordersTest, ::testing::Values(
-    ::libvpx_test::kTwoPassGood));
+VP10_INSTANTIATE_TEST_CASE(BordersTest,
+                           ::testing::Values(::libvpx_test::kTwoPassGood));
 }  // namespace
diff --git a/test/clear_system_state.h b/test/clear_system_state.h
index 5e76797..044a5c7 100644
--- a/test/clear_system_state.h
+++ b/test/clear_system_state.h
@@ -12,7 +12,7 @@
 
 #include "./vpx_config.h"
 #if ARCH_X86 || ARCH_X86_64
-# include "vpx_ports/x86.h"
+#include "vpx_ports/x86.h"
 #endif
 
 namespace libvpx_test {
diff --git a/test/codec_factory.h b/test/codec_factory.h
index e16dbbe..6a8d0c8 100644
--- a/test/codec_factory.h
+++ b/test/codec_factory.h
@@ -32,15 +32,15 @@
 
   virtual ~CodecFactory() {}
 
-  virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg,
+  virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
                                  unsigned long deadline) const = 0;
 
-  virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg,
+  virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
                                  const vpx_codec_flags_t flags,
                                  unsigned long deadline)  // NOLINT(runtime/int)
-                                 const = 0;
+      const = 0;
 
-  virtual Encoder* CreateEncoder(vpx_codec_enc_cfg_t cfg,
+  virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
                                  unsigned long deadline,
                                  const unsigned long init_flags,
                                  TwopassStatsStore *stats) const = 0;
@@ -53,20 +53,20 @@
  * to avoid having to include a pointer to the CodecFactory in every test
  * definition.
  */
-template<class T1>
-class CodecTestWithParam : public ::testing::TestWithParam<
-    std::tr1::tuple< const libvpx_test::CodecFactory*, T1 > > {
-};
+template <class T1>
+class CodecTestWithParam
+    : public ::testing::TestWithParam<
+          std::tr1::tuple<const libvpx_test::CodecFactory *, T1> > {};
 
-template<class T1, class T2>
-class CodecTestWith2Params : public ::testing::TestWithParam<
-    std::tr1::tuple< const libvpx_test::CodecFactory*, T1, T2 > > {
-};
+template <class T1, class T2>
+class CodecTestWith2Params
+    : public ::testing::TestWithParam<
+          std::tr1::tuple<const libvpx_test::CodecFactory *, T1, T2> > {};
 
-template<class T1, class T2, class T3>
-class CodecTestWith3Params : public ::testing::TestWithParam<
-    std::tr1::tuple< const libvpx_test::CodecFactory*, T1, T2, T3 > > {
-};
+template <class T1, class T2, class T3>
+class CodecTestWith3Params
+    : public ::testing::TestWithParam<
+          std::tr1::tuple<const libvpx_test::CodecFactory *, T1, T2, T3> > {};
 
 /*
  * VP10 Codec Definitions
@@ -82,7 +82,7 @@
       : Decoder(cfg, flag, deadline) {}
 
  protected:
-  virtual vpx_codec_iface_t* CodecInterface() const {
+  virtual vpx_codec_iface_t *CodecInterface() const {
 #if CONFIG_VP10_DECODER
     return &vpx_codec_vp10_dx_algo;
 #else
@@ -98,7 +98,7 @@
       : Encoder(cfg, deadline, init_flags, stats) {}
 
  protected:
-  virtual vpx_codec_iface_t* CodecInterface() const {
+  virtual vpx_codec_iface_t *CodecInterface() const {
 #if CONFIG_VP10_ENCODER
     return &vpx_codec_vp10_cx_algo;
 #else
@@ -111,12 +111,12 @@
  public:
   VP10CodecFactory() : CodecFactory() {}
 
-  virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg,
+  virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
                                  unsigned long deadline) const {
     return CreateDecoder(cfg, 0, deadline);
   }
 
-  virtual Decoder* CreateDecoder(vpx_codec_dec_cfg_t cfg,
+  virtual Decoder *CreateDecoder(vpx_codec_dec_cfg_t cfg,
                                  const vpx_codec_flags_t flags,
                                  unsigned long deadline) const {  // NOLINT
 #if CONFIG_VP10_DECODER
@@ -126,7 +126,7 @@
 #endif
   }
 
-  virtual Encoder* CreateEncoder(vpx_codec_enc_cfg_t cfg,
+  virtual Encoder *CreateEncoder(vpx_codec_enc_cfg_t cfg,
                                  unsigned long deadline,
                                  const unsigned long init_flags,
                                  TwopassStatsStore *stats) const {
@@ -149,11 +149,12 @@
 
 const libvpx_test::VP10CodecFactory kVP10;
 
-#define VP10_INSTANTIATE_TEST_CASE(test, ...)\
-  INSTANTIATE_TEST_CASE_P(VP10, test, \
-      ::testing::Combine( \
-          ::testing::Values(static_cast<const libvpx_test::CodecFactory*>( \
-               &libvpx_test::kVP10)), \
+#define VP10_INSTANTIATE_TEST_CASE(test, ...)                               \
+  INSTANTIATE_TEST_CASE_P(                                                  \
+      VP10, test,                                                           \
+      ::testing::Combine(                                                   \
+          ::testing::Values(static_cast<const libvpx_test::CodecFactory *>( \
+              &libvpx_test::kVP10)),                                        \
           __VA_ARGS__))
 #else
 #define VP10_INSTANTIATE_TEST_CASE(test, ...)
diff --git a/test/convolve_test.cc b/test/convolve_test.cc
index f9bea21..e3e75d1 100644
--- a/test/convolve_test.cc
+++ b/test/convolve_test.cc
@@ -34,14 +34,12 @@
                              int w, int h);
 
 struct ConvolveFunctions {
-  ConvolveFunctions(ConvolveFunc copy, ConvolveFunc avg,
-                    ConvolveFunc h8, ConvolveFunc h8_avg,
-                    ConvolveFunc v8, ConvolveFunc v8_avg,
-                    ConvolveFunc hv8, ConvolveFunc hv8_avg,
-                    ConvolveFunc sh8, ConvolveFunc sh8_avg,
-                    ConvolveFunc sv8, ConvolveFunc sv8_avg,
-                    ConvolveFunc shv8, ConvolveFunc shv8_avg,
-                    int bd)
+  ConvolveFunctions(ConvolveFunc copy, ConvolveFunc avg, ConvolveFunc h8,
+                    ConvolveFunc h8_avg, ConvolveFunc v8, ConvolveFunc v8_avg,
+                    ConvolveFunc hv8, ConvolveFunc hv8_avg, ConvolveFunc sh8,
+                    ConvolveFunc sh8_avg, ConvolveFunc sv8,
+                    ConvolveFunc sv8_avg, ConvolveFunc shv8,
+                    ConvolveFunc shv8_avg, int bd)
       : copy_(copy), avg_(avg), h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg),
         v8_avg_(v8_avg), hv8_avg_(hv8_avg), sh8_(sh8), sv8_(sv8), shv8_(shv8),
         sh8_avg_(sh8_avg), sv8_avg_(sv8_avg), shv8_avg_(shv8_avg),
@@ -55,69 +53,47 @@
   ConvolveFunc h8_avg_;
   ConvolveFunc v8_avg_;
   ConvolveFunc hv8_avg_;
-  ConvolveFunc sh8_;        // scaled horiz
-  ConvolveFunc sv8_;        // scaled vert
-  ConvolveFunc shv8_;       // scaled horiz/vert
-  ConvolveFunc sh8_avg_;    // scaled avg horiz
-  ConvolveFunc sv8_avg_;    // scaled avg vert
-  ConvolveFunc shv8_avg_;   // scaled avg horiz/vert
+  ConvolveFunc sh8_;       // scaled horiz
+  ConvolveFunc sv8_;       // scaled vert
+  ConvolveFunc shv8_;      // scaled horiz/vert
+  ConvolveFunc sh8_avg_;   // scaled avg horiz
+  ConvolveFunc sv8_avg_;   // scaled avg vert
+  ConvolveFunc shv8_avg_;  // scaled avg horiz/vert
   int use_highbd_;  // 0 if high bitdepth not used, else the actual bit depth.
 };
 
 typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam;
 
 #if CONFIG_VP10 && CONFIG_EXT_PARTITION
-#define ALL_SIZES(convolve_fn) \
-    make_tuple(128, 64, &convolve_fn),  \
-    make_tuple(64, 128, &convolve_fn),  \
-    make_tuple(128, 128, &convolve_fn), \
-    make_tuple(4, 4, &convolve_fn),     \
-    make_tuple(8, 4, &convolve_fn),     \
-    make_tuple(4, 8, &convolve_fn),     \
-    make_tuple(8, 8, &convolve_fn),     \
-    make_tuple(16, 8, &convolve_fn),    \
-    make_tuple(8, 16, &convolve_fn),    \
-    make_tuple(16, 16, &convolve_fn),   \
-    make_tuple(32, 16, &convolve_fn),   \
-    make_tuple(16, 32, &convolve_fn),   \
-    make_tuple(32, 32, &convolve_fn),   \
-    make_tuple(64, 32, &convolve_fn),   \
-    make_tuple(32, 64, &convolve_fn),   \
-    make_tuple(64, 64, &convolve_fn)
+#define ALL_SIZES(convolve_fn)                                            \
+  make_tuple(128, 64, &convolve_fn), make_tuple(64, 128, &convolve_fn),   \
+      make_tuple(128, 128, &convolve_fn), make_tuple(4, 4, &convolve_fn), \
+      make_tuple(8, 4, &convolve_fn), make_tuple(4, 8, &convolve_fn),     \
+      make_tuple(8, 8, &convolve_fn), make_tuple(16, 8, &convolve_fn),    \
+      make_tuple(8, 16, &convolve_fn), make_tuple(16, 16, &convolve_fn),  \
+      make_tuple(32, 16, &convolve_fn), make_tuple(16, 32, &convolve_fn), \
+      make_tuple(32, 32, &convolve_fn), make_tuple(64, 32, &convolve_fn), \
+      make_tuple(32, 64, &convolve_fn), make_tuple(64, 64, &convolve_fn)
 #else
-#define ALL_SIZES(convolve_fn) \
-    make_tuple(4, 4, &convolve_fn),     \
-    make_tuple(8, 4, &convolve_fn),     \
-    make_tuple(4, 8, &convolve_fn),     \
-    make_tuple(8, 8, &convolve_fn),     \
-    make_tuple(16, 8, &convolve_fn),    \
-    make_tuple(8, 16, &convolve_fn),    \
-    make_tuple(16, 16, &convolve_fn),   \
-    make_tuple(32, 16, &convolve_fn),   \
-    make_tuple(16, 32, &convolve_fn),   \
-    make_tuple(32, 32, &convolve_fn),   \
-    make_tuple(64, 32, &convolve_fn),   \
-    make_tuple(32, 64, &convolve_fn),   \
-    make_tuple(64, 64, &convolve_fn)
+#define ALL_SIZES(convolve_fn)                                            \
+  make_tuple(4, 4, &convolve_fn), make_tuple(8, 4, &convolve_fn),         \
+      make_tuple(4, 8, &convolve_fn), make_tuple(8, 8, &convolve_fn),     \
+      make_tuple(16, 8, &convolve_fn), make_tuple(8, 16, &convolve_fn),   \
+      make_tuple(16, 16, &convolve_fn), make_tuple(32, 16, &convolve_fn), \
+      make_tuple(16, 32, &convolve_fn), make_tuple(32, 32, &convolve_fn), \
+      make_tuple(64, 32, &convolve_fn), make_tuple(32, 64, &convolve_fn), \
+      make_tuple(64, 64, &convolve_fn)
 #endif  // CONFIG_VP10 && CONFIG_EXT_PARTITION
 
 // Reference 8-tap subpixel filter, slightly modified to fit into this test.
 #define VP9_FILTER_WEIGHT 128
 #define VP9_FILTER_SHIFT 7
-uint8_t clip_pixel(int x) {
-  return x < 0 ? 0 :
-         x > 255 ? 255 :
-         x;
-}
+uint8_t clip_pixel(int x) { return x < 0 ? 0 : x > 255 ? 255 : x; }
 
-void filter_block2d_8_c(const uint8_t *src_ptr,
-                        const unsigned int src_stride,
-                        const int16_t *HFilter,
-                        const int16_t *VFilter,
-                        uint8_t *dst_ptr,
-                        unsigned int dst_stride,
-                        unsigned int output_width,
-                        unsigned int output_height) {
+void filter_block2d_8_c(const uint8_t *src_ptr, const unsigned int src_stride,
+                        const int16_t *HFilter, const int16_t *VFilter,
+                        uint8_t *dst_ptr, unsigned int dst_stride,
+                        unsigned int output_width, unsigned int output_height) {
   // Between passes, we use an intermediate buffer whose height is extended to
   // have enough horizontally filtered values as input for the vertical pass.
   // This buffer is allocated to be big enough for the largest block type we
@@ -134,7 +110,7 @@
   //                               = 23
   // and filter_max_width          = 16
   //
-  uint8_t intermediate_buffer[(kMaxDimension+8) * kMaxDimension];
+  uint8_t intermediate_buffer[(kMaxDimension + 8) * kMaxDimension];
   const int intermediate_next_stride =
       1 - static_cast<int>(intermediate_height * output_width);
 
@@ -145,15 +121,11 @@
   for (i = 0; i < intermediate_height; ++i) {
     for (j = 0; j < output_width; ++j) {
       // Apply filter...
-      const int temp = (src_ptr[0] * HFilter[0]) +
-          (src_ptr[1] * HFilter[1]) +
-          (src_ptr[2] * HFilter[2]) +
-          (src_ptr[3] * HFilter[3]) +
-          (src_ptr[4] * HFilter[4]) +
-          (src_ptr[5] * HFilter[5]) +
-          (src_ptr[6] * HFilter[6]) +
-          (src_ptr[7] * HFilter[7]) +
-          (VP9_FILTER_WEIGHT >> 1);  // Rounding
+      const int temp = (src_ptr[0] * HFilter[0]) + (src_ptr[1] * HFilter[1]) +
+                       (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
+                       (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
+                       (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
+                       (VP9_FILTER_WEIGHT >> 1);  // Rounding
 
       // Normalize back to 0-255...
       *output_ptr = clip_pixel(temp >> VP9_FILTER_SHIFT);
@@ -170,15 +142,11 @@
   for (i = 0; i < output_height; ++i) {
     for (j = 0; j < output_width; ++j) {
       // Apply filter...
-      const int temp = (src_ptr[0] * VFilter[0]) +
-          (src_ptr[1] * VFilter[1]) +
-          (src_ptr[2] * VFilter[2]) +
-          (src_ptr[3] * VFilter[3]) +
-          (src_ptr[4] * VFilter[4]) +
-          (src_ptr[5] * VFilter[5]) +
-          (src_ptr[6] * VFilter[6]) +
-          (src_ptr[7] * VFilter[7]) +
-          (VP9_FILTER_WEIGHT >> 1);  // Rounding
+      const int temp = (src_ptr[0] * VFilter[0]) + (src_ptr[1] * VFilter[1]) +
+                       (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
+                       (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
+                       (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
+                       (VP9_FILTER_WEIGHT >> 1);  // Rounding
 
       // Normalize back to 0-255...
       *dst_ptr++ = clip_pixel(temp >> VP9_FILTER_SHIFT);
@@ -189,12 +157,9 @@
   }
 }
 
-void block2d_average_c(uint8_t *src,
-                       unsigned int src_stride,
-                       uint8_t *output_ptr,
-                       unsigned int output_stride,
-                       unsigned int output_width,
-                       unsigned int output_height) {
+void block2d_average_c(uint8_t *src, unsigned int src_stride,
+                       uint8_t *output_ptr, unsigned int output_stride,
+                       unsigned int output_width, unsigned int output_height) {
   unsigned int i, j;
   for (i = 0; i < output_height; ++i) {
     for (j = 0; j < output_width; ++j) {
@@ -206,10 +171,8 @@
 
 void filter_average_block2d_8_c(const uint8_t *src_ptr,
                                 const unsigned int src_stride,
-                                const int16_t *HFilter,
-                                const int16_t *VFilter,
-                                uint8_t *dst_ptr,
-                                unsigned int dst_stride,
+                                const int16_t *HFilter, const int16_t *VFilter,
+                                uint8_t *dst_ptr, unsigned int dst_stride,
                                 unsigned int output_width,
                                 unsigned int output_height) {
   uint8_t tmp[kMaxDimension * kMaxDimension];
@@ -218,20 +181,17 @@
   assert(output_height <= kMaxDimension);
   filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, kMaxDimension,
                      output_width, output_height);
-  block2d_average_c(tmp, kMaxDimension, dst_ptr, dst_stride,
-                    output_width, output_height);
+  block2d_average_c(tmp, kMaxDimension, dst_ptr, dst_stride, output_width,
+                    output_height);
 }
 
 #if CONFIG_VP9_HIGHBITDEPTH
 void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
                                const unsigned int src_stride,
-                               const int16_t *HFilter,
-                               const int16_t *VFilter,
-                               uint16_t *dst_ptr,
-                               unsigned int dst_stride,
+                               const int16_t *HFilter, const int16_t *VFilter,
+                               uint16_t *dst_ptr, unsigned int dst_stride,
                                unsigned int output_width,
-                               unsigned int output_height,
-                               int bd) {
+                               unsigned int output_height, int bd) {
   // Between passes, we use an intermediate buffer whose height is extended to
   // have enough horizontally filtered values as input for the vertical pass.
   // This buffer is allocated to be big enough for the largest block type we
@@ -247,7 +207,7 @@
    *                               = 23
    * and filter_max_width = 16
    */
-  uint16_t intermediate_buffer[(kMaxDimension+8) * kMaxDimension];
+  uint16_t intermediate_buffer[(kMaxDimension + 8) * kMaxDimension];
   const int intermediate_next_stride =
       1 - static_cast<int>(intermediate_height * output_width);
 
@@ -260,14 +220,10 @@
     for (i = 0; i < intermediate_height; ++i) {
       for (j = 0; j < output_width; ++j) {
         // Apply filter...
-        const int temp = (src_ptr[0] * HFilter[0]) +
-                         (src_ptr[1] * HFilter[1]) +
-                         (src_ptr[2] * HFilter[2]) +
-                         (src_ptr[3] * HFilter[3]) +
-                         (src_ptr[4] * HFilter[4]) +
-                         (src_ptr[5] * HFilter[5]) +
-                         (src_ptr[6] * HFilter[6]) +
-                         (src_ptr[7] * HFilter[7]) +
+        const int temp = (src_ptr[0] * HFilter[0]) + (src_ptr[1] * HFilter[1]) +
+                         (src_ptr[2] * HFilter[2]) + (src_ptr[3] * HFilter[3]) +
+                         (src_ptr[4] * HFilter[4]) + (src_ptr[5] * HFilter[5]) +
+                         (src_ptr[6] * HFilter[6]) + (src_ptr[7] * HFilter[7]) +
                          (VP9_FILTER_WEIGHT >> 1);  // Rounding
 
         // Normalize back to 0-255...
@@ -288,14 +244,10 @@
     for (i = 0; i < output_height; ++i) {
       for (j = 0; j < output_width; ++j) {
         // Apply filter...
-        const int temp = (src_ptr[0] * VFilter[0]) +
-                         (src_ptr[1] * VFilter[1]) +
-                         (src_ptr[2] * VFilter[2]) +
-                         (src_ptr[3] * VFilter[3]) +
-                         (src_ptr[4] * VFilter[4]) +
-                         (src_ptr[5] * VFilter[5]) +
-                         (src_ptr[6] * VFilter[6]) +
-                         (src_ptr[7] * VFilter[7]) +
+        const int temp = (src_ptr[0] * VFilter[0]) + (src_ptr[1] * VFilter[1]) +
+                         (src_ptr[2] * VFilter[2]) + (src_ptr[3] * VFilter[3]) +
+                         (src_ptr[4] * VFilter[4]) + (src_ptr[5] * VFilter[5]) +
+                         (src_ptr[6] * VFilter[6]) + (src_ptr[7] * VFilter[7]) +
                          (VP9_FILTER_WEIGHT >> 1);  // Rounding
 
         // Normalize back to 0-255...
@@ -308,10 +260,8 @@
   }
 }
 
-void highbd_block2d_average_c(uint16_t *src,
-                              unsigned int src_stride,
-                              uint16_t *output_ptr,
-                              unsigned int output_stride,
+void highbd_block2d_average_c(uint16_t *src, unsigned int src_stride,
+                              uint16_t *output_ptr, unsigned int output_stride,
                               unsigned int output_width,
                               unsigned int output_height) {
   unsigned int i, j;
@@ -323,22 +273,17 @@
   }
 }
 
-void highbd_filter_average_block2d_8_c(const uint16_t *src_ptr,
-                                       const unsigned int src_stride,
-                                       const int16_t *HFilter,
-                                       const int16_t *VFilter,
-                                       uint16_t *dst_ptr,
-                                       unsigned int dst_stride,
-                                       unsigned int output_width,
-                                       unsigned int output_height,
-                                       int bd) {
+void highbd_filter_average_block2d_8_c(
+    const uint16_t *src_ptr, const unsigned int src_stride,
+    const int16_t *HFilter, const int16_t *VFilter, uint16_t *dst_ptr,
+    unsigned int dst_stride, unsigned int output_width,
+    unsigned int output_height, int bd) {
   uint16_t tmp[kMaxDimension * kMaxDimension];
 
   assert(output_width <= kMaxDimension);
   assert(output_height <= kMaxDimension);
-  highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
-                            tmp, kMaxDimension,
-                            output_width, output_height, bd);
+  highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp,
+                            kMaxDimension, output_width, output_height, bd);
   highbd_block2d_average_c(tmp, kMaxDimension, dst_ptr, dst_stride,
                            output_width, output_height);
 }
@@ -348,19 +293,20 @@
  public:
   static void SetUpTestCase() {
     // Force input_ to be unaligned, output to be 16 byte aligned.
-    input_ = reinterpret_cast<uint8_t*>(
-        vpx_memalign(kDataAlignment, kInputBufferSize + 1)) + 1;
-    output_ = reinterpret_cast<uint8_t*>(
+    input_ = reinterpret_cast<uint8_t *>(
+                 vpx_memalign(kDataAlignment, kInputBufferSize + 1)) +
+             1;
+    output_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kOutputBufferSize));
-    output_ref_ = reinterpret_cast<uint8_t*>(
+    output_ref_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kOutputBufferSize));
 #if CONFIG_VP9_HIGHBITDEPTH
-    input16_ = reinterpret_cast<uint16_t*>(
-        vpx_memalign(kDataAlignment,
-                     (kInputBufferSize + 1) * sizeof(uint16_t))) + 1;
-    output16_ = reinterpret_cast<uint16_t*>(
+    input16_ = reinterpret_cast<uint16_t *>(vpx_memalign(
+                   kDataAlignment, (kInputBufferSize + 1) * sizeof(uint16_t))) +
+               1;
+    output16_ = reinterpret_cast<uint16_t *>(
         vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
-    output16_ref_ = reinterpret_cast<uint16_t*>(
+    output16_ref_ = reinterpret_cast<uint16_t *>(
         vpx_memalign(kDataAlignment, (kOutputBufferSize) * sizeof(uint16_t)));
 #endif
   }
@@ -386,7 +332,7 @@
 
  protected:
   static const int kDataAlignment = 16;
-  static const int kOuterBlockSize = 4*kMaxDimension;
+  static const int kOuterBlockSize = 4 * kMaxDimension;
   static const int kInputStride = kOuterBlockSize;
   static const int kOutputStride = kOuterBlockSize;
   static const int kInputBufferSize = kOuterBlockSize * kOuterBlockSize;
@@ -456,8 +402,7 @@
 
   void CheckGuardBlocks() {
     for (int i = 0; i < kOutputBufferSize; ++i) {
-      if (IsIndexInBorder(i))
-        EXPECT_EQ(255, output_[i]);
+      if (IsIndexInBorder(i)) EXPECT_EQ(255, output_[i]);
     }
   }
 
@@ -515,98 +460,88 @@
   void assign_val(uint8_t *list, int index, uint16_t val) const {
 #if CONFIG_VP9_HIGHBITDEPTH
     if (UUT_->use_highbd_ == 0) {
-      list[index] = (uint8_t) val;
+      list[index] = (uint8_t)val;
     } else {
       CONVERT_TO_SHORTPTR(list)[index] = val;
     }
 #else
-    list[index] = (uint8_t) val;
+    list[index] = (uint8_t)val;
 #endif
   }
 
-  void wrapper_filter_average_block2d_8_c(const uint8_t *src_ptr,
-                                          const unsigned int src_stride,
-                                          const int16_t *HFilter,
-                                          const int16_t *VFilter,
-                                          uint8_t *dst_ptr,
-                                          unsigned int dst_stride,
-                                          unsigned int output_width,
-                                          unsigned int output_height) {
+  void wrapper_filter_average_block2d_8_c(
+      const uint8_t *src_ptr, const unsigned int src_stride,
+      const int16_t *HFilter, const int16_t *VFilter, uint8_t *dst_ptr,
+      unsigned int dst_stride, unsigned int output_width,
+      unsigned int output_height) {
 #if CONFIG_VP9_HIGHBITDEPTH
     if (UUT_->use_highbd_ == 0) {
-      filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
-                                 dst_ptr, dst_stride, output_width,
-                                 output_height);
+      filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
+                                 dst_stride, output_width, output_height);
     } else {
-      highbd_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr),
-                                        src_stride, HFilter, VFilter,
-                                        CONVERT_TO_SHORTPTR(dst_ptr),
-                                        dst_stride, output_width, output_height,
-                                        UUT_->use_highbd_);
+      highbd_filter_average_block2d_8_c(
+          CONVERT_TO_SHORTPTR(src_ptr), src_stride, HFilter, VFilter,
+          CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, output_width, output_height,
+          UUT_->use_highbd_);
     }
 #else
-    filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
-                               dst_ptr, dst_stride, output_width,
-                               output_height);
+    filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
+                               dst_stride, output_width, output_height);
 #endif
   }
 
   void wrapper_filter_block2d_8_c(const uint8_t *src_ptr,
                                   const unsigned int src_stride,
                                   const int16_t *HFilter,
-                                  const int16_t *VFilter,
-                                  uint8_t *dst_ptr,
+                                  const int16_t *VFilter, uint8_t *dst_ptr,
                                   unsigned int dst_stride,
                                   unsigned int output_width,
                                   unsigned int output_height) {
 #if CONFIG_VP9_HIGHBITDEPTH
     if (UUT_->use_highbd_ == 0) {
-      filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
-                         dst_ptr, dst_stride, output_width, output_height);
+      filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
+                         dst_stride, output_width, output_height);
     } else {
       highbd_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
-                                HFilter, VFilter,
-                                CONVERT_TO_SHORTPTR(dst_ptr), dst_stride,
-                                output_width, output_height, UUT_->use_highbd_);
+                                HFilter, VFilter, CONVERT_TO_SHORTPTR(dst_ptr),
+                                dst_stride, output_width, output_height,
+                                UUT_->use_highbd_);
     }
 #else
-    filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
-                       dst_ptr, dst_stride, output_width, output_height);
+    filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, dst_ptr,
+                       dst_stride, output_width, output_height);
 #endif
   }
 
-  const ConvolveFunctions* UUT_;
-  static uint8_t* input_;
-  static uint8_t* output_;
-  static uint8_t* output_ref_;
+  const ConvolveFunctions *UUT_;
+  static uint8_t *input_;
+  static uint8_t *output_;
+  static uint8_t *output_ref_;
 #if CONFIG_VP9_HIGHBITDEPTH
-  static uint16_t* input16_;
-  static uint16_t* output16_;
-  static uint16_t* output16_ref_;
+  static uint16_t *input16_;
+  static uint16_t *output16_;
+  static uint16_t *output16_ref_;
   int mask_;
 #endif
 };
 
-uint8_t* ConvolveTest::input_ = NULL;
-uint8_t* ConvolveTest::output_ = NULL;
-uint8_t* ConvolveTest::output_ref_ = NULL;
+uint8_t *ConvolveTest::input_ = NULL;
+uint8_t *ConvolveTest::output_ = NULL;
+uint8_t *ConvolveTest::output_ref_ = NULL;
 #if CONFIG_VP9_HIGHBITDEPTH
-uint16_t* ConvolveTest::input16_ = NULL;
-uint16_t* ConvolveTest::output16_ = NULL;
-uint16_t* ConvolveTest::output16_ref_ = NULL;
+uint16_t *ConvolveTest::input16_ = NULL;
+uint16_t *ConvolveTest::output16_ = NULL;
+uint16_t *ConvolveTest::output16_ref_ = NULL;
 #endif
 
-TEST_P(ConvolveTest, GuardBlocks) {
-  CheckGuardBlocks();
-}
+TEST_P(ConvolveTest, GuardBlocks) { CheckGuardBlocks(); }
 
 TEST_P(ConvolveTest, Copy) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
+  uint8_t *const in = input();
+  uint8_t *const out = output();
 
-  ASM_REGISTER_STATE_CHECK(
-      UUT_->copy_(in, kInputStride, out, kOutputStride, NULL, 0, NULL, 0,
-                  Width(), Height()));
+  ASM_REGISTER_STATE_CHECK(UUT_->copy_(in, kInputStride, out, kOutputStride,
+                                       NULL, 0, NULL, 0, Width(), Height()));
 
   CheckGuardBlocks();
 
@@ -618,14 +553,13 @@
 }
 
 TEST_P(ConvolveTest, Avg) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
-  uint8_t* const out_ref = output_ref();
+  uint8_t *const in = input();
+  uint8_t *const out = output();
+  uint8_t *const out_ref = output_ref();
   CopyOutputToRef();
 
-  ASM_REGISTER_STATE_CHECK(
-      UUT_->avg_(in, kInputStride, out, kOutputStride, NULL, 0, NULL, 0,
-                Width(), Height()));
+  ASM_REGISTER_STATE_CHECK(UUT_->avg_(in, kInputStride, out, kOutputStride,
+                                      NULL, 0, NULL, 0, Width(), Height()));
 
   CheckGuardBlocks();
 
@@ -633,18 +567,20 @@
     for (int x = 0; x < Width(); ++x)
       ASSERT_EQ(lookup(out, y * kOutputStride + x),
                 ROUND_POWER_OF_TWO(lookup(in, y * kInputStride + x) +
-                                   lookup(out_ref, y * kOutputStride + x), 1))
+                                       lookup(out_ref, y * kOutputStride + x),
+                                   1))
           << "(" << x << "," << y << ")";
 }
 
 TEST_P(ConvolveTest, CopyHoriz) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
-  DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0};
+  uint8_t *const in = input();
+  uint8_t *const out = output();
+  DECLARE_ALIGNED(256, const int16_t,
+                  filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
 
-  ASM_REGISTER_STATE_CHECK(
-      UUT_->sh8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8, 16,
-                 Width(), Height()));
+  ASM_REGISTER_STATE_CHECK(UUT_->sh8_(in, kInputStride, out, kOutputStride,
+                                      filter8, 16, filter8, 16, Width(),
+                                      Height()));
 
   CheckGuardBlocks();
 
@@ -656,13 +592,14 @@
 }
 
 TEST_P(ConvolveTest, CopyVert) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
-  DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0};
+  uint8_t *const in = input();
+  uint8_t *const out = output();
+  DECLARE_ALIGNED(256, const int16_t,
+                  filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
 
-  ASM_REGISTER_STATE_CHECK(
-      UUT_->sv8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8, 16,
-                 Width(), Height()));
+  ASM_REGISTER_STATE_CHECK(UUT_->sv8_(in, kInputStride, out, kOutputStride,
+                                      filter8, 16, filter8, 16, Width(),
+                                      Height()));
 
   CheckGuardBlocks();
 
@@ -674,13 +611,14 @@
 }
 
 TEST_P(ConvolveTest, Copy2D) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
-  DECLARE_ALIGNED(256, const int16_t, filter8[8]) = {0, 0, 0, 128, 0, 0, 0, 0};
+  uint8_t *const in = input();
+  uint8_t *const out = output();
+  DECLARE_ALIGNED(256, const int16_t,
+                  filter8[8]) = { 0, 0, 0, 128, 0, 0, 0, 0 };
 
-  ASM_REGISTER_STATE_CHECK(
-      UUT_->shv8_(in, kInputStride, out, kOutputStride, filter8, 16, filter8,
-                  16, Width(), Height()));
+  ASM_REGISTER_STATE_CHECK(UUT_->shv8_(in, kInputStride, out, kOutputStride,
+                                       filter8, 16, filter8, 16, Width(),
+                                       Height()));
 
   CheckGuardBlocks();
 
@@ -718,12 +656,12 @@
 const int16_t kInvalidFilter[8] = { 0 };
 
 TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
+  uint8_t *const in = input();
+  uint8_t *const out = output();
 #if CONFIG_VP9_HIGHBITDEPTH
   uint8_t ref8[kOutputStride * kMaxDimension];
   uint16_t ref16[kOutputStride * kMaxDimension];
-  uint8_t* ref;
+  uint8_t *ref;
   if (UUT_->use_highbd_ == 0) {
     ref = ref8;
   } else {
@@ -739,31 +677,26 @@
 
     for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
       for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
-        wrapper_filter_block2d_8_c(in, kInputStride,
-                                   filters[filter_x], filters[filter_y],
-                                   ref, kOutputStride,
+        wrapper_filter_block2d_8_c(in, kInputStride, filters[filter_x],
+                                   filters[filter_y], ref, kOutputStride,
                                    Width(), Height());
 
         if (filter_x && filter_y)
-          ASM_REGISTER_STATE_CHECK(
-              UUT_->hv8_(in, kInputStride, out, kOutputStride,
-                         filters[filter_x], 16, filters[filter_y], 16,
-                         Width(), Height()));
+          ASM_REGISTER_STATE_CHECK(UUT_->hv8_(
+              in, kInputStride, out, kOutputStride, filters[filter_x], 16,
+              filters[filter_y], 16, Width(), Height()));
         else if (filter_y)
           ASM_REGISTER_STATE_CHECK(
-              UUT_->v8_(in, kInputStride, out, kOutputStride,
-                        kInvalidFilter, 16, filters[filter_y], 16,
-                        Width(), Height()));
+              UUT_->v8_(in, kInputStride, out, kOutputStride, kInvalidFilter,
+                        16, filters[filter_y], 16, Width(), Height()));
         else if (filter_x)
           ASM_REGISTER_STATE_CHECK(
-              UUT_->h8_(in, kInputStride, out, kOutputStride,
-                        filters[filter_x], 16, kInvalidFilter, 16,
-                        Width(), Height()));
+              UUT_->h8_(in, kInputStride, out, kOutputStride, filters[filter_x],
+                        16, kInvalidFilter, 16, Width(), Height()));
         else
           ASM_REGISTER_STATE_CHECK(
-              UUT_->copy_(in, kInputStride, out, kOutputStride,
-                          kInvalidFilter, 0, kInvalidFilter, 0,
-                          Width(), Height()));
+              UUT_->copy_(in, kInputStride, out, kOutputStride, kInvalidFilter,
+                          0, kInvalidFilter, 0, Width(), Height()));
 
         CheckGuardBlocks();
 
@@ -772,20 +705,20 @@
             ASSERT_EQ(lookup(ref, y * kOutputStride + x),
                       lookup(out, y * kOutputStride + x))
                 << "mismatch at (" << x << "," << y << "), "
-                << "filters (" << filter_bank << ","
-                << filter_x << "," << filter_y << ")";
+                << "filters (" << filter_bank << "," << filter_x << ","
+                << filter_y << ")";
       }
     }
   }
 }
 
 TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
+  uint8_t *const in = input();
+  uint8_t *const out = output();
 #if CONFIG_VP9_HIGHBITDEPTH
   uint8_t ref8[kOutputStride * kMaxDimension];
   uint16_t ref16[kOutputStride * kMaxDimension];
-  uint8_t* ref;
+  uint8_t *ref;
   if (UUT_->use_highbd_ == 0) {
     ref = ref8;
   } else {
@@ -821,31 +754,26 @@
 
     for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
       for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
-        wrapper_filter_average_block2d_8_c(in, kInputStride,
-                                           filters[filter_x], filters[filter_y],
-                                           ref, kOutputStride,
-                                           Width(), Height());
+        wrapper_filter_average_block2d_8_c(in, kInputStride, filters[filter_x],
+                                           filters[filter_y], ref,
+                                           kOutputStride, Width(), Height());
 
         if (filter_x && filter_y)
-          ASM_REGISTER_STATE_CHECK(
-              UUT_->hv8_avg_(in, kInputStride, out, kOutputStride,
-                             filters[filter_x], 16, filters[filter_y], 16,
-                             Width(), Height()));
+          ASM_REGISTER_STATE_CHECK(UUT_->hv8_avg_(
+              in, kInputStride, out, kOutputStride, filters[filter_x], 16,
+              filters[filter_y], 16, Width(), Height()));
         else if (filter_y)
-          ASM_REGISTER_STATE_CHECK(
-              UUT_->v8_avg_(in, kInputStride, out, kOutputStride,
-                            kInvalidFilter, 16, filters[filter_y], 16,
-                            Width(), Height()));
+          ASM_REGISTER_STATE_CHECK(UUT_->v8_avg_(
+              in, kInputStride, out, kOutputStride, kInvalidFilter, 16,
+              filters[filter_y], 16, Width(), Height()));
         else if (filter_x)
-          ASM_REGISTER_STATE_CHECK(
-              UUT_->h8_avg_(in, kInputStride, out, kOutputStride,
-                            filters[filter_x], 16, kInvalidFilter, 16,
-                            Width(), Height()));
+          ASM_REGISTER_STATE_CHECK(UUT_->h8_avg_(
+              in, kInputStride, out, kOutputStride, filters[filter_x], 16,
+              kInvalidFilter, 16, Width(), Height()));
         else
           ASM_REGISTER_STATE_CHECK(
-              UUT_->avg_(in, kInputStride, out, kOutputStride,
-                          kInvalidFilter, 0, kInvalidFilter, 0,
-                          Width(), Height()));
+              UUT_->avg_(in, kInputStride, out, kOutputStride, kInvalidFilter,
+                         0, kInvalidFilter, 0, Width(), Height()));
 
         CheckGuardBlocks();
 
@@ -854,8 +782,8 @@
             ASSERT_EQ(lookup(ref, y * kOutputStride + x),
                       lookup(out, y * kOutputStride + x))
                 << "mismatch at (" << x << "," << y << "), "
-                << "filters (" << filter_bank << ","
-                << filter_x << "," << filter_y << ")";
+                << "filters (" << filter_bank << "," << filter_x << ","
+                << filter_y << ")";
       }
     }
   }
@@ -902,16 +830,16 @@
       for (int y = 0; y < 8; ++y) {
         for (int x = 0; x < 8; ++x) {
 #if CONFIG_VP9_HIGHBITDEPTH
-            assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
-                       ((seed_val >> (axis ? y : x)) & 1) * mask_);
+          assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
+                     ((seed_val >> (axis ? y : x)) & 1) * mask_);
 #else
-            assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
-                       ((seed_val >> (axis ? y : x)) & 1) * 255);
+          assign_val(in, y * kOutputStride + x - SUBPEL_TAPS / 2 + 1,
+                     ((seed_val >> (axis ? y : x)) & 1) * 255);
 #endif
           if (axis) seed_val++;
         }
         if (axis)
-          seed_val-= 8;
+          seed_val -= 8;
         else
           seed_val++;
       }
@@ -922,38 +850,33 @@
             vp9_filter_kernels[static_cast<INTERP_FILTER>(filter_bank)];
         for (int filter_x = 0; filter_x < kNumFilters; ++filter_x) {
           for (int filter_y = 0; filter_y < kNumFilters; ++filter_y) {
-            wrapper_filter_block2d_8_c(in, kInputStride,
-                                       filters[filter_x], filters[filter_y],
-                                       ref, kOutputStride,
+            wrapper_filter_block2d_8_c(in, kInputStride, filters[filter_x],
+                                       filters[filter_y], ref, kOutputStride,
                                        Width(), Height());
             if (filter_x && filter_y)
-              ASM_REGISTER_STATE_CHECK(
-                  UUT_->hv8_(in, kInputStride, out, kOutputStride,
-                             filters[filter_x], 16, filters[filter_y], 16,
-                             Width(), Height()));
+              ASM_REGISTER_STATE_CHECK(UUT_->hv8_(
+                  in, kInputStride, out, kOutputStride, filters[filter_x], 16,
+                  filters[filter_y], 16, Width(), Height()));
             else if (filter_y)
-              ASM_REGISTER_STATE_CHECK(
-                  UUT_->v8_(in, kInputStride, out, kOutputStride,
-                            kInvalidFilter, 16, filters[filter_y], 16,
-                            Width(), Height()));
+              ASM_REGISTER_STATE_CHECK(UUT_->v8_(
+                  in, kInputStride, out, kOutputStride, kInvalidFilter, 16,
+                  filters[filter_y], 16, Width(), Height()));
             else if (filter_x)
-              ASM_REGISTER_STATE_CHECK(
-                  UUT_->h8_(in, kInputStride, out, kOutputStride,
-                            filters[filter_x], 16, kInvalidFilter, 16,
-                            Width(), Height()));
+              ASM_REGISTER_STATE_CHECK(UUT_->h8_(
+                  in, kInputStride, out, kOutputStride, filters[filter_x], 16,
+                  kInvalidFilter, 16, Width(), Height()));
             else
-              ASM_REGISTER_STATE_CHECK(
-                  UUT_->copy_(in, kInputStride, out, kOutputStride,
-                              kInvalidFilter, 0, kInvalidFilter, 0,
-                              Width(), Height()));
+              ASM_REGISTER_STATE_CHECK(UUT_->copy_(
+                  in, kInputStride, out, kOutputStride, kInvalidFilter, 0,
+                  kInvalidFilter, 0, Width(), Height()));
 
             for (int y = 0; y < Height(); ++y)
               for (int x = 0; x < Width(); ++x)
                 ASSERT_EQ(lookup(ref, y * kOutputStride + x),
                           lookup(out, y * kOutputStride + x))
                     << "mismatch at (" << x << "," << y << "), "
-                    << "filters (" << filter_bank << ","
-                    << filter_x << "," << filter_y << ")";
+                    << "filters (" << filter_bank << "," << filter_x << ","
+                    << filter_y << ")";
           }
         }
       }
@@ -964,8 +887,8 @@
 /* This test exercises that enough rows and columns are filtered with every
    possible initial fractional positions and scaling steps. */
 TEST_P(ConvolveTest, CheckScalingFiltering) {
-  uint8_t* const in = input();
-  uint8_t* const out = output();
+  uint8_t *const in = input();
+  uint8_t *const out = output();
   const InterpKernel *const eighttap = vp9_filter_kernels[EIGHTTAP];
 
   SetConstantInput(127);
@@ -974,9 +897,8 @@
     for (int step = 1; step <= 32; ++step) {
       /* Test the horizontal and vertical filters in combination. */
       ASM_REGISTER_STATE_CHECK(UUT_->shv8_(in, kInputStride, out, kOutputStride,
-                                           eighttap[frac], step,
-                                           eighttap[frac], step,
-                                           Width(), Height()));
+                                           eighttap[frac], step, eighttap[frac],
+                                           step, Width(), Height()));
 
       CheckGuardBlocks();
 
@@ -984,8 +906,8 @@
         for (int x = 0; x < Width(); ++x) {
           ASSERT_EQ(lookup(in, y * kInputStride + x),
                     lookup(out, y * kOutputStride + x))
-              << "x == " << x << ", y == " << y
-              << ", frac == " << frac << ", step == " << step;
+              << "x == " << x << ", y == " << y << ", frac == " << frac
+              << ", step == " << step;
         }
       }
     }
@@ -995,18 +917,14 @@
 using std::tr1::make_tuple;
 
 #if CONFIG_VP9_HIGHBITDEPTH
-#define WRAP(func, bd) \
-void wrap_ ## func ## _ ## bd(const uint8_t *src, ptrdiff_t src_stride, \
-                              uint8_t *dst, ptrdiff_t dst_stride, \
-                              const int16_t *filter_x, \
-                              int filter_x_stride, \
-                              const int16_t *filter_y, \
-                              int filter_y_stride, \
-                              int w, int h) { \
-  vpx_highbd_ ## func(src, src_stride, dst, dst_stride, filter_x, \
-                      filter_x_stride, filter_y, filter_y_stride, \
-                      w, h, bd); \
-}
+#define WRAP(func, bd)                                                       \
+  void wrap_##func##_##bd(                                                   \
+      const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,                \
+      ptrdiff_t dst_stride, const int16_t *filter_x, int filter_x_stride,    \
+      const int16_t *filter_y, int filter_y_stride, int w, int h) {          \
+    vpx_highbd_##func(src, src_stride, dst, dst_stride, filter_x,            \
+                      filter_x_stride, filter_y, filter_y_stride, w, h, bd); \
+  }
 #if HAVE_SSE2 && ARCH_X86_64
 WRAP(convolve_copy_sse2, 8)
 WRAP(convolve_avg_sse2, 8)
@@ -1061,48 +979,40 @@
 #undef WRAP
 
 const ConvolveFunctions convolve8_c(
-    wrap_convolve_copy_c_8, wrap_convolve_avg_c_8,
+    wrap_convolve_copy_c_8, wrap_convolve_avg_c_8, wrap_convolve8_horiz_c_8,
+    wrap_convolve8_avg_horiz_c_8, wrap_convolve8_vert_c_8,
+    wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8, wrap_convolve8_avg_c_8,
     wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8,
-    wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8,
-    wrap_convolve8_c_8, wrap_convolve8_avg_c_8,
-    wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8,
-    wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8,
-    wrap_convolve8_c_8, wrap_convolve8_avg_c_8, 8);
+    wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, wrap_convolve8_c_8,
+    wrap_convolve8_avg_c_8, 8);
 const ConvolveFunctions convolve10_c(
-    wrap_convolve_copy_c_10, wrap_convolve_avg_c_10,
+    wrap_convolve_copy_c_10, wrap_convolve_avg_c_10, wrap_convolve8_horiz_c_10,
+    wrap_convolve8_avg_horiz_c_10, wrap_convolve8_vert_c_10,
+    wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10, wrap_convolve8_avg_c_10,
     wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10,
-    wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10,
-    wrap_convolve8_c_10, wrap_convolve8_avg_c_10,
-    wrap_convolve8_horiz_c_10, wrap_convolve8_avg_horiz_c_10,
-    wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10,
-    wrap_convolve8_c_10, wrap_convolve8_avg_c_10, 10);
+    wrap_convolve8_vert_c_10, wrap_convolve8_avg_vert_c_10, wrap_convolve8_c_10,
+    wrap_convolve8_avg_c_10, 10);
 const ConvolveFunctions convolve12_c(
-    wrap_convolve_copy_c_12, wrap_convolve_avg_c_12,
+    wrap_convolve_copy_c_12, wrap_convolve_avg_c_12, wrap_convolve8_horiz_c_12,
+    wrap_convolve8_avg_horiz_c_12, wrap_convolve8_vert_c_12,
+    wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12, wrap_convolve8_avg_c_12,
     wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12,
-    wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12,
-    wrap_convolve8_c_12, wrap_convolve8_avg_c_12,
-    wrap_convolve8_horiz_c_12, wrap_convolve8_avg_horiz_c_12,
-    wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12,
-    wrap_convolve8_c_12, wrap_convolve8_avg_c_12, 12);
+    wrap_convolve8_vert_c_12, wrap_convolve8_avg_vert_c_12, wrap_convolve8_c_12,
+    wrap_convolve8_avg_c_12, 12);
 const ConvolveParam kArrayConvolve_c[] = {
-    ALL_SIZES(convolve8_c),
-    ALL_SIZES(convolve10_c),
-    ALL_SIZES(convolve12_c)
+  ALL_SIZES(convolve8_c), ALL_SIZES(convolve10_c), ALL_SIZES(convolve12_c)
 };
 
 #else
 const ConvolveFunctions convolve8_c(
-    vpx_convolve_copy_c, vpx_convolve_avg_c,
-    vpx_convolve8_horiz_c, vpx_convolve8_avg_horiz_c,
-    vpx_convolve8_vert_c, vpx_convolve8_avg_vert_c,
-    vpx_convolve8_c, vpx_convolve8_avg_c,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
+    vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_c,
+    vpx_convolve8_avg_horiz_c, vpx_convolve8_vert_c, vpx_convolve8_avg_vert_c,
+    vpx_convolve8_c, vpx_convolve8_avg_c, vpx_scaled_horiz_c,
+    vpx_scaled_avg_horiz_c, vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
     vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 const ConvolveParam kArrayConvolve_c[] = { ALL_SIZES(convolve8_c) };
 #endif
-INSTANTIATE_TEST_CASE_P(C, ConvolveTest,
-                        ::testing::ValuesIn(kArrayConvolve_c));
+INSTANTIATE_TEST_CASE_P(C, ConvolveTest, ::testing::ValuesIn(kArrayConvolve_c));
 
 #if HAVE_SSE2 && ARCH_X86_64
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -1130,20 +1040,16 @@
     wrap_convolve8_horiz_sse2_12, wrap_convolve8_avg_horiz_sse2_12,
     wrap_convolve8_vert_sse2_12, wrap_convolve8_avg_vert_sse2_12,
     wrap_convolve8_sse2_12, wrap_convolve8_avg_sse2_12, 12);
-const ConvolveParam kArrayConvolve_sse2[] = {
-    ALL_SIZES(convolve8_sse2),
-    ALL_SIZES(convolve10_sse2),
-    ALL_SIZES(convolve12_sse2)
-};
+const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2),
+                                              ALL_SIZES(convolve10_sse2),
+                                              ALL_SIZES(convolve12_sse2) };
 #else
 const ConvolveFunctions convolve8_sse2(
-    vpx_convolve_copy_sse2, vpx_convolve_avg_sse2,
-    vpx_convolve8_horiz_sse2, vpx_convolve8_avg_horiz_sse2,
-    vpx_convolve8_vert_sse2, vpx_convolve8_avg_vert_sse2,
-    vpx_convolve8_sse2, vpx_convolve8_avg_sse2,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_sse2, vpx_convolve_avg_sse2, vpx_convolve8_horiz_sse2,
+    vpx_convolve8_avg_horiz_sse2, vpx_convolve8_vert_sse2,
+    vpx_convolve8_avg_vert_sse2, vpx_convolve8_sse2, vpx_convolve8_avg_sse2,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 
 const ConvolveParam kArrayConvolve_sse2[] = { ALL_SIZES(convolve8_sse2) };
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -1153,13 +1059,11 @@
 
 #if HAVE_SSSE3
 const ConvolveFunctions convolve8_ssse3(
-    vpx_convolve_copy_c, vpx_convolve_avg_c,
-    vpx_convolve8_horiz_ssse3, vpx_convolve8_avg_horiz_ssse3,
-    vpx_convolve8_vert_ssse3, vpx_convolve8_avg_vert_ssse3,
-    vpx_convolve8_ssse3, vpx_convolve8_avg_ssse3,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_ssse3, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_ssse3,
+    vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_ssse3,
+    vpx_convolve8_avg_vert_ssse3, vpx_convolve8_ssse3, vpx_convolve8_avg_ssse3,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_ssse3, vpx_scaled_avg_2d_c, 0);
 
 const ConvolveParam kArrayConvolve8_ssse3[] = { ALL_SIZES(convolve8_ssse3) };
 INSTANTIATE_TEST_CASE_P(SSSE3, ConvolveTest,
@@ -1168,13 +1072,11 @@
 
 #if HAVE_AVX2 && HAVE_SSSE3
 const ConvolveFunctions convolve8_avx2(
-    vpx_convolve_copy_c, vpx_convolve_avg_c,
-    vpx_convolve8_horiz_avx2, vpx_convolve8_avg_horiz_ssse3,
-    vpx_convolve8_vert_avx2, vpx_convolve8_avg_vert_ssse3,
-    vpx_convolve8_avx2, vpx_convolve8_avg_ssse3,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_c, vpx_convolve_avg_c, vpx_convolve8_horiz_avx2,
+    vpx_convolve8_avg_horiz_ssse3, vpx_convolve8_vert_avx2,
+    vpx_convolve8_avg_vert_ssse3, vpx_convolve8_avx2, vpx_convolve8_avg_ssse3,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 
 const ConvolveParam kArrayConvolve8_avx2[] = { ALL_SIZES(convolve8_avx2) };
 INSTANTIATE_TEST_CASE_P(AVX2, ConvolveTest,
@@ -1185,22 +1087,18 @@
 #if HAVE_NEON && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
 #if HAVE_NEON_ASM
 const ConvolveFunctions convolve8_neon(
-    vpx_convolve_copy_neon, vpx_convolve_avg_neon,
-    vpx_convolve8_horiz_neon, vpx_convolve8_avg_horiz_neon,
-    vpx_convolve8_vert_neon, vpx_convolve8_avg_vert_neon,
-    vpx_convolve8_neon, vpx_convolve8_avg_neon,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
-#else  // HAVE_NEON
+    vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
+    vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
+    vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+#else   // HAVE_NEON
 const ConvolveFunctions convolve8_neon(
-    vpx_convolve_copy_neon, vpx_convolve_avg_neon,
-    vpx_convolve8_horiz_neon, vpx_convolve8_avg_horiz_neon,
-    vpx_convolve8_vert_neon, vpx_convolve8_avg_vert_neon,
-    vpx_convolve8_neon, vpx_convolve8_avg_neon,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_neon, vpx_convolve_avg_neon, vpx_convolve8_horiz_neon,
+    vpx_convolve8_avg_horiz_neon, vpx_convolve8_vert_neon,
+    vpx_convolve8_avg_vert_neon, vpx_convolve8_neon, vpx_convolve8_avg_neon,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 #endif  // HAVE_NEON_ASM
 
 const ConvolveParam kArrayConvolve8_neon[] = { ALL_SIZES(convolve8_neon) };
@@ -1211,13 +1109,11 @@
 // TODO(any): Make DSPR2 versions support 128x128 128x64 64x128 block sizes
 #if HAVE_DSPR2 && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
 const ConvolveFunctions convolve8_dspr2(
-    vpx_convolve_copy_dspr2, vpx_convolve_avg_dspr2,
-    vpx_convolve8_horiz_dspr2, vpx_convolve8_avg_horiz_dspr2,
-    vpx_convolve8_vert_dspr2, vpx_convolve8_avg_vert_dspr2,
-    vpx_convolve8_dspr2, vpx_convolve8_avg_dspr2,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_dspr2, vpx_convolve_avg_dspr2, vpx_convolve8_horiz_dspr2,
+    vpx_convolve8_avg_horiz_dspr2, vpx_convolve8_vert_dspr2,
+    vpx_convolve8_avg_vert_dspr2, vpx_convolve8_dspr2, vpx_convolve8_avg_dspr2,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 
 const ConvolveParam kArrayConvolve8_dspr2[] = { ALL_SIZES(convolve8_dspr2) };
 INSTANTIATE_TEST_CASE_P(DSPR2, ConvolveTest,
@@ -1227,13 +1123,11 @@
 // TODO(any): Make MSA versions support 128x128 128x64 64x128 block sizes
 #if HAVE_MSA && !(CONFIG_VP10 && CONFIG_EXT_PARTITION)
 const ConvolveFunctions convolve8_msa(
-    vpx_convolve_copy_msa, vpx_convolve_avg_msa,
-    vpx_convolve8_horiz_msa, vpx_convolve8_avg_horiz_msa,
-    vpx_convolve8_vert_msa, vpx_convolve8_avg_vert_msa,
-    vpx_convolve8_msa, vpx_convolve8_avg_msa,
-    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c,
-    vpx_scaled_vert_c, vpx_scaled_avg_vert_c,
-    vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
+    vpx_convolve_copy_msa, vpx_convolve_avg_msa, vpx_convolve8_horiz_msa,
+    vpx_convolve8_avg_horiz_msa, vpx_convolve8_vert_msa,
+    vpx_convolve8_avg_vert_msa, vpx_convolve8_msa, vpx_convolve8_avg_msa,
+    vpx_scaled_horiz_c, vpx_scaled_avg_horiz_c, vpx_scaled_vert_c,
+    vpx_scaled_avg_vert_c, vpx_scaled_2d_c, vpx_scaled_avg_2d_c, 0);
 
 const ConvolveParam kArrayConvolve8_msa[] = { ALL_SIZES(convolve8_msa) };
 INSTANTIATE_TEST_CASE_P(MSA, ConvolveTest,
diff --git a/test/cpu_speed_test.cc b/test/cpu_speed_test.cc
index 3a9593b..2ed9113 100644
--- a/test/cpu_speed_test.cc
+++ b/test/cpu_speed_test.cc
@@ -23,10 +23,8 @@
       public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   CpuSpeedTest()
-      : EncoderTest(GET_PARAM(0)),
-        encoding_mode_(GET_PARAM(1)),
-        set_cpu_used_(GET_PARAM(2)),
-        min_psnr_(kMaxPSNR),
+      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
+        set_cpu_used_(GET_PARAM(2)), min_psnr_(kMaxPSNR),
         tune_content_(VPX_CONTENT_DEFAULT) {}
   virtual ~CpuSpeedTest() {}
 
@@ -42,9 +40,7 @@
     }
   }
 
-  virtual void BeginPassHook(unsigned int /*pass*/) {
-    min_psnr_ = kMaxPSNR;
-  }
+  virtual void BeginPassHook(unsigned int /*pass*/) { min_psnr_ = kMaxPSNR; }
 
   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
                                   ::libvpx_test::Encoder *encoder) {
@@ -61,8 +57,7 @@
   }
 
   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
-    if (pkt->data.psnr.psnr[0] < min_psnr_)
-      min_psnr_ = pkt->data.psnr.psnr[0];
+    if (pkt->data.psnr.psnr[0] < min_psnr_) min_psnr_ = pkt->data.psnr.psnr[0];
   }
 
   void TestQ0();
@@ -173,12 +168,12 @@
 TEST_P(CpuSpeedTestLarge, TestEncodeHighBitrate) { TestEncodeHighBitrate(); }
 TEST_P(CpuSpeedTestLarge, TestLowBitrate) { TestLowBitrate(); }
 
-VP10_INSTANTIATE_TEST_CASE(
-    CpuSpeedTest,
-    ::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood),
-    ::testing::Range(1, 3));
-VP10_INSTANTIATE_TEST_CASE(
-    CpuSpeedTestLarge,
-    ::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood),
-    ::testing::Range(0, 1));
+VP10_INSTANTIATE_TEST_CASE(CpuSpeedTest,
+                           ::testing::Values(::libvpx_test::kTwoPassGood,
+                                             ::libvpx_test::kOnePassGood),
+                           ::testing::Range(1, 3));
+VP10_INSTANTIATE_TEST_CASE(CpuSpeedTestLarge,
+                           ::testing::Values(::libvpx_test::kTwoPassGood,
+                                             ::libvpx_test::kOnePassGood),
+                           ::testing::Range(0, 1));
 }  // namespace
diff --git a/test/datarate_test.cc b/test/datarate_test.cc
index 89761e7..300b11e 100644
--- a/test/datarate_test.cc
+++ b/test/datarate_test.cc
@@ -18,8 +18,9 @@
 
 namespace {
 
-class DatarateTestLarge : public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
+class DatarateTestLarge
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  public:
   DatarateTestLarge() : EncoderTest(GET_PARAM(0)) {}
 
@@ -49,8 +50,7 @@
 
   virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
                                   ::libvpx_test::Encoder *encoder) {
-    if (video->frame() == 0)
-      encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
+    if (video->frame() == 0) encoder->Control(VP8E_SET_CPUUSED, set_cpu_used_);
 
     if (denoiser_offon_test_) {
       ASSERT_GT(denoiser_offon_period_, 0)
@@ -74,8 +74,7 @@
 
     if (duration > 1) {
       // If first drop not set and we have a drop set it to this time.
-      if (!first_drop_)
-        first_drop_ = last_pts_ + 1;
+      if (!first_drop_) first_drop_ = last_pts_ + 1;
       // Update the number of frame drops.
       num_drops_ += static_cast<int>(duration - 1);
       // Update counter for total number of frames (#frames input to encoder).
@@ -89,7 +88,7 @@
 
     // Buffer should not go negative.
     ASSERT_GE(bits_in_buffer_model_, 0) << "Buffer Underrun at frame "
-        << pkt->data.frame.pts;
+                                        << pkt->data.frame.pts;
 
     const size_t frame_size_in_bits = pkt->data.frame.sz * 8;
 
@@ -194,7 +193,7 @@
     ASSERT_LE(static_cast<double>(cfg_.rc_target_bitrate),
               effective_datarate_ * 1.15)
         << " The datarate for the file missed the target!"
-        << cfg_.rc_target_bitrate << " "<< effective_datarate_;
+        << cfg_.rc_target_bitrate << " " << effective_datarate_;
   }
 }
 
diff --git a/test/dct16x16_test.cc b/test/dct16x16_test.cc
index 7d1146b..d0e2b4b 100644
--- a/test/dct16x16_test.cc
+++ b/test/dct16x16_test.cc
@@ -54,16 +54,16 @@
   double temp1, temp2;
 
   // step 1
-  step[ 0] = input[0] + input[15];
-  step[ 1] = input[1] + input[14];
-  step[ 2] = input[2] + input[13];
-  step[ 3] = input[3] + input[12];
-  step[ 4] = input[4] + input[11];
-  step[ 5] = input[5] + input[10];
-  step[ 6] = input[6] + input[ 9];
-  step[ 7] = input[7] + input[ 8];
-  step[ 8] = input[7] - input[ 8];
-  step[ 9] = input[6] - input[ 9];
+  step[0] = input[0] + input[15];
+  step[1] = input[1] + input[14];
+  step[2] = input[2] + input[13];
+  step[3] = input[3] + input[12];
+  step[4] = input[4] + input[11];
+  step[5] = input[5] + input[10];
+  step[6] = input[6] + input[9];
+  step[7] = input[7] + input[8];
+  step[8] = input[7] - input[8];
+  step[9] = input[6] - input[9];
   step[10] = input[5] - input[10];
   step[11] = input[4] - input[11];
   step[12] = input[3] - input[12];
@@ -81,13 +81,13 @@
   output[6] = step[1] - step[6];
   output[7] = step[0] - step[7];
 
-  temp1 = step[ 8] * C7;
+  temp1 = step[8] * C7;
   temp2 = step[15] * C9;
-  output[ 8] = temp1 + temp2;
+  output[8] = temp1 + temp2;
 
-  temp1 = step[ 9] * C11;
+  temp1 = step[9] * C11;
   temp2 = step[14] * C5;
-  output[ 9] = temp1 - temp2;
+  output[9] = temp1 - temp2;
 
   temp1 = step[10] * C3;
   temp2 = step[13] * C13;
@@ -105,40 +105,40 @@
   temp2 = step[13] * C3;
   output[13] = temp2 - temp1;
 
-  temp1 = step[ 9] * C5;
+  temp1 = step[9] * C5;
   temp2 = step[14] * C11;
   output[14] = temp2 + temp1;
 
-  temp1 = step[ 8] * C9;
+  temp1 = step[8] * C9;
   temp2 = step[15] * C7;
   output[15] = temp2 - temp1;
 
   // step 3
-  step[ 0] = output[0] + output[3];
-  step[ 1] = output[1] + output[2];
-  step[ 2] = output[1] - output[2];
-  step[ 3] = output[0] - output[3];
+  step[0] = output[0] + output[3];
+  step[1] = output[1] + output[2];
+  step[2] = output[1] - output[2];
+  step[3] = output[0] - output[3];
 
   temp1 = output[4] * C14;
   temp2 = output[7] * C2;
-  step[ 4] = temp1 + temp2;
+  step[4] = temp1 + temp2;
 
   temp1 = output[5] * C10;
   temp2 = output[6] * C6;
-  step[ 5] = temp1 + temp2;
+  step[5] = temp1 + temp2;
 
   temp1 = output[5] * C6;
   temp2 = output[6] * C10;
-  step[ 6] = temp2 - temp1;
+  step[6] = temp2 - temp1;
 
   temp1 = output[4] * C2;
   temp2 = output[7] * C14;
-  step[ 7] = temp2 - temp1;
+  step[7] = temp2 - temp1;
 
-  step[ 8] = output[ 8] + output[11];
-  step[ 9] = output[ 9] + output[10];
-  step[10] = output[ 9] - output[10];
-  step[11] = output[ 8] - output[11];
+  step[8] = output[8] + output[11];
+  step[9] = output[9] + output[10];
+  step[10] = output[9] - output[10];
+  step[11] = output[8] - output[11];
 
   step[12] = output[12] + output[15];
   step[13] = output[13] + output[14];
@@ -146,25 +146,25 @@
   step[15] = output[12] - output[15];
 
   // step 4
-  output[ 0] = (step[ 0] + step[ 1]);
-  output[ 8] = (step[ 0] - step[ 1]);
+  output[0] = (step[0] + step[1]);
+  output[8] = (step[0] - step[1]);
 
   temp1 = step[2] * C12;
   temp2 = step[3] * C4;
   temp1 = temp1 + temp2;
-  output[ 4] = 2*(temp1 * C8);
+  output[4] = 2 * (temp1 * C8);
 
   temp1 = step[2] * C4;
   temp2 = step[3] * C12;
   temp1 = temp2 - temp1;
   output[12] = 2 * (temp1 * C8);
 
-  output[ 2] = 2 * ((step[4] + step[ 5]) * C8);
-  output[14] = 2 * ((step[7] - step[ 6]) * C8);
+  output[2] = 2 * ((step[4] + step[5]) * C8);
+  output[14] = 2 * ((step[7] - step[6]) * C8);
 
   temp1 = step[4] - step[5];
   temp2 = step[6] + step[7];
-  output[ 6] = (temp1 + temp2);
+  output[6] = (temp1 + temp2);
   output[10] = (temp1 - temp2);
 
   intermediate[8] = step[8] + step[14];
@@ -180,18 +180,18 @@
   temp1 = temp2 + temp1;
   output[13] = 2 * (temp1 * C8);
 
-  output[ 9] = 2 * ((step[10] + step[11]) * C8);
+  output[9] = 2 * ((step[10] + step[11]) * C8);
 
   intermediate[11] = step[10] - step[11];
   intermediate[12] = step[12] + step[13];
   intermediate[13] = step[12] - step[13];
-  intermediate[14] = step[ 8] - step[14];
-  intermediate[15] = step[ 9] - step[15];
+  intermediate[14] = step[8] - step[14];
+  intermediate[15] = step[9] - step[15];
 
   output[15] = (intermediate[11] + intermediate[12]);
-  output[ 1] = -(intermediate[11] - intermediate[12]);
+  output[1] = -(intermediate[11] - intermediate[12]);
 
-  output[ 7] = 2 * (intermediate[13] * C8);
+  output[7] = 2 * (intermediate[13] * C8);
 
   temp1 = intermediate[14] * C12;
   temp2 = intermediate[15] * C4;
@@ -201,28 +201,24 @@
   temp1 = intermediate[14] * C4;
   temp2 = intermediate[15] * C12;
   temp1 = temp2 + temp1;
-  output[ 5] = 2 * (temp1 * C8);
+  output[5] = 2 * (temp1 * C8);
 }
 
 void reference_16x16_dct_2d(int16_t input[256], double output[256]) {
   // First transform columns
   for (int i = 0; i < 16; ++i) {
     double temp_in[16], temp_out[16];
-    for (int j = 0; j < 16; ++j)
-      temp_in[j] = input[j * 16 + i];
+    for (int j = 0; j < 16; ++j) temp_in[j] = input[j * 16 + i];
     butterfly_16x16_dct_1d(temp_in, temp_out);
-    for (int j = 0; j < 16; ++j)
-      output[j * 16 + i] = temp_out[j];
+    for (int j = 0; j < 16; ++j) output[j * 16 + i] = temp_out[j];
   }
   // Then transform rows
   for (int i = 0; i < 16; ++i) {
     double temp_in[16], temp_out[16];
-    for (int j = 0; j < 16; ++j)
-      temp_in[j] = output[j + i * 16];
+    for (int j = 0; j < 16; ++j) temp_in[j] = output[j + i * 16];
     butterfly_16x16_dct_1d(temp_in, temp_out);
     // Scale by some magic number
-    for (int j = 0; j < 16; ++j)
-      output[j + i * 16] = temp_out[j]/2;
+    for (int j = 0; j < 16; ++j) output[j + i * 16] = temp_out[j] / 2;
   }
 }
 
@@ -248,8 +244,7 @@
   vpx_idct16x16_256_add_c(in, dest, stride);
 }
 
-void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride,
-                  int tx_type) {
+void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
   vp10_fht16x16_c(in, out, stride, tx_type);
 }
 
@@ -351,11 +346,10 @@
         }
       }
 
-      ASM_REGISTER_STATE_CHECK(RunFwdTxfm(test_input_block,
-                                          test_temp_block, pitch_));
+      ASM_REGISTER_STATE_CHECK(
+          RunFwdTxfm(test_input_block, test_temp_block, pitch_));
       if (bit_depth_ == VPX_BITS_8) {
-        ASM_REGISTER_STATE_CHECK(
-            RunInvTxfm(test_temp_block, dst, pitch_));
+        ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
         ASM_REGISTER_STATE_CHECK(
@@ -366,18 +360,17 @@
       for (int j = 0; j < kNumCoeffs; ++j) {
 #if CONFIG_VP9_HIGHBITDEPTH
         const int32_t diff =
-            bit_depth_ == VPX_BITS_8 ?  dst[j] - src[j] : dst16[j] - src16[j];
+            bit_depth_ == VPX_BITS_8 ? dst[j] - src[j] : dst16[j] - src16[j];
 #else
         const int32_t diff = dst[j] - src[j];
 #endif
         const uint32_t error = diff * diff;
-        if (max_error < error)
-          max_error = error;
+        if (max_error < error) max_error = error;
         total_error += error;
       }
     }
 
-    EXPECT_GE(1u  << 2 * (bit_depth_ - 8), max_error)
+    EXPECT_GE(1u << 2 * (bit_depth_ - 8), max_error)
         << "Error: 16x16 FHT/IHT has an individual round trip error > 1";
 
     EXPECT_GE(count_test_block << 2 * (bit_depth_ - 8), total_error)
@@ -418,16 +411,14 @@
         input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
       }
       if (i == 0) {
-        for (int j = 0; j < kNumCoeffs; ++j)
-          input_extreme_block[j] = mask_;
+        for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
       } else if (i == 1) {
-        for (int j = 0; j < kNumCoeffs; ++j)
-          input_extreme_block[j] = -mask_;
+        for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
       }
 
       fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
-      ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block,
-                                          output_block, pitch_));
+      ASM_REGISTER_STATE_CHECK(
+          RunFwdTxfm(input_extreme_block, output_block, pitch_));
 
       // The minimum quant value is 4.
       for (int j = 0; j < kNumCoeffs; ++j) {
@@ -457,11 +448,9 @@
         input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
       }
       if (i == 0)
-        for (int j = 0; j < kNumCoeffs; ++j)
-          input_extreme_block[j] = mask_;
+        for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
       if (i == 1)
-        for (int j = 0; j < kNumCoeffs; ++j)
-          input_extreme_block[j] = -mask_;
+        for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
 
       fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
 
@@ -484,17 +473,15 @@
       } else {
         inv_txfm_ref(output_ref_block, CONVERT_TO_BYTEPTR(ref16), pitch_,
                      tx_type_);
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(output_ref_block,
-                                            CONVERT_TO_BYTEPTR(dst16), pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(output_ref_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif
       }
       if (bit_depth_ == VPX_BITS_8) {
-        for (int j = 0; j < kNumCoeffs; ++j)
-          EXPECT_EQ(ref[j], dst[j]);
+        for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref[j], dst[j]);
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
-        for (int j = 0; j < kNumCoeffs; ++j)
-          EXPECT_EQ(ref16[j], dst16[j]);
+        for (int j = 0; j < kNumCoeffs; ++j) EXPECT_EQ(ref16[j], dst16[j]);
 #endif
       }
     }
@@ -538,8 +525,8 @@
         ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, 16));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16),
-                                            16));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), 16));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
       }
 
@@ -551,9 +538,8 @@
         const uint32_t diff = dst[j] - src[j];
 #endif  // CONFIG_VP9_HIGHBITDEPTH
         const uint32_t error = diff * diff;
-        EXPECT_GE(1u, error)
-            << "Error: 16x16 IDCT has error " << error
-            << " at index " << j;
+        EXPECT_GE(1u, error) << "Error: 16x16 IDCT has error " << error
+                             << " at index " << j;
       }
     }
   }
@@ -595,8 +581,8 @@
       } else {
 #if CONFIG_VP9_HIGHBITDEPTH
         ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16),
-                                 pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
       }
 
@@ -608,9 +594,8 @@
         const uint32_t diff = dst[j] - ref[j];
 #endif  // CONFIG_VP9_HIGHBITDEPTH
         const uint32_t error = diff * diff;
-        EXPECT_EQ(0u, error)
-            << "Error: 16x16 IDCT Comparison has error " << error
-            << " at index " << j;
+        EXPECT_EQ(0u, error) << "Error: 16x16 IDCT Comparison has error "
+                             << error << " at index " << j;
       }
     }
   }
@@ -623,32 +608,25 @@
   IhtFunc inv_txfm_ref;
 };
 
-class Trans16x16DCT
-    : public Trans16x16TestBase,
-      public ::testing::TestWithParam<Dct16x16Param> {
+class Trans16x16DCT : public Trans16x16TestBase,
+                      public ::testing::TestWithParam<Dct16x16Param> {
  public:
   virtual ~Trans16x16DCT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
+    tx_type_ = GET_PARAM(2);
     bit_depth_ = GET_PARAM(3);
-    pitch_    = 16;
+    pitch_ = 16;
     fwd_txfm_ref = fdct16x16_ref;
     inv_txfm_ref = idct16x16_ref;
     mask_ = (1 << bit_depth_) - 1;
 #if CONFIG_VP9_HIGHBITDEPTH
     switch (bit_depth_) {
-      case VPX_BITS_10:
-        inv_txfm_ref = idct16x16_10_ref;
-        break;
-      case VPX_BITS_12:
-        inv_txfm_ref = idct16x16_12_ref;
-        break;
-      default:
-        inv_txfm_ref = idct16x16_ref;
-        break;
+      case VPX_BITS_10: inv_txfm_ref = idct16x16_10_ref; break;
+      case VPX_BITS_12: inv_txfm_ref = idct16x16_12_ref; break;
+      default: inv_txfm_ref = idct16x16_ref; break;
     }
 #else
     inv_txfm_ref = idct16x16_ref;
@@ -668,17 +646,11 @@
   IdctFunc inv_txfm_;
 };
 
-TEST_P(Trans16x16DCT, AccuracyCheck) {
-  RunAccuracyCheck();
-}
+TEST_P(Trans16x16DCT, AccuracyCheck) { RunAccuracyCheck(); }
 
-TEST_P(Trans16x16DCT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(Trans16x16DCT, CoeffCheck) { RunCoeffCheck(); }
 
-TEST_P(Trans16x16DCT, MemCheck) {
-  RunMemCheck();
-}
+TEST_P(Trans16x16DCT, MemCheck) { RunMemCheck(); }
 
 TEST_P(Trans16x16DCT, QuantCheck) {
   // Use maximally allowed quantization step sizes for DC and AC
@@ -686,36 +658,27 @@
   RunQuantCheck(1336, 1828);
 }
 
-TEST_P(Trans16x16DCT, InvAccuracyCheck) {
-  RunInvAccuracyCheck();
-}
+TEST_P(Trans16x16DCT, InvAccuracyCheck) { RunInvAccuracyCheck(); }
 
-class Trans16x16HT
-    : public Trans16x16TestBase,
-      public ::testing::TestWithParam<Ht16x16Param> {
+class Trans16x16HT : public Trans16x16TestBase,
+                     public ::testing::TestWithParam<Ht16x16Param> {
  public:
   virtual ~Trans16x16HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
+    tx_type_ = GET_PARAM(2);
     bit_depth_ = GET_PARAM(3);
-    pitch_    = 16;
+    pitch_ = 16;
     fwd_txfm_ref = fht16x16_ref;
     inv_txfm_ref = iht16x16_ref;
     mask_ = (1 << bit_depth_) - 1;
 #if CONFIG_VP9_HIGHBITDEPTH
     switch (bit_depth_) {
-      case VPX_BITS_10:
-        inv_txfm_ref = iht16x16_10;
-        break;
-      case VPX_BITS_12:
-        inv_txfm_ref = iht16x16_12;
-        break;
-      default:
-        inv_txfm_ref = iht16x16_ref;
-        break;
+      case VPX_BITS_10: inv_txfm_ref = iht16x16_10; break;
+      case VPX_BITS_12: inv_txfm_ref = iht16x16_12; break;
+      default: inv_txfm_ref = iht16x16_ref; break;
     }
 #else
     inv_txfm_ref = iht16x16_ref;
@@ -735,17 +698,11 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(Trans16x16HT, AccuracyCheck) {
-  RunAccuracyCheck();
-}
+TEST_P(Trans16x16HT, AccuracyCheck) { RunAccuracyCheck(); }
 
-TEST_P(Trans16x16HT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(Trans16x16HT, CoeffCheck) { RunCoeffCheck(); }
 
-TEST_P(Trans16x16HT, MemCheck) {
-  RunMemCheck();
-}
+TEST_P(Trans16x16HT, MemCheck) { RunMemCheck(); }
 
 TEST_P(Trans16x16HT, QuantCheck) {
   // The encoder skips any non-DC intra prediction modes,
@@ -753,9 +710,8 @@
   RunQuantCheck(429, 729);
 }
 
-class InvTrans16x16DCT
-    : public Trans16x16TestBase,
-      public ::testing::TestWithParam<Idct16x16Param> {
+class InvTrans16x16DCT : public Trans16x16TestBase,
+                         public ::testing::TestWithParam<Idct16x16Param> {
  public:
   virtual ~InvTrans16x16DCT() {}
 
@@ -766,7 +722,7 @@
     bit_depth_ = GET_PARAM(3);
     pitch_ = 16;
     mask_ = (1 << bit_depth_) - 1;
-}
+  }
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
@@ -784,9 +740,8 @@
   CompareInvReference(ref_txfm_, thresh_);
 }
 
-class PartialTrans16x16Test
-    : public ::testing::TestWithParam<
-          std::tr1::tuple<FdctFunc, vpx_bit_depth_t> > {
+class PartialTrans16x16Test : public ::testing::TestWithParam<
+                                  std::tr1::tuple<FdctFunc, vpx_bit_depth_t> > {
  public:
   virtual ~PartialTrans16x16Test() {}
   virtual void SetUp() {
@@ -855,10 +810,10 @@
         make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12),
         make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
 #else
-INSTANTIATE_TEST_CASE_P(
-    C, Trans16x16DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(C, Trans16x16DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct16x16_c,
+                                                     &vpx_idct16x16_256_add_c,
+                                                     0, VPX_BITS_8)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -898,28 +853,25 @@
 #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     NEON, Trans16x16DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_neon, 0, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_neon,
+                                 0, VPX_BITS_8)));
 #endif
 
 #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans16x16DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct16x16_sse2,
-                   &vpx_idct16x16_256_add_sse2, 0, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct16x16_sse2,
+                                 &vpx_idct16x16_256_add_sse2, 0, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans16x16HT,
-    ::testing::Values(
-        make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 0,
-                   VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 1,
-                   VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 2,
-                   VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 3,
-                   VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vp10_fht16x16_sse2,
+                                 &vp10_iht16x16_256_add_sse2, 0, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2,
+                                 &vp10_iht16x16_256_add_sse2, 1, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2,
+                                 &vp10_iht16x16_256_add_sse2, 2, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2,
+                                 &vp10_iht16x16_256_add_sse2, 3, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
                         ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
                                                      VPX_BITS_8)));
@@ -929,62 +881,56 @@
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans16x16DCT,
     ::testing::Values(
-        make_tuple(&vpx_highbd_fdct16x16_sse2,
-                   &idct16x16_10, 0, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct16x16_c,
-                   &idct16x16_256_add_10_sse2, 0, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct16x16_sse2,
-                   &idct16x16_12, 0, VPX_BITS_12),
-        make_tuple(&vpx_highbd_fdct16x16_c,
-                   &idct16x16_256_add_12_sse2, 0, VPX_BITS_12),
-        make_tuple(&vpx_fdct16x16_sse2,
-                   &vpx_idct16x16_256_add_c, 0, VPX_BITS_8)));
+        make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_10, 0, VPX_BITS_10),
+        make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_10_sse2, 0,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_fdct16x16_sse2, &idct16x16_12, 0, VPX_BITS_12),
+        make_tuple(&vpx_highbd_fdct16x16_c, &idct16x16_256_add_12_sse2, 0,
+                   VPX_BITS_12),
+        make_tuple(&vpx_fdct16x16_sse2, &vpx_idct16x16_256_add_c, 0,
+                   VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans16x16HT,
-    ::testing::Values(
-        make_tuple(&vp10_fht16x16_sse2,
-                   &vp10_iht16x16_256_add_c, 0, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2,
-                   &vp10_iht16x16_256_add_c, 1, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2,
-                   &vp10_iht16x16_256_add_c, 2, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c, 3,
-                   VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
+                                 0, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
+                                 1, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
+                                 2, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_c,
+                                 3, VPX_BITS_8)));
 // Optimizations take effect at a threshold of 3155, so we use a value close to
 // that to test both branches.
 INSTANTIATE_TEST_CASE_P(
     SSE2, InvTrans16x16DCT,
-    ::testing::Values(
-        make_tuple(&idct16x16_10_add_10_c,
-                   &idct16x16_10_add_10_sse2, 3167, VPX_BITS_10),
-        make_tuple(&idct16x16_10,
-                   &idct16x16_256_add_10_sse2, 3167, VPX_BITS_10),
-        make_tuple(&idct16x16_10_add_12_c,
-                   &idct16x16_10_add_12_sse2, 3167, VPX_BITS_12),
-        make_tuple(&idct16x16_12,
-                   &idct16x16_256_add_12_sse2, 3167, VPX_BITS_12)));
+    ::testing::Values(make_tuple(&idct16x16_10_add_10_c,
+                                 &idct16x16_10_add_10_sse2, 3167, VPX_BITS_10),
+                      make_tuple(&idct16x16_10, &idct16x16_256_add_10_sse2,
+                                 3167, VPX_BITS_10),
+                      make_tuple(&idct16x16_10_add_12_c,
+                                 &idct16x16_10_add_12_sse2, 3167, VPX_BITS_12),
+                      make_tuple(&idct16x16_12, &idct16x16_256_add_12_sse2,
+                                 3167, VPX_BITS_12)));
 INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans16x16Test,
                         ::testing::Values(make_tuple(&vpx_fdct16x16_1_sse2,
                                                      VPX_BITS_8)));
 #endif  // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    MSA, Trans16x16DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct16x16_msa,
-                   &vpx_idct16x16_256_add_msa, 0, VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(MSA, Trans16x16DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct16x16_msa,
+                                                     &vpx_idct16x16_256_add_msa,
+                                                     0, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     MSA, Trans16x16HT,
-    ::testing::Values(
-        make_tuple(&vp10_fht16x16_msa,
-                   &vp10_iht16x16_256_add_msa, 0, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_msa,
-                   &vp10_iht16x16_256_add_msa, 1, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_msa,
-                   &vp10_iht16x16_256_add_msa, 2, VPX_BITS_8),
-        make_tuple(&vp10_fht16x16_msa,
-                   &vp10_iht16x16_256_add_msa, 3, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
+                                 0, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
+                                 1, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
+                                 2, VPX_BITS_8),
+                      make_tuple(&vp10_fht16x16_msa, &vp10_iht16x16_256_add_msa,
+                                 3, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(MSA, PartialTrans16x16Test,
                         ::testing::Values(make_tuple(&vpx_fdct16x16_1_msa,
                                                      VPX_BITS_8)));
diff --git a/test/dct32x32_test.cc b/test/dct32x32_test.cc
index 88d64ec3..b59ab03 100644
--- a/test/dct32x32_test.cc
+++ b/test/dct32x32_test.cc
@@ -39,8 +39,7 @@
     out[k] = 0.0;
     for (int n = 0; n < 32; n++)
       out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 64.0);
-    if (k == 0)
-      out[k] = out[k] * kInvSqrt2;
+    if (k == 0) out[k] = out[k] * kInvSqrt2;
   }
 }
 
@@ -49,21 +48,17 @@
   // First transform columns
   for (int i = 0; i < 32; ++i) {
     double temp_in[32], temp_out[32];
-    for (int j = 0; j < 32; ++j)
-      temp_in[j] = input[j*32 + i];
+    for (int j = 0; j < 32; ++j) temp_in[j] = input[j * 32 + i];
     reference_32x32_dct_1d(temp_in, temp_out);
-    for (int j = 0; j < 32; ++j)
-      output[j * 32 + i] = temp_out[j];
+    for (int j = 0; j < 32; ++j) output[j * 32 + i] = temp_out[j];
   }
   // Then transform rows
   for (int i = 0; i < 32; ++i) {
     double temp_in[32], temp_out[32];
-    for (int j = 0; j < 32; ++j)
-      temp_in[j] = output[j + i*32];
+    for (int j = 0; j < 32; ++j) temp_in[j] = output[j + i * 32];
     reference_32x32_dct_1d(temp_in, temp_out);
     // Scale by some magic number
-    for (int j = 0; j < 32; ++j)
-      output[j + i * 32] = temp_out[j] / 4;
+    for (int j = 0; j < 32; ++j) output[j + i * 32] = temp_out[j] / 4;
   }
 }
 
@@ -89,8 +84,8 @@
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    version_  = GET_PARAM(2);  // 0: high precision forward transform
-                               // 1: low precision version for rd loop
+    version_ = GET_PARAM(2);  // 0: high precision forward transform
+                              // 1: low precision version for rd loop
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
   }
@@ -140,8 +135,8 @@
       ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block, dst, 32));
 #if CONFIG_VP9_HIGHBITDEPTH
     } else {
-      ASM_REGISTER_STATE_CHECK(inv_txfm_(test_temp_block,
-                                         CONVERT_TO_BYTEPTR(dst16), 32));
+      ASM_REGISTER_STATE_CHECK(
+          inv_txfm_(test_temp_block, CONVERT_TO_BYTEPTR(dst16), 32));
 #endif
     }
 
@@ -153,8 +148,7 @@
       const int32_t diff = dst[j] - src[j];
 #endif
       const uint32_t error = diff * diff;
-      if (max_error < error)
-        max_error = error;
+      if (max_error < error) max_error = error;
       total_error += error;
     }
   }
@@ -213,11 +207,9 @@
       input_extreme_block[j] = rnd.Rand8() & 1 ? mask_ : -mask_;
     }
     if (i == 0) {
-      for (int j = 0; j < kNumCoeffs; ++j)
-        input_extreme_block[j] = mask_;
+      for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = mask_;
     } else if (i == 1) {
-      for (int j = 0; j < kNumCoeffs; ++j)
-        input_extreme_block[j] = -mask_;
+      for (int j = 0; j < kNumCoeffs; ++j) input_extreme_block[j] = -mask_;
     }
 
     const int stride = 32;
@@ -291,9 +283,8 @@
       const int diff = dst[j] - src[j];
 #endif
       const int error = diff * diff;
-      EXPECT_GE(1, error)
-          << "Error: 32x32 IDCT has error " << error
-          << " at index " << j;
+      EXPECT_GE(1, error) << "Error: 32x32 IDCT has error " << error
+                          << " at index " << j;
     }
   }
 }
@@ -365,18 +356,13 @@
 INSTANTIATE_TEST_CASE_P(
     C, Trans32x32Test,
     ::testing::Values(
-        make_tuple(&vpx_highbd_fdct32x32_c,
-                   &idct32x32_10, 0, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct32x32_rd_c,
-                   &idct32x32_10, 1, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct32x32_c,
-                   &idct32x32_12, 0, VPX_BITS_12),
-        make_tuple(&vpx_highbd_fdct32x32_rd_c,
-                   &idct32x32_12, 1, VPX_BITS_12),
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_c,
-                   &vpx_idct32x32_1024_add_c, 1, VPX_BITS_8)));
+        make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_10, 0, VPX_BITS_10),
+        make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_10, 1, VPX_BITS_10),
+        make_tuple(&vpx_highbd_fdct32x32_c, &idct32x32_12, 0, VPX_BITS_12),
+        make_tuple(&vpx_highbd_fdct32x32_rd_c, &idct32x32_12, 1, VPX_BITS_12),
+        make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
+        make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c, 1,
+                   VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     C, PartialTrans32x32Test,
     ::testing::Values(make_tuple(&vpx_highbd_fdct32x32_1_c, VPX_BITS_8),
@@ -385,11 +371,10 @@
 #else
 INSTANTIATE_TEST_CASE_P(
     C, Trans32x32Test,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_c,
-                   &vpx_idct32x32_1024_add_c, 1, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c, 0,
+                                 VPX_BITS_8),
+                      make_tuple(&vpx_fdct32x32_rd_c, &vpx_idct32x32_1024_add_c,
+                                 1, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(C, PartialTrans32x32Test,
                         ::testing::Values(make_tuple(&vpx_fdct32x32_1_c,
                                                      VPX_BITS_8)));
@@ -398,21 +383,19 @@
 #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     NEON, Trans32x32Test,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_neon, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_c,
-                   &vpx_idct32x32_1024_add_neon, 1, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_neon,
+                                 0, VPX_BITS_8),
+                      make_tuple(&vpx_fdct32x32_rd_c,
+                                 &vpx_idct32x32_1024_add_neon, 1, VPX_BITS_8)));
 #endif  // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans32x32Test,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_sse2,
-                   &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_sse2,
-                   &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_sse2,
+                                 &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
+                      make_tuple(&vpx_fdct32x32_rd_sse2,
+                                 &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(SSE2, PartialTrans32x32Test,
                         ::testing::Values(make_tuple(&vpx_fdct32x32_1_sse2,
                                                      VPX_BITS_8)));
@@ -440,21 +423,19 @@
 #if HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     AVX2, Trans32x32Test,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_avx2,
-                   &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_avx2,
-                   &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_avx2,
+                                 &vpx_idct32x32_1024_add_sse2, 0, VPX_BITS_8),
+                      make_tuple(&vpx_fdct32x32_rd_avx2,
+                                 &vpx_idct32x32_1024_add_sse2, 1, VPX_BITS_8)));
 #endif  // HAVE_AVX2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     MSA, Trans32x32Test,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_msa,
-                   &vpx_idct32x32_1024_add_msa, 0, VPX_BITS_8),
-        make_tuple(&vpx_fdct32x32_rd_msa,
-                   &vpx_idct32x32_1024_add_msa, 1, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_msa,
+                                 &vpx_idct32x32_1024_add_msa, 0, VPX_BITS_8),
+                      make_tuple(&vpx_fdct32x32_rd_msa,
+                                 &vpx_idct32x32_1024_add_msa, 1, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(MSA, PartialTrans32x32Test,
                         ::testing::Values(make_tuple(&vpx_fdct32x32_1_msa,
                                                      VPX_BITS_8)));
diff --git a/test/decode_api_test.cc b/test/decode_api_test.cc
index a819da5..6571154 100644
--- a/test/decode_api_test.cc
+++ b/test/decode_api_test.cc
@@ -25,7 +25,7 @@
     &vpx_codec_vp10_dx_algo,
 #endif
   };
-  uint8_t buf[1] = {0};
+  uint8_t buf[1] = { 0 };
   vpx_codec_ctx_t dec;
 
   EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_dec_init(NULL, NULL, NULL, 0));
@@ -48,8 +48,7 @@
               vpx_codec_decode(&dec, buf, NELEMENTS(buf), NULL, 0));
     EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
               vpx_codec_decode(&dec, NULL, NELEMENTS(buf), NULL, 0));
-    EXPECT_EQ(VPX_CODEC_INVALID_PARAM,
-              vpx_codec_decode(&dec, buf, 0, NULL, 0));
+    EXPECT_EQ(VPX_CODEC_INVALID_PARAM, vpx_codec_decode(&dec, buf, 0, NULL, 0));
 
     EXPECT_EQ(VPX_CODEC_OK, vpx_codec_destroy(&dec));
   }
diff --git a/test/decode_perf_test.cc b/test/decode_perf_test.cc
index 000f9c8..d8bfcbe 100644
--- a/test/decode_perf_test.cc
+++ b/test/decode_perf_test.cc
@@ -70,8 +70,7 @@
    power/temp/min max frame decode times/etc
  */
 
-class DecodePerfTest : public ::testing::TestWithParam<DecodePerfParam> {
-};
+class DecodePerfTest : public ::testing::TestWithParam<DecodePerfParam> {};
 
 TEST_P(DecodePerfTest, PerfTest) {
   const char *const video_name = GET_PARAM(VIDEO_NAME);
@@ -92,8 +91,7 @@
   }
 
   vpx_usec_timer_mark(&t);
-  const double elapsed_secs = double(vpx_usec_timer_elapsed(&t))
-                              / kUsecsInSec;
+  const double elapsed_secs = double(vpx_usec_timer_elapsed(&t)) / kUsecsInSec;
   const unsigned frames = video.frame_number();
   const double fps = double(frames) / elapsed_secs;
 
@@ -111,17 +109,13 @@
 INSTANTIATE_TEST_CASE_P(VP9, DecodePerfTest,
                         ::testing::ValuesIn(kVP9DecodePerfVectors));
 
-class VP9NewEncodeDecodePerfTest :
-    public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
+class VP9NewEncodeDecodePerfTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   VP9NewEncodeDecodePerfTest()
-      : EncoderTest(GET_PARAM(0)),
-        encoding_mode_(GET_PARAM(1)),
-        speed_(0),
-        outfile_(0),
-        out_frames_(0) {
-  }
+      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)), speed_(0),
+        outfile_(0), out_frames_(0) {}
 
   virtual ~VP9NewEncodeDecodePerfTest() {}
 
@@ -182,9 +176,7 @@
 
   virtual bool DoDecode() { return false; }
 
-  void set_speed(unsigned int speed) {
-    speed_ = speed;
-  }
+  void set_speed(unsigned int speed) { speed_ = speed; }
 
  private:
   libvpx_test::TestMode encoding_mode_;
@@ -196,10 +188,7 @@
 struct EncodePerfTestVideo {
   EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_,
                       uint32_t bitrate_, int frames_)
-      : name(name_),
-        width(width_),
-        height(height_),
-        bitrate(bitrate_),
+      : name(name_), width(width_), height(height_), bitrate(bitrate_),
         frames(frames_) {}
   const char *name;
   uint32_t width;
@@ -225,10 +214,8 @@
 
   const char *video_name = kVP9EncodePerfTestVectors[i].name;
   libvpx_test::I420VideoSource video(
-      video_name,
-      kVP9EncodePerfTestVectors[i].width,
-      kVP9EncodePerfTestVectors[i].height,
-      timebase.den, timebase.num, 0,
+      video_name, kVP9EncodePerfTestVectors[i].width,
+      kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
       kVP9EncodePerfTestVectors[i].frames);
   set_speed(2);
 
@@ -268,6 +255,6 @@
   printf("}\n");
 }
 
-VP10_INSTANTIATE_TEST_CASE(
-  VP9NewEncodeDecodePerfTest, ::testing::Values(::libvpx_test::kTwoPassGood));
+VP10_INSTANTIATE_TEST_CASE(VP9NewEncodeDecodePerfTest,
+                           ::testing::Values(::libvpx_test::kTwoPassGood));
 }  // namespace
diff --git a/test/decode_test_driver.cc b/test/decode_test_driver.cc
index 7fb3e37..a62ddbd 100644
--- a/test/decode_test_driver.cc
+++ b/test/decode_test_driver.cc
@@ -22,9 +22,8 @@
 
 vpx_codec_err_t Decoder::PeekStream(const uint8_t *cxdata, size_t size,
                                     vpx_codec_stream_info_t *stream_info) {
-  return vpx_codec_peek_stream_info(CodecInterface(),
-                                    cxdata, static_cast<unsigned int>(size),
-                                    stream_info);
+  return vpx_codec_peek_stream_info(
+      CodecInterface(), cxdata, static_cast<unsigned int>(size), stream_info);
 }
 
 vpx_codec_err_t Decoder::DecodeFrame(const uint8_t *cxdata, size_t size) {
@@ -36,9 +35,8 @@
   vpx_codec_err_t res_dec;
   InitOnce();
   API_REGISTER_STATE_CHECK(
-      res_dec = vpx_codec_decode(&decoder_,
-                                 cxdata, static_cast<unsigned int>(size),
-                                 user_priv, 0));
+      res_dec = vpx_codec_decode(
+          &decoder_, cxdata, static_cast<unsigned int>(size), user_priv, 0));
   return res_dec;
 }
 
@@ -73,7 +71,7 @@
 
 void DecoderTest::RunLoop(CompressedVideoSource *video,
                           const vpx_codec_dec_cfg_t &dec_cfg) {
-  Decoder* const decoder = codec_->CreateDecoder(dec_cfg, flags_, 0);
+  Decoder *const decoder = codec_->CreateDecoder(dec_cfg, flags_, 0);
   ASSERT_TRUE(decoder != NULL);
   bool end_of_file = false;
 
@@ -86,16 +84,14 @@
     stream_info.sz = sizeof(stream_info);
 
     if (video->cxdata() != NULL) {
-      const vpx_codec_err_t res_peek = decoder->PeekStream(video->cxdata(),
-                                                           video->frame_size(),
-                                                           &stream_info);
+      const vpx_codec_err_t res_peek = decoder->PeekStream(
+          video->cxdata(), video->frame_size(), &stream_info);
       HandlePeekResult(decoder, video, res_peek);
       ASSERT_FALSE(::testing::Test::HasFailure());
 
-      vpx_codec_err_t res_dec = decoder->DecodeFrame(video->cxdata(),
-                                                     video->frame_size());
-      if (!HandleDecodeResult(res_dec, *video, decoder))
-        break;
+      vpx_codec_err_t res_dec =
+          decoder->DecodeFrame(video->cxdata(), video->frame_size());
+      if (!HandleDecodeResult(res_dec, *video, decoder)) break;
     } else {
       // Signal end of the file to the decoder.
       const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
@@ -122,8 +118,6 @@
   memcpy(&cfg_, &dec_cfg, sizeof(cfg_));
 }
 
-void DecoderTest::set_flags(const vpx_codec_flags_t flags) {
-  flags_ = flags;
-}
+void DecoderTest::set_flags(const vpx_codec_flags_t flags) { flags_ = flags; }
 
 }  // namespace libvpx_test
diff --git a/test/decode_test_driver.h b/test/decode_test_driver.h
index 1492c5a..e6ef853 100644
--- a/test/decode_test_driver.h
+++ b/test/decode_test_driver.h
@@ -26,13 +26,11 @@
   explicit DxDataIterator(vpx_codec_ctx_t *decoder)
       : decoder_(decoder), iter_(NULL) {}
 
-  const vpx_image_t *Next() {
-    return vpx_codec_get_frame(decoder_, &iter_);
-  }
+  const vpx_image_t *Next() { return vpx_codec_get_frame(decoder_, &iter_); }
 
  private:
-  vpx_codec_ctx_t  *decoder_;
-  vpx_codec_iter_t  iter_;
+  vpx_codec_ctx_t *decoder_;
+  vpx_codec_iter_t iter_;
 };
 
 // Provides a simplified interface to manage one video decoding.
@@ -47,13 +45,14 @@
 
   Decoder(vpx_codec_dec_cfg_t cfg, const vpx_codec_flags_t flag,
           unsigned long deadline)  // NOLINT
-      : cfg_(cfg), flags_(flag), deadline_(deadline), init_done_(false) {
+      : cfg_(cfg),
+        flags_(flag),
+        deadline_(deadline),
+        init_done_(false) {
     memset(&decoder_, 0, sizeof(decoder_));
   }
 
-  virtual ~Decoder() {
-    vpx_codec_destroy(&decoder_);
-  }
+  virtual ~Decoder() { vpx_codec_destroy(&decoder_); }
 
   vpx_codec_err_t PeekStream(const uint8_t *cxdata, size_t size,
                              vpx_codec_stream_info_t *stream_info);
@@ -63,17 +62,11 @@
   vpx_codec_err_t DecodeFrame(const uint8_t *cxdata, size_t size,
                               void *user_priv);
 
-  DxDataIterator GetDxData() {
-    return DxDataIterator(&decoder_);
-  }
+  DxDataIterator GetDxData() { return DxDataIterator(&decoder_); }
 
-  void set_deadline(unsigned long deadline) {
-    deadline_ = deadline;
-  }
+  void set_deadline(unsigned long deadline) { deadline_ = deadline; }
 
-  void Control(int ctrl_id, int arg) {
-    Control(ctrl_id, arg, VPX_CODEC_OK);
-  }
+  void Control(int ctrl_id, int arg) { Control(ctrl_id, arg, VPX_CODEC_OK); }
 
   void Control(int ctrl_id, const void *arg) {
     InitOnce();
@@ -87,7 +80,7 @@
     ASSERT_EQ(expected_value, res) << DecodeError();
   }
 
-  const char* DecodeError() {
+  const char *DecodeError() {
     const char *detail = vpx_codec_error_detail(&decoder_);
     return detail ? detail : vpx_codec_error(&decoder_);
   }
@@ -97,11 +90,11 @@
       vpx_get_frame_buffer_cb_fn_t cb_get,
       vpx_release_frame_buffer_cb_fn_t cb_release, void *user_priv) {
     InitOnce();
-    return vpx_codec_set_frame_buffer_functions(
-        &decoder_, cb_get, cb_release, user_priv);
+    return vpx_codec_set_frame_buffer_functions(&decoder_, cb_get, cb_release,
+                                                user_priv);
   }
 
-  const char* GetDecoderName() const {
+  const char *GetDecoderName() const {
     return vpx_codec_iface_name(CodecInterface());
   }
 
@@ -109,28 +102,25 @@
 
   bool IsVP10() const;
 
-  vpx_codec_ctx_t * GetDecoder() {
-    return &decoder_;
-  }
+  vpx_codec_ctx_t *GetDecoder() { return &decoder_; }
 
  protected:
-  virtual vpx_codec_iface_t* CodecInterface() const = 0;
+  virtual vpx_codec_iface_t *CodecInterface() const = 0;
 
   void InitOnce() {
     if (!init_done_) {
-      const vpx_codec_err_t res = vpx_codec_dec_init(&decoder_,
-                                                     CodecInterface(),
-                                                     &cfg_, flags_);
+      const vpx_codec_err_t res =
+          vpx_codec_dec_init(&decoder_, CodecInterface(), &cfg_, flags_);
       ASSERT_EQ(VPX_CODEC_OK, res) << DecodeError();
       init_done_ = true;
     }
   }
 
-  vpx_codec_ctx_t     decoder_;
+  vpx_codec_ctx_t decoder_;
   vpx_codec_dec_cfg_t cfg_;
-  vpx_codec_flags_t   flags_;
-  unsigned int        deadline_;
-  bool                init_done_;
+  vpx_codec_flags_t flags_;
+  unsigned int deadline_;
+  bool init_done_;
 };
 
 // Common test functionality for all Decoder tests.
@@ -145,37 +135,35 @@
   virtual void set_flags(const vpx_codec_flags_t flags);
 
   // Hook to be called before decompressing every frame.
-  virtual void PreDecodeFrameHook(const CompressedVideoSource& /*video*/,
-                                  Decoder* /*decoder*/) {}
+  virtual void PreDecodeFrameHook(const CompressedVideoSource & /*video*/,
+                                  Decoder * /*decoder*/) {}
 
   // Hook to be called to handle decode result. Return true to continue.
   virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
-                                  const CompressedVideoSource& /*video*/,
+                                  const CompressedVideoSource & /*video*/,
                                   Decoder *decoder) {
     EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
     return VPX_CODEC_OK == res_dec;
   }
 
   // Hook to be called on every decompressed frame.
-  virtual void DecompressedFrameHook(const vpx_image_t& /*img*/,
+  virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
                                      const unsigned int /*frame_number*/) {}
 
   // Hook to be called on peek result
-  virtual void HandlePeekResult(Decoder* const decoder,
+  virtual void HandlePeekResult(Decoder *const decoder,
                                 CompressedVideoSource *video,
                                 const vpx_codec_err_t res_peek);
 
  protected:
   explicit DecoderTest(const CodecFactory *codec)
-      : codec_(codec),
-        cfg_(),
-        flags_(0) {}
+      : codec_(codec), cfg_(), flags_(0) {}
 
   virtual ~DecoderTest() {}
 
   const CodecFactory *codec_;
   vpx_codec_dec_cfg_t cfg_;
-  vpx_codec_flags_t   flags_;
+  vpx_codec_flags_t flags_;
 };
 
 }  // namespace libvpx_test
diff --git a/test/denoiser_sse2_test.cc b/test/denoiser_sse2_test.cc
index 793cd17..daca510 100644
--- a/test/denoiser_sse2_test.cc
+++ b/test/denoiser_sse2_test.cc
@@ -33,9 +33,7 @@
  public:
   virtual ~VP9DenoiserTest() {}
 
-  virtual void SetUp() {
-    bs_ = GetParam();
-  }
+  virtual void SetUp() { bs_ = GetParam(); }
 
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
@@ -68,19 +66,19 @@
       sig_block[j] = rnd.Rand8();
       // The pixels in mc_avg_block are generated by adding a random
       // number in range [-19, 19] to corresponding pixels in sig_block.
-      temp = sig_block[j] + ((rnd.Rand8() % 2 == 0) ? -1 : 1) *
-             (rnd.Rand8() % 20);
+      temp =
+          sig_block[j] + ((rnd.Rand8() % 2 == 0) ? -1 : 1) * (rnd.Rand8() % 20);
       // Clip.
       mc_avg_block[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
     }
 
-    ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_c(
-        sig_block, 64, mc_avg_block, 64, avg_block_c,
-        64, 0, bs_, motion_magnitude_random));
+    ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_c(sig_block, 64, mc_avg_block,
+                                                   64, avg_block_c, 64, 0, bs_,
+                                                   motion_magnitude_random));
 
     ASM_REGISTER_STATE_CHECK(vp9_denoiser_filter_sse2(
-        sig_block, 64, mc_avg_block, 64, avg_block_sse2,
-        64, 0, bs_, motion_magnitude_random));
+        sig_block, 64, mc_avg_block, 64, avg_block_sse2, 64, 0, bs_,
+        motion_magnitude_random));
 
     // Test bitexactness.
     for (int h = 0; h < (4 << b_height_log2_lookup[bs_]); ++h) {
@@ -92,9 +90,9 @@
 }
 
 // Test for all block size.
-INSTANTIATE_TEST_CASE_P(
-    SSE2, VP9DenoiserTest,
-    ::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8, BLOCK_16X16,
-                      BLOCK_16X32, BLOCK_32X16, BLOCK_32X32, BLOCK_32X64,
-                      BLOCK_64X32, BLOCK_64X64));
+INSTANTIATE_TEST_CASE_P(SSE2, VP9DenoiserTest,
+                        ::testing::Values(BLOCK_8X8, BLOCK_8X16, BLOCK_16X8,
+                                          BLOCK_16X16, BLOCK_16X32, BLOCK_32X16,
+                                          BLOCK_32X32, BLOCK_32X64, BLOCK_64X32,
+                                          BLOCK_64X64));
 }  // namespace
diff --git a/test/encode_api_test.cc b/test/encode_api_test.cc
index 9e99bb8..6c1d5e3 100644
--- a/test/encode_api_test.cc
+++ b/test/encode_api_test.cc
@@ -24,7 +24,7 @@
     &vpx_codec_vp10_cx_algo,
 #endif
   };
-  uint8_t buf[1] = {0};
+  uint8_t buf[1] = { 0 };
   vpx_image_t img;
   vpx_codec_ctx_t enc;
   vpx_codec_enc_cfg_t cfg;
diff --git a/test/encode_perf_test.cc b/test/encode_perf_test.cc
index 69be9ea..2411dcd 100644
--- a/test/encode_perf_test.cc
+++ b/test/encode_perf_test.cc
@@ -26,10 +26,7 @@
 struct EncodePerfTestVideo {
   EncodePerfTestVideo(const char *name_, uint32_t width_, uint32_t height_,
                       uint32_t bitrate_, int frames_)
-      : name(name_),
-        width(width_),
-        height(height_),
-        bitrate(bitrate_),
+      : name(name_), width(width_), height(height_), bitrate(bitrate_),
         frames(frames_) {}
   const char *name;
   uint32_t width;
@@ -45,8 +42,8 @@
   EncodePerfTestVideo("macmarcostationary_640_480_30.yuv", 640, 480, 200, 718),
   EncodePerfTestVideo("niklas_640_480_30.yuv", 640, 480, 200, 471),
   EncodePerfTestVideo("tacomanarrows_640_480_30.yuv", 640, 480, 200, 300),
-  EncodePerfTestVideo("tacomasmallcameramovement_640_480_30.yuv",
-                      640, 480, 200, 300),
+  EncodePerfTestVideo("tacomasmallcameramovement_640_480_30.yuv", 640, 480, 200,
+                      300),
   EncodePerfTestVideo("thaloundeskmtg_640_480_30.yuv", 640, 480, 200, 300),
   EncodePerfTestVideo("niklas_1280_720_30.yuv", 1280, 720, 600, 470),
 };
@@ -61,12 +58,8 @@
       public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   VP9EncodePerfTest()
-      : EncoderTest(GET_PARAM(0)),
-        min_psnr_(kMaxPsnr),
-        nframes_(0),
-        encoding_mode_(GET_PARAM(1)),
-        speed_(0),
-        threads_(1) {}
+      : EncoderTest(GET_PARAM(0)), min_psnr_(kMaxPsnr), nframes_(0),
+        encoding_mode_(GET_PARAM(1)), speed_(0), threads_(1) {}
 
   virtual ~VP9EncodePerfTest() {}
 
@@ -107,24 +100,18 @@
 
   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
     if (pkt->data.psnr.psnr[0] < min_psnr_) {
-      min_psnr_= pkt->data.psnr.psnr[0];
+      min_psnr_ = pkt->data.psnr.psnr[0];
     }
   }
 
   // for performance reasons don't decode
   virtual bool DoDecode() { return 0; }
 
-  double min_psnr() const {
-    return min_psnr_;
-  }
+  double min_psnr() const { return min_psnr_; }
 
-  void set_speed(unsigned int speed) {
-    speed_ = speed;
-  }
+  void set_speed(unsigned int speed) { speed_ = speed; }
 
-  void set_threads(unsigned int threads) {
-    threads_ = threads;
-  }
+  void set_threads(unsigned int threads) { threads_ = threads; }
 
  private:
   double min_psnr_;
@@ -157,10 +144,8 @@
         const unsigned frames = kVP9EncodePerfTestVectors[i].frames;
         const char *video_name = kVP9EncodePerfTestVectors[i].name;
         libvpx_test::I420VideoSource video(
-            video_name,
-            kVP9EncodePerfTestVectors[i].width,
-            kVP9EncodePerfTestVectors[i].height,
-            timebase.den, timebase.num, 0,
+            video_name, kVP9EncodePerfTestVectors[i].width,
+            kVP9EncodePerfTestVectors[i].height, timebase.den, timebase.num, 0,
             kVP9EncodePerfTestVectors[i].frames);
         set_speed(kEncodePerfTestSpeeds[j]);
 
@@ -197,6 +182,6 @@
   }
 }
 
-VP10_INSTANTIATE_TEST_CASE(
-    VP9EncodePerfTest, ::testing::Values(::libvpx_test::kRealTime));
+VP10_INSTANTIATE_TEST_CASE(VP9EncodePerfTest,
+                           ::testing::Values(::libvpx_test::kRealTime));
 }  // namespace
diff --git a/test/encode_test_driver.cc b/test/encode_test_driver.cc
index a8a76c5..61044ee 100644
--- a/test/encode_test_driver.cc
+++ b/test/encode_test_driver.cc
@@ -31,14 +31,13 @@
     cfg_.g_timebase = video->timebase();
     cfg_.rc_twopass_stats_in = stats_->buf();
 
-    res = vpx_codec_enc_init(&encoder_, CodecInterface(), &cfg_,
-                             init_flags_);
+    res = vpx_codec_enc_init(&encoder_, CodecInterface(), &cfg_, init_flags_);
     ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 
 #if CONFIG_VP10_ENCODER
     if (CodecInterface() == &vpx_codec_vp10_cx_algo) {
-      // Default to 1 tile column for VP10. With CONFIG_EXT_TILE, the
-      // default is already the largest possible tile size
+// Default to 1 tile column for VP10. With CONFIG_EXT_TILE, the
+// default is already the largest possible tile size
 #if !CONFIG_EXT_TILE
       const int log2_tile_columns = 0;
       res = vpx_codec_control_(&encoder_, VP9E_SET_TILE_COLUMNS,
@@ -62,8 +61,7 @@
   CxDataIterator iter = GetCxData();
 
   while (const vpx_codec_cx_pkt_t *pkt = iter.Next()) {
-    if (pkt->kind != VPX_CODEC_STATS_PKT)
-      continue;
+    if (pkt->kind != VPX_CODEC_STATS_PKT) continue;
 
     stats_->Append(*pkt);
   }
@@ -83,15 +81,15 @@
   }
 
   // Encode the frame
-  API_REGISTER_STATE_CHECK(
-      res = vpx_codec_encode(&encoder_, img, video.pts(), video.duration(),
-                             frame_flags, deadline_));
+  API_REGISTER_STATE_CHECK(res = vpx_codec_encode(&encoder_, img, video.pts(),
+                                                  video.duration(), frame_flags,
+                                                  deadline_));
   ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
 }
 
 void Encoder::Flush() {
-  const vpx_codec_err_t res = vpx_codec_encode(&encoder_, NULL, 0, 0, 0,
-                                               deadline_);
+  const vpx_codec_err_t res =
+      vpx_codec_encode(&encoder_, NULL, 0, 0, 0, deadline_);
   if (!encoder_.priv)
     ASSERT_EQ(VPX_CODEC_ERROR, res) << EncoderError();
   else
@@ -106,22 +104,15 @@
 
 void EncoderTest::SetMode(TestMode mode) {
   switch (mode) {
-    case kRealTime:
-      deadline_ = VPX_DL_REALTIME;
-      break;
+    case kRealTime: deadline_ = VPX_DL_REALTIME; break;
 
     case kOnePassGood:
-    case kTwoPassGood:
-      deadline_ = VPX_DL_GOOD_QUALITY;
-      break;
+    case kTwoPassGood: deadline_ = VPX_DL_GOOD_QUALITY; break;
 
     case kOnePassBest:
-    case kTwoPassBest:
-      deadline_ = VPX_DL_BEST_QUALITY;
-      break;
+    case kTwoPassBest: deadline_ = VPX_DL_BEST_QUALITY; break;
 
-    default:
-      ASSERT_TRUE(false) << "Unexpected mode " << mode;
+    default: ASSERT_TRUE(false) << "Unexpected mode " << mode;
   }
 
   if (mode == kTwoPassGood || mode == kTwoPassBest)
@@ -132,10 +123,8 @@
 
 static bool compare_plane(const uint8_t *const buf1, const int stride1,
                           const uint8_t *const buf2, const int stride2,
-                          const int w, const int h,
-                          int *const mismatch_row,
-                          int *const mismatch_col,
-                          int *const mismatch_pix1,
+                          const int w, const int h, int *const mismatch_row,
+                          int *const mismatch_col, int *const mismatch_pix1,
                           int *const mismatch_pix2) {
   int r, c;
 
@@ -145,14 +134,10 @@
       const int pix2 = buf2[r * stride2 + c];
 
       if (pix1 != pix2) {
-        if (mismatch_row != NULL)
-          *mismatch_row = r;
-        if (mismatch_col != NULL)
-          *mismatch_col = c;
-        if (mismatch_pix1 != NULL)
-          *mismatch_pix1 = pix1;
-        if (mismatch_pix2 != NULL)
-          *mismatch_pix2 = pix2;
+        if (mismatch_row != NULL) *mismatch_row = r;
+        if (mismatch_col != NULL) *mismatch_col = c;
+        if (mismatch_pix1 != NULL) *mismatch_pix1 = pix1;
+        if (mismatch_pix2 != NULL) *mismatch_pix2 = pix2;
         return false;
       }
     }
@@ -163,86 +148,67 @@
 
 // The function should return "true" most of the time, therefore no early
 // break-out is implemented within the match checking process.
-static bool compare_img(const vpx_image_t *img1,
-                        const vpx_image_t *img2,
-                        int *const mismatch_row,
-                        int *const mismatch_col,
-                        int *const mismatch_plane,
-                        int *const mismatch_pix1,
+static bool compare_img(const vpx_image_t *img1, const vpx_image_t *img2,
+                        int *const mismatch_row, int *const mismatch_col,
+                        int *const mismatch_plane, int *const mismatch_pix1,
                         int *const mismatch_pix2) {
-
   const unsigned int w_y = img1->d_w;
   const unsigned int h_y = img1->d_h;
   const unsigned int w_uv = ROUND_POWER_OF_TWO(w_y, img1->x_chroma_shift);
   const unsigned int h_uv = ROUND_POWER_OF_TWO(h_y, img1->y_chroma_shift);
 
-  if (img1->fmt != img2->fmt
-      || img1->cs != img2->cs
-      || img1->d_w != img2->d_w
-      || img1->d_h != img2->d_h) {
-    if (mismatch_row != NULL)
-      *mismatch_row = -1;
-    if (mismatch_col != NULL)
-      *mismatch_col = -1;
+  if (img1->fmt != img2->fmt || img1->cs != img2->cs ||
+      img1->d_w != img2->d_w || img1->d_h != img2->d_h) {
+    if (mismatch_row != NULL) *mismatch_row = -1;
+    if (mismatch_col != NULL) *mismatch_col = -1;
     return false;
   }
 
-  if (!compare_plane(img1->planes[VPX_PLANE_Y],  img1->stride[VPX_PLANE_Y],
-                     img2->planes[VPX_PLANE_Y],  img2->stride[VPX_PLANE_Y],
-                     w_y, h_y,
-                     mismatch_row, mismatch_col,
-                     mismatch_pix1, mismatch_pix2)) {
-    if (mismatch_plane != NULL)
-      *mismatch_plane = VPX_PLANE_Y;
+  if (!compare_plane(img1->planes[VPX_PLANE_Y], img1->stride[VPX_PLANE_Y],
+                     img2->planes[VPX_PLANE_Y], img2->stride[VPX_PLANE_Y], w_y,
+                     h_y, mismatch_row, mismatch_col, mismatch_pix1,
+                     mismatch_pix2)) {
+    if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_Y;
     return false;
   }
 
-  if (!compare_plane(img1->planes[VPX_PLANE_U],  img1->stride[VPX_PLANE_U],
-                     img2->planes[VPX_PLANE_U],  img2->stride[VPX_PLANE_U],
-                     w_uv, h_uv,
-                     mismatch_row, mismatch_col,
-                     mismatch_pix1, mismatch_pix2)) {
-    if (mismatch_plane != NULL)
-      *mismatch_plane = VPX_PLANE_U;
+  if (!compare_plane(img1->planes[VPX_PLANE_U], img1->stride[VPX_PLANE_U],
+                     img2->planes[VPX_PLANE_U], img2->stride[VPX_PLANE_U], w_uv,
+                     h_uv, mismatch_row, mismatch_col, mismatch_pix1,
+                     mismatch_pix2)) {
+    if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_U;
     return false;
   }
 
-  if (!compare_plane(img1->planes[VPX_PLANE_V],  img1->stride[VPX_PLANE_V],
-                     img2->planes[VPX_PLANE_V],  img2->stride[VPX_PLANE_V],
-                     w_uv, h_uv,
-                     mismatch_row, mismatch_col,
-                     mismatch_pix1, mismatch_pix2)) {
-    if (mismatch_plane != NULL)
-      *mismatch_plane = VPX_PLANE_U;
+  if (!compare_plane(img1->planes[VPX_PLANE_V], img1->stride[VPX_PLANE_V],
+                     img2->planes[VPX_PLANE_V], img2->stride[VPX_PLANE_V], w_uv,
+                     h_uv, mismatch_row, mismatch_col, mismatch_pix1,
+                     mismatch_pix2)) {
+    if (mismatch_plane != NULL) *mismatch_plane = VPX_PLANE_U;
     return false;
   }
 
   return true;
 }
 
-void EncoderTest::MismatchHook(const vpx_image_t* img_enc,
-                               const vpx_image_t* img_dec) {
+void EncoderTest::MismatchHook(const vpx_image_t *img_enc,
+                               const vpx_image_t *img_dec) {
   int mismatch_row = 0;
   int mismatch_col = 0;
   int mismatch_plane = 0;
   int mismatch_pix_enc = 0;
   int mismatch_pix_dec = 0;
 
-  ASSERT_FALSE(compare_img(img_enc, img_dec,
-                           &mismatch_row, &mismatch_col,
-                           &mismatch_plane,
-                           &mismatch_pix_enc,
+  ASSERT_FALSE(compare_img(img_enc, img_dec, &mismatch_row, &mismatch_col,
+                           &mismatch_plane, &mismatch_pix_enc,
                            &mismatch_pix_dec));
 
-  GTEST_FAIL()
-    << "Encode/Decode mismatch found:"
-    << std::endl
-    << "  pixel value enc/dec: "  << mismatch_pix_enc << "/" << mismatch_pix_dec
-    << std::endl
-    << "                plane: " << mismatch_plane
-    << std::endl
-    << "              row/col: " << mismatch_row << "/" << mismatch_col
-    << std::endl;
+  GTEST_FAIL() << "Encode/Decode mismatch found:" << std::endl
+               << "  pixel value enc/dec: " << mismatch_pix_enc << "/"
+               << mismatch_pix_dec << std::endl
+               << "                plane: " << mismatch_plane << std::endl
+               << "              row/col: " << mismatch_row << "/"
+               << mismatch_col << std::endl;
 }
 
 void EncoderTest::RunLoop(VideoSource *video) {
@@ -306,10 +272,9 @@
             has_cxdata = true;
             if (decoder.get() != NULL && DoDecode()) {
               vpx_codec_err_t res_dec = decoder->DecodeFrame(
-                  (const uint8_t*)pkt->data.frame.buf, pkt->data.frame.sz);
+                  (const uint8_t *)pkt->data.frame.buf, pkt->data.frame.sz);
 
-              if (!HandleDecodeResult(res_dec, *video, decoder.get()))
-                break;
+              if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
 
               has_dxdata = true;
             }
@@ -318,20 +283,16 @@
             FramePktHook(pkt);
             break;
 
-          case VPX_CODEC_PSNR_PKT:
-            PSNRPktHook(pkt);
-            break;
+          case VPX_CODEC_PSNR_PKT: PSNRPktHook(pkt); break;
 
-          default:
-            break;
+          default: break;
         }
       }
 
       // Flush the decoder when there are no more fragments.
       if ((init_flags_ & VPX_CODEC_USE_OUTPUT_PARTITION) && has_dxdata) {
         const vpx_codec_err_t res_dec = decoder->DecodeFrame(NULL, 0);
-        if (!HandleDecodeResult(res_dec, *video, decoder.get()))
-          break;
+        if (!HandleDecodeResult(res_dec, *video, decoder.get())) break;
       }
 
       if (has_dxdata && has_cxdata) {
@@ -339,23 +300,20 @@
         DxDataIterator dec_iter = decoder->GetDxData();
         const vpx_image_t *img_dec = dec_iter.Next();
         if (img_enc && img_dec) {
-          const bool res = compare_img(img_enc, img_dec,
-                                       NULL, NULL, NULL, NULL, NULL);
+          const bool res =
+              compare_img(img_enc, img_dec, NULL, NULL, NULL, NULL, NULL);
           if (!res) {  // Mismatch
             MismatchHook(img_enc, img_dec);
           }
         }
-        if (img_dec)
-          DecompressedFrameHook(*img_dec, video->pts());
+        if (img_dec) DecompressedFrameHook(*img_dec, video->pts());
       }
-      if (!Continue())
-        break;
+      if (!Continue()) break;
     }
 
     EndPassHook();
 
-    if (!Continue())
-      break;
+    if (!Continue()) break;
   }
 }
 
diff --git a/test/encode_test_driver.h b/test/encode_test_driver.h
index 720ec84..94abd03 100644
--- a/test/encode_test_driver.h
+++ b/test/encode_test_driver.h
@@ -33,19 +33,17 @@
   kTwoPassGood,
   kTwoPassBest
 };
-#define ALL_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \
-                                         ::libvpx_test::kOnePassGood, \
-                                         ::libvpx_test::kOnePassBest, \
-                                         ::libvpx_test::kTwoPassGood, \
-                                         ::libvpx_test::kTwoPassBest)
+#define ALL_TEST_MODES                                                        \
+  ::testing::Values(::libvpx_test::kRealTime, ::libvpx_test::kOnePassGood,    \
+                    ::libvpx_test::kOnePassBest, ::libvpx_test::kTwoPassGood, \
+                    ::libvpx_test::kTwoPassBest)
 
-#define ONE_PASS_TEST_MODES ::testing::Values(::libvpx_test::kRealTime, \
-                                              ::libvpx_test::kOnePassGood, \
-                                              ::libvpx_test::kOnePassBest)
+#define ONE_PASS_TEST_MODES                                                \
+  ::testing::Values(::libvpx_test::kRealTime, ::libvpx_test::kOnePassGood, \
+                    ::libvpx_test::kOnePassBest)
 
-#define TWO_PASS_TEST_MODES ::testing::Values(::libvpx_test::kTwoPassGood, \
-                                              ::libvpx_test::kTwoPassBest)
-
+#define TWO_PASS_TEST_MODES \
+  ::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kTwoPassBest)
 
 // Provides an object to handle the libvpx get_cx_data() iteration pattern
 class CxDataIterator {
@@ -58,8 +56,8 @@
   }
 
  private:
-  vpx_codec_ctx_t  *encoder_;
-  vpx_codec_iter_t  iter_;
+  vpx_codec_ctx_t *encoder_;
+  vpx_codec_iter_t iter_;
 };
 
 // Implements an in-memory store for libvpx twopass statistics
@@ -75,15 +73,12 @@
     return buf;
   }
 
-  void Reset() {
-    buffer_.clear();
-  }
+  void Reset() { buffer_.clear(); }
 
  protected:
-  std::string  buffer_;
+  std::string buffer_;
 };
 
-
 // Provides a simplified interface to manage one video encoding pass, given
 // a configuration and video source.
 //
@@ -97,13 +92,9 @@
     memset(&encoder_, 0, sizeof(encoder_));
   }
 
-  virtual ~Encoder() {
-    vpx_codec_destroy(&encoder_);
-  }
+  virtual ~Encoder() { vpx_codec_destroy(&encoder_); }
 
-  CxDataIterator GetCxData() {
-    return CxDataIterator(&encoder_);
-  }
+  CxDataIterator GetCxData() { return CxDataIterator(&encoder_); }
 
   void InitEncoder(VideoSource *video);
 
@@ -115,9 +106,7 @@
   void EncodeFrame(VideoSource *video, const unsigned long frame_flags);
 
   // Convenience wrapper for EncodeFrame()
-  void EncodeFrame(VideoSource *video) {
-    EncodeFrame(video, 0);
-  }
+  void EncodeFrame(VideoSource *video) { EncodeFrame(video, 0); }
 
   void Control(int ctrl_id, int arg) {
     const vpx_codec_err_t res = vpx_codec_control_(&encoder_, ctrl_id, arg);
@@ -147,12 +136,10 @@
     cfg_ = *cfg;
   }
 
-  void set_deadline(unsigned long deadline) {
-    deadline_ = deadline;
-  }
+  void set_deadline(unsigned long deadline) { deadline_ = deadline; }
 
  protected:
-  virtual vpx_codec_iface_t* CodecInterface() const = 0;
+  virtual vpx_codec_iface_t *CodecInterface() const = 0;
 
   const char *EncoderError() {
     const char *detail = vpx_codec_error_detail(&encoder_);
@@ -166,11 +153,11 @@
   // Flush the encoder on EOS
   void Flush();
 
-  vpx_codec_ctx_t      encoder_;
-  vpx_codec_enc_cfg_t  cfg_;
-  unsigned long        deadline_;
-  unsigned long        init_flags_;
-  TwopassStatsStore   *stats_;
+  vpx_codec_ctx_t encoder_;
+  vpx_codec_enc_cfg_t cfg_;
+  unsigned long deadline_;
+  unsigned long init_flags_;
+  TwopassStatsStore *stats_;
 };
 
 // Common test functionality for all Encoder tests.
@@ -212,36 +199,35 @@
   virtual void EndPassHook() {}
 
   // Hook to be called before encoding a frame.
-  virtual void PreEncodeFrameHook(VideoSource* /*video*/) {}
-  virtual void PreEncodeFrameHook(VideoSource* /*video*/,
-                                  Encoder* /*encoder*/) {}
+  virtual void PreEncodeFrameHook(VideoSource * /*video*/) {}
+  virtual void PreEncodeFrameHook(VideoSource * /*video*/,
+                                  Encoder * /*encoder*/) {}
 
   // Hook to be called on every compressed data packet.
-  virtual void FramePktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {}
+  virtual void FramePktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
 
   // Hook to be called on every PSNR packet.
-  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t* /*pkt*/) {}
+  virtual void PSNRPktHook(const vpx_codec_cx_pkt_t * /*pkt*/) {}
 
   // Hook to determine whether the encode loop should continue.
   virtual bool Continue() const {
     return !(::testing::Test::HasFatalFailure() || abort_);
   }
 
-  const CodecFactory   *codec_;
+  const CodecFactory *codec_;
   // Hook to determine whether to decode frame after encoding
   virtual bool DoDecode() const { return 1; }
 
   // Hook to handle encode/decode mismatch
-  virtual void MismatchHook(const vpx_image_t *img1,
-                            const vpx_image_t *img2);
+  virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2);
 
   // Hook to be called on every decompressed frame.
-  virtual void DecompressedFrameHook(const vpx_image_t& /*img*/,
+  virtual void DecompressedFrameHook(const vpx_image_t & /*img*/,
                                      vpx_codec_pts_t /*pts*/) {}
 
   // Hook to be called to handle decode result. Return true to continue.
   virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
-                                  const VideoSource& /*video*/,
+                                  const VideoSource & /*video*/,
                                   Decoder *decoder) {
     EXPECT_EQ(VPX_CODEC_OK, res_dec) << decoder->DecodeError();
     return VPX_CODEC_OK == res_dec;
@@ -253,15 +239,15 @@
     return pkt;
   }
 
-  bool                 abort_;
-  vpx_codec_enc_cfg_t  cfg_;
-  vpx_codec_dec_cfg_t  dec_cfg_;
-  unsigned int         passes_;
-  unsigned long        deadline_;
-  TwopassStatsStore    stats_;
-  unsigned long        init_flags_;
-  unsigned long        frame_flags_;
-  vpx_codec_pts_t      last_pts_;
+  bool abort_;
+  vpx_codec_enc_cfg_t cfg_;
+  vpx_codec_dec_cfg_t dec_cfg_;
+  unsigned int passes_;
+  unsigned long deadline_;
+  TwopassStatsStore stats_;
+  unsigned long init_flags_;
+  unsigned long frame_flags_;
+  vpx_codec_pts_t last_pts_;
 };
 
 }  // namespace libvpx_test
diff --git a/test/encoder_parms_get_to_decoder.cc b/test/encoder_parms_get_to_decoder.cc
index ea4640c..8af0b7d 100644
--- a/test/encoder_parms_get_to_decoder.cc
+++ b/test/encoder_parms_get_to_decoder.cc
@@ -29,7 +29,7 @@
 };
 
 const EncodePerfTestVideo kVP9EncodePerfTestVectors[] = {
-  {"niklas_1280_720_30.y4m", 1280, 720, 600, 10},
+  { "niklas_1280_720_30.y4m", 1280, 720, 600, 10 },
 };
 
 struct EncodeParameters {
@@ -45,10 +45,10 @@
 };
 
 const EncodeParameters kVP9EncodeParameterSet[] = {
-  {0, 0, 0, 1, 0, VPX_CR_STUDIO_RANGE, VPX_CS_BT_601, { 0, 0 }},
-  {0, 0, 0, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_709, { 0, 0 }},
-  {0, 0, 1, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_2020, { 0, 0 }},
-  {0, 2, 0, 0, 1, VPX_CR_STUDIO_RANGE, VPX_CS_UNKNOWN, { 640, 480 }},
+  { 0, 0, 0, 1, 0, VPX_CR_STUDIO_RANGE, VPX_CS_BT_601, { 0, 0 } },
+  { 0, 0, 0, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_709, { 0, 0 } },
+  { 0, 0, 1, 0, 0, VPX_CR_FULL_RANGE, VPX_CS_BT_2020, { 0, 0 } },
+  { 0, 2, 0, 0, 1, VPX_CR_STUDIO_RANGE, VPX_CS_UNKNOWN, { 640, 480 } },
   // TODO(JBB): Test profiles (requires more work).
 };
 
@@ -144,6 +144,6 @@
 }
 
 VP10_INSTANTIATE_TEST_CASE(VpxEncoderParmsGetToDecoder,
-                          ::testing::ValuesIn(kVP9EncodeParameterSet),
-                          ::testing::ValuesIn(kVP9EncodePerfTestVectors));
+                           ::testing::ValuesIn(kVP9EncodeParameterSet),
+                           ::testing::ValuesIn(kVP9EncodePerfTestVectors));
 }  // namespace
diff --git a/test/end_to_end_test.cc b/test/end_to_end_test.cc
index b858008..fe5c479 100644
--- a/test/end_to_end_test.cc
+++ b/test/end_to_end_test.cc
@@ -18,7 +18,7 @@
 
 namespace {
 
-const unsigned int kWidth  = 160;
+const unsigned int kWidth = 160;
 const unsigned int kHeight = 90;
 const unsigned int kFramerate = 50;
 const unsigned int kFrames = 10;
@@ -30,23 +30,15 @@
 // We make two cases here to enable the testing and
 // guard picture quality.
 #if CONFIG_VP10_ENCODER && CONFIG_VP9_HIGHBITDEPTH
-  { 36.0, 37.0, 37.0, 37.0, 37.0 },
-  { 31.0, 36.0, 36.0, 36.0, 36.0 },
-  { 31.0, 35.0, 35.0, 35.0, 35.0 },
-  { 31.0, 34.0, 34.0, 34.0, 34.0 },
-  { 31.0, 33.0, 33.0, 33.0, 33.0 },
-  { 31.0, 32.0, 32.0, 32.0, 32.0 },
-  { 30.0, 31.0, 31.0, 31.0, 31.0 },
-  { 29.0, 30.0, 30.0, 30.0, 30.0 },
+  { 36.0, 37.0, 37.0, 37.0, 37.0 }, { 31.0, 36.0, 36.0, 36.0, 36.0 },
+  { 31.0, 35.0, 35.0, 35.0, 35.0 }, { 31.0, 34.0, 34.0, 34.0, 34.0 },
+  { 31.0, 33.0, 33.0, 33.0, 33.0 }, { 31.0, 32.0, 32.0, 32.0, 32.0 },
+  { 30.0, 31.0, 31.0, 31.0, 31.0 }, { 29.0, 30.0, 30.0, 30.0, 30.0 },
 #else
-  { 36.0, 37.0, 37.0, 37.0, 37.0 },
-  { 35.0, 36.0, 36.0, 36.0, 36.0 },
-  { 34.0, 35.0, 35.0, 35.0, 35.0 },
-  { 33.0, 34.0, 34.0, 34.0, 34.0 },
-  { 32.0, 33.0, 33.0, 33.0, 33.0 },
-  { 31.0, 32.0, 32.0, 32.0, 32.0 },
-  { 30.0, 31.0, 31.0, 31.0, 31.0 },
-  { 29.0, 30.0, 30.0, 30.0, 30.0 },
+  { 36.0, 37.0, 37.0, 37.0, 37.0 }, { 35.0, 36.0, 36.0, 36.0, 36.0 },
+  { 34.0, 35.0, 35.0, 35.0, 35.0 }, { 33.0, 34.0, 34.0, 34.0, 34.0 },
+  { 32.0, 33.0, 33.0, 33.0, 33.0 }, { 31.0, 32.0, 32.0, 32.0, 32.0 },
+  { 30.0, 31.0, 31.0, 31.0, 31.0 }, { 29.0, 30.0, 30.0, 30.0, 30.0 },
 #endif  // CONFIG_VP9_HIGHBITDEPTH && CONFIG_VP10_ENCODER
 };
 
@@ -59,31 +51,30 @@
 } TestVideoParam;
 
 const TestVideoParam kTestVectors[] = {
-  {"park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0},
-  {"park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, VPX_BITS_8, 1},
-  {"park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1},
-  {"park_joy_90p_8_440.yuv", 8, VPX_IMG_FMT_I440, VPX_BITS_8, 1},
+  { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0 },
+  { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422, VPX_BITS_8, 1 },
+  { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1 },
+  { "park_joy_90p_8_440.yuv", 8, VPX_IMG_FMT_I440, VPX_BITS_8, 1 },
 #if CONFIG_VP9_HIGHBITDEPTH
-  {"park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, VPX_BITS_10, 2},
-  {"park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, VPX_BITS_10, 3},
-  {"park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, VPX_BITS_10, 3},
-  {"park_joy_90p_10_440.yuv", 10, VPX_IMG_FMT_I44016, VPX_BITS_10, 3},
-  {"park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, VPX_BITS_12, 2},
-  {"park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, VPX_BITS_12, 3},
-  {"park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, VPX_BITS_12, 3},
-  {"park_joy_90p_12_440.yuv", 12, VPX_IMG_FMT_I44016, VPX_BITS_12, 3},
+  { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016, VPX_BITS_10, 2 },
+  { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216, VPX_BITS_10, 3 },
+  { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416, VPX_BITS_10, 3 },
+  { "park_joy_90p_10_440.yuv", 10, VPX_IMG_FMT_I44016, VPX_BITS_10, 3 },
+  { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016, VPX_BITS_12, 2 },
+  { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216, VPX_BITS_12, 3 },
+  { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416, VPX_BITS_12, 3 },
+  { "park_joy_90p_12_440.yuv", 12, VPX_IMG_FMT_I44016, VPX_BITS_12, 3 },
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 };
 
 // Encoding modes tested
 const libvpx_test::TestMode kEncodingModeVectors[] = {
-  ::libvpx_test::kTwoPassGood,
-  ::libvpx_test::kOnePassGood,
+  ::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood,
   ::libvpx_test::kRealTime,
 };
 
 // Speed settings tested
-const int kCpuUsedVectors[] = {1, 2, 3, 5, 6};
+const int kCpuUsedVectors[] = { 1, 2, 3, 5, 6 };
 
 int is_extension_y4m(const char *filename) {
   const char *dot = strrchr(filename, '.');
@@ -95,17 +86,13 @@
 
 class EndToEndTestLarge
     : public ::libvpx_test::EncoderTest,
-      public ::libvpx_test::CodecTestWith3Params<libvpx_test::TestMode, \
+      public ::libvpx_test::CodecTestWith3Params<libvpx_test::TestMode,
                                                  TestVideoParam, int> {
  protected:
   EndToEndTestLarge()
-      : EncoderTest(GET_PARAM(0)),
-        test_video_param_(GET_PARAM(2)),
-        cpu_used_(GET_PARAM(3)),
-        psnr_(0.0),
-        nframes_(0),
-        encoding_mode_(GET_PARAM(1)) {
-  }
+      : EncoderTest(GET_PARAM(0)), test_video_param_(GET_PARAM(2)),
+        cpu_used_(GET_PARAM(3)), psnr_(0.0), nframes_(0),
+        encoding_mode_(GET_PARAM(1)) {}
 
   virtual ~EndToEndTestLarge() {}
 
@@ -156,8 +143,7 @@
   }
 
   double GetAveragePsnr() const {
-    if (nframes_)
-      return psnr_ / nframes_;
+    if (nframes_) return psnr_ / nframes_;
     return 0.0;
   }
 
@@ -181,30 +167,26 @@
   cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
   cfg_.g_bit_depth = test_video_param_.bit_depth;
   init_flags_ = VPX_CODEC_USE_PSNR;
-  if (cfg_.g_bit_depth > 8)
-    init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
+  if (cfg_.g_bit_depth > 8) init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
 
   libvpx_test::VideoSource *video;
   if (is_extension_y4m(test_video_param_.filename)) {
-    video = new libvpx_test::Y4mVideoSource(test_video_param_.filename,
-                                            0, kFrames);
+    video =
+        new libvpx_test::Y4mVideoSource(test_video_param_.filename, 0, kFrames);
   } else {
     video = new libvpx_test::YUVVideoSource(test_video_param_.filename,
-                                            test_video_param_.fmt,
-                                            kWidth, kHeight,
-                                            kFramerate, 1, 0, kFrames);
+                                            test_video_param_.fmt, kWidth,
+                                            kHeight, kFramerate, 1, 0, kFrames);
   }
 
   ASSERT_NO_FATAL_FAILURE(RunLoop(video));
   const double psnr = GetAveragePsnr();
   EXPECT_GT(psnr, GetPsnrThreshold());
-  delete(video);
+  delete (video);
 }
 
-
-VP10_INSTANTIATE_TEST_CASE(
-    EndToEndTestLarge,
-    ::testing::ValuesIn(kEncodingModeVectors),
-    ::testing::ValuesIn(kTestVectors),
-    ::testing::ValuesIn(kCpuUsedVectors));
+VP10_INSTANTIATE_TEST_CASE(EndToEndTestLarge,
+                           ::testing::ValuesIn(kEncodingModeVectors),
+                           ::testing::ValuesIn(kTestVectors),
+                           ::testing::ValuesIn(kCpuUsedVectors));
 }  // namespace
diff --git a/test/error_block_test.cc b/test/error_block_test.cc
index 629ba97..90130ca 100644
--- a/test/error_block_test.cc
+++ b/test/error_block_test.cc
@@ -32,20 +32,18 @@
 
 typedef int64_t (*ErrorBlockFunc)(const tran_low_t *coeff,
                                   const tran_low_t *dqcoeff,
-                                  intptr_t block_size,
-                                  int64_t *ssz, int bps);
+                                  intptr_t block_size, int64_t *ssz, int bps);
 
 typedef std::tr1::tuple<ErrorBlockFunc, ErrorBlockFunc, vpx_bit_depth_t>
-                        ErrorBlockParam;
+    ErrorBlockParam;
 
-class ErrorBlockTest
-  : public ::testing::TestWithParam<ErrorBlockParam> {
+class ErrorBlockTest : public ::testing::TestWithParam<ErrorBlockParam> {
  public:
   virtual ~ErrorBlockTest() {}
   virtual void SetUp() {
-    error_block_op_     = GET_PARAM(0);
+    error_block_op_ = GET_PARAM(0);
     ref_error_block_op_ = GET_PARAM(1);
-    bit_depth_  = GET_PARAM(2);
+    bit_depth_ = GET_PARAM(2);
   }
 
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
@@ -76,18 +74,18 @@
       // can be used for optimization, so generate test input precisely.
       if (rnd(2)) {
         // Positive number
-        coeff[j]   = rnd(1 << msb);
+        coeff[j] = rnd(1 << msb);
         dqcoeff[j] = rnd(1 << msb);
       } else {
         // Negative number
-        coeff[j]   = -rnd(1 << msb);
+        coeff[j] = -rnd(1 << msb);
         dqcoeff[j] = -rnd(1 << msb);
       }
     }
-    ref_ret = ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz,
-                                  bit_depth_);
-    ASM_REGISTER_STATE_CHECK(ret = error_block_op_(coeff, dqcoeff, block_size,
-                                                   &ssz, bit_depth_));
+    ref_ret =
+        ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
+    ASM_REGISTER_STATE_CHECK(
+        ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
     err_count += (ref_ret != ret) | (ref_ssz != ssz);
     if (err_count && !err_count_total) {
       first_failure = i;
@@ -117,35 +115,35 @@
     int k = (i / 9) % 9;
 
     // Change the maximum coeff value, to test different bit boundaries
-    if ( k == 8 && (i % 9) == 0 ) {
+    if (k == 8 && (i % 9) == 0) {
       max_val >>= 1;
     }
     block_size = 16 << (i % 9);  // All block sizes from 4x4, 8x4 ..64x64
     for (int j = 0; j < block_size; j++) {
       if (k < 4) {
         // Test at positive maximum values
-        coeff[j]   = k % 2 ? max_val : 0;
+        coeff[j] = k % 2 ? max_val : 0;
         dqcoeff[j] = (k >> 1) % 2 ? max_val : 0;
       } else if (k < 8) {
         // Test at negative maximum values
-        coeff[j]   = k % 2 ? -max_val : 0;
+        coeff[j] = k % 2 ? -max_val : 0;
         dqcoeff[j] = (k >> 1) % 2 ? -max_val : 0;
       } else {
         if (rnd(2)) {
           // Positive number
-          coeff[j]   = rnd(1 << 14);
+          coeff[j] = rnd(1 << 14);
           dqcoeff[j] = rnd(1 << 14);
         } else {
           // Negative number
-          coeff[j]   = -rnd(1 << 14);
+          coeff[j] = -rnd(1 << 14);
           dqcoeff[j] = -rnd(1 << 14);
         }
       }
     }
-    ref_ret = ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz,
-                                  bit_depth_);
-    ASM_REGISTER_STATE_CHECK(ret = error_block_op_(coeff, dqcoeff, block_size,
-                                                   &ssz, bit_depth_));
+    ref_ret =
+        ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
+    ASM_REGISTER_STATE_CHECK(
+        ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
     err_count += (ref_ret != ret) | (ref_ssz != ssz);
     if (err_count && !err_count_total) {
       first_failure = i;
@@ -162,13 +160,12 @@
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, ErrorBlockTest,
-    ::testing::Values(
-        make_tuple(&vp10_highbd_block_error_sse2,
-                   &vp10_highbd_block_error_c, VPX_BITS_10),
-        make_tuple(&vp10_highbd_block_error_sse2,
-                   &vp10_highbd_block_error_c, VPX_BITS_12),
-        make_tuple(&vp10_highbd_block_error_sse2,
-                   &vp10_highbd_block_error_c, VPX_BITS_8)));
+    ::testing::Values(make_tuple(&vp10_highbd_block_error_sse2,
+                                 &vp10_highbd_block_error_c, VPX_BITS_10),
+                      make_tuple(&vp10_highbd_block_error_sse2,
+                                 &vp10_highbd_block_error_c, VPX_BITS_12),
+                      make_tuple(&vp10_highbd_block_error_sse2,
+                                 &vp10_highbd_block_error_c, VPX_BITS_8)));
 #endif  // HAVE_SSE2
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
diff --git a/test/error_resilience_test.cc b/test/error_resilience_test.cc
index 99419ad..2c1392c 100644
--- a/test/error_resilience_test.cc
+++ b/test/error_resilience_test.cc
@@ -19,16 +19,13 @@
 const int kMaxErrorFrames = 12;
 const int kMaxDroppableFrames = 12;
 
-class ErrorResilienceTestLarge : public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
+class ErrorResilienceTestLarge
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   ErrorResilienceTestLarge()
-      : EncoderTest(GET_PARAM(0)),
-        psnr_(0.0),
-        nframes_(0),
-        mismatch_psnr_(0.0),
-        mismatch_nframes_(0),
-        encoding_mode_(GET_PARAM(1)) {
+      : EncoderTest(GET_PARAM(0)), psnr_(0.0), nframes_(0), mismatch_psnr_(0.0),
+        mismatch_nframes_(0), encoding_mode_(GET_PARAM(1)) {
     Reset();
   }
 
@@ -59,17 +56,15 @@
 
   virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
                                   ::libvpx_test::Encoder * /*encoder*/) {
-    frame_flags_ &= ~(VP8_EFLAG_NO_UPD_LAST |
-                      VP8_EFLAG_NO_UPD_GF |
-                      VP8_EFLAG_NO_UPD_ARF);
+    frame_flags_ &=
+        ~(VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF);
     if (droppable_nframes_ > 0 &&
         (cfg_.g_pass == VPX_RC_LAST_PASS || cfg_.g_pass == VPX_RC_ONE_PASS)) {
       for (unsigned int i = 0; i < droppable_nframes_; ++i) {
         if (droppable_frames_[i] == video->frame()) {
-          std::cout << "Encoding droppable frame: "
-                    << droppable_frames_[i] << "\n";
-          frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST |
-                           VP8_EFLAG_NO_UPD_GF |
+          std::cout << "Encoding droppable frame: " << droppable_frames_[i]
+                    << "\n";
+          frame_flags_ |= (VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
                            VP8_EFLAG_NO_UPD_ARF);
           return;
         }
@@ -78,14 +73,12 @@
   }
 
   double GetAveragePsnr() const {
-    if (nframes_)
-      return psnr_ / nframes_;
+    if (nframes_) return psnr_ / nframes_;
     return 0.0;
   }
 
   double GetAverageMismatchPsnr() const {
-    if (mismatch_nframes_)
-      return mismatch_psnr_ / mismatch_nframes_;
+    if (mismatch_nframes_) return mismatch_psnr_ / mismatch_nframes_;
     return 0.0;
   }
 
@@ -103,8 +96,7 @@
     return 1;
   }
 
-  virtual void MismatchHook(const vpx_image_t *img1,
-                            const vpx_image_t *img2) {
+  virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
     double mismatch_psnr = compute_psnr(img1, img2);
     mismatch_psnr_ += mismatch_psnr;
     ++mismatch_nframes_;
@@ -132,13 +124,9 @@
       droppable_frames_[i] = list[i];
   }
 
-  unsigned int GetMismatchFrames() {
-    return mismatch_nframes_;
-  }
+  unsigned int GetMismatchFrames() { return mismatch_nframes_; }
 
-  void SetPatternSwitch(int frame_switch) {
-     pattern_switch_ = frame_switch;
-   }
+  void SetPatternSwitch(int frame_switch) { pattern_switch_ = frame_switch; }
 
  private:
   double psnr_;
@@ -209,15 +197,14 @@
   // In addition to isolated loss/drop, add a long consecutive series
   // (of size 9) of dropped frames.
   unsigned int num_droppable_frames = 11;
-  unsigned int droppable_frame_list[] = {5, 16, 22, 23, 24, 25, 26, 27, 28,
-                                         29, 30};
+  unsigned int droppable_frame_list[] = { 5,  16, 22, 23, 24, 25,
+                                          26, 27, 28, 29, 30 };
   SetDroppableFrames(num_droppable_frames, droppable_frame_list);
   SetErrorFrames(num_droppable_frames, droppable_frame_list);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   // Test that no mismatches have been found
-  std::cout << "             Mismatch frames: "
-            << GetMismatchFrames() << "\n";
-  EXPECT_EQ(GetMismatchFrames(), (unsigned int) 0);
+  std::cout << "             Mismatch frames: " << GetMismatchFrames() << "\n";
+  EXPECT_EQ(GetMismatchFrames(), (unsigned int)0);
 
   // Reset previously set of error/droppable frames.
   Reset();
diff --git a/test/ethread_test.cc b/test/ethread_test.cc
index cb0497a..6b80ccc 100644
--- a/test/ethread_test.cc
+++ b/test/ethread_test.cc
@@ -23,10 +23,8 @@
       public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   VPxEncoderThreadTest()
-      : EncoderTest(GET_PARAM(0)),
-        encoder_initialized_(false),
-        encoding_mode_(GET_PARAM(1)),
-        set_cpu_used_(GET_PARAM(2)) {
+      : EncoderTest(GET_PARAM(0)), encoder_initialized_(false),
+        encoding_mode_(GET_PARAM(1)), set_cpu_used_(GET_PARAM(2)) {
     init_flags_ = VPX_CODEC_USE_PSNR;
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     cfg.w = 1280;
@@ -43,9 +41,7 @@
     md5_dec_.clear();
     md5_enc_.clear();
   }
-  virtual ~VPxEncoderThreadTest() {
-    delete decoder_;
-  }
+  virtual ~VPxEncoderThreadTest() { delete decoder_; }
 
   virtual void SetUp() {
     InitializeConfig();
@@ -104,12 +100,12 @@
     size_enc_.push_back(pkt->data.frame.sz);
 
     ::libvpx_test::MD5 md5_enc;
-    md5_enc.Add(reinterpret_cast<uint8_t*>(pkt->data.frame.buf),
+    md5_enc.Add(reinterpret_cast<uint8_t *>(pkt->data.frame.buf),
                 pkt->data.frame.sz);
     md5_enc_.push_back(md5_enc.Get());
 
     const vpx_codec_err_t res = decoder_->DecodeFrame(
-        reinterpret_cast<uint8_t*>(pkt->data.frame.buf), pkt->data.frame.sz);
+        reinterpret_cast<uint8_t *>(pkt->data.frame.buf), pkt->data.frame.sz);
     if (res != VPX_CODEC_OK) {
       abort_ = true;
       ASSERT_EQ(VPX_CODEC_OK, res);
@@ -169,24 +165,19 @@
   std::vector<std::string> md5_dec_;
 };
 
-TEST_P(VPxEncoderThreadTest, EncoderResultTest) {
-  DoTest();
-}
+TEST_P(VPxEncoderThreadTest, EncoderResultTest) { DoTest(); }
 
 class VPxEncoderThreadTestLarge : public VPxEncoderThreadTest {};
 
-TEST_P(VPxEncoderThreadTestLarge, EncoderResultTest) {
-  DoTest();
-}
+TEST_P(VPxEncoderThreadTestLarge, EncoderResultTest) { DoTest(); }
 
+VP10_INSTANTIATE_TEST_CASE(VPxEncoderThreadTest,
+                           ::testing::Values(::libvpx_test::kTwoPassGood,
+                                             ::libvpx_test::kOnePassGood),
+                           ::testing::Range(3, 9));
 
-VP10_INSTANTIATE_TEST_CASE(
-    VPxEncoderThreadTest,
-    ::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood),
-    ::testing::Range(3, 9));
-
-VP10_INSTANTIATE_TEST_CASE(
-    VPxEncoderThreadTestLarge,
-    ::testing::Values(::libvpx_test::kTwoPassGood, ::libvpx_test::kOnePassGood),
-    ::testing::Range(1, 3));
+VP10_INSTANTIATE_TEST_CASE(VPxEncoderThreadTestLarge,
+                           ::testing::Values(::libvpx_test::kTwoPassGood,
+                                             ::libvpx_test::kOnePassGood),
+                           ::testing::Range(1, 3));
 }  // namespace
diff --git a/test/fdct4x4_test.cc b/test/fdct4x4_test.cc
index fe9ffcc..00114f4 100644
--- a/test/fdct4x4_test.cc
+++ b/test/fdct4x4_test.cc
@@ -36,9 +36,8 @@
 using libvpx_test::FhtFunc;
 
 typedef std::tr1::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t, int>
-Dct4x4Param;
-typedef std::tr1::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int>
-Ht4x4Param;
+    Dct4x4Param;
+typedef std::tr1::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht4x4Param;
 
 void fdct4x4_ref(const int16_t *in, tran_low_t *out, int stride,
                  int /*tx_type*/) {
@@ -90,18 +89,16 @@
 #endif  // HAVE_SSE2
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
-
-class Trans4x4DCT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Dct4x4Param> {
+class Trans4x4DCT : public libvpx_test::TransformTestBase,
+                    public ::testing::TestWithParam<Dct4x4Param> {
  public:
   virtual ~Trans4x4DCT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 4;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 4;
     fwd_txfm_ref = fdct4x4_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -121,33 +118,24 @@
   IdctFunc inv_txfm_;
 };
 
-TEST_P(Trans4x4DCT, AccuracyCheck) {
-  RunAccuracyCheck(1);
-}
+TEST_P(Trans4x4DCT, AccuracyCheck) { RunAccuracyCheck(1); }
 
-TEST_P(Trans4x4DCT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(Trans4x4DCT, CoeffCheck) { RunCoeffCheck(); }
 
-TEST_P(Trans4x4DCT, MemCheck) {
-  RunMemCheck();
-}
+TEST_P(Trans4x4DCT, MemCheck) { RunMemCheck(); }
 
-TEST_P(Trans4x4DCT, InvAccuracyCheck) {
-  RunInvAccuracyCheck(1);
-}
+TEST_P(Trans4x4DCT, InvAccuracyCheck) { RunInvAccuracyCheck(1); }
 
-class Trans4x4HT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Ht4x4Param> {
+class Trans4x4HT : public libvpx_test::TransformTestBase,
+                   public ::testing::TestWithParam<Ht4x4Param> {
  public:
   virtual ~Trans4x4HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 4;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 4;
     fwd_txfm_ref = fht4x4_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -168,33 +156,24 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(Trans4x4HT, AccuracyCheck) {
-  RunAccuracyCheck(1);
-}
+TEST_P(Trans4x4HT, AccuracyCheck) { RunAccuracyCheck(1); }
 
-TEST_P(Trans4x4HT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(Trans4x4HT, CoeffCheck) { RunCoeffCheck(); }
 
-TEST_P(Trans4x4HT, MemCheck) {
-  RunMemCheck();
-}
+TEST_P(Trans4x4HT, MemCheck) { RunMemCheck(); }
 
-TEST_P(Trans4x4HT, InvAccuracyCheck) {
-  RunInvAccuracyCheck(1);
-}
+TEST_P(Trans4x4HT, InvAccuracyCheck) { RunInvAccuracyCheck(1); }
 
-class Trans4x4WHT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Dct4x4Param> {
+class Trans4x4WHT : public libvpx_test::TransformTestBase,
+                    public ::testing::TestWithParam<Dct4x4Param> {
  public:
   virtual ~Trans4x4WHT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 4;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 4;
     fwd_txfm_ref = fwht4x4_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -214,21 +193,13 @@
   IdctFunc inv_txfm_;
 };
 
-TEST_P(Trans4x4WHT, AccuracyCheck) {
-  RunAccuracyCheck(0);
-}
+TEST_P(Trans4x4WHT, AccuracyCheck) { RunAccuracyCheck(0); }
 
-TEST_P(Trans4x4WHT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(Trans4x4WHT, CoeffCheck) { RunCoeffCheck(); }
 
-TEST_P(Trans4x4WHT, MemCheck) {
-  RunMemCheck();
-}
+TEST_P(Trans4x4WHT, MemCheck) { RunMemCheck(); }
 
-TEST_P(Trans4x4WHT, InvAccuracyCheck) {
-  RunInvAccuracyCheck(0);
-}
+TEST_P(Trans4x4WHT, InvAccuracyCheck) { RunInvAccuracyCheck(0); }
 using std::tr1::make_tuple;
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -239,10 +210,10 @@
         make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12, 16),
         make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8, 16)));
 #else
-INSTANTIATE_TEST_CASE_P(
-    C, Trans4x4DCT,
-    ::testing::Values(
-         make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8, 16)));
+INSTANTIATE_TEST_CASE_P(C, Trans4x4DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct4x4_c,
+                                                     &vpx_idct4x4_16_add_c, 0,
+                                                     VPX_BITS_8, 16)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -279,107 +250,93 @@
         make_tuple(&vp10_highbd_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12, 16),
         make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8, 16)));
 #else
-INSTANTIATE_TEST_CASE_P(
-    C, Trans4x4WHT,
-    ::testing::Values(
-        make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0, VPX_BITS_8, 16)));
+INSTANTIATE_TEST_CASE_P(C, Trans4x4WHT,
+                        ::testing::Values(make_tuple(&vp10_fwht4x4_c,
+                                                     &vpx_iwht4x4_16_add_c, 0,
+                                                     VPX_BITS_8, 16)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    NEON, Trans4x4DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct4x4_c,
-                   &vpx_idct4x4_16_add_neon, 0, VPX_BITS_8, 16)));
+INSTANTIATE_TEST_CASE_P(NEON, Trans4x4DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct4x4_c,
+                                                     &vpx_idct4x4_16_add_neon,
+                                                     0, VPX_BITS_8, 16)));
 #endif  // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     NEON, Trans4x4HT,
     ::testing::Values(
-        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon,
-                   0, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon,
-                   1, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon,
-                   2, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon,
-                   3, VPX_BITS_8, 16)));
+        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 0, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 1, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 2, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_c, &vp10_iht4x4_16_add_neon, 3, VPX_BITS_8,
+                   16)));
 #endif  // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans4x4WHT,
-    ::testing::Values(
-        make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c,
-                   0, VPX_BITS_8, 16),
-        make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_sse2,
-                   0, VPX_BITS_8, 16)));
+    ::testing::Values(make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_c, 0,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fwht4x4_c, &vpx_iwht4x4_16_add_sse2, 0,
+                                 VPX_BITS_8, 16)));
 #endif
 
 #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    SSE2, Trans4x4DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct4x4_sse2,
-                   &vpx_idct4x4_16_add_sse2, 0, VPX_BITS_8, 16)));
+INSTANTIATE_TEST_CASE_P(SSE2, Trans4x4DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct4x4_sse2,
+                                                     &vpx_idct4x4_16_add_sse2,
+                                                     0, VPX_BITS_8, 16)));
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans4x4HT,
-    ::testing::Values(
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3,
-                   VPX_BITS_8, 16)));
+    ::testing::Values(make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3,
+                                 VPX_BITS_8, 16)));
 #endif  // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans4x4DCT,
     ::testing::Values(
-        make_tuple(&vpx_highbd_fdct4x4_c,    &idct4x4_10_sse2, 0,
-                   VPX_BITS_10, 16),
-        make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0,
-                   VPX_BITS_10, 16),
-        make_tuple(&vpx_highbd_fdct4x4_c,    &idct4x4_12_sse2, 0,
-                   VPX_BITS_12, 16),
-        make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0,
-                   VPX_BITS_12, 16),
-        make_tuple(&vpx_fdct4x4_sse2,      &vpx_idct4x4_16_add_c, 0,
-                   VPX_BITS_8, 16)));
+        make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_10_sse2, 0, VPX_BITS_10, 16),
+        make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_10_sse2, 0, VPX_BITS_10,
+                   16),
+        make_tuple(&vpx_highbd_fdct4x4_c, &idct4x4_12_sse2, 0, VPX_BITS_12, 16),
+        make_tuple(&vpx_highbd_fdct4x4_sse2, &idct4x4_12_sse2, 0, VPX_BITS_12,
+                   16),
+        make_tuple(&vpx_fdct4x4_sse2, &vpx_idct4x4_16_add_c, 0, VPX_BITS_8,
+                   16)));
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, Trans4x4HT,
     ::testing::Values(
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c,
-                   0, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c,
-                   1, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c,
-                   2, VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c,
-                   3, VPX_BITS_8, 16)));
+        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 0, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 1, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 2, VPX_BITS_8, 16),
+        make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_c, 3, VPX_BITS_8,
+                   16)));
 #endif  // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    MSA, Trans4x4DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct4x4_msa, &vpx_idct4x4_16_add_msa, 0,
-                   VPX_BITS_8, 16)));
+INSTANTIATE_TEST_CASE_P(MSA, Trans4x4DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct4x4_msa,
+                                                     &vpx_idct4x4_16_add_msa, 0,
+                                                     VPX_BITS_8, 16)));
 INSTANTIATE_TEST_CASE_P(
     MSA, Trans4x4HT,
-    ::testing::Values(
-        make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 0,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 1,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 2,
-                   VPX_BITS_8, 16),
-        make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 3,
-                   VPX_BITS_8, 16)));
+    ::testing::Values(make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 0,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 1,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 2,
+                                 VPX_BITS_8, 16),
+                      make_tuple(&vp10_fht4x4_msa, &vp10_iht4x4_16_add_msa, 3,
+                                 VPX_BITS_8, 16)));
 #endif  // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 }  // namespace
diff --git a/test/fdct8x8_test.cc b/test/fdct8x8_test.cc
index 123ff53..cfdf519 100644
--- a/test/fdct8x8_test.cc
+++ b/test/fdct8x8_test.cc
@@ -53,8 +53,7 @@
     out[k] = 0.0;
     for (int n = 0; n < 8; n++)
       out[k] += in[n] * cos(kPi * (2 * n + 1) * k / 16.0);
-    if (k == 0)
-      out[k] = out[k] * kInvSqrt2;
+    if (k == 0) out[k] = out[k] * kInvSqrt2;
   }
 }
 
@@ -63,25 +62,20 @@
   // First transform columns
   for (int i = 0; i < 8; ++i) {
     double temp_in[8], temp_out[8];
-    for (int j = 0; j < 8; ++j)
-      temp_in[j] = input[j*8 + i];
+    for (int j = 0; j < 8; ++j) temp_in[j] = input[j * 8 + i];
     reference_8x8_dct_1d(temp_in, temp_out);
-    for (int j = 0; j < 8; ++j)
-      output[j * 8 + i] = temp_out[j];
+    for (int j = 0; j < 8; ++j) output[j * 8 + i] = temp_out[j];
   }
   // Then transform rows
   for (int i = 0; i < 8; ++i) {
     double temp_in[8], temp_out[8];
-    for (int j = 0; j < 8; ++j)
-      temp_in[j] = output[j + i*8];
+    for (int j = 0; j < 8; ++j) temp_in[j] = output[j + i * 8];
     reference_8x8_dct_1d(temp_in, temp_out);
     // Scale by some magic number
-    for (int j = 0; j < 8; ++j)
-      output[j + i * 8] = temp_out[j] * 2;
+    for (int j = 0; j < 8; ++j) output[j + i * 8] = temp_out[j] * 2;
   }
 }
 
-
 void fdct8x8_ref(const int16_t *in, tran_low_t *out, int stride,
                  int /*tx_type*/) {
   vpx_fdct8x8_c(in, out, stride);
@@ -177,8 +171,7 @@
           << 1. * max_diff / count_test_block * 100 << "%"
           << " for input range [-255, 255] at index " << j
           << " count0: " << count_sign_block[j][0]
-          << " count1: " << count_sign_block[j][1]
-          << " diff: " << diff;
+          << " count1: " << count_sign_block[j][1] << " diff: " << diff;
     }
 
     memset(count_sign_block, 0, sizeof(count_sign_block));
@@ -186,8 +179,8 @@
     for (int i = 0; i < count_test_block; ++i) {
       // Initialize a test block with input range [-mask_ / 16, mask_ / 16].
       for (int j = 0; j < 64; ++j)
-        test_input_block[j] = ((rnd.Rand16() & mask_) >> 4) -
-                              ((rnd.Rand16() & mask_) >> 4);
+        test_input_block[j] =
+            ((rnd.Rand16() & mask_) >> 4) - ((rnd.Rand16() & mask_) >> 4);
       ASM_REGISTER_STATE_CHECK(
           RunFwdTxfm(test_input_block, test_output_block, pitch_));
 
@@ -207,8 +200,7 @@
           << 1. * max_diff / count_test_block * 100 << "%"
           << " for input range [-15, 15] at index " << j
           << " count0: " << count_sign_block[j][0]
-          << " count1: " << count_sign_block[j][1]
-          << " diff: " << diff;
+          << " count1: " << count_sign_block[j][1] << " diff: " << diff;
     }
   }
 
@@ -245,19 +237,18 @@
       ASM_REGISTER_STATE_CHECK(
           RunFwdTxfm(test_input_block, test_temp_block, pitch_));
       for (int j = 0; j < 64; ++j) {
-          if (test_temp_block[j] > 0) {
-            test_temp_block[j] += 2;
-            test_temp_block[j] /= 4;
-            test_temp_block[j] *= 4;
-          } else {
-            test_temp_block[j] -= 2;
-            test_temp_block[j] /= 4;
-            test_temp_block[j] *= 4;
-          }
+        if (test_temp_block[j] > 0) {
+          test_temp_block[j] += 2;
+          test_temp_block[j] /= 4;
+          test_temp_block[j] *= 4;
+        } else {
+          test_temp_block[j] -= 2;
+          test_temp_block[j] /= 4;
+          test_temp_block[j] *= 4;
+        }
       }
       if (bit_depth_ == VPX_BITS_8) {
-        ASM_REGISTER_STATE_CHECK(
-            RunInvTxfm(test_temp_block, dst, pitch_));
+        ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
         ASM_REGISTER_STATE_CHECK(
@@ -273,19 +264,18 @@
         const int diff = dst[j] - src[j];
 #endif
         const int error = diff * diff;
-        if (max_error < error)
-          max_error = error;
+        if (max_error < error) max_error = error;
         total_error += error;
       }
     }
 
     EXPECT_GE(1 << 2 * (bit_depth_ - 8), max_error)
-      << "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual"
-      << " roundtrip error > 1";
+        << "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual"
+        << " roundtrip error > 1";
 
-    EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8))/5, total_error)
-      << "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip "
-      << "error > 1/5 per block";
+    EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8)) / 5, total_error)
+        << "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip "
+        << "error > 1/5 per block";
   }
 
   void RunExtremalCheck() {
@@ -341,8 +331,7 @@
       ASM_REGISTER_STATE_CHECK(
           fwd_txfm_ref(test_input_block, ref_temp_block, pitch_, tx_type_));
       if (bit_depth_ == VPX_BITS_8) {
-        ASM_REGISTER_STATE_CHECK(
-            RunInvTxfm(test_temp_block, dst, pitch_));
+        ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
         ASM_REGISTER_STATE_CHECK(
@@ -358,8 +347,7 @@
         const int diff = dst[j] - src[j];
 #endif
         const int error = diff * diff;
-        if (max_error < error)
-          max_error = error;
+        if (max_error < error) max_error = error;
         total_error += error;
 
         const int coeff_diff = test_temp_block[j] - ref_temp_block[j];
@@ -370,7 +358,7 @@
           << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has"
           << "an individual roundtrip error > 1";
 
-      EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8))/5, total_error)
+      EXPECT_GE((count_test_block << 2 * (bit_depth_ - 8)) / 5, total_error)
           << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average"
           << " roundtrip error > 1/5 per block";
 
@@ -418,8 +406,8 @@
         ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16),
-                                            pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif
       }
 
@@ -432,8 +420,7 @@
 #endif
         const uint32_t error = diff * diff;
         EXPECT_GE(1u << 2 * (bit_depth_ - 8), error)
-            << "Error: 8x8 IDCT has error " << error
-            << " at index " << j;
+            << "Error: 8x8 IDCT has error " << error << " at index " << j;
       }
     }
   }
@@ -461,13 +448,12 @@
         const int32_t diff = coeff[j] - coeff_r[j];
         const uint32_t error = diff * diff;
         EXPECT_GE(9u << 2 * (bit_depth_ - 8), error)
-            << "Error: 8x8 DCT has error " << error
-            << " at index " << j;
+            << "Error: 8x8 DCT has error " << error << " at index " << j;
       }
     }
   }
 
-void CompareInvReference(IdctFunc ref_txfm, int thresh) {
+  void CompareInvReference(IdctFunc ref_txfm, int thresh) {
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 10000;
     const int eob = 12;
@@ -484,7 +470,7 @@
       for (int j = 0; j < kNumCoeffs; ++j) {
         if (j < eob) {
           // Random values less than the threshold, either positive or negative
-          coeff[scan[j]] = rnd(thresh) * (1-2*(i%2));
+          coeff[scan[j]] = rnd(thresh) * (1 - 2 * (i % 2));
         } else {
           coeff[scan[j]] = 0;
         }
@@ -504,8 +490,8 @@
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
         ref_txfm(coeff, CONVERT_TO_BYTEPTR(ref16), pitch_);
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16),
-                                            pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif
       }
 
@@ -517,9 +503,8 @@
         const int diff = dst[j] - ref[j];
 #endif
         const uint32_t error = diff * diff;
-        EXPECT_EQ(0u, error)
-            << "Error: 8x8 IDCT has error " << error
-            << " at index " << j;
+        EXPECT_EQ(0u, error) << "Error: 8x8 IDCT has error " << error
+                             << " at index " << j;
       }
     }
   }
@@ -530,17 +515,16 @@
   int mask_;
 };
 
-class FwdTrans8x8DCT
-    : public FwdTrans8x8TestBase,
-      public ::testing::TestWithParam<Dct8x8Param> {
+class FwdTrans8x8DCT : public FwdTrans8x8TestBase,
+                       public ::testing::TestWithParam<Dct8x8Param> {
  public:
   virtual ~FwdTrans8x8DCT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 8;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 8;
     fwd_txfm_ref = fdct8x8_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -560,37 +544,26 @@
   IdctFunc inv_txfm_;
 };
 
-TEST_P(FwdTrans8x8DCT, SignBiasCheck) {
-  RunSignBiasCheck();
-}
+TEST_P(FwdTrans8x8DCT, SignBiasCheck) { RunSignBiasCheck(); }
 
-TEST_P(FwdTrans8x8DCT, RoundTripErrorCheck) {
-  RunRoundTripErrorCheck();
-}
+TEST_P(FwdTrans8x8DCT, RoundTripErrorCheck) { RunRoundTripErrorCheck(); }
 
-TEST_P(FwdTrans8x8DCT, ExtremalCheck) {
-  RunExtremalCheck();
-}
+TEST_P(FwdTrans8x8DCT, ExtremalCheck) { RunExtremalCheck(); }
 
-TEST_P(FwdTrans8x8DCT, FwdAccuracyCheck) {
-  RunFwdAccuracyCheck();
-}
+TEST_P(FwdTrans8x8DCT, FwdAccuracyCheck) { RunFwdAccuracyCheck(); }
 
-TEST_P(FwdTrans8x8DCT, InvAccuracyCheck) {
-  RunInvAccuracyCheck();
-}
+TEST_P(FwdTrans8x8DCT, InvAccuracyCheck) { RunInvAccuracyCheck(); }
 
-class FwdTrans8x8HT
-    : public FwdTrans8x8TestBase,
-      public ::testing::TestWithParam<Ht8x8Param> {
+class FwdTrans8x8HT : public FwdTrans8x8TestBase,
+                      public ::testing::TestWithParam<Ht8x8Param> {
  public:
   virtual ~FwdTrans8x8HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 8;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 8;
     fwd_txfm_ref = fht8x8_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -610,21 +583,14 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(FwdTrans8x8HT, SignBiasCheck) {
-  RunSignBiasCheck();
-}
+TEST_P(FwdTrans8x8HT, SignBiasCheck) { RunSignBiasCheck(); }
 
-TEST_P(FwdTrans8x8HT, RoundTripErrorCheck) {
-  RunRoundTripErrorCheck();
-}
+TEST_P(FwdTrans8x8HT, RoundTripErrorCheck) { RunRoundTripErrorCheck(); }
 
-TEST_P(FwdTrans8x8HT, ExtremalCheck) {
-  RunExtremalCheck();
-}
+TEST_P(FwdTrans8x8HT, ExtremalCheck) { RunExtremalCheck(); }
 
-class InvTrans8x8DCT
-    : public FwdTrans8x8TestBase,
-      public ::testing::TestWithParam<Idct8x8Param> {
+class InvTrans8x8DCT : public FwdTrans8x8TestBase,
+                       public ::testing::TestWithParam<Idct8x8Param> {
  public:
   virtual ~InvTrans8x8DCT() {}
 
@@ -664,10 +630,10 @@
         make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10),
         make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12)));
 #else
-INSTANTIATE_TEST_CASE_P(
-    C, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c, 0, VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(C, FwdTrans8x8DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct8x8_c,
+                                                     &vpx_idct8x8_64_add_c, 0,
+                                                     VPX_BITS_8)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -697,11 +663,10 @@
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    NEON, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_neon, &vpx_idct8x8_64_add_neon, 0,
-                   VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(NEON, FwdTrans8x8DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct8x8_neon,
+                                                     &vpx_idct8x8_64_add_neon,
+                                                     0, VPX_BITS_8)));
 #endif  // HAVE_NEON_ASM && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
@@ -715,37 +680,33 @@
 #endif  // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    SSE2, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_sse2, 0,
-                   VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(SSE2, FwdTrans8x8DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct8x8_sse2,
+                                                     &vpx_idct8x8_64_add_sse2,
+                                                     0, VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     SSE2, FwdTrans8x8HT,
     ::testing::Values(
-        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2,
-                   0, VPX_BITS_8),
-        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2,
-                   1, VPX_BITS_8),
-        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2,
-                   2, VPX_BITS_8),
-        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2,
-                   3, VPX_BITS_8)));
+        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 0, VPX_BITS_8),
+        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 1, VPX_BITS_8),
+        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 2, VPX_BITS_8),
+        make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 3,
+                   VPX_BITS_8)));
 #endif  // HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_c, 0, VPX_BITS_8),
-        make_tuple(&vpx_highbd_fdct8x8_c,
-                   &idct8x8_64_add_10_sse2, 12, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct8x8_sse2,
-                   &idct8x8_64_add_10_sse2, 12, VPX_BITS_10),
-        make_tuple(&vpx_highbd_fdct8x8_c,
-                   &idct8x8_64_add_12_sse2, 12, VPX_BITS_12),
-        make_tuple(&vpx_highbd_fdct8x8_sse2,
-                   &idct8x8_64_add_12_sse2, 12, VPX_BITS_12)));
+    ::testing::Values(make_tuple(&vpx_fdct8x8_sse2, &vpx_idct8x8_64_add_c, 0,
+                                 VPX_BITS_8),
+                      make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_10_sse2,
+                                 12, VPX_BITS_10),
+                      make_tuple(&vpx_highbd_fdct8x8_sse2,
+                                 &idct8x8_64_add_10_sse2, 12, VPX_BITS_10),
+                      make_tuple(&vpx_highbd_fdct8x8_c, &idct8x8_64_add_12_sse2,
+                                 12, VPX_BITS_12),
+                      make_tuple(&vpx_highbd_fdct8x8_sse2,
+                                 &idct8x8_64_add_12_sse2, 12, VPX_BITS_12)));
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, FwdTrans8x8HT,
@@ -760,30 +721,27 @@
 INSTANTIATE_TEST_CASE_P(
     SSE2, InvTrans8x8DCT,
     ::testing::Values(
-        make_tuple(&idct8x8_10_add_10_c,
-                   &idct8x8_10_add_10_sse2, 6225, VPX_BITS_10),
-        make_tuple(&idct8x8_10,
-                   &idct8x8_64_add_10_sse2, 6225, VPX_BITS_10),
-        make_tuple(&idct8x8_10_add_12_c,
-                   &idct8x8_10_add_12_sse2, 6225, VPX_BITS_12),
-        make_tuple(&idct8x8_12,
-                   &idct8x8_64_add_12_sse2, 6225, VPX_BITS_12)));
+        make_tuple(&idct8x8_10_add_10_c, &idct8x8_10_add_10_sse2, 6225,
+                   VPX_BITS_10),
+        make_tuple(&idct8x8_10, &idct8x8_64_add_10_sse2, 6225, VPX_BITS_10),
+        make_tuple(&idct8x8_10_add_12_c, &idct8x8_10_add_12_sse2, 6225,
+                   VPX_BITS_12),
+        make_tuple(&idct8x8_12, &idct8x8_64_add_12_sse2, 6225, VPX_BITS_12)));
 #endif  // HAVE_SSE2 && CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
-#if HAVE_SSSE3 && ARCH_X86_64 && \
-    !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    SSSE3, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_ssse3, &vpx_idct8x8_64_add_ssse3, 0,
-                   VPX_BITS_8)));
+#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
+    !CONFIG_EMULATE_HARDWARE
+INSTANTIATE_TEST_CASE_P(SSSE3, FwdTrans8x8DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct8x8_ssse3,
+                                                     &vpx_idct8x8_64_add_ssse3,
+                                                     0, VPX_BITS_8)));
 #endif
 
 #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
-INSTANTIATE_TEST_CASE_P(
-    MSA, FwdTrans8x8DCT,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_msa, &vpx_idct8x8_64_add_msa, 0, VPX_BITS_8)));
+INSTANTIATE_TEST_CASE_P(MSA, FwdTrans8x8DCT,
+                        ::testing::Values(make_tuple(&vpx_fdct8x8_msa,
+                                                     &vpx_idct8x8_64_add_msa, 0,
+                                                     VPX_BITS_8)));
 INSTANTIATE_TEST_CASE_P(
     MSA, FwdTrans8x8HT,
     ::testing::Values(
diff --git a/test/frame_size_tests.cc b/test/frame_size_tests.cc
index d630e05..cc72d8e 100644
--- a/test/frame_size_tests.cc
+++ b/test/frame_size_tests.cc
@@ -13,12 +13,11 @@
 
 namespace {
 
-class VP9FrameSizeTestsLarge
-    : public ::libvpx_test::EncoderTest,
-      public ::testing::Test {
+class VP9FrameSizeTestsLarge : public ::libvpx_test::EncoderTest,
+                               public ::testing::Test {
  protected:
-  VP9FrameSizeTestsLarge() : EncoderTest(&::libvpx_test::kVP10),
-                             expected_res_(VPX_CODEC_OK) {}
+  VP9FrameSizeTestsLarge()
+      : EncoderTest(&::libvpx_test::kVP10), expected_res_(VPX_CODEC_OK) {}
   virtual ~VP9FrameSizeTestsLarge() {}
 
   virtual void SetUp() {
@@ -27,7 +26,7 @@
   }
 
   virtual bool HandleDecodeResult(const vpx_codec_err_t res_dec,
-                                  const libvpx_test::VideoSource& /*video*/,
+                                  const libvpx_test::VideoSource & /*video*/,
                                   libvpx_test::Decoder *decoder) {
     EXPECT_EQ(expected_res_, res_dec) << decoder->DecodeError();
     return !::testing::Test::HasFailure();
@@ -67,13 +66,13 @@
   expected_res_ = VPX_CODEC_OK;
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 #else
-  // This test produces a pretty large single frame allocation,  (roughly
-  // 25 megabits). The encoder allocates a good number of these frames
-  // one for each lag in frames (for 2 pass), and then one for each possible
-  // reference buffer (8) - we can end up with up to 30 buffers of roughly this
-  // size or almost 1 gig of memory.
-  // In total the allocations will exceed 2GiB which may cause a failure with
-  // mingw + wine, use a smaller size in that case.
+// This test produces a pretty large single frame allocation,  (roughly
+// 25 megabits). The encoder allocates a good number of these frames
+// one for each lag in frames (for 2 pass), and then one for each possible
+// reference buffer (8) - we can end up with up to 30 buffers of roughly this
+// size or almost 1 gig of memory.
+// In total the allocations will exceed 2GiB which may cause a failure with
+// mingw + wine, use a smaller size in that case.
 #if defined(_WIN32) && !defined(_WIN64) || defined(__OS2__)
   video.SetSize(4096, 3072);
 #else
diff --git a/test/function_equivalence_test.h b/test/function_equivalence_test.h
index 70f33d1..4c5a97f 100644
--- a/test/function_equivalence_test.h
+++ b/test/function_equivalence_test.h
@@ -48,18 +48,14 @@
 
   virtual ~FunctionEquivalenceTest() {}
 
-  virtual void SetUp() {
-    params_ = this->GetParam();
-  }
+  virtual void SetUp() { params_ = this->GetParam(); }
 
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   ACMRandom rng_;
   FuncParam<T> params_;
 };
 
-}   // namespace libvpx_test
+}  // namespace libvpx_test
 #endif  // TEST_FUNCTION_EQUIVALENCE_TEST_H_
diff --git a/test/hadamard_test.cc b/test/hadamard_test.cc
index b8eec52..e771595 100644
--- a/test/hadamard_test.cc
+++ b/test/hadamard_test.cc
@@ -80,8 +80,8 @@
     const int16_t b3 = (a2 - a3) >> 1;
 
     /* Store a 16 bit value. */
-    b[  0] = b0 + b2;
-    b[ 64] = b1 + b3;
+    b[0] = b0 + b2;
+    b[64] = b1 + b3;
     b[128] = b0 - b2;
     b[192] = b1 - b3;
 
diff --git a/test/hbd_metrics_test.cc b/test/hbd_metrics_test.cc
index 14a8815..f8c0517 100644
--- a/test/hbd_metrics_test.cc
+++ b/test/hbd_metrics_test.cc
@@ -22,7 +22,6 @@
 #include "vpx_ports/msvc.h"
 #include "vpx_scale/yv12config.h"
 
-
 using libvpx_test::ACMRandom;
 
 namespace {
@@ -30,70 +29,65 @@
 typedef double (*LBDMetricFunc)(const YV12_BUFFER_CONFIG *source,
                                 const YV12_BUFFER_CONFIG *dest);
 typedef double (*HBDMetricFunc)(const YV12_BUFFER_CONFIG *source,
-                                const YV12_BUFFER_CONFIG *dest,
-                                uint32_t in_bd, uint32_t bd);
+                                const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
+                                uint32_t bd);
 
 double compute_hbd_psnr(const YV12_BUFFER_CONFIG *source,
-                        const YV12_BUFFER_CONFIG *dest,
-                        uint32_t in_bd, uint32_t bd) {
+                        const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
+                        uint32_t bd) {
   PSNR_STATS psnr;
   vpx_calc_highbd_psnr(source, dest, &psnr, bd, in_bd);
   return psnr.psnr[0];
 }
 
 double compute_psnr(const YV12_BUFFER_CONFIG *source,
-  const YV12_BUFFER_CONFIG *dest) {
+                    const YV12_BUFFER_CONFIG *dest) {
   PSNR_STATS psnr;
   vpx_calc_psnr(source, dest, &psnr);
   return psnr.psnr[0];
 }
 
 double compute_hbd_psnrhvs(const YV12_BUFFER_CONFIG *source,
-                           const YV12_BUFFER_CONFIG *dest,
-                           uint32_t in_bd, uint32_t bd) {
+                           const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
+                           uint32_t bd) {
   double tempy, tempu, tempv;
-  return vpx_psnrhvs(source, dest,
-                     &tempy, &tempu, &tempv, bd, in_bd);
+  return vpx_psnrhvs(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
 }
 
 double compute_psnrhvs(const YV12_BUFFER_CONFIG *source,
-  const YV12_BUFFER_CONFIG *dest) {
+                       const YV12_BUFFER_CONFIG *dest) {
   double tempy, tempu, tempv;
-  return vpx_psnrhvs(source, dest,
-                     &tempy, &tempu, &tempv, 8, 8);
+  return vpx_psnrhvs(source, dest, &tempy, &tempu, &tempv, 8, 8);
 }
 
 double compute_hbd_fastssim(const YV12_BUFFER_CONFIG *source,
-                            const YV12_BUFFER_CONFIG *dest,
-                            uint32_t in_bd, uint32_t bd) {
+                            const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
+                            uint32_t bd) {
   double tempy, tempu, tempv;
-  return vpx_calc_fastssim(source, dest,
-                               &tempy, &tempu, &tempv, bd, in_bd);
+  return vpx_calc_fastssim(source, dest, &tempy, &tempu, &tempv, bd, in_bd);
 }
 
 double compute_fastssim(const YV12_BUFFER_CONFIG *source,
                         const YV12_BUFFER_CONFIG *dest) {
   double tempy, tempu, tempv;
-  return vpx_calc_fastssim(source, dest,
-                           &tempy, &tempu, &tempv, 8, 8);
+  return vpx_calc_fastssim(source, dest, &tempy, &tempu, &tempv, 8, 8);
 }
 
 double compute_hbd_vpxssim(const YV12_BUFFER_CONFIG *source,
-                           const YV12_BUFFER_CONFIG *dest,
-                           uint32_t in_bd, uint32_t bd) {
+                           const YV12_BUFFER_CONFIG *dest, uint32_t in_bd,
+                           uint32_t bd) {
   double ssim, weight;
   ssim = vpx_highbd_calc_ssim(source, dest, &weight, bd, in_bd);
   return 100 * pow(ssim / weight, 8.0);
 }
 
 double compute_vpxssim(const YV12_BUFFER_CONFIG *source,
-  const YV12_BUFFER_CONFIG *dest) {
+                       const YV12_BUFFER_CONFIG *dest) {
   double ssim, weight;
   ssim = vpx_calc_ssim(source, dest, &weight);
   return 100 * pow(ssim / weight, 8.0);
 }
 
-
 class HBDMetricsTestBase {
  public:
   virtual ~HBDMetricsTestBase() {}
@@ -126,8 +120,8 @@
       // Create some distortion for dst buffer.
       dpel = rnd.Rand8();
       lbd_dst.buffer_alloc[i] = (uint8_t)dpel;
-      ((uint16_t*)(hbd_src.buffer_alloc))[i] = spel << (bit_depth_ - 8);
-      ((uint16_t*)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
+      ((uint16_t *)(hbd_src.buffer_alloc))[i] = spel << (bit_depth_ - 8);
+      ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
       i++;
     }
 
@@ -141,7 +135,7 @@
       // Create some small distortion for dst buffer.
       dpel = 120 + (rnd.Rand8() >> 4);
       lbd_dst.buffer_alloc[i] = (uint8_t)dpel;
-      ((uint16_t*)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
+      ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
       i++;
     }
 
@@ -155,7 +149,7 @@
       // Create some small distortion for dst buffer.
       dpel = 126 + (rnd.Rand8() >> 6);
       lbd_dst.buffer_alloc[i] = (uint8_t)dpel;
-      ((uint16_t*)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
+      ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8);
       i++;
     }
 
@@ -176,11 +170,10 @@
   HBDMetricFunc hbd_metric_;
 };
 
-typedef std::tr1::tuple<LBDMetricFunc,
-                        HBDMetricFunc, int, int, double> MetricTestTParam;
-class HBDMetricsTest
-    : public HBDMetricsTestBase,
-      public ::testing::TestWithParam<MetricTestTParam> {
+typedef std::tr1::tuple<LBDMetricFunc, HBDMetricFunc, int, int, double>
+    MetricTestTParam;
+class HBDMetricsTest : public HBDMetricsTestBase,
+                       public ::testing::TestWithParam<MetricTestTParam> {
  public:
   virtual void SetUp() {
     lbd_metric_ = GET_PARAM(0);
@@ -192,9 +185,7 @@
   virtual void TearDown() {}
 };
 
-TEST_P(HBDMetricsTest, RunAccuracyCheck) {
-  RunAccuracyCheck();
-}
+TEST_P(HBDMetricsTest, RunAccuracyCheck) { RunAccuracyCheck(); }
 
 // Allow small variation due to floating point operations.
 static const double kSsim_thresh = 0.001;
@@ -205,47 +196,41 @@
 
 INSTANTIATE_TEST_CASE_P(
     VPXSSIM, HBDMetricsTest,
-    ::testing::Values(
-        MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim, 8, 10,
-                         kSsim_thresh),
-        MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim, 10, 10,
-                         kPhvs_thresh),
-        MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim, 8, 12,
-                         kSsim_thresh),
-        MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim, 12, 12,
-                         kPhvs_thresh)));
+    ::testing::Values(MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+                                       8, 10, kSsim_thresh),
+                      MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+                                       10, 10, kPhvs_thresh),
+                      MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+                                       8, 12, kSsim_thresh),
+                      MetricTestTParam(&compute_vpxssim, &compute_hbd_vpxssim,
+                                       12, 12, kPhvs_thresh)));
 INSTANTIATE_TEST_CASE_P(
     FASTSSIM, HBDMetricsTest,
-    ::testing::Values(
-        MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 8, 10,
-                         kFSsim_thresh),
-        MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 10, 10,
-                         kFSsim_thresh),
-        MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 8, 12,
-                         kFSsim_thresh),
-        MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 12, 12,
-                         kFSsim_thresh)));
+    ::testing::Values(MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim,
+                                       8, 10, kFSsim_thresh),
+                      MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim,
+                                       10, 10, kFSsim_thresh),
+                      MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim,
+                                       8, 12, kFSsim_thresh),
+                      MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim,
+                                       12, 12, kFSsim_thresh)));
 INSTANTIATE_TEST_CASE_P(
     PSNRHVS, HBDMetricsTest,
-    ::testing::Values(
-        MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 8, 10,
-                         kPhvs_thresh),
-        MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 10, 10,
-                         kPhvs_thresh),
-        MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 8, 12,
-                         kPhvs_thresh),
-        MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 12, 12,
-                         kPhvs_thresh)));
+    ::testing::Values(MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs,
+                                       8, 10, kPhvs_thresh),
+                      MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs,
+                                       10, 10, kPhvs_thresh),
+                      MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs,
+                                       8, 12, kPhvs_thresh),
+                      MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs,
+                                       12, 12, kPhvs_thresh)));
 INSTANTIATE_TEST_CASE_P(
     PSNR, HBDMetricsTest,
     ::testing::Values(
-        MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 10,
-                         kPhvs_thresh),
+        MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 10, kPhvs_thresh),
         MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 10, 10,
                          kPhvs_thresh),
-        MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 12,
-                         kPhvs_thresh),
+        MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 12, kPhvs_thresh),
         MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 12, 12,
                          kPhvs_thresh)));
 }  // namespace
-
diff --git a/test/i420_video_source.h b/test/i420_video_source.h
index 0a18480..4957382 100644
--- a/test/i420_video_source.h
+++ b/test/i420_video_source.h
@@ -21,14 +21,11 @@
 // so that we can do actual file encodes.
 class I420VideoSource : public YUVVideoSource {
  public:
-  I420VideoSource(const std::string &file_name,
-                  unsigned int width, unsigned int height,
-                  int rate_numerator, int rate_denominator,
+  I420VideoSource(const std::string &file_name, unsigned int width,
+                  unsigned int height, int rate_numerator, int rate_denominator,
                   unsigned int start, int limit)
-      : YUVVideoSource(file_name, VPX_IMG_FMT_I420,
-                       width, height,
-                       rate_numerator, rate_denominator,
-                       start, limit) {}
+      : YUVVideoSource(file_name, VPX_IMG_FMT_I420, width, height,
+                       rate_numerator, rate_denominator, start, limit) {}
 };
 
 }  // namespace libvpx_test
diff --git a/test/idct8x8_test.cc b/test/idct8x8_test.cc
index 04487c4..ee75805 100644
--- a/test/idct8x8_test.cc
+++ b/test/idct8x8_test.cc
@@ -29,9 +29,8 @@
   for (int k = 0; k < 8; k++) {
     output[k] = 0.0;
     for (int n = 0; n < 8; n++)
-      output[k] += input[n]*cos(kPi*(2*n+1)*k/16.0);
-    if (k == 0)
-      output[k] = output[k]*kInvSqrt2;
+      output[k] += input[n] * cos(kPi * (2 * n + 1) * k / 16.0);
+    if (k == 0) output[k] = output[k] * kInvSqrt2;
   }
 }
 
@@ -39,24 +38,19 @@
   // First transform columns
   for (int i = 0; i < 8; ++i) {
     double temp_in[8], temp_out[8];
-    for (int j = 0; j < 8; ++j)
-      temp_in[j] = input[j*8 + i];
+    for (int j = 0; j < 8; ++j) temp_in[j] = input[j * 8 + i];
     reference_dct_1d(temp_in, temp_out);
-    for (int j = 0; j < 8; ++j)
-      output[j*8 + i] = temp_out[j];
+    for (int j = 0; j < 8; ++j) output[j * 8 + i] = temp_out[j];
   }
   // Then transform rows
   for (int i = 0; i < 8; ++i) {
     double temp_in[8], temp_out[8];
-    for (int j = 0; j < 8; ++j)
-      temp_in[j] = output[j + i*8];
+    for (int j = 0; j < 8; ++j) temp_in[j] = output[j + i * 8];
     reference_dct_1d(temp_in, temp_out);
-    for (int j = 0; j < 8; ++j)
-      output[j + i*8] = temp_out[j];
+    for (int j = 0; j < 8; ++j) output[j + i * 8] = temp_out[j];
   }
   // Scale by some magic number
-  for (int i = 0; i < 64; ++i)
-    output[i] *= 2;
+  for (int i = 0; i < 64; ++i) output[i] *= 2;
 }
 
 TEST(VP9Idct8x8Test, AccuracyCheck) {
@@ -73,8 +67,7 @@
       dst[j] = rnd.Rand8();
     }
     // Initialize a test block with input range [-255, 255].
-    for (int j = 0; j < 64; ++j)
-      input[j] = src[j] - dst[j];
+    for (int j = 0; j < 64; ++j) input[j] = src[j] - dst[j];
 
     reference_dct_2d(input, output_r);
     for (int j = 0; j < 64; ++j)
@@ -83,9 +76,8 @@
     for (int j = 0; j < 64; ++j) {
       const int diff = dst[j] - src[j];
       const int error = diff * diff;
-      EXPECT_GE(1, error)
-          << "Error: 8x8 FDCT/IDCT has error " << error
-          << " at index " << j;
+      EXPECT_GE(1, error) << "Error: 8x8 FDCT/IDCT has error " << error
+                          << " at index " << j;
     }
   }
 }
diff --git a/test/intrapred_test.cc b/test/intrapred_test.cc
index 4ff1ccb..5d0cb58 100644
--- a/test/intrapred_test.cc
+++ b/test/intrapred_test.cc
@@ -28,15 +28,14 @@
 
 const int count_test_block = 100000;
 
-typedef void (*IntraPred)(uint16_t* dst, ptrdiff_t stride,
-                          const uint16_t* above, const uint16_t* left,
-                          int bps);
+typedef void (*IntraPred)(uint16_t *dst, ptrdiff_t stride,
+                          const uint16_t *above, const uint16_t *left, int bps);
 
 struct IntraPredFunc {
   IntraPredFunc(IntraPred pred = NULL, IntraPred ref = NULL,
                 int block_size_value = 0, int bit_depth_value = 0)
-      : pred_fn(pred), ref_fn(ref),
-        block_size(block_size_value), bit_depth(bit_depth_value) {}
+      : pred_fn(pred), ref_fn(ref), block_size(block_size_value),
+        bit_depth(bit_depth_value) {}
 
   IntraPred pred_fn;
   IntraPred ref_fn;
@@ -46,8 +45,8 @@
 
 class VP9IntraPredTest : public ::testing::TestWithParam<IntraPredFunc> {
  public:
-  void RunTest(uint16_t* left_col, uint16_t* above_data,
-               uint16_t* dst, uint16_t* ref_dst) {
+  void RunTest(uint16_t *left_col, uint16_t *above_data, uint16_t *dst,
+               uint16_t *ref_dst) {
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int block_size = params_.block_size;
     above_row_ = above_data + 16;
@@ -81,14 +80,14 @@
   virtual void SetUp() {
     params_ = GetParam();
     stride_ = params_.block_size * 3;
-    mask_   = (1 << params_.bit_depth) - 1;
+    mask_ = (1 << params_.bit_depth) - 1;
   }
 
   void Predict() {
     const int bit_depth = params_.bit_depth;
     params_.ref_fn(ref_dst_, stride_, above_row_, left_col_, bit_depth);
-    ASM_REGISTER_STATE_CHECK(params_.pred_fn(dst_, stride_,
-                                             above_row_, left_col_, bit_depth));
+    ASM_REGISTER_STATE_CHECK(
+        params_.pred_fn(dst_, stride_, above_row_, left_col_, bit_depth));
   }
 
   void CheckPrediction(int test_case_number, int *error_count) const {
@@ -99,7 +98,7 @@
         *error_count += ref_dst_[x + y * stride_] != dst_[x + y * stride_];
         if (*error_count == 1) {
           ASSERT_EQ(ref_dst_[x + y * stride_], dst_[x + y * stride_])
-              << " Failed on Test Case Number "<< test_case_number;
+              << " Failed on Test Case Number " << test_case_number;
         }
       }
     }
@@ -117,8 +116,8 @@
 
 TEST_P(VP9IntraPredTest, IntraPredTests) {
   // max block size is 32
-  DECLARE_ALIGNED(16, uint16_t, left_col[2*32]);
-  DECLARE_ALIGNED(16, uint16_t, above_data[2*32+32]);
+  DECLARE_ALIGNED(16, uint16_t, left_col[2 * 32]);
+  DECLARE_ALIGNED(16, uint16_t, above_data[2 * 32 + 32]);
   DECLARE_ALIGNED(16, uint16_t, dst[3 * 32 * 32]);
   DECLARE_ALIGNED(16, uint16_t, ref_dst[3 * 32 * 32]);
   RunTest(left_col, above_data, dst, ref_dst);
@@ -126,86 +125,86 @@
 
 #if HAVE_SSE2
 #if CONFIG_VP9_HIGHBITDEPTH
-INSTANTIATE_TEST_CASE_P(SSE2_TO_C_8, VP9IntraPredTest,
-    ::testing::Values(
-      IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
-                    &vpx_highbd_dc_predictor_32x32_c, 32, 8),
-      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
-                    &vpx_highbd_tm_predictor_16x16_c, 16, 8),
-      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
-                    &vpx_highbd_tm_predictor_32x32_c, 32, 8),
-      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
-                    &vpx_highbd_dc_predictor_4x4_c, 4, 8),
-      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
-                    &vpx_highbd_dc_predictor_8x8_c, 8, 8),
-      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
-                    &vpx_highbd_dc_predictor_16x16_c, 16, 8),
-      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
-                    &vpx_highbd_v_predictor_4x4_c, 4, 8),
-      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
-                    &vpx_highbd_v_predictor_8x8_c, 8, 8),
-      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
-                    &vpx_highbd_v_predictor_16x16_c, 16, 8),
-      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
-                    &vpx_highbd_v_predictor_32x32_c, 32, 8),
-      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
-                    &vpx_highbd_tm_predictor_4x4_c, 4, 8),
-      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
-                    &vpx_highbd_tm_predictor_8x8_c, 8, 8)));
+INSTANTIATE_TEST_CASE_P(
+    SSE2_TO_C_8, VP9IntraPredTest,
+    ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
+                                    &vpx_highbd_dc_predictor_32x32_c, 32, 8),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
+                                    &vpx_highbd_tm_predictor_16x16_c, 16, 8),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
+                                    &vpx_highbd_tm_predictor_32x32_c, 32, 8),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
+                                    &vpx_highbd_dc_predictor_4x4_c, 4, 8),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
+                                    &vpx_highbd_dc_predictor_8x8_c, 8, 8),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
+                                    &vpx_highbd_dc_predictor_16x16_c, 16, 8),
+                      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
+                                    &vpx_highbd_v_predictor_4x4_c, 4, 8),
+                      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
+                                    &vpx_highbd_v_predictor_8x8_c, 8, 8),
+                      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
+                                    &vpx_highbd_v_predictor_16x16_c, 16, 8),
+                      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
+                                    &vpx_highbd_v_predictor_32x32_c, 32, 8),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
+                                    &vpx_highbd_tm_predictor_4x4_c, 4, 8),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
+                                    &vpx_highbd_tm_predictor_8x8_c, 8, 8)));
 
-INSTANTIATE_TEST_CASE_P(SSE2_TO_C_10, VP9IntraPredTest,
-    ::testing::Values(
-      IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
-                    &vpx_highbd_dc_predictor_32x32_c, 32, 10),
-      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
-                    &vpx_highbd_tm_predictor_16x16_c, 16, 10),
-      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
-                    &vpx_highbd_tm_predictor_32x32_c, 32, 10),
-      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
-                    &vpx_highbd_dc_predictor_4x4_c, 4, 10),
-      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
-                    &vpx_highbd_dc_predictor_8x8_c, 8, 10),
-      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
-                    &vpx_highbd_dc_predictor_16x16_c, 16, 10),
-      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
-                    &vpx_highbd_v_predictor_4x4_c, 4, 10),
-      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
-                    &vpx_highbd_v_predictor_8x8_c, 8, 10),
-      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
-                    &vpx_highbd_v_predictor_16x16_c, 16, 10),
-      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
-                    &vpx_highbd_v_predictor_32x32_c, 32, 10),
-      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
-                    &vpx_highbd_tm_predictor_4x4_c, 4, 10),
-      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
-                    &vpx_highbd_tm_predictor_8x8_c, 8, 10)));
+INSTANTIATE_TEST_CASE_P(
+    SSE2_TO_C_10, VP9IntraPredTest,
+    ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
+                                    &vpx_highbd_dc_predictor_32x32_c, 32, 10),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
+                                    &vpx_highbd_tm_predictor_16x16_c, 16, 10),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
+                                    &vpx_highbd_tm_predictor_32x32_c, 32, 10),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
+                                    &vpx_highbd_dc_predictor_4x4_c, 4, 10),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
+                                    &vpx_highbd_dc_predictor_8x8_c, 8, 10),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
+                                    &vpx_highbd_dc_predictor_16x16_c, 16, 10),
+                      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
+                                    &vpx_highbd_v_predictor_4x4_c, 4, 10),
+                      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
+                                    &vpx_highbd_v_predictor_8x8_c, 8, 10),
+                      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
+                                    &vpx_highbd_v_predictor_16x16_c, 16, 10),
+                      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
+                                    &vpx_highbd_v_predictor_32x32_c, 32, 10),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
+                                    &vpx_highbd_tm_predictor_4x4_c, 4, 10),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
+                                    &vpx_highbd_tm_predictor_8x8_c, 8, 10)));
 
-INSTANTIATE_TEST_CASE_P(SSE2_TO_C_12, VP9IntraPredTest,
-    ::testing::Values(
-      IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
-                    &vpx_highbd_dc_predictor_32x32_c, 32, 12),
-      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
-                    &vpx_highbd_tm_predictor_16x16_c, 16, 12),
-      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
-                    &vpx_highbd_tm_predictor_32x32_c, 32, 12),
-      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
-                    &vpx_highbd_dc_predictor_4x4_c, 4, 12),
-      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
-                    &vpx_highbd_dc_predictor_8x8_c, 8, 12),
-      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
-                    &vpx_highbd_dc_predictor_16x16_c, 16, 12),
-      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
-                    &vpx_highbd_v_predictor_4x4_c, 4, 12),
-      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
-                    &vpx_highbd_v_predictor_8x8_c, 8, 12),
-      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
-                    &vpx_highbd_v_predictor_16x16_c, 16, 12),
-      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
-                    &vpx_highbd_v_predictor_32x32_c, 32, 12),
-      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
-                    &vpx_highbd_tm_predictor_4x4_c, 4, 12),
-      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
-                    &vpx_highbd_tm_predictor_8x8_c, 8, 12)));
+INSTANTIATE_TEST_CASE_P(
+    SSE2_TO_C_12, VP9IntraPredTest,
+    ::testing::Values(IntraPredFunc(&vpx_highbd_dc_predictor_32x32_sse2,
+                                    &vpx_highbd_dc_predictor_32x32_c, 32, 12),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_16x16_sse2,
+                                    &vpx_highbd_tm_predictor_16x16_c, 16, 12),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_32x32_sse2,
+                                    &vpx_highbd_tm_predictor_32x32_c, 32, 12),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_4x4_sse2,
+                                    &vpx_highbd_dc_predictor_4x4_c, 4, 12),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_8x8_sse2,
+                                    &vpx_highbd_dc_predictor_8x8_c, 8, 12),
+                      IntraPredFunc(&vpx_highbd_dc_predictor_16x16_sse2,
+                                    &vpx_highbd_dc_predictor_16x16_c, 16, 12),
+                      IntraPredFunc(&vpx_highbd_v_predictor_4x4_sse2,
+                                    &vpx_highbd_v_predictor_4x4_c, 4, 12),
+                      IntraPredFunc(&vpx_highbd_v_predictor_8x8_sse2,
+                                    &vpx_highbd_v_predictor_8x8_c, 8, 12),
+                      IntraPredFunc(&vpx_highbd_v_predictor_16x16_sse2,
+                                    &vpx_highbd_v_predictor_16x16_c, 16, 12),
+                      IntraPredFunc(&vpx_highbd_v_predictor_32x32_sse2,
+                                    &vpx_highbd_v_predictor_32x32_c, 32, 12),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_4x4_sse2,
+                                    &vpx_highbd_tm_predictor_4x4_c, 4, 12),
+                      IntraPredFunc(&vpx_highbd_tm_predictor_8x8_sse2,
+                                    &vpx_highbd_tm_predictor_8x8_c, 8, 12)));
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif  // HAVE_SSE2
diff --git a/test/ivf_video_source.h b/test/ivf_video_source.h
index 824a39d..b87624a 100644
--- a/test/ivf_video_source.h
+++ b/test/ivf_video_source.h
@@ -29,19 +29,13 @@
 class IVFVideoSource : public CompressedVideoSource {
  public:
   explicit IVFVideoSource(const std::string &file_name)
-      : file_name_(file_name),
-        input_file_(NULL),
-        compressed_frame_buf_(NULL),
-        frame_sz_(0),
-        frame_(0),
-        end_of_file_(false) {
-  }
+      : file_name_(file_name), input_file_(NULL), compressed_frame_buf_(NULL),
+        frame_sz_(0), frame_(0), end_of_file_(false) {}
 
   virtual ~IVFVideoSource() {
     delete[] compressed_frame_buf_;
 
-    if (input_file_)
-      fclose(input_file_);
+    if (input_file_) fclose(input_file_);
   }
 
   virtual void Init() {
@@ -54,15 +48,16 @@
   virtual void Begin() {
     input_file_ = OpenTestDataFile(file_name_);
     ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: "
-        << file_name_;
+                                     << file_name_;
 
     // Read file header
     uint8_t file_hdr[kIvfFileHdrSize];
     ASSERT_EQ(kIvfFileHdrSize, fread(file_hdr, 1, kIvfFileHdrSize, input_file_))
         << "File header read failed.";
     // Check file header
-    ASSERT_TRUE(file_hdr[0] == 'D' && file_hdr[1] == 'K' && file_hdr[2] == 'I'
-                && file_hdr[3] == 'F') << "Input is not an IVF file.";
+    ASSERT_TRUE(file_hdr[0] == 'D' && file_hdr[1] == 'K' &&
+                file_hdr[2] == 'I' && file_hdr[3] == 'F')
+        << "Input is not an IVF file.";
 
     FillFrame();
   }
@@ -76,8 +71,8 @@
     ASSERT_TRUE(input_file_ != NULL);
     uint8_t frame_hdr[kIvfFrameHdrSize];
     // Check frame header and read a frame from input_file.
-    if (fread(frame_hdr, 1, kIvfFrameHdrSize, input_file_)
-        != kIvfFrameHdrSize) {
+    if (fread(frame_hdr, 1, kIvfFrameHdrSize, input_file_) !=
+        kIvfFrameHdrSize) {
       end_of_file_ = true;
     } else {
       end_of_file_ = false;
diff --git a/test/level_test.cc b/test/level_test.cc
index 62d0247..fbbb539 100644
--- a/test/level_test.cc
+++ b/test/level_test.cc
@@ -19,12 +19,9 @@
       public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   LevelTest()
-     : EncoderTest(GET_PARAM(0)),
-       encoding_mode_(GET_PARAM(1)),
-       cpu_used_(GET_PARAM(2)),
-       min_gf_internal_(24),
-       target_level_(0),
-       level_(0) {}
+      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
+        cpu_used_(GET_PARAM(2)), min_gf_internal_(24), target_level_(0),
+        level_(0) {}
   virtual ~LevelTest() {}
 
   virtual void SetUp() {
diff --git a/test/lossless_test.cc b/test/lossless_test.cc
index 1584979..c7f1963 100644
--- a/test/lossless_test.cc
+++ b/test/lossless_test.cc
@@ -21,15 +21,13 @@
 
 const int kMaxPsnr = 100;
 
-class LosslessTestLarge : public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
+class LosslessTestLarge
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   LosslessTestLarge()
-      : EncoderTest(GET_PARAM(0)),
-        psnr_(kMaxPsnr),
-        nframes_(0),
-        encoding_mode_(GET_PARAM(1)) {
-  }
+      : EncoderTest(GET_PARAM(0)), psnr_(kMaxPsnr), nframes_(0),
+        encoding_mode_(GET_PARAM(1)) {}
 
   virtual ~LosslessTestLarge() {}
 
@@ -55,13 +53,10 @@
   }
 
   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
-    if (pkt->data.psnr.psnr[0] < psnr_)
-      psnr_= pkt->data.psnr.psnr[0];
+    if (pkt->data.psnr.psnr[0] < psnr_) psnr_ = pkt->data.psnr.psnr[0];
   }
 
-  double GetMinPsnr() const {
-      return psnr_;
-  }
+  double GetMinPsnr() const { return psnr_; }
 
  private:
   double psnr_;
@@ -123,7 +118,6 @@
   EXPECT_GE(psnr_lossless, kMaxPsnr);
 }
 
-
 VP10_INSTANTIATE_TEST_CASE(LosslessTestLarge,
                            ::testing::Values(::libvpx_test::kOnePassGood,
                                              ::libvpx_test::kTwoPassGood));
diff --git a/test/lpf_8_test.cc b/test/lpf_8_test.cc
index b14352c..8aaab23 100644
--- a/test/lpf_8_test.cc
+++ b/test/lpf_8_test.cc
@@ -36,8 +36,7 @@
 
 #if CONFIG_VP9_HIGHBITDEPTH
 typedef void (*loop_op_t)(uint16_t *s, int p, const uint8_t *blimit,
-                          const uint8_t *limit, const uint8_t *thresh,
-                          int bd);
+                          const uint8_t *limit, const uint8_t *thresh, int bd);
 typedef void (*dual_loop_op_t)(uint16_t *s, int p, const uint8_t *blimit0,
                                const uint8_t *limit0, const uint8_t *thresh0,
                                const uint8_t *blimit1, const uint8_t *limit1,
@@ -108,21 +107,18 @@
   for (int i = 0; i < count_test_block; ++i) {
     int err_count = 0;
     uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                   tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
-    int32_t p = kNumCoeffs/32;
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
+    int32_t p = kNumCoeffs / 32;
 
     uint16_t tmp_s[kNumCoeffs];
     int j = 0;
@@ -158,7 +154,7 @@
     ASM_REGISTER_STATE_CHECK(
         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
 #else
-    ref_loopfilter_op_(ref_s+8+p*8, p, blimit, limit, thresh);
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
     ASM_REGISTER_STATE_CHECK(
         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -206,20 +202,17 @@
   for (int i = 0; i < count_test_block; ++i) {
     int err_count = 0;
     uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                   tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     int32_t p = kNumCoeffs / 32;
     for (int j = 0; j < kNumCoeffs; ++j) {
       s[j] = rnd.Rand16() & mask_;
@@ -230,7 +223,7 @@
     ASM_REGISTER_STATE_CHECK(
         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh, bd));
 #else
-    ref_loopfilter_op_(ref_s+8+p*8, p, blimit, limit, thresh);
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit, limit, thresh);
     ASM_REGISTER_STATE_CHECK(
         loopfilter_op_(s + 8 + p * 8, p, blimit, limit, thresh));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -256,43 +249,37 @@
   DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
   DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
 #else
-  DECLARE_ALIGNED(8,  uint8_t,  s[kNumCoeffs]);
-  DECLARE_ALIGNED(8,  uint8_t,  ref_s[kNumCoeffs]);
+  DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
+  DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
   int err_count_total = 0;
   int first_failure = -1;
   for (int i = 0; i < count_test_block; ++i) {
     int err_count = 0;
     uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit0[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit0[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh0[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit1[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit1[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh1[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     int32_t p = kNumCoeffs / 32;
     uint16_t tmp_s[kNumCoeffs];
     int j = 0;
@@ -325,17 +312,16 @@
       ref_s[j] = s[j];
     }
 #if CONFIG_VP9_HIGHBITDEPTH
-    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1, bd);
-    ASM_REGISTER_STATE_CHECK(
-        loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1, bd));
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
+                       limit1, thresh1, bd);
+    ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
+                                            thresh0, blimit1, limit1, thresh1,
+                                            bd));
 #else
-    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1);
-    ASM_REGISTER_STATE_CHECK(
-        loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1));
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
+                       limit1, thresh1);
+    ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
+                                            thresh0, blimit1, limit1, thresh1));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
     for (int j = 0; j < kNumCoeffs; ++j) {
       err_count += ref_s[j] != s[j];
@@ -358,43 +344,37 @@
   DECLARE_ALIGNED(16, uint16_t, s[kNumCoeffs]);
   DECLARE_ALIGNED(16, uint16_t, ref_s[kNumCoeffs]);
 #else
-  DECLARE_ALIGNED(8,  uint8_t, s[kNumCoeffs]);
-  DECLARE_ALIGNED(8,  uint8_t, ref_s[kNumCoeffs]);
+  DECLARE_ALIGNED(8, uint8_t, s[kNumCoeffs]);
+  DECLARE_ALIGNED(8, uint8_t, ref_s[kNumCoeffs]);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
   int err_count_total = 0;
   int first_failure = -1;
   for (int i = 0; i < count_test_block; ++i) {
     int err_count = 0;
     uint8_t tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit0[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit0[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh0[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh0[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(3 * MAX_LOOP_FILTER + 4));
-    DECLARE_ALIGNED(16, const uint8_t, blimit1[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    blimit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = static_cast<uint8_t>(rnd(MAX_LOOP_FILTER));
-    DECLARE_ALIGNED(16, const uint8_t, limit1[16])  = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    limit1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                    tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     tmp = rnd.Rand8();
-    DECLARE_ALIGNED(16, const uint8_t, thresh1[16]) = {
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
-        tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp
-    };
+    DECLARE_ALIGNED(16, const uint8_t,
+                    thresh1[16]) = { tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp,
+                                     tmp, tmp, tmp, tmp, tmp, tmp, tmp, tmp };
     int32_t p = kNumCoeffs / 32;  // TODO(pdlf) can we have non-square here?
     for (int j = 0; j < kNumCoeffs; ++j) {
       s[j] = rnd.Rand16() & mask_;
@@ -402,17 +382,16 @@
     }
 #if CONFIG_VP9_HIGHBITDEPTH
     const int32_t bd = bit_depth_;
-    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1, bd);
-    ASM_REGISTER_STATE_CHECK(
-        loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
-                       thresh0, blimit1, limit1, thresh1, bd));
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
+                       limit1, thresh1, bd);
+    ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
+                                            thresh0, blimit1, limit1, thresh1,
+                                            bd));
 #else
-    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1);
-    ASM_REGISTER_STATE_CHECK(
-        loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0, thresh0,
-                       blimit1, limit1, thresh1));
+    ref_loopfilter_op_(ref_s + 8 + p * 8, p, blimit0, limit0, thresh0, blimit1,
+                       limit1, thresh1);
+    ASM_REGISTER_STATE_CHECK(loopfilter_op_(s + 8 + p * 8, p, blimit0, limit0,
+                                            thresh0, blimit1, limit1, thresh1));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
     for (int j = 0; j < kNumCoeffs; ++j) {
       err_count += ref_s[j] != s[j];
@@ -434,129 +413,120 @@
 #if CONFIG_VP9_HIGHBITDEPTH
 INSTANTIATE_TEST_CASE_P(
     SSE2, Loop8Test6Param,
-    ::testing::Values(
-        make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
-                   &vpx_highbd_lpf_horizontal_4_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
-                   &vpx_highbd_lpf_vertical_4_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
-                   &vpx_highbd_lpf_horizontal_8_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_8_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_16_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
-                   &vpx_highbd_lpf_vertical_8_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
-                   &vpx_highbd_lpf_vertical_16_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
-                   &vpx_highbd_lpf_horizontal_4_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
-                   &vpx_highbd_lpf_vertical_4_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
-                   &vpx_highbd_lpf_horizontal_8_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_8_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_16_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
-                   &vpx_highbd_lpf_vertical_8_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
-                   &vpx_highbd_lpf_vertical_16_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
-                   &vpx_highbd_lpf_horizontal_4_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
-                   &vpx_highbd_lpf_vertical_4_c, 12),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
-                   &vpx_highbd_lpf_horizontal_8_c, 12),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_8_c, 12),
-        make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
-                   &vpx_highbd_lpf_horizontal_edge_16_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
-                   &vpx_highbd_lpf_vertical_8_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
-                   &vpx_highbd_lpf_vertical_16_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
-                   &vpx_highbd_lpf_vertical_16_dual_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
-                   &vpx_highbd_lpf_vertical_16_dual_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
-                   &vpx_highbd_lpf_vertical_16_dual_c, 12)));
+    ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
+                                 &vpx_highbd_lpf_vertical_4_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_8_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_16_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
+                                 &vpx_highbd_lpf_vertical_8_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
+                                 &vpx_highbd_lpf_vertical_16_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
+                                 &vpx_highbd_lpf_vertical_4_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_8_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_16_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
+                                 &vpx_highbd_lpf_vertical_8_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
+                                 &vpx_highbd_lpf_vertical_16_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_4_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_sse2,
+                                 &vpx_highbd_lpf_vertical_4_c, 12),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_c, 12),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_8_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_8_c, 12),
+                      make_tuple(&vpx_highbd_lpf_horizontal_edge_16_sse2,
+                                 &vpx_highbd_lpf_horizontal_edge_16_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_sse2,
+                                 &vpx_highbd_lpf_vertical_8_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_sse2,
+                                 &vpx_highbd_lpf_vertical_16_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_16_dual_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_16_dual_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_16_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_16_dual_c, 12)));
 #else
 INSTANTIATE_TEST_CASE_P(
     SSE2, Loop8Test6Param,
     ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_sse2,
-                   &vpx_lpf_horizontal_4_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_sse2,
-                   &vpx_lpf_horizontal_8_c, 8),
+        make_tuple(&vpx_lpf_horizontal_4_sse2, &vpx_lpf_horizontal_4_c, 8),
+        make_tuple(&vpx_lpf_horizontal_8_sse2, &vpx_lpf_horizontal_8_c, 8),
         make_tuple(&vpx_lpf_horizontal_edge_8_sse2,
                    &vpx_lpf_horizontal_edge_8_c, 8),
         make_tuple(&vpx_lpf_horizontal_edge_16_sse2,
                    &vpx_lpf_horizontal_edge_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_sse2,
-                   &vpx_lpf_vertical_4_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_sse2,
-                   &vpx_lpf_vertical_8_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_sse2,
-                   &vpx_lpf_vertical_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_dual_sse2,
-                   &vpx_lpf_vertical_16_dual_c, 8)));
+        make_tuple(&vpx_lpf_vertical_4_sse2, &vpx_lpf_vertical_4_c, 8),
+        make_tuple(&vpx_lpf_vertical_8_sse2, &vpx_lpf_vertical_8_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_sse2, &vpx_lpf_vertical_16_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_dual_sse2, &vpx_lpf_vertical_16_dual_c,
+                   8)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif
 
 #if HAVE_AVX2 && (!CONFIG_VP9_HIGHBITDEPTH)
 INSTANTIATE_TEST_CASE_P(
     AVX2, Loop8Test6Param,
-    ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_edge_8_avx2,
-                   &vpx_lpf_horizontal_edge_8_c, 8),
-        make_tuple(&vpx_lpf_horizontal_edge_16_avx2,
-                   &vpx_lpf_horizontal_edge_16_c, 8)));
+    ::testing::Values(make_tuple(&vpx_lpf_horizontal_edge_8_avx2,
+                                 &vpx_lpf_horizontal_edge_8_c, 8),
+                      make_tuple(&vpx_lpf_horizontal_edge_16_avx2,
+                                 &vpx_lpf_horizontal_edge_16_c, 8)));
 #endif
 
 #if HAVE_SSE2
 #if CONFIG_VP9_HIGHBITDEPTH
 INSTANTIATE_TEST_CASE_P(
     SSE2, Loop8Test9Param,
-    ::testing::Values(
-        make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_4_dual_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_8_dual_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
-                   &vpx_highbd_lpf_vertical_4_dual_c, 8),
-        make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
-                   &vpx_highbd_lpf_vertical_8_dual_c, 8),
-        make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_4_dual_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_8_dual_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
-                   &vpx_highbd_lpf_vertical_4_dual_c, 10),
-        make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
-                   &vpx_highbd_lpf_vertical_8_dual_c, 10),
-        make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_4_dual_c, 12),
-        make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
-                   &vpx_highbd_lpf_horizontal_8_dual_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
-                   &vpx_highbd_lpf_vertical_4_dual_c, 12),
-        make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
-                   &vpx_highbd_lpf_vertical_8_dual_c, 12)));
+    ::testing::Values(make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_dual_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_dual_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_4_dual_c, 8),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_8_dual_c, 8),
+                      make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_dual_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_dual_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_4_dual_c, 10),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_8_dual_c, 10),
+                      make_tuple(&vpx_highbd_lpf_horizontal_4_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_4_dual_c, 12),
+                      make_tuple(&vpx_highbd_lpf_horizontal_8_dual_sse2,
+                                 &vpx_highbd_lpf_horizontal_8_dual_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_4_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_4_dual_c, 12),
+                      make_tuple(&vpx_highbd_lpf_vertical_8_dual_sse2,
+                                 &vpx_highbd_lpf_vertical_8_dual_c, 12)));
 #else
 INSTANTIATE_TEST_CASE_P(
     SSE2, Loop8Test9Param,
-    ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_dual_sse2,
-                   &vpx_lpf_horizontal_4_dual_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_dual_sse2,
-                   &vpx_lpf_horizontal_8_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_dual_sse2,
-                   &vpx_lpf_vertical_4_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_dual_sse2,
-                   &vpx_lpf_vertical_8_dual_c, 8)));
+    ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_sse2,
+                                 &vpx_lpf_horizontal_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_horizontal_8_dual_sse2,
+                                 &vpx_lpf_horizontal_8_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_4_dual_sse2,
+                                 &vpx_lpf_vertical_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_8_dual_sse2,
+                                 &vpx_lpf_vertical_8_dual_c, 8)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif
 
@@ -568,38 +538,33 @@
     NEON, Loop8Test6Param,
     ::testing::Values(
 #if HAVE_NEON_ASM
-// Using #if inside the macro is unsupported on MSVS but the tests are not
-// currently built for MSVS with ARM and NEON.
+        // Using #if inside the macro is unsupported on MSVS but the tests are
+        // not
+        // currently built for MSVS with ARM and NEON.
         make_tuple(&vpx_lpf_horizontal_edge_8_neon,
                    &vpx_lpf_horizontal_edge_8_c, 8),
         make_tuple(&vpx_lpf_horizontal_edge_16_neon,
                    &vpx_lpf_horizontal_edge_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_neon,
-                   &vpx_lpf_vertical_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_dual_neon,
-                   &vpx_lpf_vertical_16_dual_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_neon, &vpx_lpf_vertical_16_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_dual_neon, &vpx_lpf_vertical_16_dual_c,
+                   8),
 #endif  // HAVE_NEON_ASM
-        make_tuple(&vpx_lpf_horizontal_8_neon,
-                   &vpx_lpf_horizontal_8_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_neon,
-                   &vpx_lpf_vertical_8_c, 8),
-        make_tuple(&vpx_lpf_horizontal_4_neon,
-                   &vpx_lpf_horizontal_4_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_neon,
-                   &vpx_lpf_vertical_4_c, 8)));
-INSTANTIATE_TEST_CASE_P(
-    NEON, Loop8Test9Param,
-    ::testing::Values(
+        make_tuple(&vpx_lpf_horizontal_8_neon, &vpx_lpf_horizontal_8_c, 8),
+        make_tuple(&vpx_lpf_vertical_8_neon, &vpx_lpf_vertical_8_c, 8),
+        make_tuple(&vpx_lpf_horizontal_4_neon, &vpx_lpf_horizontal_4_c, 8),
+        make_tuple(&vpx_lpf_vertical_4_neon, &vpx_lpf_vertical_4_c, 8)));
+INSTANTIATE_TEST_CASE_P(NEON, Loop8Test9Param,
+                        ::testing::Values(
 #if HAVE_NEON_ASM
-        make_tuple(&vpx_lpf_horizontal_8_dual_neon,
-                   &vpx_lpf_horizontal_8_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_dual_neon,
-                   &vpx_lpf_vertical_8_dual_c, 8),
+                            make_tuple(&vpx_lpf_horizontal_8_dual_neon,
+                                       &vpx_lpf_horizontal_8_dual_c, 8),
+                            make_tuple(&vpx_lpf_vertical_8_dual_neon,
+                                       &vpx_lpf_vertical_8_dual_c, 8),
 #endif  // HAVE_NEON_ASM
-        make_tuple(&vpx_lpf_horizontal_4_dual_neon,
-                   &vpx_lpf_horizontal_4_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_dual_neon,
-                   &vpx_lpf_vertical_4_dual_c, 8)));
+                            make_tuple(&vpx_lpf_horizontal_4_dual_neon,
+                                       &vpx_lpf_horizontal_4_dual_c, 8),
+                            make_tuple(&vpx_lpf_vertical_4_dual_neon,
+                                       &vpx_lpf_vertical_4_dual_c, 8)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif  // HAVE_NEON
 
@@ -607,66 +572,52 @@
 INSTANTIATE_TEST_CASE_P(
     DSPR2, Loop8Test6Param,
     ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_dspr2,
-                   &vpx_lpf_horizontal_4_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_dspr2,
-                   &vpx_lpf_horizontal_8_c, 8),
-        make_tuple(&vpx_lpf_horizontal_edge_8,
-                   &vpx_lpf_horizontal_edge_8, 8),
-        make_tuple(&vpx_lpf_horizontal_edge_16,
-                   &vpx_lpf_horizontal_edge_16, 8),
-        make_tuple(&vpx_lpf_vertical_4_dspr2,
-                   &vpx_lpf_vertical_4_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_dspr2,
-                   &vpx_lpf_vertical_8_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_dspr2,
-                   &vpx_lpf_vertical_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_dual_dspr2,
-                   &vpx_lpf_vertical_16_dual_c, 8)));
+        make_tuple(&vpx_lpf_horizontal_4_dspr2, &vpx_lpf_horizontal_4_c, 8),
+        make_tuple(&vpx_lpf_horizontal_8_dspr2, &vpx_lpf_horizontal_8_c, 8),
+        make_tuple(&vpx_lpf_horizontal_edge_8, &vpx_lpf_horizontal_edge_8, 8),
+        make_tuple(&vpx_lpf_horizontal_edge_16, &vpx_lpf_horizontal_edge_16, 8),
+        make_tuple(&vpx_lpf_vertical_4_dspr2, &vpx_lpf_vertical_4_c, 8),
+        make_tuple(&vpx_lpf_vertical_8_dspr2, &vpx_lpf_vertical_8_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_dspr2, &vpx_lpf_vertical_16_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_dual_dspr2, &vpx_lpf_vertical_16_dual_c,
+                   8)));
 
 INSTANTIATE_TEST_CASE_P(
     DSPR2, Loop8Test9Param,
-    ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_dual_dspr2,
-                   &vpx_lpf_horizontal_4_dual_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_dual_dspr2,
-                   &vpx_lpf_horizontal_8_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_dual_dspr2,
-                   &vpx_lpf_vertical_4_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_dual_dspr2,
-                   &vpx_lpf_vertical_8_dual_c, 8)));
+    ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_dspr2,
+                                 &vpx_lpf_horizontal_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_horizontal_8_dual_dspr2,
+                                 &vpx_lpf_horizontal_8_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_4_dual_dspr2,
+                                 &vpx_lpf_vertical_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_8_dual_dspr2,
+                                 &vpx_lpf_vertical_8_dual_c, 8)));
 #endif  // HAVE_DSPR2 && !CONFIG_VP9_HIGHBITDEPTH
 
 #if HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
 INSTANTIATE_TEST_CASE_P(
     MSA, Loop8Test6Param,
     ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_msa,
-                   &vpx_lpf_horizontal_4_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_msa,
-                   &vpx_lpf_horizontal_8_c, 8),
-        make_tuple(&vpx_lpf_horizontal_edge_8_msa,
-                   &vpx_lpf_horizontal_edge_8_c, 8),
+        make_tuple(&vpx_lpf_horizontal_4_msa, &vpx_lpf_horizontal_4_c, 8),
+        make_tuple(&vpx_lpf_horizontal_8_msa, &vpx_lpf_horizontal_8_c, 8),
+        make_tuple(&vpx_lpf_horizontal_edge_8_msa, &vpx_lpf_horizontal_edge_8_c,
+                   8),
         make_tuple(&vpx_lpf_horizontal_edge_16_msa,
                    &vpx_lpf_horizontal_edge_16_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_msa,
-                   &vpx_lpf_vertical_4_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_msa,
-                   &vpx_lpf_vertical_8_c, 8),
-        make_tuple(&vpx_lpf_vertical_16_msa,
-                   &vpx_lpf_vertical_16_c, 8)));
+        make_tuple(&vpx_lpf_vertical_4_msa, &vpx_lpf_vertical_4_c, 8),
+        make_tuple(&vpx_lpf_vertical_8_msa, &vpx_lpf_vertical_8_c, 8),
+        make_tuple(&vpx_lpf_vertical_16_msa, &vpx_lpf_vertical_16_c, 8)));
 
 INSTANTIATE_TEST_CASE_P(
     MSA, Loop8Test9Param,
-    ::testing::Values(
-        make_tuple(&vpx_lpf_horizontal_4_dual_msa,
-                   &vpx_lpf_horizontal_4_dual_c, 8),
-        make_tuple(&vpx_lpf_horizontal_8_dual_msa,
-                   &vpx_lpf_horizontal_8_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_4_dual_msa,
-                   &vpx_lpf_vertical_4_dual_c, 8),
-        make_tuple(&vpx_lpf_vertical_8_dual_msa,
-                   &vpx_lpf_vertical_8_dual_c, 8)));
+    ::testing::Values(make_tuple(&vpx_lpf_horizontal_4_dual_msa,
+                                 &vpx_lpf_horizontal_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_horizontal_8_dual_msa,
+                                 &vpx_lpf_horizontal_8_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_4_dual_msa,
+                                 &vpx_lpf_vertical_4_dual_c, 8),
+                      make_tuple(&vpx_lpf_vertical_8_dual_msa,
+                                 &vpx_lpf_vertical_8_dual_c, 8)));
 #endif  // HAVE_MSA && (!CONFIG_VP9_HIGHBITDEPTH)
 
 }  // namespace
diff --git a/test/masked_sad_test.cc b/test/masked_sad_test.cc
index 13fff0f..c5b5081 100644
--- a/test/masked_sad_test.cc
+++ b/test/masked_sad_test.cc
@@ -36,7 +36,7 @@
  public:
   virtual ~MaskedSADTest() {}
   virtual void SetUp() {
-    maskedSAD_op_   = GET_PARAM(0);
+    maskedSAD_op_ = GET_PARAM(0);
     ref_maskedSAD_op_ = GET_PARAM(1);
   }
 
@@ -50,36 +50,35 @@
 TEST_P(MaskedSADTest, OperationCheck) {
   unsigned int ref_ret, ret;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
   int ref_stride = MAX_SB_SIZE;
   int msk_stride = MAX_SB_SIZE;
   for (int i = 0; i < number_of_iterations; ++i) {
-    for (int j = 0; j < MAX_SB_SIZE*MAX_SB_SIZE; j++) {
+    for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
       src_ptr[j] = rnd.Rand8();
       ref_ptr[j] = rnd.Rand8();
-      msk_ptr[j] = ((rnd.Rand8()&0x7f) > 64) ? rnd.Rand8()&0x3f : 64;
+      msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
       assert(msk_ptr[j] <= 64);
     }
 
     ref_ret = ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride,
                                 msk_ptr, msk_stride);
-    ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src_ptr, src_stride,
-                                                 ref_ptr, ref_stride,
-                                                 msk_ptr, msk_stride));
+    ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src_ptr, src_stride, ref_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride));
     if (ret != ref_ret) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
   EXPECT_EQ(0, err_count)
-    << "Error: Masked SAD Test, C output doesn't match SSSE3 output. "
-    << "First failed at test case " << first_failure;
+      << "Error: Masked SAD Test, C output doesn't match SSSE3 output. "
+      << "First failed at test case " << first_failure;
 }
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -89,12 +88,12 @@
 typedef std::tr1::tuple<HighbdMaskedSADFunc, HighbdMaskedSADFunc>
     HighbdMaskedSADParam;
 
-class HighbdMaskedSADTest : public ::testing::
-        TestWithParam<HighbdMaskedSADParam> {
+class HighbdMaskedSADTest
+    : public ::testing::TestWithParam<HighbdMaskedSADParam> {
  public:
   virtual ~HighbdMaskedSADTest() {}
   virtual void SetUp() {
-    maskedSAD_op_   = GET_PARAM(0);
+    maskedSAD_op_ = GET_PARAM(0);
     ref_maskedSAD_op_ = GET_PARAM(1);
   }
 
@@ -108,37 +107,36 @@
 TEST_P(HighbdMaskedSADTest, OperationCheck) {
   unsigned int ref_ret, ret;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  uint8_t* src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
-  uint8_t* ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
+  uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
   int ref_stride = MAX_SB_SIZE;
   int msk_stride = MAX_SB_SIZE;
   for (int i = 0; i < number_of_iterations; ++i) {
-    for (int j = 0; j < MAX_SB_SIZE*MAX_SB_SIZE; j++) {
-      src_ptr[j] = rnd.Rand16()&0xfff;
-      ref_ptr[j] = rnd.Rand16()&0xfff;
-      msk_ptr[j] = ((rnd.Rand8()&0x7f) > 64) ? rnd.Rand8()&0x3f : 64;
+    for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
+      src_ptr[j] = rnd.Rand16() & 0xfff;
+      ref_ptr[j] = rnd.Rand16() & 0xfff;
+      msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
     }
 
     ref_ret = ref_maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
                                 msk_ptr, msk_stride);
-    ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride,
-                                                 ref8_ptr, ref_stride,
-                                                 msk_ptr, msk_stride));
+    ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride, ref8_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride));
     if (ret != ref_ret) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
   EXPECT_EQ(0, err_count)
-    << "Error: High BD Masked SAD Test, C output doesn't match SSSE3 output. "
-    << "First failed at test case " << first_failure;
+      << "Error: High BD Masked SAD Test, C output doesn't match SSSE3 output. "
+      << "First failed at test case " << first_failure;
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
@@ -146,80 +144,63 @@
 
 #if HAVE_SSSE3
 INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, MaskedSADTest,
-  ::testing::Values(
+    SSSE3_C_COMPARE, MaskedSADTest,
+    ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_sad128x128_ssse3,
-               &vpx_masked_sad128x128_c),
-    make_tuple(&vpx_masked_sad128x64_ssse3,
-               &vpx_masked_sad128x64_c),
-    make_tuple(&vpx_masked_sad64x128_ssse3,
-               &vpx_masked_sad64x128_c),
+        make_tuple(&vpx_masked_sad128x128_ssse3, &vpx_masked_sad128x128_c),
+        make_tuple(&vpx_masked_sad128x64_ssse3, &vpx_masked_sad128x64_c),
+        make_tuple(&vpx_masked_sad64x128_ssse3, &vpx_masked_sad64x128_c),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_sad64x64_ssse3,
-               &vpx_masked_sad64x64_c),
-    make_tuple(&vpx_masked_sad64x32_ssse3,
-               &vpx_masked_sad64x32_c),
-    make_tuple(&vpx_masked_sad32x64_ssse3,
-               &vpx_masked_sad32x64_c),
-    make_tuple(&vpx_masked_sad32x32_ssse3,
-               &vpx_masked_sad32x32_c),
-    make_tuple(&vpx_masked_sad32x16_ssse3,
-               &vpx_masked_sad32x16_c),
-    make_tuple(&vpx_masked_sad16x32_ssse3,
-               &vpx_masked_sad16x32_c),
-    make_tuple(&vpx_masked_sad16x16_ssse3,
-               &vpx_masked_sad16x16_c),
-    make_tuple(&vpx_masked_sad16x8_ssse3,
-               &vpx_masked_sad16x8_c),
-    make_tuple(&vpx_masked_sad8x16_ssse3,
-               &vpx_masked_sad8x16_c),
-    make_tuple(&vpx_masked_sad8x8_ssse3,
-               &vpx_masked_sad8x8_c),
-    make_tuple(&vpx_masked_sad8x4_ssse3,
-               &vpx_masked_sad8x4_c),
-    make_tuple(&vpx_masked_sad4x8_ssse3,
-               &vpx_masked_sad4x8_c),
-    make_tuple(&vpx_masked_sad4x4_ssse3,
-               &vpx_masked_sad4x4_c)));
+        make_tuple(&vpx_masked_sad64x64_ssse3, &vpx_masked_sad64x64_c),
+        make_tuple(&vpx_masked_sad64x32_ssse3, &vpx_masked_sad64x32_c),
+        make_tuple(&vpx_masked_sad32x64_ssse3, &vpx_masked_sad32x64_c),
+        make_tuple(&vpx_masked_sad32x32_ssse3, &vpx_masked_sad32x32_c),
+        make_tuple(&vpx_masked_sad32x16_ssse3, &vpx_masked_sad32x16_c),
+        make_tuple(&vpx_masked_sad16x32_ssse3, &vpx_masked_sad16x32_c),
+        make_tuple(&vpx_masked_sad16x16_ssse3, &vpx_masked_sad16x16_c),
+        make_tuple(&vpx_masked_sad16x8_ssse3, &vpx_masked_sad16x8_c),
+        make_tuple(&vpx_masked_sad8x16_ssse3, &vpx_masked_sad8x16_c),
+        make_tuple(&vpx_masked_sad8x8_ssse3, &vpx_masked_sad8x8_c),
+        make_tuple(&vpx_masked_sad8x4_ssse3, &vpx_masked_sad8x4_c),
+        make_tuple(&vpx_masked_sad4x8_ssse3, &vpx_masked_sad4x8_c),
+        make_tuple(&vpx_masked_sad4x4_ssse3, &vpx_masked_sad4x4_c)));
 #if CONFIG_VP9_HIGHBITDEPTH
-INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, HighbdMaskedSADTest,
-  ::testing::Values(
+INSTANTIATE_TEST_CASE_P(SSSE3_C_COMPARE, HighbdMaskedSADTest,
+                        ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_sad128x128_ssse3,
-               &vpx_highbd_masked_sad128x128_c),
-    make_tuple(&vpx_highbd_masked_sad128x64_ssse3,
-               &vpx_highbd_masked_sad128x64_c),
-    make_tuple(&vpx_highbd_masked_sad64x128_ssse3,
-               &vpx_highbd_masked_sad64x128_c),
+                            make_tuple(&vpx_highbd_masked_sad128x128_ssse3,
+                                       &vpx_highbd_masked_sad128x128_c),
+                            make_tuple(&vpx_highbd_masked_sad128x64_ssse3,
+                                       &vpx_highbd_masked_sad128x64_c),
+                            make_tuple(&vpx_highbd_masked_sad64x128_ssse3,
+                                       &vpx_highbd_masked_sad64x128_c),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_sad64x64_ssse3,
-               &vpx_highbd_masked_sad64x64_c),
-    make_tuple(&vpx_highbd_masked_sad64x32_ssse3,
-               &vpx_highbd_masked_sad64x32_c),
-    make_tuple(&vpx_highbd_masked_sad32x64_ssse3,
-               &vpx_highbd_masked_sad32x64_c),
-    make_tuple(&vpx_highbd_masked_sad32x32_ssse3,
-               &vpx_highbd_masked_sad32x32_c),
-    make_tuple(&vpx_highbd_masked_sad32x16_ssse3,
-               &vpx_highbd_masked_sad32x16_c),
-    make_tuple(&vpx_highbd_masked_sad16x32_ssse3,
-               &vpx_highbd_masked_sad16x32_c),
-    make_tuple(&vpx_highbd_masked_sad16x16_ssse3,
-               &vpx_highbd_masked_sad16x16_c),
-    make_tuple(&vpx_highbd_masked_sad16x8_ssse3,
-               &vpx_highbd_masked_sad16x8_c),
-    make_tuple(&vpx_highbd_masked_sad8x16_ssse3,
-               &vpx_highbd_masked_sad8x16_c),
-    make_tuple(&vpx_highbd_masked_sad8x8_ssse3,
-               &vpx_highbd_masked_sad8x8_c),
-    make_tuple(&vpx_highbd_masked_sad8x4_ssse3,
-               &vpx_highbd_masked_sad8x4_c),
-    make_tuple(&vpx_highbd_masked_sad4x8_ssse3,
-               &vpx_highbd_masked_sad4x8_c),
-    make_tuple(&vpx_highbd_masked_sad4x4_ssse3,
-               &vpx_highbd_masked_sad4x4_c)));
+                            make_tuple(&vpx_highbd_masked_sad64x64_ssse3,
+                                       &vpx_highbd_masked_sad64x64_c),
+                            make_tuple(&vpx_highbd_masked_sad64x32_ssse3,
+                                       &vpx_highbd_masked_sad64x32_c),
+                            make_tuple(&vpx_highbd_masked_sad32x64_ssse3,
+                                       &vpx_highbd_masked_sad32x64_c),
+                            make_tuple(&vpx_highbd_masked_sad32x32_ssse3,
+                                       &vpx_highbd_masked_sad32x32_c),
+                            make_tuple(&vpx_highbd_masked_sad32x16_ssse3,
+                                       &vpx_highbd_masked_sad32x16_c),
+                            make_tuple(&vpx_highbd_masked_sad16x32_ssse3,
+                                       &vpx_highbd_masked_sad16x32_c),
+                            make_tuple(&vpx_highbd_masked_sad16x16_ssse3,
+                                       &vpx_highbd_masked_sad16x16_c),
+                            make_tuple(&vpx_highbd_masked_sad16x8_ssse3,
+                                       &vpx_highbd_masked_sad16x8_c),
+                            make_tuple(&vpx_highbd_masked_sad8x16_ssse3,
+                                       &vpx_highbd_masked_sad8x16_c),
+                            make_tuple(&vpx_highbd_masked_sad8x8_ssse3,
+                                       &vpx_highbd_masked_sad8x8_c),
+                            make_tuple(&vpx_highbd_masked_sad8x4_ssse3,
+                                       &vpx_highbd_masked_sad8x4_c),
+                            make_tuple(&vpx_highbd_masked_sad4x8_ssse3,
+                                       &vpx_highbd_masked_sad4x8_c),
+                            make_tuple(&vpx_highbd_masked_sad4x4_ssse3,
+                                       &vpx_highbd_masked_sad4x4_c)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 #endif  // HAVE_SSSE3
 }  // namespace
diff --git a/test/masked_variance_test.cc b/test/masked_variance_test.cc
index 1710285..131599f 100644
--- a/test/masked_variance_test.cc
+++ b/test/masked_variance_test.cc
@@ -35,11 +35,11 @@
                                            const uint8_t *m, int m_stride,
                                            unsigned int *sse);
 
-typedef std::tr1::tuple<MaskedVarianceFunc,
-                        MaskedVarianceFunc> MaskedVarianceParam;
+typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc>
+    MaskedVarianceParam;
 
-class MaskedVarianceTest :
-  public ::testing::TestWithParam<MaskedVarianceParam> {
+class MaskedVarianceTest
+    : public ::testing::TestWithParam<MaskedVarianceParam> {
  public:
   virtual ~MaskedVarianceTest() {}
   virtual void SetUp() {
@@ -58,9 +58,9 @@
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t,  src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
@@ -68,41 +68,36 @@
   int msk_stride = MAX_SB_SIZE;
 
   for (int i = 0; i < number_of_iterations; ++i) {
-    for (int j = 0; j < MAX_SB_SIZE*MAX_SB_SIZE; j++) {
+    for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
       src_ptr[j] = rnd.Rand8();
       ref_ptr[j] = rnd.Rand8();
       msk_ptr[j] = rnd(65);
     }
 
-    ref_ret = ref_func_(src_ptr, src_stride,
-                        ref_ptr, ref_stride,
-                        msk_ptr, msk_stride,
-                        &ref_sse);
-    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride,
-                                                 ref_ptr, ref_stride,
-                                                 msk_ptr, msk_stride,
-                                                 &opt_sse));
+    ref_ret = ref_func_(src_ptr, src_stride, ref_ptr, ref_stride, msk_ptr,
+                        msk_stride, &ref_sse);
+    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride, ref_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride, &opt_sse));
 
     if (opt_ret != ref_ret || opt_sse != ref_sse) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test OperationCheck,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test OperationCheck,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure;
 }
 
 TEST_P(MaskedVarianceTest, ExtremeValues) {
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t,  src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
@@ -110,44 +105,36 @@
   int msk_stride = MAX_SB_SIZE;
 
   for (int i = 0; i < 8; ++i) {
-    memset(src_ptr, (i & 0x1) ? 255 : 0, MAX_SB_SIZE*MAX_SB_SIZE);
-    memset(ref_ptr, (i & 0x2) ? 255 : 0, MAX_SB_SIZE*MAX_SB_SIZE);
-    memset(msk_ptr, (i & 0x4) ?  64 : 0, MAX_SB_SIZE*MAX_SB_SIZE);
+    memset(src_ptr, (i & 0x1) ? 255 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
+    memset(ref_ptr, (i & 0x2) ? 255 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
+    memset(msk_ptr, (i & 0x4) ? 64 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
 
-    ref_ret = ref_func_(src_ptr, src_stride,
-                        ref_ptr, ref_stride,
-                        msk_ptr, msk_stride,
-                        &ref_sse);
-    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride,
-                                                 ref_ptr, ref_stride,
-                                                 msk_ptr, msk_stride,
-                                                 &opt_sse));
+    ref_ret = ref_func_(src_ptr, src_stride, ref_ptr, ref_stride, msk_ptr,
+                        msk_stride, &ref_sse);
+    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride, ref_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride, &opt_sse));
 
     if (opt_ret != ref_ret || opt_sse != ref_sse) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test ExtremeValues,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure;
 }
 
 typedef unsigned int (*MaskedSubPixelVarianceFunc)(
-    const uint8_t *a, int a_stride,
-    int xoffset, int  yoffset,
-    const uint8_t *b, int b_stride,
-    const uint8_t *m, int m_stride,
-    unsigned int *sse);
+    const uint8_t *a, int a_stride, int xoffset, int yoffset, const uint8_t *b,
+    int b_stride, const uint8_t *m, int m_stride, unsigned int *sse);
 
-typedef std::tr1::tuple<MaskedSubPixelVarianceFunc,
-                        MaskedSubPixelVarianceFunc> MaskedSubPixelVarianceParam;
+typedef std::tr1::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc>
+    MaskedSubPixelVarianceParam;
 
-class MaskedSubPixelVarianceTest :
-  public ::testing::TestWithParam<MaskedSubPixelVarianceParam> {
+class MaskedSubPixelVarianceTest
+    : public ::testing::TestWithParam<MaskedSubPixelVarianceParam> {
  public:
   virtual ~MaskedSubPixelVarianceTest() {}
   virtual void SetUp() {
@@ -166,21 +153,21 @@
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t,  src_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  ref_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
+  DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
   int err_count = 0;
   int first_failure = -1;
-  int src_stride = (MAX_SB_SIZE+1);
-  int ref_stride = (MAX_SB_SIZE+1);
-  int msk_stride = (MAX_SB_SIZE+1);
+  int src_stride = (MAX_SB_SIZE + 1);
+  int ref_stride = (MAX_SB_SIZE + 1);
+  int msk_stride = (MAX_SB_SIZE + 1);
   int xoffset;
   int yoffset;
 
   for (int i = 0; i < number_of_iterations; ++i) {
-    int xoffsets[] = {0, 4, rnd(BIL_SUBPEL_SHIFTS)};
-    int yoffsets[] = {0, 4, rnd(BIL_SUBPEL_SHIFTS)};
-    for (int j = 0; j < (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1); j++) {
+    int xoffsets[] = { 0, 4, rnd(BIL_SUBPEL_SHIFTS) };
+    int yoffsets[] = { 0, 4, rnd(BIL_SUBPEL_SHIFTS) };
+    for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1); j++) {
       src_ptr[j] = rnd.Rand8();
       ref_ptr[j] = rnd.Rand8();
       msk_ptr[j] = rnd(65);
@@ -191,64 +178,56 @@
         xoffset = xoffsets[k];
         yoffset = yoffsets[l];
 
-        ref_ret = ref_func_(src_ptr, src_stride,
-                            xoffset, yoffset,
-                            ref_ptr, ref_stride,
-                            msk_ptr, msk_stride,
-                            &ref_sse);
-        ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride,
-                                                     xoffset, yoffset,
-                                                     ref_ptr, ref_stride,
-                                                     msk_ptr, msk_stride,
-                                                     &opt_sse));
+        ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+                            ref_stride, msk_ptr, msk_stride, &ref_sse);
+        ASM_REGISTER_STATE_CHECK(
+            opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+                                ref_stride, msk_ptr, msk_stride, &opt_sse));
 
         if (opt_ret != ref_ret || opt_sse != ref_sse) {
-        err_count++;
-        if (first_failure == -1)
-            first_failure = i;
+          err_count++;
+          if (first_failure == -1) first_failure = i;
         }
       }
     }
   }
 
   EXPECT_EQ(0, err_count)
-    << "Error: Masked Sub Pixel Variance Test OperationCheck,"
-    << "C output doesn't match SSSE3 output. "
-    << "First failed at test case " << first_failure;
+      << "Error: Masked Sub Pixel Variance Test OperationCheck,"
+      << "C output doesn't match SSSE3 output. "
+      << "First failed at test case " << first_failure;
 }
 
 TEST_P(MaskedSubPixelVarianceTest, ExtremeValues) {
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t,  src_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  ref_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
+  DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
   int first_failure_x = -1;
   int first_failure_y = -1;
   int err_count = 0;
   int first_failure = -1;
-  int src_stride = (MAX_SB_SIZE+1);
-  int ref_stride = (MAX_SB_SIZE+1);
-  int msk_stride = (MAX_SB_SIZE+1);
+  int src_stride = (MAX_SB_SIZE + 1);
+  int ref_stride = (MAX_SB_SIZE + 1);
+  int msk_stride = (MAX_SB_SIZE + 1);
 
-  for (int xoffset = 0 ; xoffset < BIL_SUBPEL_SHIFTS ; xoffset++) {
-    for (int yoffset = 0 ; yoffset < BIL_SUBPEL_SHIFTS ; yoffset++) {
+  for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
+    for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
       for (int i = 0; i < 8; ++i) {
-        memset(src_ptr, (i & 0x1) ? 255 : 0, (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
-        memset(ref_ptr, (i & 0x2) ? 255 : 0, (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
-        memset(msk_ptr, (i & 0x4) ?  64 : 0, (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
+        memset(src_ptr, (i & 0x1) ? 255 : 0,
+               (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
+        memset(ref_ptr, (i & 0x2) ? 255 : 0,
+               (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
+        memset(msk_ptr, (i & 0x4) ? 64 : 0,
+               (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
 
-        ref_ret = ref_func_(src_ptr, src_stride,
-                            xoffset, yoffset,
-                            ref_ptr, ref_stride,
-                            msk_ptr, msk_stride,
-                            &ref_sse);
-        ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride,
-                                                     xoffset, yoffset,
-                                                     ref_ptr, ref_stride,
-                                                     msk_ptr, msk_stride,
-                                                     &opt_sse));
+        ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+                            ref_stride, msk_ptr, msk_stride, &ref_sse);
+        ASM_REGISTER_STATE_CHECK(
+            opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+                                ref_stride, msk_ptr, msk_stride, &opt_sse));
 
         if (opt_ret != ref_ret || opt_sse != ref_sse) {
           err_count++;
@@ -262,21 +241,19 @@
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test ExtremeValues,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure
-  << " x_offset = " << first_failure_x
-  << " y_offset = " << first_failure_y;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure
+                          << " x_offset = " << first_failure_x
+                          << " y_offset = " << first_failure_y;
 }
 
 #if CONFIG_VP9_HIGHBITDEPTH
-typedef std::tr1::tuple<MaskedVarianceFunc,
-                        MaskedVarianceFunc,
-                        vpx_bit_depth_t> HighbdMaskedVarianceParam;
+typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc, vpx_bit_depth_t>
+    HighbdMaskedVarianceParam;
 
-class HighbdMaskedVarianceTest :
-  public ::testing::TestWithParam<HighbdMaskedVarianceParam> {
+class HighbdMaskedVarianceTest
+    : public ::testing::TestWithParam<HighbdMaskedVarianceParam> {
  public:
   virtual ~HighbdMaskedVarianceTest() {}
   virtual void SetUp() {
@@ -297,11 +274,11 @@
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  uint8_t* src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
-  uint8_t* ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
+  uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
@@ -309,43 +286,38 @@
   int msk_stride = MAX_SB_SIZE;
 
   for (int i = 0; i < number_of_iterations; ++i) {
-    for (int j = 0; j < MAX_SB_SIZE*MAX_SB_SIZE; j++) {
+    for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
       src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
       ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
       msk_ptr[j] = rnd(65);
     }
 
-    ref_ret = ref_func_(src8_ptr, src_stride,
-                        ref8_ptr, ref_stride,
-                        msk_ptr, msk_stride,
-                        &ref_sse);
-    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride,
-                                                 ref8_ptr, ref_stride,
-                                                 msk_ptr, msk_stride,
-                                                 &opt_sse));
+    ref_ret = ref_func_(src8_ptr, src_stride, ref8_ptr, ref_stride, msk_ptr,
+                        msk_stride, &ref_sse);
+    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride, ref8_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride, &opt_sse));
 
     if (opt_ret != ref_ret || opt_sse != ref_sse) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test OperationCheck,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test OperationCheck,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure;
 }
 
 TEST_P(HighbdMaskedVarianceTest, ExtremeValues) {
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[MAX_SB_SIZE*MAX_SB_SIZE]);
-  uint8_t* src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
-  uint8_t* ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+  DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+  uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
+  uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
   int err_count = 0;
   int first_failure = -1;
   int src_stride = MAX_SB_SIZE;
@@ -354,39 +326,33 @@
 
   for (int i = 0; i < 8; ++i) {
     vpx_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
-                 MAX_SB_SIZE*MAX_SB_SIZE);
+                 MAX_SB_SIZE * MAX_SB_SIZE);
     vpx_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
-                 MAX_SB_SIZE*MAX_SB_SIZE);
-    memset(msk_ptr, (i & 0x4) ?  64 : 0, MAX_SB_SIZE*MAX_SB_SIZE);
+                 MAX_SB_SIZE * MAX_SB_SIZE);
+    memset(msk_ptr, (i & 0x4) ? 64 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
 
-    ref_ret = ref_func_(src8_ptr, src_stride,
-                        ref8_ptr, ref_stride,
-                        msk_ptr, msk_stride,
-                        &ref_sse);
-    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride,
-                                                 ref8_ptr, ref_stride,
-                                                 msk_ptr, msk_stride,
-                                                 &opt_sse));
+    ref_ret = ref_func_(src8_ptr, src_stride, ref8_ptr, ref_stride, msk_ptr,
+                        msk_stride, &ref_sse);
+    ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride, ref8_ptr,
+                                                 ref_stride, msk_ptr,
+                                                 msk_stride, &opt_sse));
 
     if (opt_ret != ref_ret || opt_sse != ref_sse) {
       err_count++;
-      if (first_failure == -1)
-        first_failure = i;
+      if (first_failure == -1) first_failure = i;
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test ExtremeValues,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure;
 }
 
-typedef std::tr1::tuple<MaskedSubPixelVarianceFunc,
-                        MaskedSubPixelVarianceFunc,
+typedef std::tr1::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc,
                         vpx_bit_depth_t> HighbdMaskedSubPixelVarianceParam;
 
-class HighbdMaskedSubPixelVarianceTest :
-  public ::testing::TestWithParam<HighbdMaskedSubPixelVarianceParam> {
+class HighbdMaskedSubPixelVarianceTest
+    : public ::testing::TestWithParam<HighbdMaskedSubPixelVarianceParam> {
  public:
   virtual ~HighbdMaskedSubPixelVarianceTest() {}
   virtual void SetUp() {
@@ -407,39 +373,35 @@
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  uint8_t* src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
-  uint8_t* ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+  DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
+  uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
   int err_count = 0;
   int first_failure = -1;
   int first_failure_x = -1;
   int first_failure_y = -1;
-  int src_stride = (MAX_SB_SIZE+1);
-  int ref_stride = (MAX_SB_SIZE+1);
-  int msk_stride = (MAX_SB_SIZE+1);
+  int src_stride = (MAX_SB_SIZE + 1);
+  int ref_stride = (MAX_SB_SIZE + 1);
+  int msk_stride = (MAX_SB_SIZE + 1);
   int xoffset, yoffset;
 
   for (int i = 0; i < number_of_iterations; ++i) {
     for (xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
       for (yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
-        for (int j = 0; j < (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1); j++) {
+        for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1); j++) {
           src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
           ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
           msk_ptr[j] = rnd(65);
         }
 
-        ref_ret = ref_func_(src8_ptr, src_stride,
-                            xoffset, yoffset,
-                            ref8_ptr, ref_stride,
-                            msk_ptr, msk_stride,
-                            &ref_sse);
-        ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride,
-                                                     xoffset, yoffset,
-                                                     ref8_ptr, ref_stride,
-                                                     msk_ptr, msk_stride,
-                                                     &opt_sse));
+        ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
+                            ref_stride, msk_ptr, msk_stride, &ref_sse);
+        ASM_REGISTER_STATE_CHECK(opt_ret =
+                                     opt_func_(src8_ptr, src_stride, xoffset,
+                                               yoffset, ref8_ptr, ref_stride,
+                                               msk_ptr, msk_stride, &opt_sse));
 
         if (opt_ret != ref_ret || opt_sse != ref_sse) {
           err_count++;
@@ -454,49 +416,45 @@
   }
 
   EXPECT_EQ(0, err_count)
-    << "Error: Masked Sub Pixel Variance Test OperationCheck,"
-    << "C output doesn't match SSSE3 output. "
-    << "First failed at test case " << first_failure
-    << " x_offset = " << first_failure_x
-    << " y_offset = " << first_failure_y;
+      << "Error: Masked Sub Pixel Variance Test OperationCheck,"
+      << "C output doesn't match SSSE3 output. "
+      << "First failed at test case " << first_failure
+      << " x_offset = " << first_failure_x << " y_offset = " << first_failure_y;
 }
 
 TEST_P(HighbdMaskedSubPixelVarianceTest, ExtremeValues) {
   unsigned int ref_ret, opt_ret;
   unsigned int ref_sse, opt_sse;
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  DECLARE_ALIGNED(16, uint8_t,  msk_ptr[(MAX_SB_SIZE+1)*(MAX_SB_SIZE+1)]);
-  uint8_t* src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
-  uint8_t* ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+  DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+  uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
+  uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
   int first_failure_x = -1;
   int first_failure_y = -1;
   int err_count = 0;
   int first_failure = -1;
-  int src_stride = (MAX_SB_SIZE+1);
-  int ref_stride = (MAX_SB_SIZE+1);
-  int msk_stride = (MAX_SB_SIZE+1);
+  int src_stride = (MAX_SB_SIZE + 1);
+  int ref_stride = (MAX_SB_SIZE + 1);
+  int msk_stride = (MAX_SB_SIZE + 1);
 
-  for (int xoffset = 0 ; xoffset < BIL_SUBPEL_SHIFTS ; xoffset++) {
-    for (int yoffset = 0 ; yoffset < BIL_SUBPEL_SHIFTS ; yoffset++) {
+  for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
+    for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
       for (int i = 0; i < 8; ++i) {
         vpx_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
-                     (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
+                     (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
         vpx_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
-                     (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
-        memset(msk_ptr, (i & 0x4) ?   64 : 0, (MAX_SB_SIZE+1)*(MAX_SB_SIZE+1));
+                     (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
+        memset(msk_ptr, (i & 0x4) ? 64 : 0,
+               (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
 
-        ref_ret = ref_func_(src8_ptr, src_stride,
-                            xoffset, yoffset,
-                            ref8_ptr, ref_stride,
-                            msk_ptr, msk_stride,
-                            &ref_sse);
-        ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride,
-                                                     xoffset, yoffset,
-                                                     ref8_ptr, ref_stride,
-                                                     msk_ptr, msk_stride,
-                                                     &opt_sse));
+        ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
+                            ref_stride, msk_ptr, msk_stride, &ref_sse);
+        ASM_REGISTER_STATE_CHECK(opt_ret =
+                                     opt_func_(src8_ptr, src_stride, xoffset,
+                                               yoffset, ref8_ptr, ref_stride,
+                                               msk_ptr, msk_stride, &opt_sse));
 
         if (opt_ret != ref_ret || opt_sse != ref_sse) {
           err_count++;
@@ -510,12 +468,11 @@
     }
   }
 
-  EXPECT_EQ(0, err_count)
-  << "Error: Masked Variance Test ExtremeValues,"
-  << "C output doesn't match SSSE3 output. "
-  << "First failed at test case " << first_failure
-  << " x_offset = " << first_failure_x
-  << " y_offset = " << first_failure_y;
+  EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
+                          << "C output doesn't match SSSE3 output. "
+                          << "First failed at test case " << first_failure
+                          << " x_offset = " << first_failure_x
+                          << " y_offset = " << first_failure_y;
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
@@ -523,293 +480,308 @@
 
 #if HAVE_SSSE3
 INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, MaskedVarianceTest,
-  ::testing::Values(
+    SSSE3_C_COMPARE, MaskedVarianceTest,
+    ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_variance128x128_ssse3,
-               &vpx_masked_variance128x128_c),
-    make_tuple(&vpx_masked_variance128x64_ssse3,
-               &vpx_masked_variance128x64_c),
-    make_tuple(&vpx_masked_variance64x128_ssse3,
-               &vpx_masked_variance64x128_c),
+        make_tuple(&vpx_masked_variance128x128_ssse3,
+                   &vpx_masked_variance128x128_c),
+        make_tuple(&vpx_masked_variance128x64_ssse3,
+                   &vpx_masked_variance128x64_c),
+        make_tuple(&vpx_masked_variance64x128_ssse3,
+                   &vpx_masked_variance64x128_c),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_variance64x64_ssse3,
-               &vpx_masked_variance64x64_c),
-    make_tuple(&vpx_masked_variance64x32_ssse3,
-               &vpx_masked_variance64x32_c),
-    make_tuple(&vpx_masked_variance32x64_ssse3,
-               &vpx_masked_variance32x64_c),
-    make_tuple(&vpx_masked_variance32x32_ssse3,
-               &vpx_masked_variance32x32_c),
-    make_tuple(&vpx_masked_variance32x16_ssse3,
-               &vpx_masked_variance32x16_c),
-    make_tuple(&vpx_masked_variance16x32_ssse3,
-               &vpx_masked_variance16x32_c),
-    make_tuple(&vpx_masked_variance16x16_ssse3,
-               &vpx_masked_variance16x16_c),
-    make_tuple(&vpx_masked_variance16x8_ssse3,
-               &vpx_masked_variance16x8_c),
-    make_tuple(&vpx_masked_variance8x16_ssse3,
-               &vpx_masked_variance8x16_c),
-    make_tuple(&vpx_masked_variance8x8_ssse3,
-               &vpx_masked_variance8x8_c),
-    make_tuple(&vpx_masked_variance8x4_ssse3,
-               &vpx_masked_variance8x4_c),
-    make_tuple(&vpx_masked_variance4x8_ssse3,
-               &vpx_masked_variance4x8_c),
-    make_tuple(&vpx_masked_variance4x4_ssse3,
-               &vpx_masked_variance4x4_c)));
+        make_tuple(&vpx_masked_variance64x64_ssse3,
+                   &vpx_masked_variance64x64_c),
+        make_tuple(&vpx_masked_variance64x32_ssse3,
+                   &vpx_masked_variance64x32_c),
+        make_tuple(&vpx_masked_variance32x64_ssse3,
+                   &vpx_masked_variance32x64_c),
+        make_tuple(&vpx_masked_variance32x32_ssse3,
+                   &vpx_masked_variance32x32_c),
+        make_tuple(&vpx_masked_variance32x16_ssse3,
+                   &vpx_masked_variance32x16_c),
+        make_tuple(&vpx_masked_variance16x32_ssse3,
+                   &vpx_masked_variance16x32_c),
+        make_tuple(&vpx_masked_variance16x16_ssse3,
+                   &vpx_masked_variance16x16_c),
+        make_tuple(&vpx_masked_variance16x8_ssse3, &vpx_masked_variance16x8_c),
+        make_tuple(&vpx_masked_variance8x16_ssse3, &vpx_masked_variance8x16_c),
+        make_tuple(&vpx_masked_variance8x8_ssse3, &vpx_masked_variance8x8_c),
+        make_tuple(&vpx_masked_variance8x4_ssse3, &vpx_masked_variance8x4_c),
+        make_tuple(&vpx_masked_variance4x8_ssse3, &vpx_masked_variance4x8_c),
+        make_tuple(&vpx_masked_variance4x4_ssse3, &vpx_masked_variance4x4_c)));
 
 INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, MaskedSubPixelVarianceTest,
-  ::testing::Values(
+    SSSE3_C_COMPARE, MaskedSubPixelVarianceTest,
+    ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_sub_pixel_variance128x128_ssse3,
-               &vpx_masked_sub_pixel_variance128x128_c),
-    make_tuple(&vpx_masked_sub_pixel_variance128x64_ssse3,
-               &vpx_masked_sub_pixel_variance128x64_c),
-    make_tuple(&vpx_masked_sub_pixel_variance64x128_ssse3,
-               &vpx_masked_sub_pixel_variance64x128_c),
+        make_tuple(&vpx_masked_sub_pixel_variance128x128_ssse3,
+                   &vpx_masked_sub_pixel_variance128x128_c),
+        make_tuple(&vpx_masked_sub_pixel_variance128x64_ssse3,
+                   &vpx_masked_sub_pixel_variance128x64_c),
+        make_tuple(&vpx_masked_sub_pixel_variance64x128_ssse3,
+                   &vpx_masked_sub_pixel_variance64x128_c),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_masked_sub_pixel_variance64x64_ssse3,
-               &vpx_masked_sub_pixel_variance64x64_c),
-    make_tuple(&vpx_masked_sub_pixel_variance64x32_ssse3,
-               &vpx_masked_sub_pixel_variance64x32_c),
-    make_tuple(&vpx_masked_sub_pixel_variance32x64_ssse3,
-               &vpx_masked_sub_pixel_variance32x64_c),
-    make_tuple(&vpx_masked_sub_pixel_variance32x32_ssse3,
-               &vpx_masked_sub_pixel_variance32x32_c),
-    make_tuple(&vpx_masked_sub_pixel_variance32x16_ssse3,
-               &vpx_masked_sub_pixel_variance32x16_c),
-    make_tuple(&vpx_masked_sub_pixel_variance16x32_ssse3,
-               &vpx_masked_sub_pixel_variance16x32_c),
-    make_tuple(&vpx_masked_sub_pixel_variance16x16_ssse3,
-               &vpx_masked_sub_pixel_variance16x16_c),
-    make_tuple(&vpx_masked_sub_pixel_variance16x8_ssse3,
-               &vpx_masked_sub_pixel_variance16x8_c),
-    make_tuple(&vpx_masked_sub_pixel_variance8x16_ssse3,
-               &vpx_masked_sub_pixel_variance8x16_c),
-    make_tuple(&vpx_masked_sub_pixel_variance8x8_ssse3,
-               &vpx_masked_sub_pixel_variance8x8_c),
-    make_tuple(&vpx_masked_sub_pixel_variance8x4_ssse3,
-               &vpx_masked_sub_pixel_variance8x4_c),
-    make_tuple(&vpx_masked_sub_pixel_variance4x8_ssse3,
-               &vpx_masked_sub_pixel_variance4x8_c),
-    make_tuple(&vpx_masked_sub_pixel_variance4x4_ssse3,
-               &vpx_masked_sub_pixel_variance4x4_c)));
+        make_tuple(&vpx_masked_sub_pixel_variance64x64_ssse3,
+                   &vpx_masked_sub_pixel_variance64x64_c),
+        make_tuple(&vpx_masked_sub_pixel_variance64x32_ssse3,
+                   &vpx_masked_sub_pixel_variance64x32_c),
+        make_tuple(&vpx_masked_sub_pixel_variance32x64_ssse3,
+                   &vpx_masked_sub_pixel_variance32x64_c),
+        make_tuple(&vpx_masked_sub_pixel_variance32x32_ssse3,
+                   &vpx_masked_sub_pixel_variance32x32_c),
+        make_tuple(&vpx_masked_sub_pixel_variance32x16_ssse3,
+                   &vpx_masked_sub_pixel_variance32x16_c),
+        make_tuple(&vpx_masked_sub_pixel_variance16x32_ssse3,
+                   &vpx_masked_sub_pixel_variance16x32_c),
+        make_tuple(&vpx_masked_sub_pixel_variance16x16_ssse3,
+                   &vpx_masked_sub_pixel_variance16x16_c),
+        make_tuple(&vpx_masked_sub_pixel_variance16x8_ssse3,
+                   &vpx_masked_sub_pixel_variance16x8_c),
+        make_tuple(&vpx_masked_sub_pixel_variance8x16_ssse3,
+                   &vpx_masked_sub_pixel_variance8x16_c),
+        make_tuple(&vpx_masked_sub_pixel_variance8x8_ssse3,
+                   &vpx_masked_sub_pixel_variance8x8_c),
+        make_tuple(&vpx_masked_sub_pixel_variance8x4_ssse3,
+                   &vpx_masked_sub_pixel_variance8x4_c),
+        make_tuple(&vpx_masked_sub_pixel_variance4x8_ssse3,
+                   &vpx_masked_sub_pixel_variance4x8_c),
+        make_tuple(&vpx_masked_sub_pixel_variance4x4_ssse3,
+                   &vpx_masked_sub_pixel_variance4x4_c)));
 
 #if CONFIG_VP9_HIGHBITDEPTH
 INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, HighbdMaskedVarianceTest,
-  ::testing::Values(
+    SSSE3_C_COMPARE, HighbdMaskedVarianceTest,
+    ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_variance128x128_ssse3,
-               &vpx_highbd_masked_variance128x128_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance128x64_ssse3,
-               &vpx_highbd_masked_variance128x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance64x128_ssse3,
-               &vpx_highbd_masked_variance64x128_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance128x128_ssse3,
+                   &vpx_highbd_masked_variance128x128_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance128x64_ssse3,
+                   &vpx_highbd_masked_variance128x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance64x128_ssse3,
+                   &vpx_highbd_masked_variance64x128_c, VPX_BITS_8),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_variance64x64_ssse3,
-               &vpx_highbd_masked_variance64x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance64x32_ssse3,
-               &vpx_highbd_masked_variance64x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance32x64_ssse3,
-               &vpx_highbd_masked_variance32x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance32x32_ssse3,
-               &vpx_highbd_masked_variance32x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance32x16_ssse3,
-               &vpx_highbd_masked_variance32x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance16x32_ssse3,
-               &vpx_highbd_masked_variance16x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance16x16_ssse3,
-               &vpx_highbd_masked_variance16x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance16x8_ssse3,
-               &vpx_highbd_masked_variance16x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance8x16_ssse3,
-               &vpx_highbd_masked_variance8x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance8x8_ssse3,
-               &vpx_highbd_masked_variance8x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance8x4_ssse3,
-               &vpx_highbd_masked_variance8x4_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance4x8_ssse3,
-               &vpx_highbd_masked_variance4x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_variance4x4_ssse3,
-               &vpx_highbd_masked_variance4x4_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance64x64_ssse3,
+                   &vpx_highbd_masked_variance64x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance64x32_ssse3,
+                   &vpx_highbd_masked_variance64x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance32x64_ssse3,
+                   &vpx_highbd_masked_variance32x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance32x32_ssse3,
+                   &vpx_highbd_masked_variance32x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance32x16_ssse3,
+                   &vpx_highbd_masked_variance32x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance16x32_ssse3,
+                   &vpx_highbd_masked_variance16x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance16x16_ssse3,
+                   &vpx_highbd_masked_variance16x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance16x8_ssse3,
+                   &vpx_highbd_masked_variance16x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance8x16_ssse3,
+                   &vpx_highbd_masked_variance8x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance8x8_ssse3,
+                   &vpx_highbd_masked_variance8x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance8x4_ssse3,
+                   &vpx_highbd_masked_variance8x4_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance4x8_ssse3,
+                   &vpx_highbd_masked_variance4x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_variance4x4_ssse3,
+                   &vpx_highbd_masked_variance4x4_c, VPX_BITS_8),
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_10_masked_variance128x128_ssse3,
-               &vpx_highbd_10_masked_variance128x128_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance128x64_ssse3,
-               &vpx_highbd_10_masked_variance128x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance64x128_ssse3,
-               &vpx_highbd_10_masked_variance64x128_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance128x128_ssse3,
+                   &vpx_highbd_10_masked_variance128x128_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance128x64_ssse3,
+                   &vpx_highbd_10_masked_variance128x64_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance64x128_ssse3,
+                   &vpx_highbd_10_masked_variance64x128_c, VPX_BITS_10),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_10_masked_variance64x64_ssse3,
-               &vpx_highbd_10_masked_variance64x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance64x32_ssse3,
-               &vpx_highbd_10_masked_variance64x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance32x64_ssse3,
-               &vpx_highbd_10_masked_variance32x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance32x32_ssse3,
-               &vpx_highbd_10_masked_variance32x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance32x16_ssse3,
-               &vpx_highbd_10_masked_variance32x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance16x32_ssse3,
-               &vpx_highbd_10_masked_variance16x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance16x16_ssse3,
-               &vpx_highbd_10_masked_variance16x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance16x8_ssse3,
-               &vpx_highbd_10_masked_variance16x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance8x16_ssse3,
-               &vpx_highbd_10_masked_variance8x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance8x8_ssse3,
-               &vpx_highbd_10_masked_variance8x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance8x4_ssse3,
-               &vpx_highbd_10_masked_variance8x4_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance4x8_ssse3,
-               &vpx_highbd_10_masked_variance4x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_variance4x4_ssse3,
-               &vpx_highbd_10_masked_variance4x4_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance64x64_ssse3,
+                   &vpx_highbd_10_masked_variance64x64_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance64x32_ssse3,
+                   &vpx_highbd_10_masked_variance64x32_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance32x64_ssse3,
+                   &vpx_highbd_10_masked_variance32x64_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance32x32_ssse3,
+                   &vpx_highbd_10_masked_variance32x32_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance32x16_ssse3,
+                   &vpx_highbd_10_masked_variance32x16_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance16x32_ssse3,
+                   &vpx_highbd_10_masked_variance16x32_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance16x16_ssse3,
+                   &vpx_highbd_10_masked_variance16x16_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance16x8_ssse3,
+                   &vpx_highbd_10_masked_variance16x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance8x16_ssse3,
+                   &vpx_highbd_10_masked_variance8x16_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance8x8_ssse3,
+                   &vpx_highbd_10_masked_variance8x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance8x4_ssse3,
+                   &vpx_highbd_10_masked_variance8x4_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance4x8_ssse3,
+                   &vpx_highbd_10_masked_variance4x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_variance4x4_ssse3,
+                   &vpx_highbd_10_masked_variance4x4_c, VPX_BITS_10),
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_12_masked_variance128x128_ssse3,
-               &vpx_highbd_12_masked_variance128x128_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance128x64_ssse3,
-               &vpx_highbd_12_masked_variance128x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance64x128_ssse3,
-               &vpx_highbd_12_masked_variance64x128_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance128x128_ssse3,
+                   &vpx_highbd_12_masked_variance128x128_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance128x64_ssse3,
+                   &vpx_highbd_12_masked_variance128x64_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance64x128_ssse3,
+                   &vpx_highbd_12_masked_variance64x128_c, VPX_BITS_12),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_12_masked_variance64x64_ssse3,
-               &vpx_highbd_12_masked_variance64x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance64x32_ssse3,
-               &vpx_highbd_12_masked_variance64x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance32x64_ssse3,
-               &vpx_highbd_12_masked_variance32x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance32x32_ssse3,
-               &vpx_highbd_12_masked_variance32x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance32x16_ssse3,
-               &vpx_highbd_12_masked_variance32x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance16x32_ssse3,
-               &vpx_highbd_12_masked_variance16x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance16x16_ssse3,
-               &vpx_highbd_12_masked_variance16x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance16x8_ssse3,
-               &vpx_highbd_12_masked_variance16x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance8x16_ssse3,
-               &vpx_highbd_12_masked_variance8x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance8x8_ssse3,
-               &vpx_highbd_12_masked_variance8x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance8x4_ssse3,
-               &vpx_highbd_12_masked_variance8x4_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance4x8_ssse3,
-               &vpx_highbd_12_masked_variance4x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_variance4x4_ssse3,
-               &vpx_highbd_12_masked_variance4x4_c, VPX_BITS_12)));
+        make_tuple(&vpx_highbd_12_masked_variance64x64_ssse3,
+                   &vpx_highbd_12_masked_variance64x64_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance64x32_ssse3,
+                   &vpx_highbd_12_masked_variance64x32_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance32x64_ssse3,
+                   &vpx_highbd_12_masked_variance32x64_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance32x32_ssse3,
+                   &vpx_highbd_12_masked_variance32x32_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance32x16_ssse3,
+                   &vpx_highbd_12_masked_variance32x16_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance16x32_ssse3,
+                   &vpx_highbd_12_masked_variance16x32_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance16x16_ssse3,
+                   &vpx_highbd_12_masked_variance16x16_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance16x8_ssse3,
+                   &vpx_highbd_12_masked_variance16x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance8x16_ssse3,
+                   &vpx_highbd_12_masked_variance8x16_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance8x8_ssse3,
+                   &vpx_highbd_12_masked_variance8x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance8x4_ssse3,
+                   &vpx_highbd_12_masked_variance8x4_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance4x8_ssse3,
+                   &vpx_highbd_12_masked_variance4x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_variance4x4_ssse3,
+                   &vpx_highbd_12_masked_variance4x4_c, VPX_BITS_12)));
 
 INSTANTIATE_TEST_CASE_P(
-  SSSE3_C_COMPARE, HighbdMaskedSubPixelVarianceTest,
-  ::testing::Values(
+    SSSE3_C_COMPARE, HighbdMaskedSubPixelVarianceTest,
+    ::testing::Values(
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance128x128_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance128x128_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance128x64_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance128x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance64x128_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance64x128_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance128x128_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance128x128_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance128x64_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance128x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance64x128_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance64x128_c, VPX_BITS_8),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance64x64_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance64x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance64x32_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance64x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance32x64_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance32x64_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance32x32_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance32x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance32x16_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance32x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance16x32_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance16x32_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance16x16_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance16x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance16x8_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance16x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance8x16_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance8x16_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance8x8_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance8x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance8x4_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance8x4_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance4x8_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance4x8_c, VPX_BITS_8),
-    make_tuple(&vpx_highbd_masked_sub_pixel_variance4x4_ssse3,
-               &vpx_highbd_masked_sub_pixel_variance4x4_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance64x64_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance64x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance64x32_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance64x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance32x64_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance32x64_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance32x32_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance32x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance32x16_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance32x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance16x32_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance16x32_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance16x16_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance16x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance16x8_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance16x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance8x16_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance8x16_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance8x8_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance8x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance8x4_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance8x4_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance4x8_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance4x8_c, VPX_BITS_8),
+        make_tuple(&vpx_highbd_masked_sub_pixel_variance4x4_ssse3,
+                   &vpx_highbd_masked_sub_pixel_variance4x4_c, VPX_BITS_8),
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x128_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance128x128_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x64_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance128x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x128_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance64x128_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x128_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance128x128_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance128x64_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance128x64_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x128_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance64x128_c,
+                   VPX_BITS_10),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x64_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance64x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x32_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance64x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x64_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance32x64_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x32_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance32x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x16_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance32x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x32_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance16x32_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x16_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance16x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x8_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance16x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x16_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance8x16_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x8_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance8x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x4_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance8x4_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x8_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance4x8_c, VPX_BITS_10),
-    make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x4_ssse3,
-               &vpx_highbd_10_masked_sub_pixel_variance4x4_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x64_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance64x64_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance64x32_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance64x32_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x64_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance32x64_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x32_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance32x32_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance32x16_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance32x16_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x32_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance16x32_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x16_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance16x16_c,
+                   VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance16x8_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance16x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x16_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance8x16_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x8_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance8x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance8x4_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance8x4_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x8_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance4x8_c, VPX_BITS_10),
+        make_tuple(&vpx_highbd_10_masked_sub_pixel_variance4x4_ssse3,
+                   &vpx_highbd_10_masked_sub_pixel_variance4x4_c, VPX_BITS_10),
 #if CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x128_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance128x128_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x64_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance128x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x128_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance64x128_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x128_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance128x128_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance128x64_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance128x64_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x128_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance64x128_c,
+                   VPX_BITS_12),
 #endif  // CONFIG_EXT_PARTITION
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x64_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance64x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x32_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance64x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x64_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance32x64_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x32_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance32x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x16_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance32x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x32_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance16x32_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x16_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance16x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x8_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance16x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x16_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance8x16_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x8_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance8x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x4_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance8x4_c, VPX_BITS_12) ,
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x8_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance4x8_c, VPX_BITS_12),
-    make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x4_ssse3,
-               &vpx_highbd_12_masked_sub_pixel_variance4x4_c, VPX_BITS_12)));
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x64_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance64x64_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance64x32_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance64x32_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x64_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance32x64_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x32_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance32x32_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance32x16_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance32x16_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x32_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance16x32_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x16_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance16x16_c,
+                   VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance16x8_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance16x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x16_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance8x16_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x8_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance8x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance8x4_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance8x4_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x8_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance4x8_c, VPX_BITS_12),
+        make_tuple(&vpx_highbd_12_masked_sub_pixel_variance4x4_ssse3,
+                   &vpx_highbd_12_masked_sub_pixel_variance4x4_c,
+                   VPX_BITS_12)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #endif  // HAVE_SSSE3
diff --git a/test/md5_helper.h b/test/md5_helper.h
index 742cf0b7..ef310a2 100644
--- a/test/md5_helper.h
+++ b/test/md5_helper.h
@@ -17,9 +17,7 @@
 namespace libvpx_test {
 class MD5 {
  public:
-  MD5() {
-    MD5Init(&md5_);
-  }
+  MD5() { MD5Init(&md5_); }
 
   void Add(const vpx_image_t *img) {
     for (int plane = 0; plane < 3; ++plane) {
@@ -30,10 +28,13 @@
       // This works only for chroma_shift of 0 and 1.
       const int bytes_per_sample =
           (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
-      const int h = plane ? (img->d_h + img->y_chroma_shift) >>
-                    img->y_chroma_shift : img->d_h;
-      const int w = (plane ? (img->d_w + img->x_chroma_shift) >>
-                     img->x_chroma_shift : img->d_w) * bytes_per_sample;
+      const int h =
+          plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
+                : img->d_h;
+      const int w =
+          (plane ? (img->d_w + img->x_chroma_shift) >> img->x_chroma_shift
+                 : img->d_w) *
+          bytes_per_sample;
 
       for (int y = 0; y < h; ++y) {
         MD5Update(&md5_, buf, w);
@@ -56,8 +57,8 @@
 
     MD5Final(tmp, &ctx_tmp);
     for (int i = 0; i < 16; i++) {
-      res_[i * 2 + 0]  = hex[tmp[i] >> 4];
-      res_[i * 2 + 1]  = hex[tmp[i] & 0xf];
+      res_[i * 2 + 0] = hex[tmp[i] >> 4];
+      res_[i * 2 + 1] = hex[tmp[i] & 0xf];
     }
     res_[32] = 0;
 
diff --git a/test/minmax_test.cc b/test/minmax_test.cc
index dbe4342..e51c9fd 100644
--- a/test/minmax_test.cc
+++ b/test/minmax_test.cc
@@ -23,9 +23,8 @@
 
 using ::libvpx_test::ACMRandom;
 
-typedef void (*MinMaxFunc)(const uint8_t *a, int a_stride,
-                           const uint8_t *b, int b_stride,
-                           int *min, int *max);
+typedef void (*MinMaxFunc)(const uint8_t *a, int a_stride, const uint8_t *b,
+                           int b_stride, int *min, int *max);
 
 class MinMaxTest : public ::testing::TestWithParam<MinMaxFunc> {
  public:
@@ -39,9 +38,8 @@
   ACMRandom rnd_;
 };
 
-void reference_minmax(const uint8_t *a, int a_stride,
-                      const uint8_t *b, int b_stride,
-                      int *min_ret, int *max_ret) {
+void reference_minmax(const uint8_t *a, int a_stride, const uint8_t *b,
+                      int b_stride, int *min_ret, int *max_ret) {
   int min = 255;
   int max = 0;
   for (int i = 0; i < 8; i++) {
@@ -110,9 +108,9 @@
       reference_minmax(a, a_stride, b, b_stride, &min_ref, &max_ref);
       ASM_REGISTER_STATE_CHECK(mm_func_(a, a_stride, b, b_stride, &min, &max));
       EXPECT_EQ(max_ref, max) << "when a_stride = " << a_stride
-                              << " and b_stride = " << b_stride;;
+                              << " and b_stride = " << b_stride;
       EXPECT_EQ(min_ref, min) << "when a_stride = " << a_stride
-                              << " and b_stride = " << b_stride;;
+                              << " and b_stride = " << b_stride;
     }
   }
 }
diff --git a/test/obmc_sad_test.cc b/test/obmc_sad_test.cc
index beb7106..de80373 100644
--- a/test/obmc_sad_test.cc
+++ b/test/obmc_sad_test.cc
@@ -41,10 +41,10 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     const int pre_stride = rng_(MAX_SB_SIZE + 1);
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = rng_.Rand8();
       wsrc[i] = rng_.Rand8() * rng_(kMaskMax * kMaskMax + 1);
       mask[i] = rng_(kMaskMax * kMaskMax + 1);
@@ -53,7 +53,7 @@
     const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask);
     unsigned int tst_res;
     ASM_REGISTER_STATE_CHECK(tst_res =
-        params_.tst_func(pre, pre_stride, wsrc, mask));
+                                 params_.tst_func(pre, pre_stride, wsrc, mask));
 
     ASSERT_EQ(ref_res, tst_res);
   }
@@ -64,10 +64,10 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < MAX_SB_SIZE && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
     const int pre_stride = iter;
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = UINT8_MAX;
       wsrc[i] = UINT8_MAX * kMaskMax * kMaskMax;
       mask[i] = kMaskMax * kMaskMax;
@@ -76,7 +76,7 @@
     const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask);
     unsigned int tst_res;
     ASM_REGISTER_STATE_CHECK(tst_res =
-        params_.tst_func(pre, pre_stride, wsrc, mask));
+                                 params_.tst_func(pre, pre_stride, wsrc, mask));
 
     ASSERT_EQ(ref_res, tst_res);
   }
@@ -120,20 +120,21 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     const int pre_stride = rng_(MAX_SB_SIZE + 1);
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
-      pre[i] = rng_(1<<12);
-      wsrc[i] = rng_(1<<12) * rng_(kMaskMax * kMaskMax + 1);
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
+      pre[i] = rng_(1 << 12);
+      wsrc[i] = rng_(1 << 12) * rng_(kMaskMax * kMaskMax + 1);
       mask[i] = rng_(kMaskMax * kMaskMax + 1);
     }
 
     const unsigned int ref_res =
         params_.ref_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask);
     unsigned int tst_res;
-    ASM_REGISTER_STATE_CHECK(tst_res =
-        params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
+    ASM_REGISTER_STATE_CHECK(
+        tst_res =
+            params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
 
     ASSERT_EQ(ref_res, tst_res);
   }
@@ -144,10 +145,10 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < MAX_SB_SIZE && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
     const int pre_stride = iter;
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = (1 << 12) - 1;
       wsrc[i] = ((1 << 12) - 1) * kMaskMax * kMaskMax;
       mask[i] = kMaskMax * kMaskMax;
@@ -156,8 +157,9 @@
     const unsigned int ref_res =
         params_.ref_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask);
     unsigned int tst_res;
-    ASM_REGISTER_STATE_CHECK(tst_res =
-        params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
+    ASM_REGISTER_STATE_CHECK(
+        tst_res =
+            params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask));
 
     ASSERT_EQ(ref_res, tst_res);
   }
diff --git a/test/obmc_variance_test.cc b/test/obmc_variance_test.cc
index b7de9ed..2bddcd2 100644
--- a/test/obmc_variance_test.cc
+++ b/test/obmc_variance_test.cc
@@ -44,18 +44,18 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     const int pre_stride = this->rng_(MAX_SB_SIZE + 1);
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = this->rng_.Rand8();
       wsrc[i] = this->rng_.Rand8() * this->rng_(kMaskMax * kMaskMax + 1);
       mask[i] = this->rng_(kMaskMax * kMaskMax + 1);
     }
 
     unsigned int ref_sse, tst_sse;
-    const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask,
-                                                  &ref_sse);
+    const unsigned int ref_res =
+        params_.ref_func(pre, pre_stride, wsrc, mask, &ref_sse);
     unsigned int tst_res;
     ASM_REGISTER_STATE_CHECK(
         tst_res = params_.tst_func(pre, pre_stride, wsrc, mask, &tst_sse));
@@ -70,18 +70,18 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < MAX_SB_SIZE && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
     const int pre_stride = iter;
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = UINT8_MAX;
       wsrc[i] = UINT8_MAX * kMaskMax * kMaskMax;
       mask[i] = kMaskMax * kMaskMax;
     }
 
     unsigned int ref_sse, tst_sse;
-    const unsigned int ref_res = params_.ref_func(pre, pre_stride, wsrc, mask,
-                                                  &ref_sse);
+    const unsigned int ref_res =
+        params_.ref_func(pre, pre_stride, wsrc, mask, &ref_sse);
     unsigned int tst_res;
     ASM_REGISTER_STATE_CHECK(
         tst_res = params_.tst_func(pre, pre_stride, wsrc, mask, &tst_sse));
@@ -129,10 +129,10 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     const int pre_stride = this->rng_(MAX_SB_SIZE + 1);
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = this->rng_(1 << params_.bit_depth);
       wsrc[i] = this->rng_(1 << params_.bit_depth) *
                 this->rng_(kMaskMax * kMaskMax + 1);
@@ -140,13 +140,12 @@
     }
 
     unsigned int ref_sse, tst_sse;
-    const unsigned int ref_res = params_.ref_func(CONVERT_TO_BYTEPTR(pre),
-                                                  pre_stride,
-                                                  wsrc, mask, &ref_sse);
+    const unsigned int ref_res = params_.ref_func(
+        CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask, &ref_sse);
     unsigned int tst_res;
-    ASM_REGISTER_STATE_CHECK(
-        tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre),
-                                   pre_stride, wsrc, mask, &tst_sse));
+    ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre),
+                                                        pre_stride, wsrc, mask,
+                                                        &tst_sse));
 
     ASSERT_EQ(ref_res, tst_res);
     ASSERT_EQ(ref_sse, tst_sse);
@@ -158,23 +157,22 @@
   DECLARE_ALIGNED(32, int32_t, wsrc[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int32_t, mask[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < MAX_SB_SIZE && !HasFatalFailure() ; ++iter) {
+  for (int iter = 0; iter < MAX_SB_SIZE && !HasFatalFailure(); ++iter) {
     const int pre_stride = iter;
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       pre[i] = (1 << params_.bit_depth) - 1;
       wsrc[i] = ((1 << params_.bit_depth) - 1) * kMaskMax * kMaskMax;
       mask[i] = kMaskMax * kMaskMax;
     }
 
     unsigned int ref_sse, tst_sse;
-    const unsigned int ref_res = params_.ref_func(CONVERT_TO_BYTEPTR(pre),
-                                                  pre_stride,
-                                                  wsrc, mask, &ref_sse);
+    const unsigned int ref_res = params_.ref_func(
+        CONVERT_TO_BYTEPTR(pre), pre_stride, wsrc, mask, &ref_sse);
     unsigned int tst_res;
-    ASM_REGISTER_STATE_CHECK(
-        tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre), pre_stride,
-                                   wsrc, mask, &tst_sse));
+    ASM_REGISTER_STATE_CHECK(tst_res = params_.tst_func(CONVERT_TO_BYTEPTR(pre),
+                                                        pre_stride, wsrc, mask,
+                                                        &tst_sse));
 
     ASSERT_EQ(ref_res, tst_res);
     ASSERT_EQ(ref_sse, tst_sse);
@@ -205,18 +203,18 @@
             vpx_highbd_obmc_variance16x32_sse4_1, 8),
   TestFuncs(vpx_highbd_obmc_variance16x16_c,
             vpx_highbd_obmc_variance16x16_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance16x8_c,
-            vpx_highbd_obmc_variance16x8_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance8x16_c,
-            vpx_highbd_obmc_variance8x16_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance8x8_c,
-            vpx_highbd_obmc_variance8x8_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance8x4_c,
-            vpx_highbd_obmc_variance8x4_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance4x8_c,
-            vpx_highbd_obmc_variance4x8_sse4_1, 8),
-  TestFuncs(vpx_highbd_obmc_variance4x4_c,
-            vpx_highbd_obmc_variance4x4_sse4_1, 8),
+  TestFuncs(vpx_highbd_obmc_variance16x8_c, vpx_highbd_obmc_variance16x8_sse4_1,
+            8),
+  TestFuncs(vpx_highbd_obmc_variance8x16_c, vpx_highbd_obmc_variance8x16_sse4_1,
+            8),
+  TestFuncs(vpx_highbd_obmc_variance8x8_c, vpx_highbd_obmc_variance8x8_sse4_1,
+            8),
+  TestFuncs(vpx_highbd_obmc_variance8x4_c, vpx_highbd_obmc_variance8x4_sse4_1,
+            8),
+  TestFuncs(vpx_highbd_obmc_variance4x8_c, vpx_highbd_obmc_variance4x8_sse4_1,
+            8),
+  TestFuncs(vpx_highbd_obmc_variance4x4_c, vpx_highbd_obmc_variance4x4_sse4_1,
+            8),
 #if CONFIG_EXT_PARTITION
   TestFuncs(vpx_highbd_10_obmc_variance128x128_c,
             vpx_highbd_10_obmc_variance128x128_sse4_1, 10),
diff --git a/test/partial_idct_test.cc b/test/partial_idct_test.cc
index 461fa9c..439888d 100644
--- a/test/partial_idct_test.cc
+++ b/test/partial_idct_test.cc
@@ -29,10 +29,8 @@
 namespace {
 typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
 typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
-typedef std::tr1::tuple<FwdTxfmFunc,
-                        InvTxfmFunc,
-                        InvTxfmFunc,
-                        TX_SIZE, int> PartialInvTxfmParam;
+typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, InvTxfmFunc, TX_SIZE, int>
+    PartialInvTxfmParam;
 const int kMaxNumCoeffs = 1024;
 class PartialIDctTest : public ::testing::TestWithParam<PartialInvTxfmParam> {
  public:
@@ -41,7 +39,7 @@
     ftxfm_ = GET_PARAM(0);
     full_itxfm_ = GET_PARAM(1);
     partial_itxfm_ = GET_PARAM(2);
-    tx_size_  = GET_PARAM(3);
+    tx_size_ = GET_PARAM(3);
     last_nonzero_ = GET_PARAM(4);
   }
 
@@ -59,21 +57,11 @@
   ACMRandom rnd(ACMRandom::DeterministicSeed());
   int size;
   switch (tx_size_) {
-    case TX_4X4:
-      size = 4;
-      break;
-    case TX_8X8:
-      size = 8;
-      break;
-    case TX_16X16:
-      size = 16;
-      break;
-    case TX_32X32:
-      size = 32;
-      break;
-    default:
-      FAIL() << "Wrong Size!";
-      break;
+    case TX_4X4: size = 4; break;
+    case TX_8X8: size = 8; break;
+    case TX_16X16: size = 16; break;
+    case TX_32X32: size = 32; break;
+    default: FAIL() << "Wrong Size!"; break;
   }
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@@ -99,11 +87,9 @@
     for (int i = 0; i < count_test_block; ++i) {
       // Initialize a test block with input range [-255, 255].
       if (i == 0) {
-        for (int j = 0; j < block_size; ++j)
-          input_extreme_block[j] = 255;
+        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = 255;
       } else if (i == 1) {
-        for (int j = 0; j < block_size; ++j)
-          input_extreme_block[j] = -255;
+        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = -255;
       } else {
         for (int j = 0; j < block_size; ++j) {
           input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255;
@@ -115,8 +101,8 @@
       // quantization with maximum allowed step sizes
       test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336;
       for (int j = 1; j < last_nonzero_; ++j)
-        test_coef_block1[vp10_default_scan_orders[tx_size_].scan[j]]
-                         = (output_ref_block[j] / 1828) * 1828;
+        test_coef_block1[vp10_default_scan_orders[tx_size_].scan[j]] =
+            (output_ref_block[j] / 1828) * 1828;
     }
 
     ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size));
@@ -125,8 +111,7 @@
     for (int j = 0; j < block_size; ++j) {
       const int diff = dst1[j] - dst2[j];
       const int error = diff * diff;
-      if (max_error < error)
-        max_error = error;
+      if (max_error < error) max_error = error;
     }
   }
 
@@ -138,21 +123,11 @@
   ACMRandom rnd(ACMRandom::DeterministicSeed());
   int size;
   switch (tx_size_) {
-    case TX_4X4:
-      size = 4;
-      break;
-    case TX_8X8:
-      size = 8;
-      break;
-    case TX_16X16:
-      size = 16;
-      break;
-    case TX_32X32:
-      size = 32;
-      break;
-    default:
-      FAIL() << "Wrong Size!";
-      break;
+    case TX_4X4: size = 4; break;
+    case TX_8X8: size = 8; break;
+    case TX_16X16: size = 16; break;
+    case TX_32X32: size = 32; break;
+    default: FAIL() << "Wrong Size!"; break;
   }
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@@ -189,8 +164,7 @@
     for (int j = 0; j < block_size; ++j) {
       const int diff = dst1[j] - dst2[j];
       const int error = diff * diff;
-      if (max_error < error)
-        max_error = error;
+      if (max_error < error) max_error = error;
     }
   }
 
@@ -201,143 +175,82 @@
 
 INSTANTIATE_TEST_CASE_P(
     C, PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_34_add_c,
-                   TX_32X32, 34),
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_1_add_c,
-                   TX_32X32, 1),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_10_add_c,
-                   TX_16X16, 10),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_1_add_c,
-                   TX_16X16, 1),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_12_add_c,
-                   TX_8X8, 12),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_1_add_c,
-                   TX_8X8, 1),
-        make_tuple(&vpx_fdct4x4_c,
-                   &vpx_idct4x4_16_add_c,
-                   &vpx_idct4x4_1_add_c,
-                   TX_4X4, 1)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_34_add_c, TX_32X32, 34),
+                      make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_1_add_c, TX_32X32, 1),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_10_add_c, TX_16X16, 10),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_1_add_c, TX_16X16, 1),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_12_add_c, TX_8X8, 12),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_1_add_c, TX_8X8, 1),
+                      make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
+                                 &vpx_idct4x4_1_add_c, TX_4X4, 1)));
 
 #if HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     NEON, PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_1_add_neon,
-                   TX_32X32, 1),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_10_add_neon,
-                   TX_16X16, 10),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_1_add_neon,
-                   TX_16X16, 1),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_12_add_neon,
-                   TX_8X8, 12),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_1_add_neon,
-                   TX_8X8, 1),
-        make_tuple(&vpx_fdct4x4_c,
-                   &vpx_idct4x4_16_add_c,
-                   &vpx_idct4x4_1_add_neon,
-                   TX_4X4, 1)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_1_add_neon, TX_32X32, 1),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_10_add_neon, TX_16X16, 10),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_1_add_neon, TX_16X16, 1),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_12_add_neon, TX_8X8, 12),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_1_add_neon, TX_8X8, 1),
+                      make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
+                                 &vpx_idct4x4_1_add_neon, TX_4X4, 1)));
 #endif  // HAVE_NEON && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 #if HAVE_SSE2 && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSE2, PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_34_add_sse2,
-                   TX_32X32, 34),
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_1_add_sse2,
-                   TX_32X32, 1),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_10_add_sse2,
-                   TX_16X16, 10),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_1_add_sse2,
-                   TX_16X16, 1),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_12_add_sse2,
-                   TX_8X8, 12),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_1_add_sse2,
-                   TX_8X8, 1),
-        make_tuple(&vpx_fdct4x4_c,
-                   &vpx_idct4x4_16_add_c,
-                   &vpx_idct4x4_1_add_sse2,
-                   TX_4X4, 1)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_34_add_sse2, TX_32X32, 34),
+                      make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_1_add_sse2, TX_32X32, 1),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_10_add_sse2, TX_16X16, 10),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_1_add_sse2, TX_16X16, 1),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_12_add_sse2, TX_8X8, 12),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_1_add_sse2, TX_8X8, 1),
+                      make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
+                                 &vpx_idct4x4_1_add_sse2, TX_4X4, 1)));
 #endif
 
-#if HAVE_SSSE3 && ARCH_X86_64 && \
-    !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+#if HAVE_SSSE3 && ARCH_X86_64 && !CONFIG_VP9_HIGHBITDEPTH && \
+    !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     SSSE3_64, PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_12_add_ssse3,
-                   TX_8X8, 12)));
+    ::testing::Values(make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_12_add_ssse3, TX_8X8, 12)));
 #endif
 
 #if HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     MSA, PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_34_add_msa,
-                   TX_32X32, 34),
-        make_tuple(&vpx_fdct32x32_c,
-                   &vpx_idct32x32_1024_add_c,
-                   &vpx_idct32x32_1_add_msa,
-                   TX_32X32, 1),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_10_add_msa,
-                   TX_16X16, 10),
-        make_tuple(&vpx_fdct16x16_c,
-                   &vpx_idct16x16_256_add_c,
-                   &vpx_idct16x16_1_add_msa,
-                   TX_16X16, 1),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_12_add_msa,
-                   TX_8X8, 10),
-        make_tuple(&vpx_fdct8x8_c,
-                   &vpx_idct8x8_64_add_c,
-                   &vpx_idct8x8_1_add_msa,
-                   TX_8X8, 1),
-        make_tuple(&vpx_fdct4x4_c,
-                   &vpx_idct4x4_16_add_c,
-                   &vpx_idct4x4_1_add_msa,
-                   TX_4X4, 1)));
+    ::testing::Values(make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_34_add_msa, TX_32X32, 34),
+                      make_tuple(&vpx_fdct32x32_c, &vpx_idct32x32_1024_add_c,
+                                 &vpx_idct32x32_1_add_msa, TX_32X32, 1),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_10_add_msa, TX_16X16, 10),
+                      make_tuple(&vpx_fdct16x16_c, &vpx_idct16x16_256_add_c,
+                                 &vpx_idct16x16_1_add_msa, TX_16X16, 1),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_12_add_msa, TX_8X8, 10),
+                      make_tuple(&vpx_fdct8x8_c, &vpx_idct8x8_64_add_c,
+                                 &vpx_idct8x8_1_add_msa, TX_8X8, 1),
+                      make_tuple(&vpx_fdct4x4_c, &vpx_idct4x4_16_add_c,
+                                 &vpx_idct4x4_1_add_msa, TX_4X4, 1)));
 #endif  // HAVE_MSA && !CONFIG_VP9_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
 }  // namespace
diff --git a/test/realtime_test.cc b/test/realtime_test.cc
index 24749e4..63f1ac3 100644
--- a/test/realtime_test.cc
+++ b/test/realtime_test.cc
@@ -23,8 +23,7 @@
     : public ::libvpx_test::EncoderTest,
       public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
-  RealtimeTest()
-      : EncoderTest(GET_PARAM(0)), frame_packets_(0) {}
+  RealtimeTest() : EncoderTest(GET_PARAM(0)), frame_packets_(0) {}
   virtual ~RealtimeTest() {}
 
   virtual void SetUp() {
diff --git a/test/reconintra_predictors_test.cc b/test/reconintra_predictors_test.cc
index 0ebfbae..7f9fc8d 100644
--- a/test/reconintra_predictors_test.cc
+++ b/test/reconintra_predictors_test.cc
@@ -132,10 +132,9 @@
   void DiffPred(int testNum) const {
     int i = 0;
     while (i < blockSize_ * blockSize_) {
-      EXPECT_EQ(predRef_[i], pred_[i])
-          << "Error at position: " << i << " "
-          << "Block size: " << blockSize_ << " "
-          << "Test number: " << testNum;
+      EXPECT_EQ(predRef_[i], pred_[i]) << "Error at position: " << i << " "
+                                       << "Block size: " << blockSize_ << " "
+                                       << "Test number: " << testNum;
       i += 1;
     }
   }
@@ -150,8 +149,8 @@
 };
 
 #if CONFIG_VP9_HIGHBITDEPTH
-class VP10HbdIntraPredOptimzTest :
-      public ::testing::TestWithParam<HbdPredParams> {
+class VP10HbdIntraPredOptimzTest
+    : public ::testing::TestWithParam<HbdPredParams> {
  public:
   virtual ~VP10HbdIntraPredOptimzTest() {}
   virtual void SetUp() {
@@ -227,11 +226,10 @@
   void DiffPred(int testNum) const {
     int i = 0;
     while (i < blockSize_ * blockSize_) {
-      EXPECT_EQ(predRef_[i], pred_[i])
-          << "Error at position: " << i << " "
-          << "Block size: " << blockSize_ << " "
-          << "Bit depth: " << bd_ << " "
-          << "Test number: " << testNum;
+      EXPECT_EQ(predRef_[i], pred_[i]) << "Error at position: " << i << " "
+                                       << "Block size: " << blockSize_ << " "
+                                       << "Bit depth: " << bd_ << " "
+                                       << "Test number: " << testNum;
       i += 1;
     }
   }
@@ -247,33 +245,21 @@
 };
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
-TEST_P(VP10IntraPredOptimzTest, BitExactCheck) {
-  RunTest();
-}
+TEST_P(VP10IntraPredOptimzTest, BitExactCheck) { RunTest(); }
 
 #if PREDICTORS_SPEED_TEST
-TEST_P(VP10IntraPredOptimzTest, SpeedCheckC) {
-  RunSpeedTestC();
-}
+TEST_P(VP10IntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
 
-TEST_P(VP10IntraPredOptimzTest, SpeedCheckSSE) {
-  RunSpeedTestSSE();
-}
+TEST_P(VP10IntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
 #endif
 
 #if CONFIG_VP9_HIGHBITDEPTH
-TEST_P(VP10HbdIntraPredOptimzTest, BitExactCheck) {
-  RunTest();
-}
+TEST_P(VP10HbdIntraPredOptimzTest, BitExactCheck) { RunTest(); }
 
 #if PREDICTORS_SPEED_TEST
-TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckC) {
-  RunSpeedTestC();
-}
+TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckC) { RunSpeedTestC(); }
 
-TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckSSE) {
-  RunSpeedTestSSE();
-}
+TEST_P(VP10HbdIntraPredOptimzTest, SpeedCheckSSE) { RunSpeedTestSSE(); }
 #endif  // PREDICTORS_SPEED_TEST
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
@@ -282,10 +268,8 @@
 const PredFuncMode kPredFuncMdArray[] = {
   make_tuple(vp10_dc_filter_predictor_c, vp10_dc_filter_predictor_sse4_1,
              DC_PRED),
-  make_tuple(vp10_v_filter_predictor_c, vp10_v_filter_predictor_sse4_1,
-             V_PRED),
-  make_tuple(vp10_h_filter_predictor_c, vp10_h_filter_predictor_sse4_1,
-             H_PRED),
+  make_tuple(vp10_v_filter_predictor_c, vp10_v_filter_predictor_sse4_1, V_PRED),
+  make_tuple(vp10_h_filter_predictor_c, vp10_h_filter_predictor_sse4_1, H_PRED),
   make_tuple(vp10_d45_filter_predictor_c, vp10_d45_filter_predictor_sse4_1,
              D45_PRED),
   make_tuple(vp10_d135_filter_predictor_c, vp10_d135_filter_predictor_sse4_1,
@@ -302,13 +286,12 @@
              TM_PRED),
 };
 
-const int kBlkSize[] = {4, 8, 16, 32};
+const int kBlkSize[] = { 4, 8, 16, 32 };
 
 INSTANTIATE_TEST_CASE_P(
     SSE4_1, VP10IntraPredOptimzTest,
-    ::testing::Combine(
-         ::testing::ValuesIn(kPredFuncMdArray),
-         ::testing::ValuesIn(kBlkSize)));
+    ::testing::Combine(::testing::ValuesIn(kPredFuncMdArray),
+                       ::testing::ValuesIn(kBlkSize)));
 
 #if CONFIG_VP9_HIGHBITDEPTH
 const HbdPredFuncMode kHbdPredFuncMdArray[] = {
@@ -334,14 +317,13 @@
              vp10_highbd_tm_filter_predictor_sse4_1, TM_PRED),
 };
 
-const int kBd[] = {10, 12};
+const int kBd[] = { 10, 12 };
 
 INSTANTIATE_TEST_CASE_P(
     SSE4_1, VP10HbdIntraPredOptimzTest,
-    ::testing::Combine(
-         ::testing::ValuesIn(kHbdPredFuncMdArray),
-         ::testing::ValuesIn(kBlkSize),
-         ::testing::ValuesIn(kBd)));
+    ::testing::Combine(::testing::ValuesIn(kHbdPredFuncMdArray),
+                       ::testing::ValuesIn(kBlkSize),
+                       ::testing::ValuesIn(kBd)));
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 }  // namespace
diff --git a/test/register_state_check.h b/test/register_state_check.h
index d6540f8..a6744b7 100644
--- a/test/register_state_check.h
+++ b/test/register_state_check.h
@@ -36,7 +36,7 @@
 #include <windows.h>
 #include <winnt.h>
 
-inline bool operator==(const M128A& lhs, const M128A& rhs) {
+inline bool operator==(const M128A &lhs, const M128A &rhs) {
   return (lhs.Low == rhs.Low && lhs.High == rhs.High);
 }
 
@@ -51,7 +51,7 @@
   ~RegisterStateCheck() { EXPECT_TRUE(Check()); }
 
  private:
-  static bool StoreRegisters(CONTEXT* const context) {
+  static bool StoreRegisters(CONTEXT *const context) {
     const HANDLE this_thread = GetCurrentThread();
     EXPECT_TRUE(this_thread != NULL);
     context->ContextFlags = CONTEXT_FLOATING_POINT;
@@ -66,8 +66,8 @@
     CONTEXT post_context;
     if (!StoreRegisters(&post_context)) return false;
 
-    const M128A* xmm_pre = &pre_context_.Xmm6;
-    const M128A* xmm_post = &post_context.Xmm6;
+    const M128A *xmm_pre = &pre_context_.Xmm6;
+    const M128A *xmm_post = &post_context.Xmm6;
     for (int i = 6; i <= 15; ++i) {
       EXPECT_EQ(*xmm_pre, *xmm_post) << "xmm" << i << " has been modified!";
       ++xmm_pre;
@@ -80,15 +80,16 @@
   CONTEXT pre_context_;
 };
 
-#define ASM_REGISTER_STATE_CHECK(statement) do {  \
-  libvpx_test::RegisterStateCheck reg_check;      \
-  statement;                                      \
-} while (false)
+#define ASM_REGISTER_STATE_CHECK(statement)    \
+  do {                                         \
+    libvpx_test::RegisterStateCheck reg_check; \
+    statement;                                 \
+  } while (false)
 
 }  // namespace libvpx_test
 
-#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && defined(CONFIG_VP10) \
-      && !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP10
+#elif defined(CONFIG_SHARED) && defined(HAVE_NEON_ASM) && \
+    defined(CONFIG_VP10) && !CONFIG_SHARED && HAVE_NEON_ASM && CONFIG_VP10
 
 extern "C" {
 // Save the d8-d15 registers into store.
@@ -117,8 +118,8 @@
     int64_t post_store[8];
     vpx_push_neon(post_store);
     for (int i = 0; i < 8; ++i) {
-      EXPECT_EQ(pre_store_[i], post_store[i]) << "d"
-          << i + 8 << " has been modified";
+      EXPECT_EQ(pre_store_[i], post_store[i]) << "d" << i + 8
+                                              << " has been modified";
     }
     return !testing::Test::HasNonfatalFailure();
   }
@@ -127,10 +128,11 @@
   int64_t pre_store_[8];
 };
 
-#define ASM_REGISTER_STATE_CHECK(statement) do {  \
-  libvpx_test::RegisterStateCheck reg_check;      \
-  statement;                                      \
-} while (false)
+#define ASM_REGISTER_STATE_CHECK(statement)    \
+  do {                                         \
+    libvpx_test::RegisterStateCheck reg_check; \
+    statement;                                 \
+  } while (false)
 
 }  // namespace libvpx_test
 
@@ -175,10 +177,11 @@
   uint16_t pre_fpu_env_[14];
 };
 
-#define API_REGISTER_STATE_CHECK(statement) do {  \
-  libvpx_test::RegisterStateCheckMMX reg_check;   \
-  ASM_REGISTER_STATE_CHECK(statement);            \
-} while (false)
+#define API_REGISTER_STATE_CHECK(statement)       \
+  do {                                            \
+    libvpx_test::RegisterStateCheckMMX reg_check; \
+    ASM_REGISTER_STATE_CHECK(statement);          \
+  } while (false)
 
 }  // namespace libvpx_test
 
diff --git a/test/resize_test.cc b/test/resize_test.cc
index 46a3b6e..3738a09 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -44,9 +44,9 @@
   header[1] = 'K';
   header[2] = 'I';
   header[3] = 'F';
-  mem_put_le16(header + 4,  0);                   /* version */
-  mem_put_le16(header + 6,  32);                  /* headersize */
-  mem_put_le32(header + 8,  0x30395056);          /* fourcc (vp9) */
+  mem_put_le16(header + 4, 0);                    /* version */
+  mem_put_le16(header + 6, 32);                   /* headersize */
+  mem_put_le32(header + 8, 0x30395056);           /* fourcc (vp9) */
   mem_put_le16(header + 12, cfg->g_w);            /* width */
   mem_put_le16(header + 14, cfg->g_h);            /* height */
   mem_put_le32(header + 16, cfg->g_timebase.den); /* rate */
@@ -68,8 +68,7 @@
   char header[12];
   vpx_codec_pts_t pts;
 
-  if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
-    return;
+  if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return;
 
   pts = pkt->data.frame.pts;
   mem_put_le32(header, static_cast<unsigned int>(pkt->data.frame.sz));
@@ -92,12 +91,9 @@
   unsigned int h;
 };
 
-void ScaleForFrameNumber(unsigned int frame,
-                         unsigned int initial_w,
-                         unsigned int initial_h,
-                         unsigned int *w,
-                         unsigned int *h,
-                         int flag_codec) {
+void ScaleForFrameNumber(unsigned int frame, unsigned int initial_w,
+                         unsigned int initial_h, unsigned int *w,
+                         unsigned int *h, int flag_codec) {
   if (frame < 10) {
     *w = initial_w;
     *h = initial_h;
@@ -219,7 +215,7 @@
     return;
   }
   if (frame < 250) {
-    *w = initial_w  / 2;
+    *w = initial_w / 2;
     *h = initial_h / 2;
     return;
   }
@@ -268,8 +264,9 @@
   }
 };
 
-class ResizeTest : public ::libvpx_test::EncoderTest,
-  public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
+class ResizeTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   ResizeTest() : EncoderTest(GET_PARAM(0)) {}
 
@@ -285,7 +282,7 @@
     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
   }
 
-  std::vector< FrameInfo > frame_info_list_;
+  std::vector<FrameInfo> frame_info_list_;
 };
 
 TEST_P(ResizeTest, TestExternalResizeWorks) {
@@ -299,12 +296,12 @@
     const unsigned int frame = static_cast<unsigned>(info->pts);
     unsigned int expected_w;
     unsigned int expected_h;
-    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight,
-                        &expected_w, &expected_h, 0);
-    EXPECT_EQ(expected_w, info->w)
-        << "Frame " << frame << " had unexpected width";
-    EXPECT_EQ(expected_h, info->h)
-        << "Frame " << frame << " had unexpected height";
+    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
+                        &expected_h, 0);
+    EXPECT_EQ(expected_w, info->w) << "Frame " << frame
+                                   << " had unexpected width";
+    EXPECT_EQ(expected_h, info->h) << "Frame " << frame
+                                   << " had unexpected height";
   }
 }
 
@@ -315,10 +312,7 @@
  protected:
 #if WRITE_COMPRESSED_STREAM
   ResizeInternalTest()
-      : ResizeTest(),
-        frame0_psnr_(0.0),
-        outfile_(NULL),
-        out_frames_(0) {}
+      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
 #else
   ResizeInternalTest() : ResizeTest(), frame0_psnr_(0.0) {}
 #endif
@@ -347,30 +341,29 @@
     if (change_config_) {
       int new_q = 60;
       if (video->frame() == 0) {
-        struct vpx_scaling_mode mode = {VP8E_ONETWO, VP8E_ONETWO};
+        struct vpx_scaling_mode mode = { VP8E_ONETWO, VP8E_ONETWO };
         encoder->Control(VP8E_SET_SCALEMODE, &mode);
       }
       if (video->frame() == 1) {
-        struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL};
+        struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
         encoder->Control(VP8E_SET_SCALEMODE, &mode);
         cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = new_q;
         encoder->Config(&cfg_);
       }
     } else {
       if (video->frame() == kStepDownFrame) {
-        struct vpx_scaling_mode mode = {VP8E_FOURFIVE, VP8E_THREEFIVE};
+        struct vpx_scaling_mode mode = { VP8E_FOURFIVE, VP8E_THREEFIVE };
         encoder->Control(VP8E_SET_SCALEMODE, &mode);
       }
       if (video->frame() == kStepUpFrame) {
-        struct vpx_scaling_mode mode = {VP8E_NORMAL, VP8E_NORMAL};
+        struct vpx_scaling_mode mode = { VP8E_NORMAL, VP8E_NORMAL };
         encoder->Control(VP8E_SET_SCALEMODE, &mode);
       }
     }
   }
 
   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
-    if (frame0_psnr_ == 0.)
-      frame0_psnr_ = pkt->data.psnr.psnr[0];
+    if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
   }
 
@@ -379,8 +372,7 @@
     ++out_frames_;
 
     // Write initial file header if first frame.
-    if (pkt->data.frame.pts == 0)
-      write_ivf_file_header(&cfg_, 0, outfile_);
+    if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
 
     // Write frame header and data.
     write_ivf_frame_header(pkt, outfile_);
@@ -434,8 +426,9 @@
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 }
 
-class ResizeRealtimeTest : public ::libvpx_test::EncoderTest,
-  public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
+class ResizeRealtimeTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   ResizeRealtimeTest() : EncoderTest(GET_PARAM(0)) {}
   virtual ~ResizeRealtimeTest() {}
@@ -465,16 +458,13 @@
     frame_info_list_.push_back(FrameInfo(pts, img.d_w, img.d_h));
   }
 
-  virtual void MismatchHook(const vpx_image_t *img1,
-                             const vpx_image_t *img2) {
+  virtual void MismatchHook(const vpx_image_t *img1, const vpx_image_t *img2) {
     double mismatch_psnr = compute_psnr(img1, img2);
     mismatch_psnr_ += mismatch_psnr;
     ++mismatch_nframes_;
   }
 
-  unsigned int GetMismatchFrames() {
-      return mismatch_nframes_;
-  }
+  unsigned int GetMismatchFrames() { return mismatch_nframes_; }
 
   void DefaultConfig() {
     cfg_.rc_buf_initial_sz = 500;
@@ -491,14 +481,14 @@
     // Enable dropped frames.
     cfg_.rc_dropframe_thresh = 1;
     // Enable error_resilience mode.
-    cfg_.g_error_resilient  = 1;
+    cfg_.g_error_resilient = 1;
     // Enable dynamic resizing.
     cfg_.rc_resize_allowed = 1;
     // Run at low bitrate.
     cfg_.rc_target_bitrate = 200;
   }
 
-  std::vector< FrameInfo > frame_info_list_;
+  std::vector<FrameInfo> frame_info_list_;
   int set_cpu_used_;
   bool change_bitrate_;
   double mismatch_psnr_;
@@ -521,12 +511,12 @@
     const unsigned int frame = static_cast<unsigned>(info->pts);
     unsigned int expected_w;
     unsigned int expected_h;
-    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight,
-                        &expected_w, &expected_h, 1);
-    EXPECT_EQ(expected_w, info->w)
-        << "Frame " << frame << " had unexpected width";
-    EXPECT_EQ(expected_h, info->h)
-        << "Frame " << frame << " had unexpected height";
+    ScaleForFrameNumber(frame, kInitialWidth, kInitialHeight, &expected_w,
+                        &expected_h, 1);
+    EXPECT_EQ(expected_w, info->w) << "Frame " << frame
+                                   << " had unexpected width";
+    EXPECT_EQ(expected_h, info->h) << "Frame " << frame
+                                   << " had unexpected height";
     EXPECT_EQ(static_cast<unsigned int>(0), GetMismatchFrames());
   }
 }
@@ -618,10 +608,8 @@
 }
 
 vpx_img_fmt_t CspForFrameNumber(int frame) {
-  if (frame < 10)
-    return VPX_IMG_FMT_I420;
-  if (frame < 20)
-    return VPX_IMG_FMT_I444;
+  if (frame < 10) return VPX_IMG_FMT_I420;
+  if (frame < 20) return VPX_IMG_FMT_I444;
   return VPX_IMG_FMT_I420;
 }
 
@@ -629,10 +617,7 @@
  protected:
 #if WRITE_COMPRESSED_STREAM
   ResizeCspTest()
-      : ResizeTest(),
-        frame0_psnr_(0.0),
-        outfile_(NULL),
-        out_frames_(0) {}
+      : ResizeTest(), frame0_psnr_(0.0), outfile_(NULL), out_frames_(0) {}
 #else
   ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
 #endif
@@ -671,8 +656,7 @@
   }
 
   virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
-    if (frame0_psnr_ == 0.)
-      frame0_psnr_ = pkt->data.psnr.psnr[0];
+    if (frame0_psnr_ == 0.) frame0_psnr_ = pkt->data.psnr.psnr[0];
     EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
   }
 
@@ -681,8 +665,7 @@
     ++out_frames_;
 
     // Write initial file header if first frame.
-    if (pkt->data.frame.pts == 0)
-      write_ivf_file_header(&cfg_, 0, outfile_);
+    if (pkt->data.frame.pts == 0) write_ivf_file_header(&cfg_, 0, outfile_);
 
     // Write frame header and data.
     write_ivf_frame_header(pkt, outfile_);
@@ -723,12 +706,12 @@
 }
 
 VP10_INSTANTIATE_TEST_CASE(ResizeTest,
-                          ::testing::Values(::libvpx_test::kRealTime));
+                           ::testing::Values(::libvpx_test::kRealTime));
 VP10_INSTANTIATE_TEST_CASE(ResizeInternalTest,
-                          ::testing::Values(::libvpx_test::kOnePassBest));
+                           ::testing::Values(::libvpx_test::kOnePassBest));
 VP10_INSTANTIATE_TEST_CASE(ResizeRealtimeTest,
-                          ::testing::Values(::libvpx_test::kRealTime),
-                          ::testing::Range(5, 9));
+                           ::testing::Values(::libvpx_test::kRealTime),
+                           ::testing::Range(5, 9));
 VP10_INSTANTIATE_TEST_CASE(ResizeCspTest,
-                          ::testing::Values(::libvpx_test::kRealTime));
+                           ::testing::Values(::libvpx_test::kRealTime));
 }  // namespace
diff --git a/test/sad_test.cc b/test/sad_test.cc
index 36f777d..1e6295d 100644
--- a/test/sad_test.cc
+++ b/test/sad_test.cc
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 #include <string.h>
 #include <limits.h>
 #include <stdio.h>
@@ -25,23 +24,17 @@
 #include "vpx_mem/vpx_mem.h"
 #include "vpx_ports/mem.h"
 
-typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr,
-                                   int src_stride,
-                                   const uint8_t *ref_ptr,
-                                   int ref_stride);
+typedef unsigned int (*SadMxNFunc)(const uint8_t *src_ptr, int src_stride,
+                                   const uint8_t *ref_ptr, int ref_stride);
 typedef std::tr1::tuple<int, int, SadMxNFunc, int> SadMxNParam;
 
-typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr,
-                                  int src_stride,
-                                  const uint8_t *ref_ptr,
-                                  int ref_stride,
+typedef uint32_t (*SadMxNAvgFunc)(const uint8_t *src_ptr, int src_stride,
+                                  const uint8_t *ref_ptr, int ref_stride,
                                   const uint8_t *second_pred);
 typedef std::tr1::tuple<int, int, SadMxNAvgFunc, int> SadMxNAvgParam;
 
-typedef void (*SadMxNx4Func)(const uint8_t *src_ptr,
-                             int src_stride,
-                             const uint8_t *const ref_ptr[],
-                             int ref_stride,
+typedef void (*SadMxNx4Func)(const uint8_t *src_ptr, int src_stride,
+                             const uint8_t *const ref_ptr[], int ref_stride,
                              uint32_t *sad_array);
 typedef std::tr1::tuple<int, int, SadMxNx4Func, int> SadMxNx4Param;
 
@@ -50,22 +43,22 @@
 namespace {
 class SADTestBase : public ::testing::Test {
  public:
-  SADTestBase(int width, int height, int bit_depth) :
-      width_(width), height_(height), bd_(bit_depth) {}
+  SADTestBase(int width, int height, int bit_depth)
+      : width_(width), height_(height), bd_(bit_depth) {}
 
   static void SetUpTestCase() {
-    source_data8_ = reinterpret_cast<uint8_t*>(
+    source_data8_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kDataBlockSize));
-    reference_data8_ = reinterpret_cast<uint8_t*>(
+    reference_data8_ = reinterpret_cast<uint8_t *>(
         vpx_memalign(kDataAlignment, kDataBufferSize));
-    second_pred8_ = reinterpret_cast<uint8_t*>(
-        vpx_memalign(kDataAlignment, 128*128));
-    source_data16_ = reinterpret_cast<uint16_t*>(
-        vpx_memalign(kDataAlignment, kDataBlockSize*sizeof(uint16_t)));
-    reference_data16_ = reinterpret_cast<uint16_t*>(
-        vpx_memalign(kDataAlignment, kDataBufferSize*sizeof(uint16_t)));
-    second_pred16_ = reinterpret_cast<uint16_t*>(
-        vpx_memalign(kDataAlignment, 128*128*sizeof(uint16_t)));
+    second_pred8_ =
+        reinterpret_cast<uint8_t *>(vpx_memalign(kDataAlignment, 128 * 128));
+    source_data16_ = reinterpret_cast<uint16_t *>(
+        vpx_memalign(kDataAlignment, kDataBlockSize * sizeof(uint16_t)));
+    reference_data16_ = reinterpret_cast<uint16_t *>(
+        vpx_memalign(kDataAlignment, kDataBufferSize * sizeof(uint16_t)));
+    second_pred16_ = reinterpret_cast<uint16_t *>(
+        vpx_memalign(kDataAlignment, 128 * 128 * sizeof(uint16_t)));
   }
 
   static void TearDownTestCase() {
@@ -83,9 +76,7 @@
     second_pred16_ = NULL;
   }
 
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
  protected:
   // Handle up to 4 128x128 blocks, with stride up to 256
@@ -128,12 +119,12 @@
   // difference between two pixels in the same relative location; accumulate.
   unsigned int ReferenceSAD(int block_idx) {
     unsigned int sad = 0;
-      const uint8_t *const reference8 = GetReference(block_idx);
-      const uint8_t *const source8 = source_data_;
+    const uint8_t *const reference8 = GetReference(block_idx);
+    const uint8_t *const source8 = source_data_;
 #if CONFIG_VP9_HIGHBITDEPTH
-      const uint16_t *const reference16 =
-          CONVERT_TO_SHORTPTR(GetReference(block_idx));
-      const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
+    const uint16_t *const reference16 =
+        CONVERT_TO_SHORTPTR(GetReference(block_idx));
+    const uint16_t *const source16 = CONVERT_TO_SHORTPTR(source_data_);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
     for (int h = 0; h < height_; ++h) {
       for (int w = 0; w < width_; ++w) {
@@ -169,13 +160,13 @@
       for (int w = 0; w < width_; ++w) {
         if (!use_high_bit_depth_) {
           const int tmp = second_pred8[h * width_ + w] +
-              reference8[h * reference_stride_ + w];
+                          reference8[h * reference_stride_ + w];
           const uint8_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
           sad += abs(source8[h * source_stride_ + w] - comp_pred);
 #if CONFIG_VP9_HIGHBITDEPTH
         } else {
           const int tmp = second_pred16[h * width_ + w] +
-              reference16[h * reference_stride_ + w];
+                          reference16[h * reference_stride_ + w];
           const uint16_t comp_pred = ROUND_POWER_OF_TWO(tmp, 1);
           sad += abs(source16[h * source_stride_ + w] - comp_pred);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
@@ -239,20 +230,18 @@
   ACMRandom rnd_;
 };
 
-class SADx4Test
-    : public SADTestBase,
-      public ::testing::WithParamInterface<SadMxNx4Param> {
+class SADx4Test : public SADTestBase,
+                  public ::testing::WithParamInterface<SadMxNx4Param> {
  public:
   SADx4Test() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 
  protected:
   void SADs(unsigned int *results) {
-    const uint8_t *references[] = {GetReference(0), GetReference(1),
-                                   GetReference(2), GetReference(3)};
+    const uint8_t *references[] = { GetReference(0), GetReference(1),
+                                    GetReference(2), GetReference(3) };
 
-    ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(source_data_, source_stride_,
-                                          references, reference_stride_,
-                                          results));
+    ASM_REGISTER_STATE_CHECK(GET_PARAM(2)(
+        source_data_, source_stride_, references, reference_stride_, results));
   }
 
   void CheckSADs() {
@@ -267,9 +256,8 @@
   }
 };
 
-class SADTest
-    : public SADTestBase,
-      public ::testing::WithParamInterface<SadMxNParam> {
+class SADTest : public SADTestBase,
+                public ::testing::WithParamInterface<SadMxNParam> {
  public:
   SADTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 
@@ -291,9 +279,8 @@
   }
 };
 
-class SADavgTest
-    : public SADTestBase,
-      public ::testing::WithParamInterface<SadMxNAvgParam> {
+class SADavgTest : public SADTestBase,
+                   public ::testing::WithParamInterface<SadMxNAvgParam> {
  public:
   SADavgTest() : SADTestBase(GET_PARAM(0), GET_PARAM(1), GET_PARAM(3)) {}
 
@@ -469,7 +456,7 @@
 }
 
 TEST_P(SADx4Test, SrcAlignedByWidth) {
-  uint8_t * tmp_source_data = source_data_;
+  uint8_t *tmp_source_data = source_data_;
   source_data_ += width_;
   FillRandom(source_data_, source_stride_);
   FillRandom(GetReference(0), reference_stride_);
diff --git a/test/subtract_test.cc b/test/subtract_test.cc
index 2e2f162..498b6fa 100644
--- a/test/subtract_test.cc
+++ b/test/subtract_test.cc
@@ -24,18 +24,16 @@
 
 #define USE_SPEED_TEST (0)
 
-typedef void (*SubtractFunc)(int rows, int cols,
-                             int16_t *diff_ptr, ptrdiff_t diff_stride,
-                             const uint8_t *src_ptr, ptrdiff_t src_stride,
-                             const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+typedef void (*SubtractFunc)(int rows, int cols, int16_t *diff_ptr,
+                             ptrdiff_t diff_stride, const uint8_t *src_ptr,
+                             ptrdiff_t src_stride, const uint8_t *pred_ptr,
+                             ptrdiff_t pred_stride);
 
 namespace {
 
 class VP9SubtractBlockTest : public ::testing::TestWithParam<SubtractFunc> {
  public:
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
 };
 
 using libvpx_test::ACMRandom;
@@ -52,7 +50,7 @@
         vpx_memalign(16, sizeof(*diff) * block_width * block_height * 2));
     uint8_t *pred = reinterpret_cast<uint8_t *>(
         vpx_memalign(16, block_width * block_height * 2));
-    uint8_t *src  = reinterpret_cast<uint8_t *>(
+    uint8_t *src = reinterpret_cast<uint8_t *>(
         vpx_memalign(16, block_width * block_height * 2));
 
     for (int n = 0; n < 100; n++) {
@@ -63,29 +61,26 @@
         }
       }
 
-      GetParam()(block_height, block_width, diff, block_width,
-                 src, block_width, pred, block_width);
+      GetParam()(block_height, block_width, diff, block_width, src, block_width,
+                 pred, block_width);
 
       for (int r = 0; r < block_height; ++r) {
         for (int c = 0; c < block_width; ++c) {
           EXPECT_EQ(diff[r * block_width + c],
-                    (src[r * block_width + c] -
-                     pred[r * block_width + c])) << "r = " << r
-                                                 << ", c = " << c
-                                                 << ", bs = " << bsize;
+                    (src[r * block_width + c] - pred[r * block_width + c]))
+              << "r = " << r << ", c = " << c << ", bs = " << bsize;
         }
       }
 
-      GetParam()(block_height, block_width, diff, block_width * 2,
-                 src, block_width * 2, pred, block_width * 2);
+      GetParam()(block_height, block_width, diff, block_width * 2, src,
+                 block_width * 2, pred, block_width * 2);
 
       for (int r = 0; r < block_height; ++r) {
         for (int c = 0; c < block_width; ++c) {
-          EXPECT_EQ(diff[r * block_width * 2 + c],
-                    (src[r * block_width * 2 + c] -
-                     pred[r * block_width * 2 + c])) << "r = " << r
-                                                     << ", c = " << c
-                                                     << ", bs = " << bsize;
+          EXPECT_EQ(
+              diff[r * block_width * 2 + c],
+              (src[r * block_width * 2 + c] - pred[r * block_width * 2 + c]))
+              << "r = " << r << ", c = " << c << ", bs = " << bsize;
         }
       }
     }
@@ -111,11 +106,10 @@
                         ::testing::Values(vpx_subtract_block_msa));
 #endif
 
-typedef void (*HBDSubtractFunc)(int rows, int cols,
-                                int16_t *diff_ptr, ptrdiff_t diff_stride,
-                                const uint8_t *src_ptr, ptrdiff_t src_stride,
-                                const uint8_t *pred_ptr, ptrdiff_t pred_stride,
-                                int bd);
+typedef void (*HBDSubtractFunc)(int rows, int cols, int16_t *diff_ptr,
+                                ptrdiff_t diff_stride, const uint8_t *src_ptr,
+                                ptrdiff_t src_stride, const uint8_t *pred_ptr,
+                                ptrdiff_t pred_stride, int bd);
 
 using ::std::tr1::get;
 using ::std::tr1::make_tuple;
@@ -179,8 +173,8 @@
   }
 
   for (i = 0; i < test_num; ++i) {
-    func_(block_height_, block_width_, diff_, block_width_,
-          src_, block_width_, pred_, block_width_, bit_depth_);
+    func_(block_height_, block_width_, diff_, block_width_, src_, block_width_,
+          pred_, block_width_, bit_depth_);
   }
 }
 
@@ -197,8 +191,8 @@
       CONVERT_TO_SHORTPTR(pred_)[j] = rnd_.Rand16() & mask;
     }
 
-    func_(block_height_, block_width_, diff_, block_width_,
-          src_, block_width_, pred_, block_width_, bit_depth_);
+    func_(block_height_, block_width_, diff_, block_width_, src_, block_width_,
+          pred_, block_width_, bit_depth_);
 
     for (int r = 0; r < block_height_; ++r) {
       for (int c = 0; c < block_width_; ++c) {
@@ -211,50 +205,47 @@
   }
 }
 
-TEST_P(VP10HBDSubtractBlockTest, CheckResult) {
-  CheckResult();
-}
+TEST_P(VP10HBDSubtractBlockTest, CheckResult) { CheckResult(); }
 
 #if USE_SPEED_TEST
-TEST_P(VP10HBDSubtractBlockTest, CheckSpeed) {
-  RunForSpeed();
-}
+TEST_P(VP10HBDSubtractBlockTest, CheckSpeed) { RunForSpeed(); }
 #endif  // USE_SPEED_TEST
 
 #if HAVE_SSE2
-INSTANTIATE_TEST_CASE_P(SSE2, VP10HBDSubtractBlockTest, ::testing::Values(
-    make_tuple(4, 4, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(4, 4, 12, vpx_highbd_subtract_block_c),
-    make_tuple(4, 8, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(4, 8, 12, vpx_highbd_subtract_block_c),
-    make_tuple(8, 4, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(8, 4, 12, vpx_highbd_subtract_block_c),
-    make_tuple(8, 8, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(8, 8, 12, vpx_highbd_subtract_block_c),
-    make_tuple(8, 16, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(8, 16, 12, vpx_highbd_subtract_block_c),
-    make_tuple(16, 8, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(16, 8, 12, vpx_highbd_subtract_block_c),
-    make_tuple(16, 16, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(16, 16, 12, vpx_highbd_subtract_block_c),
-    make_tuple(16, 32, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(16, 32, 12, vpx_highbd_subtract_block_c),
-    make_tuple(32, 16, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(32, 16, 12, vpx_highbd_subtract_block_c),
-    make_tuple(32, 32, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(32, 32, 12, vpx_highbd_subtract_block_c),
-    make_tuple(32, 64, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(32, 64, 12, vpx_highbd_subtract_block_c),
-    make_tuple(64, 32, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(64, 32, 12, vpx_highbd_subtract_block_c),
-    make_tuple(64, 64, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(64, 64, 12, vpx_highbd_subtract_block_c),
-    make_tuple(64, 128, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(64, 128, 12, vpx_highbd_subtract_block_c),
-    make_tuple(128, 64, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(128, 64, 12, vpx_highbd_subtract_block_c),
-    make_tuple(128, 128, 12, vpx_highbd_subtract_block_sse2),
-    make_tuple(128, 128, 12, vpx_highbd_subtract_block_c)));
+INSTANTIATE_TEST_CASE_P(
+    SSE2, VP10HBDSubtractBlockTest,
+    ::testing::Values(make_tuple(4, 4, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(4, 4, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(4, 8, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(4, 8, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(8, 4, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(8, 4, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(8, 8, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(8, 8, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(8, 16, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(8, 16, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(16, 8, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(16, 8, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(16, 16, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(16, 16, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(16, 32, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(16, 32, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(32, 16, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(32, 16, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(32, 32, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(32, 32, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(32, 64, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(32, 64, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(64, 32, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(64, 32, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(64, 64, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(64, 64, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(64, 128, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(64, 128, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(128, 64, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(128, 64, 12, vpx_highbd_subtract_block_c),
+                      make_tuple(128, 128, 12, vpx_highbd_subtract_block_sse2),
+                      make_tuple(128, 128, 12, vpx_highbd_subtract_block_c)));
 #endif  // HAVE_SSE2
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 }  // namespace
diff --git a/test/sum_squares_test.cc b/test/sum_squares_test.cc
index 9adb86e..4991a04 100644
--- a/test/sum_squares_test.cc
+++ b/test/sum_squares_test.cc
@@ -34,13 +34,10 @@
 typedef uint64_t (*SSI16Func)(const int16_t *src, int stride, int size);
 typedef libvpx_test::FuncParam<SSI16Func> TestFuncs;
 
-class SumSquaresTest :
-    public ::testing::TestWithParam<TestFuncs> {
+class SumSquaresTest : public ::testing::TestWithParam<TestFuncs> {
  public:
   virtual ~SumSquaresTest() {}
-  virtual void SetUp() {
-    params_ = this->GetParam();
-  }
+  virtual void SetUp() { params_ = this->GetParam(); }
 
   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
@@ -50,23 +47,23 @@
 
 TEST_P(SumSquaresTest, OperationCheck) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, int16_t, src[256*256]);
+  DECLARE_ALIGNED(16, int16_t, src[256 * 256]);
 
   int failed = 0;
 
-  const int msb = 11;   // Up to 12 bit input
-  const int limit = 1 << (msb+1);
+  const int msb = 11;  // Up to 12 bit input
+  const int limit = 1 << (msb + 1);
 
   for (int k = 0; k < kNumIterations; k++) {
-    int size = 4 << rnd(6);     // Up to 128x128
-    int stride = 4 << rnd(7);   // Up to 256 stride
-    while (stride < size) {     // Make sure it's valid
+    int size = 4 << rnd(6);    // Up to 128x128
+    int stride = 4 << rnd(7);  // Up to 256 stride
+    while (stride < size) {    // Make sure it's valid
       stride = 4 << rnd(7);
     }
 
-    for (int ii = 0 ; ii < size; ii++) {
+    for (int ii = 0; ii < size; ii++) {
       for (int jj = 0; jj < size; jj++) {
-        src[ii*stride+jj] = rnd(2) ? rnd(limit) : -rnd(limit);
+        src[ii * stride + jj] = rnd(2) ? rnd(limit) : -rnd(limit);
       }
     }
 
@@ -77,32 +74,32 @@
     if (!failed) {
       failed = res_ref != res_tst;
       EXPECT_EQ(res_ref, res_tst)
-        << "Error: Sum Squares Test"
-        << " C output does not match optimized output.";
+          << "Error: Sum Squares Test"
+          << " C output does not match optimized output.";
     }
   }
 }
 
 TEST_P(SumSquaresTest, ExtremeValues) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, int16_t, src[256*256]);
+  DECLARE_ALIGNED(16, int16_t, src[256 * 256]);
 
   int failed = 0;
 
-  const int msb = 11;   // Up to 12 bit input
-  const int limit = 1 << (msb+1);
+  const int msb = 11;  // Up to 12 bit input
+  const int limit = 1 << (msb + 1);
 
   for (int k = 0; k < kNumIterations; k++) {
-    int size = 4 << rnd(6);     // Up to 128x128
-    int stride = 4 << rnd(7);   // Up to 256 stride
-    while (stride < size) {     // Make sure it's valid
+    int size = 4 << rnd(6);    // Up to 128x128
+    int stride = 4 << rnd(7);  // Up to 256 stride
+    while (stride < size) {    // Make sure it's valid
       stride = 4 << rnd(7);
     }
 
-    int val = rnd(2) ? limit-1 : -(limit-1);
-    for (int ii = 0 ; ii < size; ii++) {
+    int val = rnd(2) ? limit - 1 : -(limit - 1);
+    for (int ii = 0; ii < size; ii++) {
       for (int jj = 0; jj < size; jj++) {
-        src[ii*stride+jj] = val;
+        src[ii * stride + jj] = val;
       }
     }
 
@@ -113,8 +110,8 @@
     if (!failed) {
       failed = res_ref != res_tst;
       EXPECT_EQ(res_ref, res_tst)
-        << "Error: Sum Squares Test"
-        << " C output does not match optimized output.";
+          << "Error: Sum Squares Test"
+          << " C output does not match optimized output.";
     }
   }
 }
@@ -123,8 +120,8 @@
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, SumSquaresTest,
-    ::testing::Values(
-        TestFuncs(&vpx_sum_squares_2d_i16_c, &vpx_sum_squares_2d_i16_sse2)));
+    ::testing::Values(TestFuncs(&vpx_sum_squares_2d_i16_c,
+                                &vpx_sum_squares_2d_i16_sse2)));
 
 #endif  // HAVE_SSE2
 
@@ -144,8 +141,8 @@
 TEST_P(SumSquares1DTest, RandomValues) {
   DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < kMaxSize * kMaxSize ; ++i)
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < kMaxSize * kMaxSize; ++i)
       src[i] = rng_(kInt13Max * 2 + 1) - kInt13Max;
 
     const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
@@ -162,13 +159,11 @@
 TEST_P(SumSquares1DTest, ExtremeValues) {
   DECLARE_ALIGNED(16, int16_t, src[kMaxSize * kMaxSize]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     if (rng_(2)) {
-      for (int i = 0 ; i < kMaxSize * kMaxSize ; ++i)
-        src[i] = kInt13Max;
+      for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = kInt13Max;
     } else {
-      for (int i = 0 ; i < kMaxSize * kMaxSize ; ++i)
-        src[i] = -kInt13Max;
+      for (int i = 0; i < kMaxSize * kMaxSize; ++i) src[i] = -kInt13Max;
     }
 
     const int N = rng_(2) ? rng_(kMaxSize * kMaxSize + 1 - kMaxSize) + kMaxSize
@@ -183,10 +178,9 @@
 }
 
 #if HAVE_SSE2
-INSTANTIATE_TEST_CASE_P(
-    SSE2, SumSquares1DTest,
-    ::testing::Values(
-        TestFuncs1D(vpx_sum_squares_i16_c, vpx_sum_squares_i16_sse2)));
+INSTANTIATE_TEST_CASE_P(SSE2, SumSquares1DTest,
+                        ::testing::Values(TestFuncs1D(
+                            vpx_sum_squares_i16_c, vpx_sum_squares_i16_sse2)));
 
 #endif  // HAVE_SSE2
 }  // namespace
diff --git a/test/superframe_test.cc b/test/superframe_test.cc
index 610c69b..7580375 100644
--- a/test/superframe_test.cc
+++ b/test/superframe_test.cc
@@ -21,14 +21,15 @@
 const int kTileCols = 2;
 const int kTileRows = 3;
 
-typedef std::tr1::tuple<libvpx_test::TestMode, int,
-                        int, int> SuperframeTestParam;
+typedef std::tr1::tuple<libvpx_test::TestMode, int, int, int>
+    SuperframeTestParam;
 
-class SuperframeTest : public ::libvpx_test::EncoderTest,
-    public ::libvpx_test::CodecTestWithParam<SuperframeTestParam> {
+class SuperframeTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWithParam<SuperframeTestParam> {
  protected:
-  SuperframeTest() : EncoderTest(GET_PARAM(0)), modified_buf_(NULL),
-      last_sf_pts_(0) {}
+  SuperframeTest()
+      : EncoderTest(GET_PARAM(0)), modified_buf_(NULL), last_sf_pts_(0) {}
   virtual ~SuperframeTest() {}
 
   virtual void SetUp() {
@@ -44,9 +45,7 @@
     n_tile_rows_ = std::tr1::get<kTileRows>(input);
   }
 
-  virtual void TearDown() {
-    delete[] modified_buf_;
-  }
+  virtual void TearDown() { delete[] modified_buf_; }
 
   virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
                                   libvpx_test::Encoder *encoder) {
@@ -58,26 +57,22 @@
     }
   }
 
-  virtual const vpx_codec_cx_pkt_t * MutateEncoderOutputHook(
+  virtual const vpx_codec_cx_pkt_t *MutateEncoderOutputHook(
       const vpx_codec_cx_pkt_t *pkt) {
-    if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
-      return pkt;
+    if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) return pkt;
 
-    const uint8_t *buffer = reinterpret_cast<uint8_t*>(pkt->data.frame.buf);
+    const uint8_t *buffer = reinterpret_cast<uint8_t *>(pkt->data.frame.buf);
     const uint8_t marker = buffer[pkt->data.frame.sz - 1];
     const int frames = (marker & 0x7) + 1;
     const int mag = ((marker >> 3) & 3) + 1;
     const unsigned int index_sz =
         2 + mag * (frames - is_vp10_style_superframe_);
-    if ((marker & 0xe0) == 0xc0 &&
-        pkt->data.frame.sz >= index_sz &&
+    if ((marker & 0xe0) == 0xc0 && pkt->data.frame.sz >= index_sz &&
         buffer[pkt->data.frame.sz - index_sz] == marker) {
       // frame is a superframe. strip off the index.
-      if (modified_buf_)
-        delete[] modified_buf_;
+      if (modified_buf_) delete[] modified_buf_;
       modified_buf_ = new uint8_t[pkt->data.frame.sz - index_sz];
-      memcpy(modified_buf_, pkt->data.frame.buf,
-             pkt->data.frame.sz - index_sz);
+      memcpy(modified_buf_, pkt->data.frame.buf, pkt->data.frame.sz - index_sz);
       modified_pkt_ = *pkt;
       modified_pkt_.data.frame.buf = modified_buf_;
       modified_pkt_.data.frame.sz -= index_sz;
@@ -88,8 +83,8 @@
     }
 
     // Make sure we do a few frames after the last SF
-    abort_ |= sf_count_ > sf_count_max_ &&
-              pkt->data.frame.pts - last_sf_pts_ >= 5;
+    abort_ |=
+        sf_count_ > sf_count_max_ && pkt->data.frame.pts - last_sf_pts_ >= 5;
     return pkt;
   }
 
@@ -131,16 +126,19 @@
 const int tile_col_values[] = { 1, 2, 32 };
 #endif
 const int tile_row_values[] = { 1, 2, 32 };
-VP10_INSTANTIATE_TEST_CASE(SuperframeTest, ::testing::Combine(
-    ::testing::Values(::libvpx_test::kTwoPassGood),
-    ::testing::Values(1),
-    ::testing::ValuesIn(tile_col_values),
-    ::testing::ValuesIn(tile_row_values)));
+VP10_INSTANTIATE_TEST_CASE(
+    SuperframeTest,
+    ::testing::Combine(::testing::Values(::libvpx_test::kTwoPassGood),
+                       ::testing::Values(1),
+                       ::testing::ValuesIn(tile_col_values),
+                       ::testing::ValuesIn(tile_row_values)));
 #else
 #if !CONFIG_ANS
-VP10_INSTANTIATE_TEST_CASE(SuperframeTest, ::testing::Combine(
-    ::testing::Values(::libvpx_test::kTwoPassGood),
-    ::testing::Values(1), ::testing::Values(0), ::testing::Values(0)));
+VP10_INSTANTIATE_TEST_CASE(
+    SuperframeTest,
+    ::testing::Combine(::testing::Values(::libvpx_test::kTwoPassGood),
+                       ::testing::Values(1), ::testing::Values(0),
+                       ::testing::Values(0)));
 #endif  // !CONFIG_ANS
 #endif  // CONFIG_EXT_TILE
 }  // namespace
diff --git a/test/test_intra_pred_speed.cc b/test/test_intra_pred_speed.cc
index 8928bf8..a896307 100644
--- a/test/test_intra_pred_speed.cc
+++ b/test/test_intra_pred_speed.cc
@@ -31,9 +31,9 @@
 
 const int kNumVp9IntraPredFuncs = 13;
 const char *kVp9IntraPredNames[kNumVp9IntraPredFuncs] = {
-  "DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED", "H_PRED",
-  "D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED", "D207_PRED", "D63_PRED",
-  "TM_PRED"
+  "DC_PRED",   "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
+  "H_PRED",    "D45_PRED",     "D135_PRED",   "D117_PRED",   "D153_PRED",
+  "D207_PRED", "D63_PRED",     "TM_PRED"
 };
 
 void TestIntraPred(const char name[], VpxPredFunc const *pred_funcs,
@@ -82,18 +82,12 @@
 void TestIntraPred4(VpxPredFunc const *pred_funcs) {
   static const int kNumVp9IntraFuncs = 13;
   static const char *const kSignatures[kNumVp9IntraFuncs] = {
-    "4334156168b34ab599d9b5b30f522fe9",
-    "bc4649d5ba47c7ff178d92e475960fb0",
-    "8d316e5933326dcac24e1064794b5d12",
-    "a27270fed024eafd762c95de85f4da51",
-    "c33dff000d4256c2b8f3bf9e9bab14d2",
-    "44d8cddc2ad8f79b8ed3306051722b4f",
-    "eb54839b2bad6699d8946f01ec041cd0",
-    "ecb0d56ae5f677ea45127ce9d5c058e4",
-    "0b7936841f6813da818275944895b574",
-    "9117972ef64f91a58ff73e1731c81db2",
-    "c56d5e8c729e46825f46dd5d3b5d508a",
-    "c0889e2039bcf7bcb5d2f33cdca69adc",
+    "4334156168b34ab599d9b5b30f522fe9", "bc4649d5ba47c7ff178d92e475960fb0",
+    "8d316e5933326dcac24e1064794b5d12", "a27270fed024eafd762c95de85f4da51",
+    "c33dff000d4256c2b8f3bf9e9bab14d2", "44d8cddc2ad8f79b8ed3306051722b4f",
+    "eb54839b2bad6699d8946f01ec041cd0", "ecb0d56ae5f677ea45127ce9d5c058e4",
+    "0b7936841f6813da818275944895b574", "9117972ef64f91a58ff73e1731c81db2",
+    "c56d5e8c729e46825f46dd5d3b5d508a", "c0889e2039bcf7bcb5d2f33cdca69adc",
     "309a618577b27c648f9c5ee45252bc8f",
   };
   TestIntraPred("Intra4", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@@ -103,18 +97,12 @@
 void TestIntraPred8(VpxPredFunc const *pred_funcs) {
   static const int kNumVp9IntraFuncs = 13;
   static const char *const kSignatures[kNumVp9IntraFuncs] = {
-    "7694ddeeefed887faf9d339d18850928",
-    "7d726b1213591b99f736be6dec65065b",
-    "19c5711281357a485591aaf9c96c0a67",
-    "ba6b66877a089e71cd938e3b8c40caac",
-    "802440c93317e0f8ba93fab02ef74265",
-    "9e09a47a15deb0b9d8372824f9805080",
-    "b7c2d8c662268c0c427da412d7b0311d",
-    "78339c1c60bb1d67d248ab8c4da08b7f",
-    "5c97d70f7d47de1882a6cd86c165c8a9",
-    "8182bf60688b42205acd95e59e967157",
-    "08323400005a297f16d7e57e7fe1eaac",
-    "95f7bfc262329a5849eda66d8f7c68ce",
+    "7694ddeeefed887faf9d339d18850928", "7d726b1213591b99f736be6dec65065b",
+    "19c5711281357a485591aaf9c96c0a67", "ba6b66877a089e71cd938e3b8c40caac",
+    "802440c93317e0f8ba93fab02ef74265", "9e09a47a15deb0b9d8372824f9805080",
+    "b7c2d8c662268c0c427da412d7b0311d", "78339c1c60bb1d67d248ab8c4da08b7f",
+    "5c97d70f7d47de1882a6cd86c165c8a9", "8182bf60688b42205acd95e59e967157",
+    "08323400005a297f16d7e57e7fe1eaac", "95f7bfc262329a5849eda66d8f7c68ce",
     "815b75c8e0d91cc1ae766dc5d3e445a3",
   };
   TestIntraPred("Intra8", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@@ -124,18 +112,12 @@
 void TestIntraPred16(VpxPredFunc const *pred_funcs) {
   static const int kNumVp9IntraFuncs = 13;
   static const char *const kSignatures[kNumVp9IntraFuncs] = {
-    "b40dbb555d5d16a043dc361e6694fe53",
-    "fb08118cee3b6405d64c1fd68be878c6",
-    "6c190f341475c837cc38c2e566b64875",
-    "db5c34ccbe2c7f595d9b08b0dc2c698c",
-    "a62cbfd153a1f0b9fed13e62b8408a7a",
-    "143df5b4c89335e281103f610f5052e4",
-    "d87feb124107cdf2cfb147655aa0bb3c",
-    "7841fae7d4d47b519322e6a03eeed9dc",
-    "f6ebed3f71cbcf8d6d0516ce87e11093",
-    "3cc480297dbfeed01a1c2d78dd03d0c5",
-    "b9f69fa6532b372c545397dcb78ef311",
-    "a8fe1c70432f09d0c20c67bdb6432c4d",
+    "b40dbb555d5d16a043dc361e6694fe53", "fb08118cee3b6405d64c1fd68be878c6",
+    "6c190f341475c837cc38c2e566b64875", "db5c34ccbe2c7f595d9b08b0dc2c698c",
+    "a62cbfd153a1f0b9fed13e62b8408a7a", "143df5b4c89335e281103f610f5052e4",
+    "d87feb124107cdf2cfb147655aa0bb3c", "7841fae7d4d47b519322e6a03eeed9dc",
+    "f6ebed3f71cbcf8d6d0516ce87e11093", "3cc480297dbfeed01a1c2d78dd03d0c5",
+    "b9f69fa6532b372c545397dcb78ef311", "a8fe1c70432f09d0c20c67bdb6432c4d",
     "b8a41aa968ec108af447af4217cba91b",
   };
   TestIntraPred("Intra16", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@@ -145,18 +127,12 @@
 void TestIntraPred32(VpxPredFunc const *pred_funcs) {
   static const int kNumVp9IntraFuncs = 13;
   static const char *const kSignatures[kNumVp9IntraFuncs] = {
-    "558541656d84f9ae7896db655826febe",
-    "b3587a1f9a01495fa38c8cd3c8e2a1bf",
-    "4c6501e64f25aacc55a2a16c7e8f0255",
-    "b3b01379ba08916ef6b1b35f7d9ad51c",
-    "0f1eb38b6cbddb3d496199ef9f329071",
-    "911c06efb9ed1c3b4c104b232b55812f",
-    "9225beb0ddfa7a1d24eaa1be430a6654",
-    "0a6d584a44f8db9aa7ade2e2fdb9fc9e",
-    "b01c9076525216925f3456f034fb6eee",
-    "d267e20ad9e5cd2915d1a47254d3d149",
-    "ed012a4a5da71f36c2393023184a0e59",
-    "f162b51ed618d28b936974cff4391da5",
+    "558541656d84f9ae7896db655826febe", "b3587a1f9a01495fa38c8cd3c8e2a1bf",
+    "4c6501e64f25aacc55a2a16c7e8f0255", "b3b01379ba08916ef6b1b35f7d9ad51c",
+    "0f1eb38b6cbddb3d496199ef9f329071", "911c06efb9ed1c3b4c104b232b55812f",
+    "9225beb0ddfa7a1d24eaa1be430a6654", "0a6d584a44f8db9aa7ade2e2fdb9fc9e",
+    "b01c9076525216925f3456f034fb6eee", "d267e20ad9e5cd2915d1a47254d3d149",
+    "ed012a4a5da71f36c2393023184a0e59", "f162b51ed618d28b936974cff4391da5",
     "9e1370c6d42e08d357d9612c93a71cfc",
   };
   TestIntraPred("Intra32", pred_funcs, kVp9IntraPredNames, kNumVp9IntraFuncs,
@@ -167,13 +143,13 @@
 
 // Defines a test case for |arch| (e.g., C, SSE2, ...) passing the predictors
 // to |test_func|. The test name is 'arch.test_func', e.g., C.TestIntraPred4.
-#define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h, \
-                        d45, d135, d117, d153, d207, d63, tm)               \
-  TEST(arch, test_func) {                                                   \
-    static const VpxPredFunc vpx_intra_pred[] = {                           \
-        dc,   dc_left, dc_top, dc_128, v,   h, d45,                         \
-        d135, d117,    d153,   d207,   d63, tm};                            \
-    test_func(vpx_intra_pred);                                              \
+#define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h,   \
+                        d45, d135, d117, d153, d207, d63, tm)                 \
+  TEST(arch, test_func) {                                                     \
+    static const VpxPredFunc vpx_intra_pred[] = {                             \
+      dc, dc_left, dc_top, dc_128, v, h, d45, d135, d117, d153, d207, d63, tm \
+    };                                                                        \
+    test_func(vpx_intra_pred);                                                \
   }
 
 // -----------------------------------------------------------------------------
@@ -197,9 +173,8 @@
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL,
-                vpx_d153_predictor_4x4_ssse3, NULL,
+INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                NULL, NULL, vpx_d153_predictor_4x4_ssse3, NULL,
                 vpx_d63_predictor_4x4_ssse3, NULL)
 #endif  // HAVE_SSSE3
 
@@ -222,8 +197,8 @@
 INTRA_PRED_TEST(MSA, TestIntraPred4, vpx_dc_predictor_4x4_msa,
                 vpx_dc_left_predictor_4x4_msa, vpx_dc_top_predictor_4x4_msa,
                 vpx_dc_128_predictor_4x4_msa, vpx_v_predictor_4x4_msa,
-                vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_tm_predictor_4x4_msa)
+                vpx_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_tm_predictor_4x4_msa)
 #endif  // HAVE_MSA
 
 // -----------------------------------------------------------------------------
@@ -246,10 +221,9 @@
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL,
-                vpx_d153_predictor_8x8_ssse3, vpx_d207_predictor_8x8_ssse3,
-                vpx_d63_predictor_8x8_ssse3, NULL)
+INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                NULL, NULL, vpx_d153_predictor_8x8_ssse3,
+                vpx_d207_predictor_8x8_ssse3, vpx_d63_predictor_8x8_ssse3, NULL)
 #endif  // HAVE_SSSE3
 
 #if HAVE_DSPR2
@@ -271,8 +245,8 @@
 INTRA_PRED_TEST(MSA, TestIntraPred8, vpx_dc_predictor_8x8_msa,
                 vpx_dc_left_predictor_8x8_msa, vpx_dc_top_predictor_8x8_msa,
                 vpx_dc_128_predictor_8x8_msa, vpx_v_predictor_8x8_msa,
-                vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_tm_predictor_8x8_msa)
+                vpx_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_tm_predictor_8x8_msa)
 #endif  // HAVE_MSA
 
 // -----------------------------------------------------------------------------
@@ -296,11 +270,10 @@
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_d45_predictor_16x16_ssse3,
-                NULL, NULL, vpx_d153_predictor_16x16_ssse3,
-                vpx_d207_predictor_16x16_ssse3, vpx_d63_predictor_16x16_ssse3,
-                NULL)
+INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_d45_predictor_16x16_ssse3, NULL, NULL,
+                vpx_d153_predictor_16x16_ssse3, vpx_d207_predictor_16x16_ssse3,
+                vpx_d63_predictor_16x16_ssse3, NULL)
 #endif  // HAVE_SSSE3
 
 #if HAVE_DSPR2
@@ -322,8 +295,8 @@
 INTRA_PRED_TEST(MSA, TestIntraPred16, vpx_dc_predictor_16x16_msa,
                 vpx_dc_left_predictor_16x16_msa, vpx_dc_top_predictor_16x16_msa,
                 vpx_dc_128_predictor_16x16_msa, vpx_v_predictor_16x16_msa,
-                vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_tm_predictor_16x16_msa)
+                vpx_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_tm_predictor_16x16_msa)
 #endif  // HAVE_MSA
 
 // -----------------------------------------------------------------------------
@@ -342,13 +315,13 @@
                 vpx_dc_left_predictor_32x32_sse2,
                 vpx_dc_top_predictor_32x32_sse2,
                 vpx_dc_128_predictor_32x32_sse2, vpx_v_predictor_32x32_sse2,
-                vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_tm_predictor_32x32_sse2)
+                vpx_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_tm_predictor_32x32_sse2)
 #endif  // HAVE_SSE2
 
 #if HAVE_SSSE3
-INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_d45_predictor_32x32_ssse3, NULL, NULL,
+INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_d45_predictor_32x32_ssse3, NULL, NULL,
                 vpx_d153_predictor_32x32_ssse3, vpx_d207_predictor_32x32_ssse3,
                 vpx_d63_predictor_32x32_ssse3, NULL)
 #endif  // HAVE_SSSE3
@@ -366,8 +339,8 @@
 INTRA_PRED_TEST(MSA, TestIntraPred32, vpx_dc_predictor_32x32_msa,
                 vpx_dc_left_predictor_32x32_msa, vpx_dc_top_predictor_32x32_msa,
                 vpx_dc_128_predictor_32x32_msa, vpx_v_predictor_32x32_msa,
-                vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL,
-                NULL, vpx_tm_predictor_32x32_msa)
+                vpx_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
+                vpx_tm_predictor_32x32_msa)
 #endif  // HAVE_MSA
 
 #include "test/test_libvpx.cc"
diff --git a/test/test_libvpx.cc b/test/test_libvpx.cc
index b59d876..9867f9d 100644
--- a/test/test_libvpx.cc
+++ b/test/test_libvpx.cc
@@ -38,22 +38,16 @@
 
 #if ARCH_X86 || ARCH_X86_64
   const int simd_caps = x86_simd_caps();
-  if (!(simd_caps & HAS_MMX))
-    append_negative_gtest_filter(":MMX.*:MMX/*");
-  if (!(simd_caps & HAS_SSE))
-    append_negative_gtest_filter(":SSE.*:SSE/*");
-  if (!(simd_caps & HAS_SSE2))
-    append_negative_gtest_filter(":SSE2.*:SSE2/*");
-  if (!(simd_caps & HAS_SSE3))
-    append_negative_gtest_filter(":SSE3.*:SSE3/*");
+  if (!(simd_caps & HAS_MMX)) append_negative_gtest_filter(":MMX.*:MMX/*");
+  if (!(simd_caps & HAS_SSE)) append_negative_gtest_filter(":SSE.*:SSE/*");
+  if (!(simd_caps & HAS_SSE2)) append_negative_gtest_filter(":SSE2.*:SSE2/*");
+  if (!(simd_caps & HAS_SSE3)) append_negative_gtest_filter(":SSE3.*:SSE3/*");
   if (!(simd_caps & HAS_SSSE3))
     append_negative_gtest_filter(":SSSE3.*:SSSE3/*");
   if (!(simd_caps & HAS_SSE4_1))
     append_negative_gtest_filter(":SSE4_1.*:SSE4_1/*");
-  if (!(simd_caps & HAS_AVX))
-    append_negative_gtest_filter(":AVX.*:AVX/*");
-  if (!(simd_caps & HAS_AVX2))
-    append_negative_gtest_filter(":AVX2.*:AVX2/*");
+  if (!(simd_caps & HAS_AVX)) append_negative_gtest_filter(":AVX.*:AVX/*");
+  if (!(simd_caps & HAS_AVX2)) append_negative_gtest_filter(":AVX2.*:AVX2/*");
 #endif  // ARCH_X86 || ARCH_X86_64
 
 #if !CONFIG_SHARED
diff --git a/test/tile_independence_test.cc b/test/tile_independence_test.cc
index 1fa14a2..6fb8adb 100644
--- a/test/tile_independence_test.cc
+++ b/test/tile_independence_test.cc
@@ -20,16 +20,13 @@
 #include "vpx_mem/vpx_mem.h"
 
 namespace {
-class TileIndependenceTest : public ::libvpx_test::EncoderTest,
-                             public ::libvpx_test::CodecTestWith2Params<int,
-                                                                        int> {
+class TileIndependenceTest
+    : public ::libvpx_test::EncoderTest,
+      public ::libvpx_test::CodecTestWith2Params<int, int> {
  protected:
   TileIndependenceTest()
-      : EncoderTest(GET_PARAM(0)),
-        md5_fw_order_(),
-        md5_inv_order_(),
-        n_tile_cols_(GET_PARAM(1)),
-        n_tile_rows_(GET_PARAM(2)) {
+      : EncoderTest(GET_PARAM(0)), md5_fw_order_(), md5_inv_order_(),
+        n_tile_cols_(GET_PARAM(1)), n_tile_rows_(GET_PARAM(2)) {
     init_flags_ = VPX_CODEC_USE_PSNR;
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
     cfg.w = 704;
@@ -76,7 +73,7 @@
   void UpdateMD5(::libvpx_test::Decoder *dec, const vpx_codec_cx_pkt_t *pkt,
                  ::libvpx_test::MD5 *md5) {
     const vpx_codec_err_t res = dec->DecodeFrame(
-        reinterpret_cast<uint8_t*>(pkt->data.frame.buf), pkt->data.frame.sz);
+        reinterpret_cast<uint8_t *>(pkt->data.frame.buf), pkt->data.frame.sz);
     if (res != VPX_CODEC_OK) {
       abort_ = true;
       ASSERT_EQ(VPX_CODEC_OK, res);
@@ -117,9 +114,7 @@
 // run an encode with 2 or 4 tiles, and do the decode both in normal and
 // inverted tile ordering. Ensure that the MD5 of the output in both cases
 // is identical. If so, tiles are considered independent and the test passes.
-TEST_P(TileIndependenceTest, MD5Match) {
-  DoTest();
-}
+TEST_P(TileIndependenceTest, MD5Match) { DoTest(); }
 
 class TileIndependenceTestLarge : public TileIndependenceTest {
   virtual void SetCpuUsed(libvpx_test::Encoder *encoder) {
@@ -128,22 +123,18 @@
   }
 };
 
-TEST_P(TileIndependenceTestLarge, MD5Match) {
-  DoTest();
-}
-
+TEST_P(TileIndependenceTestLarge, MD5Match) { DoTest(); }
 
 #if CONFIG_EXT_TILE
 VP10_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(1, 2, 32),
-                                                 ::testing::Values(1, 2, 32));
+                           ::testing::Values(1, 2, 32));
 VP10_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge,
                            ::testing::Values(1, 2, 32),
                            ::testing::Values(1, 2, 32));
 #else
 VP10_INSTANTIATE_TEST_CASE(TileIndependenceTest, ::testing::Values(0, 1),
-                                                 ::testing::Values(0, 1));
-VP10_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge,
-                           ::testing::Values(0, 1),
+                           ::testing::Values(0, 1));
+VP10_INSTANTIATE_TEST_CASE(TileIndependenceTestLarge, ::testing::Values(0, 1),
                            ::testing::Values(0, 1));
 #endif  // CONFIG_EXT_TILE
 }  // namespace
diff --git a/test/transform_test_base.h b/test/transform_test_base.h
index cf2facd..071018c 100644
--- a/test/transform_test_base.h
+++ b/test/transform_test_base.h
@@ -14,7 +14,6 @@
 #include "vpx_mem/vpx_mem.h"
 #include "vpx/vpx_codec.h"
 
-
 namespace libvpx_test {
 
 //  Note:
@@ -44,19 +43,19 @@
     int64_t total_error = 0;
     const int count_test_block = 10000;
 
-    int16_t *test_input_block = reinterpret_cast<int16_t *>
-        (vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
-    tran_low_t *test_temp_block = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
-    uint8_t *dst = reinterpret_cast<uint8_t *>
-        (vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
-    uint8_t *src = reinterpret_cast<uint8_t *>
-        (vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+    int16_t *test_input_block = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+    tran_low_t *test_temp_block = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    uint8_t *dst = reinterpret_cast<uint8_t *>(
+        vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+    uint8_t *src = reinterpret_cast<uint8_t *>(
+        vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
 #if CONFIG_VP9_HIGHBITDEPTH
-    uint16_t *dst16 = reinterpret_cast<uint16_t *>
-        (vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
-    uint16_t *src16 = reinterpret_cast<uint16_t *>
-        (vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+    uint16_t *dst16 = reinterpret_cast<uint16_t *>(
+        vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+    uint16_t *src16 = reinterpret_cast<uint16_t *>(
+        vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
 #endif
 
     for (int i = 0; i < count_test_block; ++i) {
@@ -75,14 +74,14 @@
         }
       }
 
-      ASM_REGISTER_STATE_CHECK(RunFwdTxfm(test_input_block,
-                                          test_temp_block, pitch_));
+      ASM_REGISTER_STATE_CHECK(
+          RunFwdTxfm(test_input_block, test_temp_block, pitch_));
       if (bit_depth_ == VPX_BITS_8) {
         ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(test_temp_block,
-                                            CONVERT_TO_BYTEPTR(dst16), pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(test_temp_block, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif
       }
 
@@ -95,15 +94,13 @@
         const uint32_t diff = dst[j] - src[j];
 #endif
         const uint32_t error = diff * diff;
-        if (max_error < error)
-          max_error = error;
+        if (max_error < error) max_error = error;
         total_error += error;
       }
     }
 
     EXPECT_GE(static_cast<uint32_t>(limit), max_error)
-        << "Error: 4x4 FHT/IHT has an individual round trip error > "
-        << limit;
+        << "Error: 4x4 FHT/IHT has an individual round trip error > " << limit;
 
     EXPECT_GE(count_test_block * limit, total_error)
         << "Error: 4x4 FHT/IHT has average round trip error > " << limit
@@ -123,12 +120,12 @@
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 5000;
 
-    int16_t *input_block = reinterpret_cast<int16_t *>
-        (vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
-    tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
-    tran_low_t *output_block = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    int16_t *input_block = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+    tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    tran_low_t *output_block = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
 
     for (int i = 0; i < count_test_block; ++i) {
       // Initialize a test block with input range [-mask_, mask_].
@@ -154,12 +151,12 @@
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 5000;
 
-    int16_t *input_extreme_block = reinterpret_cast<int16_t *>
-        (vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
-    tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
-    tran_low_t *output_block = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    int16_t *input_extreme_block = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+    tran_low_t *output_ref_block = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    tran_low_t *output_block = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
 
     for (int i = 0; i < count_test_block; ++i) {
       // Initialize a test block with input range [-mask_, mask_].
@@ -167,16 +164,14 @@
         input_extreme_block[j] = rnd.Rand8() % 2 ? mask_ : -mask_;
       }
       if (i == 0) {
-        for (int j = 0; j < num_coeffs_; ++j)
-          input_extreme_block[j] = mask_;
+        for (int j = 0; j < num_coeffs_; ++j) input_extreme_block[j] = mask_;
       } else if (i == 1) {
-        for (int j = 0; j < num_coeffs_; ++j)
-          input_extreme_block[j] = -mask_;
+        for (int j = 0; j < num_coeffs_; ++j) input_extreme_block[j] = -mask_;
       }
 
       fwd_txfm_ref(input_extreme_block, output_ref_block, pitch_, tx_type_);
-      ASM_REGISTER_STATE_CHECK(RunFwdTxfm(input_extreme_block,
-                                          output_block, pitch_));
+      ASM_REGISTER_STATE_CHECK(
+          RunFwdTxfm(input_extreme_block, output_block, pitch_));
 
       int row_length = FindRowLength();
       // The minimum quant value is 4.
@@ -196,20 +191,20 @@
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 1000;
 
-    int16_t *in = reinterpret_cast<int16_t *>
-        (vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
-    tran_low_t *coeff = reinterpret_cast<tran_low_t *>
-        (vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
-    uint8_t *dst = reinterpret_cast<uint8_t *>
-        (vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
-    uint8_t *src = reinterpret_cast<uint8_t *>
-        (vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+    int16_t *in = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * num_coeffs_));
+    tran_low_t *coeff = reinterpret_cast<tran_low_t *>(
+        vpx_memalign(16, sizeof(tran_low_t) * num_coeffs_));
+    uint8_t *dst = reinterpret_cast<uint8_t *>(
+        vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
+    uint8_t *src = reinterpret_cast<uint8_t *>(
+        vpx_memalign(16, sizeof(uint8_t) * num_coeffs_));
 
 #if CONFIG_VP9_HIGHBITDEPTH
-    uint16_t *dst16 = reinterpret_cast<uint16_t *>
-        (vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
-    uint16_t *src16 = reinterpret_cast<uint16_t *>
-        (vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+    uint16_t *dst16 = reinterpret_cast<uint16_t *>(
+        vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
+    uint16_t *src16 = reinterpret_cast<uint16_t *>(
+        vpx_memalign(16, sizeof(uint16_t) * num_coeffs_));
 #endif
 
     for (int i = 0; i < count_test_block; ++i) {
@@ -234,8 +229,8 @@
         ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, dst, pitch_));
 #if CONFIG_VP9_HIGHBITDEPTH
       } else {
-        ASM_REGISTER_STATE_CHECK(RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16),
-                                            pitch_));
+        ASM_REGISTER_STATE_CHECK(
+            RunInvTxfm(coeff, CONVERT_TO_BYTEPTR(dst16), pitch_));
 #endif
       }
 
@@ -248,8 +243,7 @@
 #endif
         const uint32_t error = diff * diff;
         EXPECT_GE(static_cast<uint32_t>(limit), error)
-            << "Error: 4x4 IDCT has error " << error
-            << " at index " << j;
+            << "Error: 4x4 IDCT has error " << error << " at index " << j;
       }
     }
     vpx_free(in);
diff --git a/test/user_priv_test.cc b/test/user_priv_test.cc
index 8512d88..4b5de09 100644
--- a/test/user_priv_test.cc
+++ b/test/user_priv_test.cc
@@ -34,8 +34,8 @@
 
 void CheckUserPrivateData(void *user_priv, int *target) {
   // actual pointer value should be the same as expected.
-  EXPECT_EQ(reinterpret_cast<void *>(target), user_priv) <<
-      "user_priv pointer value does not match.";
+  EXPECT_EQ(reinterpret_cast<void *>(target), user_priv)
+      << "user_priv pointer value does not match.";
 }
 
 // Decodes |filename|. Passes in user_priv data when calling DecodeFrame and
diff --git a/test/util.h b/test/util.h
index b27bffa..0ef2ad8 100644
--- a/test/util.h
+++ b/test/util.h
@@ -17,14 +17,13 @@
 #include "vpx/vpx_image.h"
 
 // Macros
-#define GET_PARAM(k) std::tr1::get< k >(GetParam())
+#define GET_PARAM(k) std::tr1::get<k>(GetParam())
 
 inline double compute_psnr(const vpx_image_t *img1, const vpx_image_t *img2) {
-  assert((img1->fmt == img2->fmt) &&
-         (img1->d_w == img2->d_w) &&
+  assert((img1->fmt == img2->fmt) && (img1->d_w == img2->d_w) &&
          (img1->d_h == img2->d_h));
 
-  const unsigned int width_y  = img1->d_w;
+  const unsigned int width_y = img1->d_w;
   const unsigned int height_y = img1->d_h;
   unsigned int i, j;
 
diff --git a/test/variance_test.cc b/test/variance_test.cc
index 0c1d409..e8b5669 100644
--- a/test/variance_test.cc
+++ b/test/variance_test.cc
@@ -832,63 +832,62 @@
 
 const VarianceParams kArrayHBDVariance_c[] = {
 #if CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(7, 7, &vpx_highbd_12_variance128x128_c, 12),
-        VarianceParams(7, 6, &vpx_highbd_12_variance128x64_c, 12),
-        VarianceParams(6, 7, &vpx_highbd_12_variance64x128_c, 12),
+  VarianceParams(7, 7, &vpx_highbd_12_variance128x128_c, 12),
+  VarianceParams(7, 6, &vpx_highbd_12_variance128x64_c, 12),
+  VarianceParams(6, 7, &vpx_highbd_12_variance64x128_c, 12),
 #endif  // CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
-        VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12),
-        VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12),
-        VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
-        VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12),
-        VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12),
-        VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
-        VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
-        VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
-        VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
-        VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
-        VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12),
-        VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12),
+  VarianceParams(6, 6, &vpx_highbd_12_variance64x64_c, 12),
+  VarianceParams(6, 5, &vpx_highbd_12_variance64x32_c, 12),
+  VarianceParams(5, 6, &vpx_highbd_12_variance32x64_c, 12),
+  VarianceParams(5, 5, &vpx_highbd_12_variance32x32_c, 12),
+  VarianceParams(5, 4, &vpx_highbd_12_variance32x16_c, 12),
+  VarianceParams(4, 5, &vpx_highbd_12_variance16x32_c, 12),
+  VarianceParams(4, 4, &vpx_highbd_12_variance16x16_c, 12),
+  VarianceParams(4, 3, &vpx_highbd_12_variance16x8_c, 12),
+  VarianceParams(3, 4, &vpx_highbd_12_variance8x16_c, 12),
+  VarianceParams(3, 3, &vpx_highbd_12_variance8x8_c, 12),
+  VarianceParams(3, 2, &vpx_highbd_12_variance8x4_c, 12),
+  VarianceParams(2, 3, &vpx_highbd_12_variance4x8_c, 12),
+  VarianceParams(2, 2, &vpx_highbd_12_variance4x4_c, 12),
 #if CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(7, 7, &vpx_highbd_10_variance128x128_c, 10),
-        VarianceParams(7, 6, &vpx_highbd_10_variance128x64_c, 10),
-        VarianceParams(6, 7, &vpx_highbd_10_variance64x128_c, 10),
+  VarianceParams(7, 7, &vpx_highbd_10_variance128x128_c, 10),
+  VarianceParams(7, 6, &vpx_highbd_10_variance128x64_c, 10),
+  VarianceParams(6, 7, &vpx_highbd_10_variance64x128_c, 10),
 #endif  // CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
-        VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
-        VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10),
-        VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10),
-        VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
-        VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10),
-        VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
-        VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
-        VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10),
-        VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
-        VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
-        VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
-        VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
+  VarianceParams(6, 6, &vpx_highbd_10_variance64x64_c, 10),
+  VarianceParams(6, 5, &vpx_highbd_10_variance64x32_c, 10),
+  VarianceParams(5, 6, &vpx_highbd_10_variance32x64_c, 10),
+  VarianceParams(5, 5, &vpx_highbd_10_variance32x32_c, 10),
+  VarianceParams(5, 4, &vpx_highbd_10_variance32x16_c, 10),
+  VarianceParams(4, 5, &vpx_highbd_10_variance16x32_c, 10),
+  VarianceParams(4, 4, &vpx_highbd_10_variance16x16_c, 10),
+  VarianceParams(4, 3, &vpx_highbd_10_variance16x8_c, 10),
+  VarianceParams(3, 4, &vpx_highbd_10_variance8x16_c, 10),
+  VarianceParams(3, 3, &vpx_highbd_10_variance8x8_c, 10),
+  VarianceParams(3, 2, &vpx_highbd_10_variance8x4_c, 10),
+  VarianceParams(2, 3, &vpx_highbd_10_variance4x8_c, 10),
+  VarianceParams(2, 2, &vpx_highbd_10_variance4x4_c, 10),
 #if CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(7, 7, &vpx_highbd_8_variance128x128_c, 8),
-        VarianceParams(7, 6, &vpx_highbd_8_variance128x64_c, 8),
-        VarianceParams(6, 7, &vpx_highbd_8_variance64x128_c, 8),
+  VarianceParams(7, 7, &vpx_highbd_8_variance128x128_c, 8),
+  VarianceParams(7, 6, &vpx_highbd_8_variance128x64_c, 8),
+  VarianceParams(6, 7, &vpx_highbd_8_variance64x128_c, 8),
 #endif  // CONFIG_VP10 && CONFIG_EXT_PARTITION
-        VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
-        VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
-        VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8),
-        VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
-        VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
-        VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
-        VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
-        VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
-        VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
-        VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
-        VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
-        VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
-        VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)
+  VarianceParams(6, 6, &vpx_highbd_8_variance64x64_c, 8),
+  VarianceParams(6, 5, &vpx_highbd_8_variance64x32_c, 8),
+  VarianceParams(5, 6, &vpx_highbd_8_variance32x64_c, 8),
+  VarianceParams(5, 5, &vpx_highbd_8_variance32x32_c, 8),
+  VarianceParams(5, 4, &vpx_highbd_8_variance32x16_c, 8),
+  VarianceParams(4, 5, &vpx_highbd_8_variance16x32_c, 8),
+  VarianceParams(4, 4, &vpx_highbd_8_variance16x16_c, 8),
+  VarianceParams(4, 3, &vpx_highbd_8_variance16x8_c, 8),
+  VarianceParams(3, 4, &vpx_highbd_8_variance8x16_c, 8),
+  VarianceParams(3, 3, &vpx_highbd_8_variance8x8_c, 8),
+  VarianceParams(3, 2, &vpx_highbd_8_variance8x4_c, 8),
+  VarianceParams(2, 3, &vpx_highbd_8_variance4x8_c, 8),
+  VarianceParams(2, 2, &vpx_highbd_8_variance4x4_c, 8)
 };
-INSTANTIATE_TEST_CASE_P(
-    C, VpxHBDVarianceTest,
-    ::testing::ValuesIn(kArrayHBDVariance_c));
+INSTANTIATE_TEST_CASE_P(C, VpxHBDVarianceTest,
+                        ::testing::ValuesIn(kArrayHBDVariance_c));
 
 #if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 INSTANTIATE_TEST_CASE_P(
diff --git a/test/video_source.h b/test/video_source.h
index ade323e..94a95ce 100644
--- a/test/video_source.h
+++ b/test/video_source.h
@@ -51,7 +51,7 @@
 #undef TO_STRING
 #undef STRINGIFY
 
-inline FILE *OpenTestDataFile(const std::string& file_name) {
+inline FILE *OpenTestDataFile(const std::string &file_name) {
   const std::string path_to_source = GetDataPath() + "/" + file_name;
   return fopen(path_to_source.c_str(), "rb");
 }
@@ -76,21 +76,15 @@
 
 class TempOutFile {
  public:
-  TempOutFile() {
-    file_ = GetTempOutFile(&file_name_);
-  }
+  TempOutFile() { file_ = GetTempOutFile(&file_name_); }
   ~TempOutFile() {
     CloseFile();
     if (!file_name_.empty()) {
       EXPECT_EQ(0, remove(file_name_.c_str()));
     }
   }
-  FILE *file() {
-    return file_;
-  }
-  const std::string& file_name() {
-    return file_name_;
-  }
+  FILE *file() { return file_; }
+  const std::string &file_name() { return file_name_; }
 
  protected:
   void CloseFile() {
@@ -134,14 +128,10 @@
   virtual unsigned int limit() const = 0;
 };
 
-
 class DummyVideoSource : public VideoSource {
  public:
   DummyVideoSource()
-      : img_(NULL),
-        limit_(100),
-        width_(80),
-        height_(64),
+      : img_(NULL), limit_(100), width_(80), height_(64),
         format_(VPX_IMG_FMT_I420) {
     ReallocImage();
   }
@@ -158,9 +148,7 @@
     FillFrame();
   }
 
-  virtual vpx_image_t *img() const {
-    return (frame_ < limit_) ? img_ : NULL;
-  }
+  virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
 
   // Models a stream where Timebase = 1/FPS, so pts == frame.
   virtual vpx_codec_pts_t pts() const { return frame_; }
@@ -168,7 +156,7 @@
   virtual unsigned long duration() const { return 1; }
 
   virtual vpx_rational_t timebase() const {
-    const vpx_rational_t t = {1, 30};
+    const vpx_rational_t t = { 1, 30 };
     return t;
   }
 
@@ -176,9 +164,7 @@
 
   virtual unsigned int limit() const { return limit_; }
 
-  void set_limit(unsigned int limit) {
-    limit_ = limit;
-  }
+  void set_limit(unsigned int limit) { limit_ = limit; }
 
   void SetSize(unsigned int width, unsigned int height) {
     if (width != width_ || height != height_) {
@@ -196,7 +182,9 @@
   }
 
  protected:
-  virtual void FillFrame() { if (img_) memset(img_->img_data, 0, raw_sz_); }
+  virtual void FillFrame() {
+    if (img_) memset(img_->img_data, 0, raw_sz_);
+  }
 
   void ReallocImage() {
     vpx_img_free(img_);
@@ -205,7 +193,7 @@
   }
 
   vpx_image_t *img_;
-  size_t       raw_sz_;
+  size_t raw_sz_;
   unsigned int limit_;
   unsigned int frame_;
   unsigned int width_;
@@ -213,12 +201,10 @@
   vpx_img_fmt_t format_;
 };
 
-
 class RandomVideoSource : public DummyVideoSource {
  public:
   RandomVideoSource(int seed = ACMRandom::DeterministicSeed())
-      : rnd_(seed),
-        seed_(seed) { }
+      : rnd_(seed), seed_(seed) {}
 
  protected:
   // Reset the RNG to get a matching stream for the second pass
@@ -233,8 +219,7 @@
   virtual void FillFrame() {
     if (img_) {
       if (frame_ % 30 < 15)
-        for (size_t i = 0; i < raw_sz_; ++i)
-          img_->img_data[i] = rnd_.Rand8();
+        for (size_t i = 0; i < raw_sz_; ++i) img_->img_data[i] = rnd_.Rand8();
       else
         memset(img_->img_data, 0, raw_sz_);
     }
diff --git a/test/vp10_ans_test.cc b/test/vp10_ans_test.cc
index 20aedba..ca89f20 100644
--- a/test/vp10_ans_test.cc
+++ b/test/vp10_ans_test.cc
@@ -151,7 +151,10 @@
 // TODO(aconverse): replace this with a more representative distribution from
 // the codec.
 const rans_sym rans_sym_tab[] = {
-    {16 * 4, 0 * 4}, {100 * 4, 16 * 4}, {70 * 4, 116 *4}, {70 * 4, 186 *4},
+  { 16 * 4, 0 * 4 },
+  { 100 * 4, 16 * 4 },
+  { 70 * 4, 116 * 4 },
+  { 70 * 4, 186 * 4 },
 };
 const int kDistinctSyms = sizeof(rans_sym_tab) / sizeof(rans_sym_tab[0]);
 
@@ -172,8 +175,7 @@
   return ret;
 }
 
-void rans_build_dec_tab(const struct rans_sym sym_tab[],
-                        rans_dec_lut dec_tab) {
+void rans_build_dec_tab(const struct rans_sym sym_tab[], rans_dec_lut dec_tab) {
   dec_tab[0] = 0;
   for (int i = 1; dec_tab[i - 1] < rans_precision; ++i) {
     dec_tab[i] = dec_tab[i - 1] + sym_tab[i - 1].prob;
diff --git a/test/vp10_convolve_optimz_test.cc b/test/vp10_convolve_optimz_test.cc
index ec77035..2235088 100644
--- a/test/vp10_convolve_optimz_test.cc
+++ b/test/vp10_convolve_optimz_test.cc
@@ -21,21 +21,20 @@
 using std::tr1::tuple;
 using libvpx_test::ACMRandom;
 
-typedef void (*conv_filter_t)(const uint8_t*, int, uint8_t*, int,
-                              int, int, const InterpFilterParams,
-                              const int, int, int);
+typedef void (*conv_filter_t)(const uint8_t *, int, uint8_t *, int, int, int,
+                              const InterpFilterParams, const int, int, int);
 #if CONFIG_VP9_HIGHBITDEPTH
-typedef void (*hbd_conv_filter_t)(const uint16_t*, int, uint16_t*, int,
-                                  int, int, const InterpFilterParams,
-                                  const int, int, int, int);
+typedef void (*hbd_conv_filter_t)(const uint16_t *, int, uint16_t *, int, int,
+                                  int, const InterpFilterParams, const int, int,
+                                  int, int);
 #endif
 
 // Test parameter list:
 //  <convolve_horiz_func, convolve_vert_func,
 //  <width, height>, filter_params, subpel_x_q4, avg>
 typedef tuple<int, int> BlockDimension;
-typedef tuple<conv_filter_t, conv_filter_t, BlockDimension, INTERP_FILTER,
-              int, int> ConvParams;
+typedef tuple<conv_filter_t, conv_filter_t, BlockDimension, INTERP_FILTER, int,
+              int> ConvParams;
 #if CONFIG_VP9_HIGHBITDEPTH
 // Test parameter list:
 //  <convolve_horiz_func, convolve_vert_func,
@@ -136,10 +135,11 @@
   for (r = 0; r < height_; ++r) {
     for (c = 0; c < width_; ++c) {
       EXPECT_EQ((uint8_t)dst_ref_ptr[c], (uint8_t)dst_ptr[c])
-      << "Error at row: " << r << " col: " << c << " "
-      << "w = " << width_ << " " << "h = " << height_ << " "
-      << "filter group index = " << filter_ << " "
-      << "filter index = " << subpel_;
+          << "Error at row: " << r << " col: " << c << " "
+          << "w = " << width_ << " "
+          << "h = " << height_ << " "
+          << "filter group index = " << filter_ << " "
+          << "filter index = " << subpel_;
     }
     dst_ptr += stride;
     dst_ref_ptr += stride;
@@ -154,8 +154,8 @@
   vp10_convolve_horiz_c(src_ref_, stride, dst_ref_, stride, width_, height_,
                         filter_params, subpel_, x_step_q4, avg_);
 
-  conv_horiz_(src_, stride, dst_, stride, width_, height_,
-              filter_params, subpel_, x_step_q4, avg_);
+  conv_horiz_(src_, stride, dst_, stride, width_, height_, filter_params,
+              subpel_, x_step_q4, avg_);
 
   DiffFilterBuffer();
 
@@ -170,9 +170,8 @@
                         intermediate_height, filter_params, subpel_, x_step_q4,
                         avg_);
 
-  conv_horiz_(src_, stride, dst_, stride, width_,
-              intermediate_height, filter_params, subpel_, x_step_q4,
-              avg_);
+  conv_horiz_(src_, stride, dst_, stride, width_, intermediate_height,
+              filter_params, subpel_, x_step_q4, avg_);
 
   DiffFilterBuffer();
 }
@@ -185,8 +184,8 @@
   vp10_convolve_vert_c(src_ref_, stride, dst_ref_, stride, width_, height_,
                        filter_params, subpel_, x_step_q4, avg_);
 
-  conv_vert_(src_, stride, dst_, stride, width_, height_,
-             filter_params, subpel_, x_step_q4, avg_);
+  conv_vert_(src_, stride, dst_, stride, width_, height_, filter_params,
+             subpel_, x_step_q4, avg_);
 
   DiffFilterBuffer();
 }
@@ -202,44 +201,31 @@
 
 #if (HAVE_SSSE3 || HAVE_SSE4_1) && CONFIG_EXT_INTERP
 const BlockDimension kBlockDim[] = {
-  make_tuple(2, 2),
-  make_tuple(2, 4),
-  make_tuple(4, 4),
-  make_tuple(4, 8),
-  make_tuple(8, 4),
-  make_tuple(8, 8),
-  make_tuple(8, 16),
-  make_tuple(16, 8),
-  make_tuple(16, 16),
-  make_tuple(16, 32),
-  make_tuple(32, 16),
-  make_tuple(32, 32),
-  make_tuple(32, 64),
-  make_tuple(64, 32),
-  make_tuple(64, 64),
-  make_tuple(64, 128),
-  make_tuple(128, 64),
-  make_tuple(128, 128),
+  make_tuple(2, 2),    make_tuple(2, 4),    make_tuple(4, 4),
+  make_tuple(4, 8),    make_tuple(8, 4),    make_tuple(8, 8),
+  make_tuple(8, 16),   make_tuple(16, 8),   make_tuple(16, 16),
+  make_tuple(16, 32),  make_tuple(32, 16),  make_tuple(32, 32),
+  make_tuple(32, 64),  make_tuple(64, 32),  make_tuple(64, 64),
+  make_tuple(64, 128), make_tuple(128, 64), make_tuple(128, 128),
 };
 
 // 10/12-tap filters
-const INTERP_FILTER kFilter[] = {6, 4, 2};
+const INTERP_FILTER kFilter[] = { 6, 4, 2 };
 
-const int kSubpelQ4[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+const int kSubpelQ4[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
 
-const int kAvg[] = {0, 1};
+const int kAvg[] = { 0, 1 };
 #endif
 
 #if HAVE_SSSE3 && CONFIG_EXT_INTERP
 INSTANTIATE_TEST_CASE_P(
     SSSE3, VP10ConvolveOptimzTest,
-    ::testing::Combine(
-         ::testing::Values(vp10_convolve_horiz_ssse3),
-         ::testing::Values(vp10_convolve_vert_ssse3),
-         ::testing::ValuesIn(kBlockDim),
-         ::testing::ValuesIn(kFilter),
-         ::testing::ValuesIn(kSubpelQ4),
-         ::testing::ValuesIn(kAvg)));
+    ::testing::Combine(::testing::Values(vp10_convolve_horiz_ssse3),
+                       ::testing::Values(vp10_convolve_vert_ssse3),
+                       ::testing::ValuesIn(kBlockDim),
+                       ::testing::ValuesIn(kFilter),
+                       ::testing::ValuesIn(kSubpelQ4),
+                       ::testing::ValuesIn(kAvg)));
 #endif  // HAVE_SSSE3 && CONFIG_EXT_INTERP
 
 #if CONFIG_VP9_HIGHBITDEPTH
@@ -324,11 +310,12 @@
   for (r = 0; r < height_; ++r) {
     for (c = 0; c < width_; ++c) {
       EXPECT_EQ((uint16_t)dst_ref_ptr[c], (uint16_t)dst_ptr[c])
-      << "Error at row: " << r << " col: " << c << " "
-      << "w = " << width_ << " " << "h = " << height_ << " "
-      << "filter group index = " << filter_ << " "
-      << "filter index = " << subpel_ << " "
-      << "bit depth = " << bit_depth_;
+          << "Error at row: " << r << " col: " << c << " "
+          << "w = " << width_ << " "
+          << "h = " << height_ << " "
+          << "filter group index = " << filter_ << " "
+          << "filter index = " << subpel_ << " "
+          << "bit depth = " << bit_depth_;
     }
     dst_ptr += stride;
     dst_ref_ptr += stride;
@@ -340,12 +327,12 @@
 
   InterpFilterParams filter_params = vp10_get_interp_filter_params(filter_);
 
-  vp10_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_,
-                               height_, filter_params, subpel_, x_step_q4,
-                               avg_, bit_depth_);
+  vp10_highbd_convolve_horiz_c(src_, stride, dst_ref_, stride, width_, height_,
+                               filter_params, subpel_, x_step_q4, avg_,
+                               bit_depth_);
 
-  conv_horiz_(src_, stride, dst_, stride, width_, height_,
-              filter_params, subpel_, x_step_q4, avg_, bit_depth_);
+  conv_horiz_(src_, stride, dst_, stride, width_, height_, filter_params,
+              subpel_, x_step_q4, avg_, bit_depth_);
 
   DiffFilterBuffer();
 
@@ -375,8 +362,8 @@
                               filter_params, subpel_, x_step_q4, avg_,
                               bit_depth_);
 
-  conv_vert_(src_, stride, dst_, stride, width_, height_,
-             filter_params, subpel_, x_step_q4, avg_, bit_depth_);
+  conv_vert_(src_, stride, dst_, stride, width_, height_, filter_params,
+             subpel_, x_step_q4, avg_, bit_depth_);
 
   DiffFilterBuffer();
 }
@@ -390,18 +377,17 @@
 
 #if HAVE_SSE4_1 && CONFIG_EXT_INTERP
 
-const int kBitdepth[] = {10, 12};
+const int kBitdepth[] = { 10, 12 };
 
 INSTANTIATE_TEST_CASE_P(
     SSE4_1, VP10HbdConvolveOptimzTest,
-    ::testing::Combine(
-         ::testing::Values(vp10_highbd_convolve_horiz_sse4_1),
-         ::testing::Values(vp10_highbd_convolve_vert_sse4_1),
-         ::testing::ValuesIn(kBlockDim),
-         ::testing::ValuesIn(kFilter),
-         ::testing::ValuesIn(kSubpelQ4),
-         ::testing::ValuesIn(kAvg),
-         ::testing::ValuesIn(kBitdepth)));
+    ::testing::Combine(::testing::Values(vp10_highbd_convolve_horiz_sse4_1),
+                       ::testing::Values(vp10_highbd_convolve_vert_sse4_1),
+                       ::testing::ValuesIn(kBlockDim),
+                       ::testing::ValuesIn(kFilter),
+                       ::testing::ValuesIn(kSubpelQ4),
+                       ::testing::ValuesIn(kAvg),
+                       ::testing::ValuesIn(kBitdepth)));
 #endif  // HAVE_SSE4_1 && CONFIG_EXT_INTERP
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 }  // namespace
diff --git a/test/vp10_convolve_test.cc b/test/vp10_convolve_test.cc
index 9d9ae7f..020c735 100644
--- a/test/vp10_convolve_test.cc
+++ b/test/vp10_convolve_test.cc
@@ -21,10 +21,8 @@
 TEST(VP10ConvolveTest, vp10_convolve8) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
 #if CONFIG_DUAL_FILTER
-  INTERP_FILTER interp_filter[4] = {
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR
-  };
+  INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
+                                     EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
   InterpFilterParams filter_params =
       vp10_get_interp_filter_params(interp_filter[0]);
 #else
@@ -36,8 +34,8 @@
   int filter_center = filter_size / 2 - 1;
   uint8_t src[12 * 12];
   int src_stride = filter_size;
-  uint8_t dst[1] = {0};
-  uint8_t dst1[1] = {0};
+  uint8_t dst[1] = { 0 };
+  uint8_t dst1[1] = { 0 };
   int dst_stride = 1;
   int x_step_q4 = 16;
   int y_step_q4 = 16;
@@ -58,9 +56,9 @@
                 dst, dst_stride, w, h, interp_filter, subpel_x_q4, x_step_q4,
                 subpel_y_q4, y_step_q4, avg);
 
-  const int16_t* x_filter =
+  const int16_t *x_filter =
       vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
-  const int16_t* y_filter =
+  const int16_t *y_filter =
       vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
 
   vpx_convolve8_c(src + src_stride * filter_center + filter_center, src_stride,
@@ -70,10 +68,8 @@
 TEST(VP10ConvolveTest, vp10_convolve) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
 #if CONFIG_DUAL_FILTER
-  INTERP_FILTER interp_filter[4] = {
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR
-  };
+  INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
+                                     EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
   InterpFilterParams filter_params =
       vp10_get_interp_filter_params(interp_filter[0]);
 #else
@@ -85,7 +81,7 @@
   int filter_center = filter_size / 2 - 1;
   uint8_t src[12 * 12];
   int src_stride = filter_size;
-  uint8_t dst[1] = {0};
+  uint8_t dst[1] = { 0 };
   int dst_stride = 1;
   int x_step_q4 = 16;
   int y_step_q4 = 16;
@@ -108,9 +104,9 @@
                     src_stride, dst, dst_stride, w, h, interp_filter,
                     subpel_x_q4, x_step_q4, subpel_y_q4, y_step_q4, avg);
 
-      const int16_t* x_filter =
+      const int16_t *x_filter =
           vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
-      const int16_t* y_filter =
+      const int16_t *y_filter =
           vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
 
       int temp[12];
@@ -132,10 +128,8 @@
 TEST(VP10ConvolveTest, vp10_convolve_avg) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
 #if CONFIG_DUAL_FILTER
-  INTERP_FILTER interp_filter[4] = {
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR
-  };
+  INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
+                                     EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
   InterpFilterParams filter_params =
       vp10_get_interp_filter_params(interp_filter[0]);
 #else
@@ -148,9 +142,9 @@
   uint8_t src0[12 * 12];
   uint8_t src1[12 * 12];
   int src_stride = filter_size;
-  uint8_t dst0[1] = {0};
-  uint8_t dst1[1] = {0};
-  uint8_t dst[1] = {0};
+  uint8_t dst0[1] = { 0 };
+  uint8_t dst1[1] = { 0 };
+  uint8_t dst[1] = { 0 };
   int dst_stride = 1;
   int x_step_q4 = 16;
   int y_step_q4 = 16;
@@ -200,10 +194,8 @@
 TEST(VP10ConvolveTest, vp10_highbd_convolve) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
 #if CONFIG_DUAL_FILTER
-  INTERP_FILTER interp_filter[4] = {
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR
-  };
+  INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
+                                     EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
   InterpFilterParams filter_params =
       vp10_get_interp_filter_params(interp_filter[0]);
 #else
@@ -215,7 +207,7 @@
   int filter_center = filter_size / 2 - 1;
   uint16_t src[12 * 12];
   int src_stride = filter_size;
-  uint16_t dst[1] = {0};
+  uint16_t dst[1] = { 0 };
   int dst_stride = 1;
   int x_step_q4 = 16;
   int y_step_q4 = 16;
@@ -238,9 +230,9 @@
           src_stride, CONVERT_TO_BYTEPTR(dst), dst_stride, w, h, interp_filter,
           subpel_x_q4, x_step_q4, subpel_y_q4, y_step_q4, avg, bd);
 
-      const int16_t* x_filter =
+      const int16_t *x_filter =
           vp10_get_interp_filter_subpel_kernel(filter_params, subpel_x_q4);
-      const int16_t* y_filter =
+      const int16_t *y_filter =
           vp10_get_interp_filter_subpel_kernel(filter_params, subpel_y_q4);
 
       int temp[12];
@@ -263,10 +255,8 @@
 TEST(VP10ConvolveTest, vp10_highbd_convolve_avg) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
 #if CONFIG_DUAL_FILTER
-  INTERP_FILTER interp_filter[4] = {
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
-      EIGHTTAP_REGULAR, EIGHTTAP_REGULAR
-  };
+  INTERP_FILTER interp_filter[4] = { EIGHTTAP_REGULAR, EIGHTTAP_REGULAR,
+                                     EIGHTTAP_REGULAR, EIGHTTAP_REGULAR };
   InterpFilterParams filter_params =
       vp10_get_interp_filter_params(interp_filter[0]);
 #else
@@ -279,9 +269,9 @@
   uint16_t src0[12 * 12];
   uint16_t src1[12 * 12];
   int src_stride = filter_size;
-  uint16_t dst0[1] = {0};
-  uint16_t dst1[1] = {0};
-  uint16_t dst[1] = {0};
+  uint16_t dst0[1] = { 0 };
+  uint16_t dst1[1] = { 0 };
+  uint16_t dst[1] = { 0 };
   int dst_stride = 1;
   int x_step_q4 = 16;
   int y_step_q4 = 16;
@@ -342,9 +332,9 @@
     ptrdiff_t filter_size = filter_params.tap;                               \
     int filter_center = filter_size / 2 - 1;                                 \
     DECLARE_ALIGNED(16, uint16_t,                                            \
-                    src[(frame_size + 7) * (frame_size + 7)]) = {0};         \
+                    src[(frame_size + 7) * (frame_size + 7)]) = { 0 };       \
     int src_stride = frame_size + 7;                                         \
-    DECLARE_ALIGNED(16, uint16_t, dst[frame_size * frame_size]) = {0};       \
+    DECLARE_ALIGNED(16, uint16_t, dst[frame_size * frame_size]) = { 0 };     \
     int dst_stride = frame_size;                                             \
     int x_step_q4 = 16;                                                      \
     int y_step_q4 = 16;                                                      \
@@ -355,9 +345,9 @@
     int w = block_size;                                                      \
     int h = block_size;                                                      \
                                                                              \
-    const int16_t* filter_x =                                                \
+    const int16_t *filter_x =                                                \
         vp10_get_interp_filter_kernel(filter_params, subpel_x_q4);           \
-    const int16_t* filter_y =                                                \
+    const int16_t *filter_y =                                                \
         vp10_get_interp_filter_kernel(filter_params, subpel_y_q4);           \
                                                                              \
     for (int i = 0; i < src_stride * src_stride; i++) {                      \
@@ -406,9 +396,9 @@
     int w = block_size;                                                     \
     int h = block_size;                                                     \
                                                                             \
-    const int16_t* filter_x =                                               \
+    const int16_t *filter_x =                                               \
         vp10_get_interp_filter_kernel(filter_params, subpel_x_q4);          \
-    const int16_t* filter_y =                                               \
+    const int16_t *filter_y =                                               \
         vp10_get_interp_filter_kernel(filter_params, subpel_y_q4);          \
                                                                             \
     for (int i = 0; i < src_stride * src_stride; i++) {                     \
diff --git a/test/vp10_dct_test.cc b/test/vp10_dct_test.cc
index 8cf034f..63e0202 100644
--- a/test/vp10_dct_test.cc
+++ b/test/vp10_dct_test.cc
@@ -32,8 +32,7 @@
     for (int n = 0; n < size; ++n) {
       out[k] += in[n] * cos(PI * (2 * n + 1) * k / (2 * size));
     }
-    if (k == 0)
-      out[k] = out[k] * kInvSqrt2;
+    if (k == 0) out[k] = out[k] * kInvSqrt2;
   }
 }
 
@@ -48,14 +47,14 @@
 
  protected:
   void RunFwdAccuracyCheck() {
-    tran_low_t *input  = new tran_low_t[txfm_size_];
+    tran_low_t *input = new tran_low_t[txfm_size_];
     tran_low_t *output = new tran_low_t[txfm_size_];
-    double *ref_input  = new double[txfm_size_];
+    double *ref_input = new double[txfm_size_];
     double *ref_output = new double[txfm_size_];
 
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 5000;
-    for (int ti =  0; ti < count_test_block; ++ti) {
+    for (int ti = 0; ti < count_test_block; ++ti) {
       for (int ni = 0; ni < txfm_size_; ++ni) {
         input[ni] = rnd.Rand8() - rnd.Rand8();
         ref_input[ni] = static_cast<double>(input[ni]);
@@ -84,9 +83,8 @@
 };
 
 typedef std::tr1::tuple<FdctFunc, FdctFuncRef, int, int> FdctParam;
-class Vp10FwdTxfm
-    : public TransTestBase,
-      public ::testing::TestWithParam<FdctParam> {
+class Vp10FwdTxfm : public TransTestBase,
+                    public ::testing::TestWithParam<FdctParam> {
  public:
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
@@ -97,14 +95,11 @@
   virtual void TearDown() {}
 };
 
-TEST_P(Vp10FwdTxfm, RunFwdAccuracyCheck) {
-  RunFwdAccuracyCheck();
-}
+TEST_P(Vp10FwdTxfm, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
 
 INSTANTIATE_TEST_CASE_P(
     C, Vp10FwdTxfm,
-    ::testing::Values(
-        FdctParam(&fdct4, &reference_dct_1d, 4, 1),
-        FdctParam(&fdct8, &reference_dct_1d, 8, 1),
-        FdctParam(&fdct16, &reference_dct_1d, 16, 2)));
+    ::testing::Values(FdctParam(&fdct4, &reference_dct_1d, 4, 1),
+                      FdctParam(&fdct8, &reference_dct_1d, 8, 1),
+                      FdctParam(&fdct16, &reference_dct_1d, 16, 2)));
 }  // namespace
diff --git a/test/vp10_ext_tile_test.cc b/test/vp10_ext_tile_test.cc
index ad04eeb..e3b24e7 100644
--- a/test/vp10_ext_tile_test.cc
+++ b/test/vp10_ext_tile_test.cc
@@ -34,8 +34,7 @@
       public ::libvpx_test::CodecTestWith2Params<libvpx_test::TestMode, int> {
  protected:
   VP10ExtTileTest()
-      : EncoderTest(GET_PARAM(0)),
-        encoding_mode_(GET_PARAM(1)),
+      : EncoderTest(GET_PARAM(0)), encoding_mode_(GET_PARAM(1)),
         set_cpu_used_(GET_PARAM(2)) {
     init_flags_ = VPX_CODEC_USE_PSNR;
     vpx_codec_dec_cfg_t cfg = vpx_codec_dec_cfg_t();
@@ -70,7 +69,7 @@
     cfg_.rc_min_quantizer = 0;
   }
 
-  virtual void PreEncodeFrameHook(::libvpx_test::VideoSource * video,
+  virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
                                   ::libvpx_test::Encoder *encoder) {
     if (video->frame() == 0) {
       // Encode setting
@@ -88,8 +87,8 @@
     }
 
     if (video->frame() == 1) {
-      frame_flags_ = VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF |
-          VP8_EFLAG_NO_UPD_ARF;
+      frame_flags_ =
+          VP8_EFLAG_NO_UPD_LAST | VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF;
     }
   }
 
@@ -97,8 +96,7 @@
                                      vpx_codec_pts_t pts) {
     // Skip 1 already decoded frame to be consistent with the decoder in this
     // test.
-    if (pts == (vpx_codec_pts_t)kSkip)
-      return;
+    if (pts == (vpx_codec_pts_t)kSkip) return;
 
     // Calculate MD5 as the reference.
     ::libvpx_test::MD5 md5_res;
@@ -108,8 +106,7 @@
 
   virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
     // Skip decoding 1 frame.
-    if (pkt->data.frame.pts == (vpx_codec_pts_t)kSkip)
-      return;
+    if (pkt->data.frame.pts == (vpx_codec_pts_t)kSkip) return;
 
     bool IsLastFrame = (pkt->data.frame.pts == (vpx_codec_pts_t)(kLimit - 1));
 
@@ -126,7 +123,7 @@
         }
 
         const vpx_codec_err_t res = decoder_->DecodeFrame(
-            reinterpret_cast<uint8_t*>(pkt->data.frame.buf),
+            reinterpret_cast<uint8_t *>(pkt->data.frame.buf),
             pkt->data.frame.sz);
         if (res != VPX_CODEC_OK) {
           abort_ = true;
@@ -151,15 +148,14 @@
 
           for (int tr = 0; tr < tile_height; ++tr) {
             memcpy(tile_img_.planes[plane] +
-                   tile_img_.stride[plane] * (r * tile_height + tr) +
-                   c * tile_width,
+                       tile_img_.stride[plane] * (r * tile_height + tr) +
+                       c * tile_width,
                    img->planes[plane] + img->stride[plane] * tr, tile_width);
           }
         }
       }
 
-      if (!IsLastFrame)
-        break;
+      if (!IsLastFrame) break;
     }
 
     if (IsLastFrame) {
@@ -178,8 +174,8 @@
 };
 
 TEST_P(VP10ExtTileTest, DecoderResultTest) {
-  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv",
-                                       kImgWidth, kImgHeight, 30, 1, 0, kLimit);
+  ::libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", kImgWidth,
+                                       kImgHeight, 30, 1, 0, kLimit);
   cfg_.rc_target_bitrate = 500;
   cfg_.g_error_resilient = VPX_ERROR_RESILIENT_DEFAULT;
   cfg_.g_lag_in_frames = 0;
@@ -195,7 +191,6 @@
 
 VP10_INSTANTIATE_TEST_CASE(
     // Now only test 2-pass mode.
-    VP10ExtTileTest,
-    ::testing::Values(::libvpx_test::kTwoPassGood),
+    VP10ExtTileTest, ::testing::Values(::libvpx_test::kTwoPassGood),
     ::testing::Range(0, 4));
 }  // namespace
diff --git a/test/vp10_fht16x16_test.cc b/test/vp10_fht16x16_test.cc
index deccc81..cc15353 100644
--- a/test/vp10_fht16x16_test.cc
+++ b/test/vp10_fht16x16_test.cc
@@ -29,8 +29,7 @@
 using libvpx_test::FhtFunc;
 typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht16x16Param;
 
-void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride,
-                int tx_type) {
+void fht16x16_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
   vp10_fht16x16_c(in, out, stride, tx_type);
 }
 
@@ -49,17 +48,16 @@
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
-class VP10Trans16x16HT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Ht16x16Param> {
+class VP10Trans16x16HT : public libvpx_test::TransformTestBase,
+                         public ::testing::TestWithParam<Ht16x16Param> {
  public:
   virtual ~VP10Trans16x16HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 16;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 16;
     fwd_txfm_ref = fht16x16_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -80,9 +78,7 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(VP10Trans16x16HT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(VP10Trans16x16HT, CoeffCheck) { RunCoeffCheck(); }
 
 #if CONFIG_VP9_HIGHBITDEPTH
 class VP10HighbdTrans16x16HT
@@ -93,7 +89,7 @@
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     fwd_txfm_ref_ = highbd_fht16x16_ref;
-    tx_type_  = GET_PARAM(1);
+    tx_type_ = GET_PARAM(1);
     bit_depth_ = GET_PARAM(2);
     mask_ = (1 << bit_depth_) - 1;
     num_coeffs_ = 256;
@@ -140,90 +136,85 @@
     }
 
     fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
-    ASM_REGISTER_STATE_CHECK(fwd_txfm_(input_, output_, stride, tx_type_,
-                                       bit_depth_));
+    ASM_REGISTER_STATE_CHECK(
+        fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
 
     for (j = 0; j < num_coeffs_; ++j) {
       EXPECT_EQ(output_ref_[j], output_[j])
-          << "Not bit-exact result at index: " << j
-          << " at test block: " << i;
+          << "Not bit-exact result at index: " << j << " at test block: " << i;
     }
   }
 }
 
-TEST_P(VP10HighbdTrans16x16HT, HighbdCoeffCheck) {
-  RunBitexactCheck();
-}
+TEST_P(VP10HighbdTrans16x16HT, HighbdCoeffCheck) { RunBitexactCheck(); }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 using std::tr1::make_tuple;
 
 #if HAVE_SSE2
 const Ht16x16Param kArrayHt16x16Param_sse2[] = {
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 0,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 1,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 2,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 3,
-                 VPX_BITS_8, 256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 0, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 1, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 2, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 3, VPX_BITS_8,
+             256),
 #if CONFIG_EXT_TX
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 4,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 5,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 6,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 7,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 8,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 10,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 11,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 12,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 13,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 14,
-                 VPX_BITS_8, 256),
-      make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 15,
-                 VPX_BITS_8, 256)
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 4, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 5, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 6, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 7, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 8, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 10, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 11, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 12, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 13, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 14, VPX_BITS_8,
+             256),
+  make_tuple(&vp10_fht16x16_sse2, &vp10_iht16x16_256_add_sse2, 15, VPX_BITS_8,
+             256)
 #endif  // CONFIG_EXT_TX
 };
-INSTANTIATE_TEST_CASE_P(
-    SSE2, VP10Trans16x16HT,
-    ::testing::ValuesIn(kArrayHt16x16Param_sse2));
+INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans16x16HT,
+                        ::testing::ValuesIn(kArrayHt16x16Param_sse2));
 #endif  // HAVE_SSE2
 
 #if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 const HighbdHt16x16Param kArrayHBDHt16x16Param_sse4_1[] = {
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 0, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 1, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 2, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 3, 12),
 #if CONFIG_EXT_TX
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 12),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 10),
-    make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 4, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 5, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 6, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 7, 12),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 10),
+  make_tuple(&vp10_fwd_txfm2d_16x16_sse4_1, 8, 12),
 #endif  // CONFIG_EXT_TX
 };
-INSTANTIATE_TEST_CASE_P(
-    SSE4_1, VP10HighbdTrans16x16HT,
-    ::testing::ValuesIn(kArrayHBDHt16x16Param_sse4_1));
+INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans16x16HT,
+                        ::testing::ValuesIn(kArrayHBDHt16x16Param_sse4_1));
 #endif  // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 
 }  // namespace
diff --git a/test/vp10_fht4x4_test.cc b/test/vp10_fht4x4_test.cc
index c5a4382..f1db663 100644
--- a/test/vp10_fht4x4_test.cc
+++ b/test/vp10_fht4x4_test.cc
@@ -29,8 +29,7 @@
 using libvpx_test::FhtFunc;
 typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht4x4Param;
 
-void fht4x4_ref(const int16_t *in, tran_low_t *out, int stride,
-                int tx_type) {
+void fht4x4_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
   vp10_fht4x4_c(in, out, stride, tx_type);
 }
 
@@ -44,23 +43,22 @@
 // <Target optimized function, tx_type, bit depth>
 typedef tuple<HBDFhtFunc, int, int> HighbdHt4x4Param;
 
-void highbe_fht4x4_ref(const int16_t *in, int32_t *out, int stride,
-                       int tx_type, int bd) {
+void highbe_fht4x4_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
+                       int bd) {
   vp10_fwd_txfm2d_4x4_c(in, out, stride, tx_type, bd);
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
-class VP10Trans4x4HT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Ht4x4Param> {
+class VP10Trans4x4HT : public libvpx_test::TransformTestBase,
+                       public ::testing::TestWithParam<Ht4x4Param> {
  public:
   virtual ~VP10Trans4x4HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 4;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 4;
     fwd_txfm_ref = fht4x4_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -81,9 +79,7 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(VP10Trans4x4HT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(VP10Trans4x4HT, CoeffCheck) { RunCoeffCheck(); }
 
 #if CONFIG_VP9_HIGHBITDEPTH
 class VP10HighbdTrans4x4HT : public ::testing::TestWithParam<HighbdHt4x4Param> {
@@ -93,7 +89,7 @@
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     fwd_txfm_ref_ = highbe_fht4x4_ref;
-    tx_type_  = GET_PARAM(1);
+    tx_type_ = GET_PARAM(1);
     bit_depth_ = GET_PARAM(2);
     mask_ = (1 << bit_depth_) - 1;
     num_coeffs_ = 16;
@@ -145,86 +141,66 @@
 
     for (j = 0; j < num_coeffs; ++j) {
       EXPECT_EQ(output_[j], output_ref_[j])
-          << "Not bit-exact result at index: " << j
-          << " at test block: " << i;
+          << "Not bit-exact result at index: " << j << " at test block: " << i;
     }
   }
 }
 
-TEST_P(VP10HighbdTrans4x4HT, HighbdCoeffCheck) {
-  RunBitexactCheck();
-}
+TEST_P(VP10HighbdTrans4x4HT, HighbdCoeffCheck) { RunBitexactCheck(); }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 using std::tr1::make_tuple;
 
 #if HAVE_SSE2
 const Ht4x4Param kArrayHt4x4Param_sse2[] = {
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3,
-                 VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 0, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 1, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 2, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 3, VPX_BITS_8, 16),
 #if CONFIG_EXT_TX
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 4,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 5,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 6,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 7,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 8,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 10,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 11,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 12,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 13,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 14,
-                 VPX_BITS_8, 16),
-      make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 15,
-                 VPX_BITS_8, 16)
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 4, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 5, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 6, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 7, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 8, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 10, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 11, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 12, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 13, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 14, VPX_BITS_8, 16),
+  make_tuple(&vp10_fht4x4_sse2, &vp10_iht4x4_16_add_sse2, 15, VPX_BITS_8, 16)
 #endif  // CONFIG_EXT_TX
 };
-INSTANTIATE_TEST_CASE_P(
-    SSE2, VP10Trans4x4HT,
-    ::testing::ValuesIn(kArrayHt4x4Param_sse2));
+INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans4x4HT,
+                        ::testing::ValuesIn(kArrayHt4x4Param_sse2));
 #endif  // HAVE_SSE2
 
 #if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 const HighbdHt4x4Param kArrayHighbdHt4x4Param[] = {
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 0, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 1, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 2, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 3, 12),
 #if CONFIG_EXT_TX
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 12),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 10),
-         make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 4, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 5, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 6, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 7, 12),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 10),
+  make_tuple(&vp10_fwd_txfm2d_4x4_sse4_1, 8, 12),
 #endif  // CONFIG_EXT_TX
 };
 
-INSTANTIATE_TEST_CASE_P(
-    SSE4_1, VP10HighbdTrans4x4HT,
-      ::testing::ValuesIn(kArrayHighbdHt4x4Param));
+INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans4x4HT,
+                        ::testing::ValuesIn(kArrayHighbdHt4x4Param));
 
 #endif  // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 
diff --git a/test/vp10_fht8x8_test.cc b/test/vp10_fht8x8_test.cc
index da278c4..a711901 100644
--- a/test/vp10_fht8x8_test.cc
+++ b/test/vp10_fht8x8_test.cc
@@ -30,8 +30,7 @@
 using std::tr1::tuple;
 typedef tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t, int> Ht8x8Param;
 
-void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride,
-                int tx_type) {
+void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
   vp10_fht8x8_c(in, out, stride, tx_type);
 }
 
@@ -43,23 +42,22 @@
 // Target optimized function, tx_type, bit depth
 typedef tuple<HbdHtFunc, int, int> HighbdHt8x8Param;
 
-void highbd_fht8x8_ref(const int16_t *in, int32_t *out, int stride,
-                       int tx_type, int bd) {
+void highbd_fht8x8_ref(const int16_t *in, int32_t *out, int stride, int tx_type,
+                       int bd) {
   vp10_fwd_txfm2d_8x8_c(in, out, stride, tx_type, bd);
 }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
-class VP10Trans8x8HT
-    : public libvpx_test::TransformTestBase,
-      public ::testing::TestWithParam<Ht8x8Param> {
+class VP10Trans8x8HT : public libvpx_test::TransformTestBase,
+                       public ::testing::TestWithParam<Ht8x8Param> {
  public:
   virtual ~VP10Trans8x8HT() {}
 
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     inv_txfm_ = GET_PARAM(1);
-    tx_type_  = GET_PARAM(2);
-    pitch_    = 8;
+    tx_type_ = GET_PARAM(2);
+    pitch_ = 8;
     fwd_txfm_ref = fht8x8_ref;
     bit_depth_ = GET_PARAM(3);
     mask_ = (1 << bit_depth_) - 1;
@@ -80,9 +78,7 @@
   IhtFunc inv_txfm_;
 };
 
-TEST_P(VP10Trans8x8HT, CoeffCheck) {
-  RunCoeffCheck();
-}
+TEST_P(VP10Trans8x8HT, CoeffCheck) { RunCoeffCheck(); }
 
 #if CONFIG_VP9_HIGHBITDEPTH
 class VP10HighbdTrans8x8HT : public ::testing::TestWithParam<HighbdHt8x8Param> {
@@ -92,7 +88,7 @@
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
     fwd_txfm_ref_ = highbd_fht8x8_ref;
-    tx_type_  = GET_PARAM(1);
+    tx_type_ = GET_PARAM(1);
     bit_depth_ = GET_PARAM(2);
     mask_ = (1 << bit_depth_) - 1;
     num_coeffs_ = 64;
@@ -140,90 +136,70 @@
     }
 
     fwd_txfm_ref_(input_, output_ref_, stride, tx_type_, bit_depth_);
-    ASM_REGISTER_STATE_CHECK(fwd_txfm_(input_, output_, stride, tx_type_,
-                                       bit_depth_));
+    ASM_REGISTER_STATE_CHECK(
+        fwd_txfm_(input_, output_, stride, tx_type_, bit_depth_));
 
     for (j = 0; j < num_coeffs; ++j) {
       EXPECT_EQ(output_ref_[j], output_[j])
-          << "Not bit-exact result at index: " << j
-          << " at test block: " << i;
+          << "Not bit-exact result at index: " << j << " at test block: " << i;
     }
   }
 }
 
-TEST_P(VP10HighbdTrans8x8HT, HighbdCoeffCheck) {
-  RunBitexactCheck();
-}
+TEST_P(VP10HighbdTrans8x8HT, HighbdCoeffCheck) { RunBitexactCheck(); }
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 using std::tr1::make_tuple;
 
 #if HAVE_SSE2
 const Ht8x8Param kArrayHt8x8Param_sse2[] = {
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 0,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 1,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 2,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 3,
-                 VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 0, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 1, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 2, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 3, VPX_BITS_8, 64),
 #if CONFIG_EXT_TX
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 4,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 5,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 6,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 7,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 8,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 10,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 11,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 12,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 13,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 14,
-                 VPX_BITS_8, 64),
-      make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 15,
-                 VPX_BITS_8, 64)
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 4, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 5, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 6, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 7, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 8, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 10, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 11, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 12, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 13, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 14, VPX_BITS_8, 64),
+  make_tuple(&vp10_fht8x8_sse2, &vp10_iht8x8_64_add_sse2, 15, VPX_BITS_8, 64)
 #endif  // CONFIG_EXT_TX
 };
-INSTANTIATE_TEST_CASE_P(
-    SSE2, VP10Trans8x8HT,
-    ::testing::ValuesIn(kArrayHt8x8Param_sse2));
+INSTANTIATE_TEST_CASE_P(SSE2, VP10Trans8x8HT,
+                        ::testing::ValuesIn(kArrayHt8x8Param_sse2));
 #endif  // HAVE_SSE2
 
 #if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 const HighbdHt8x8Param kArrayHBDHt8x8Param_sse4_1[] = {
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 0, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 1, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 2, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 3, 12),
 #if CONFIG_EXT_TX
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 12),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 10),
-    make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 4, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 5, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 6, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 7, 12),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 10),
+  make_tuple(&vp10_fwd_txfm2d_8x8_sse4_1, 8, 12),
 #endif  // CONFIG_EXT_TX
 };
-INSTANTIATE_TEST_CASE_P(
-    SSE4_1, VP10HighbdTrans8x8HT,
-    ::testing::ValuesIn(kArrayHBDHt8x8Param_sse4_1));
+INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdTrans8x8HT,
+                        ::testing::ValuesIn(kArrayHBDHt8x8Param_sse4_1));
 #endif  // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 
 }  // namespace
diff --git a/test/vp10_fwd_txfm1d_test.cc b/test/vp10_fwd_txfm1d_test.cc
index f8dc0b6..088924a 100644
--- a/test/vp10_fwd_txfm1d_test.cc
+++ b/test/vp10_fwd_txfm1d_test.cc
@@ -20,20 +20,20 @@
 
 namespace {
 const int txfm_type_num = 2;
-const TYPE_TXFM txfm_type_ls[2] = {TYPE_DCT, TYPE_ADST};
+const TYPE_TXFM txfm_type_ls[2] = { TYPE_DCT, TYPE_ADST };
 
 const int txfm_size_num = 5;
-const int txfm_size_ls[5] = {4, 8, 16, 32, 64};
+const int txfm_size_ls[5] = { 4, 8, 16, 32, 64 };
 
 const TxfmFunc fwd_txfm_func_ls[2][5] = {
-    {vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new,
-     vp10_fdct64_new},
-    {vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new,
-     NULL}};
+  { vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new,
+    vp10_fdct64_new },
+  { vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new, NULL }
+};
 
 // the maximum stage number of fwd/inv 1d dct/adst txfm is 12
-const int8_t cos_bit[12] = {14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14};
-const int8_t range_bit[12] = {32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32};
+const int8_t cos_bit[12] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 };
+const int8_t range_bit[12] = { 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 };
 
 TEST(vp10_fwd_txfm1d, round_shift) {
   EXPECT_EQ(round_shift(7, 1), 4);
@@ -61,17 +61,17 @@
 }
 
 TEST(vp10_fwd_txfm1d, clamp_block) {
-  int16_t block[5][5] = {{7, -5, 6, -3, 9},
-                         {7, -5, 6, -3, 9},
-                         {7, -5, 6, -3, 9},
-                         {7, -5, 6, -3, 9},
-                         {7, -5, 6, -3, 9}};
+  int16_t block[5][5] = { { 7, -5, 6, -3, 9 },
+                          { 7, -5, 6, -3, 9 },
+                          { 7, -5, 6, -3, 9 },
+                          { 7, -5, 6, -3, 9 },
+                          { 7, -5, 6, -3, 9 } };
 
-  int16_t ref_block[5][5] = {{7, -5, 6, -3, 9},
-                             {7, -5, 6, -3, 9},
-                             {7, -4, 2, -3, 9},
-                             {7, -4, 2, -3, 9},
-                             {7, -4, 2, -3, 9}};
+  int16_t ref_block[5][5] = { { 7, -5, 6, -3, 9 },
+                              { 7, -5, 6, -3, 9 },
+                              { 7, -4, 2, -3, 9 },
+                              { 7, -4, 2, -3, 9 },
+                              { 7, -4, 2, -3, 9 } };
 
   int row = 2;
   int col = 1;
diff --git a/test/vp10_fwd_txfm2d_test.cc b/test/vp10_fwd_txfm2d_test.cc
index 953ae11..8051fb5 100644
--- a/test/vp10_fwd_txfm2d_test.cc
+++ b/test/vp10_fwd_txfm2d_test.cc
@@ -52,14 +52,14 @@
     txfm1d_size_ = libvpx_test::get_txfm1d_size(tx_size_);
     txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
     get_txfm1d_type(tx_type_, &type0_, &type1_);
-    input_ = reinterpret_cast<int16_t *>
-       (vpx_memalign(16, sizeof(int16_t) * txfm2d_size_));
-    output_ = reinterpret_cast<int32_t *>
-        (vpx_memalign(16, sizeof(int32_t) * txfm2d_size_));
-    ref_input_ = reinterpret_cast<double *>
-        (vpx_memalign(16, sizeof(double) * txfm2d_size_));
-    ref_output_ = reinterpret_cast<double *>
-        (vpx_memalign(16, sizeof(double) * txfm2d_size_));
+    input_ = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * txfm2d_size_));
+    output_ = reinterpret_cast<int32_t *>(
+        vpx_memalign(16, sizeof(int32_t) * txfm2d_size_));
+    ref_input_ = reinterpret_cast<double *>(
+        vpx_memalign(16, sizeof(double) * txfm2d_size_));
+    ref_output_ = reinterpret_cast<double *>(
+        vpx_memalign(16, sizeof(double) * txfm2d_size_));
   }
 
   void RunFwdAccuracyCheck() {
@@ -82,8 +82,8 @@
       else if (ud_flip_)
         libvpx_test::flipud(ref_input_, txfm1d_size_, txfm1d_size_);
 
-      reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_,
-                          type0_, type1_);
+      reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_, type0_,
+                          type1_);
 
       for (int ni = 0; ni < txfm2d_size_; ++ni) {
         ref_output_[ni] = round(ref_output_[ni] * amplify_factor_);
@@ -121,61 +121,58 @@
   Fwd_Txfm2d_Func fwd_txfm_;
   TYPE_TXFM type0_;
   TYPE_TXFM type1_;
-  int16_t* input_;
-  int32_t* output_;
-  double* ref_input_;
-  double* ref_output_;
+  int16_t *input_;
+  int32_t *output_;
+  double *ref_input_;
+  double *ref_output_;
   int ud_flip_;  // flip upside down
   int lr_flip_;  // flip left to right
 };
 
-TEST_P(VP10FwdTxfm2d, RunFwdAccuracyCheck) {
-  RunFwdAccuracyCheck();
-}
+TEST_P(VP10FwdTxfm2d, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
 const VP10FwdTxfm2dParam vp10_fwd_txfm2d_param_c[] = {
 #if CONFIG_EXT_TX
-  VP10FwdTxfm2dParam(FLIPADST_DCT,  TX_4X4, 2, 0.2),
-  VP10FwdTxfm2dParam(DCT_FLIPADST,  TX_4X4, 2, 0.2),
+  VP10FwdTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.2),
+  VP10FwdTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.2),
   VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.2),
   VP10FwdTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.2),
   VP10FwdTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.2),
-  VP10FwdTxfm2dParam(FLIPADST_DCT,  TX_8X8, 5, 0.6),
-  VP10FwdTxfm2dParam(DCT_FLIPADST,  TX_8X8, 5, 0.6),
+  VP10FwdTxfm2dParam(FLIPADST_DCT, TX_8X8, 5, 0.6),
+  VP10FwdTxfm2dParam(DCT_FLIPADST, TX_8X8, 5, 0.6),
   VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 5, 0.6),
   VP10FwdTxfm2dParam(ADST_FLIPADST, TX_8X8, 5, 0.6),
   VP10FwdTxfm2dParam(FLIPADST_ADST, TX_8X8, 5, 0.6),
-  VP10FwdTxfm2dParam(FLIPADST_DCT,  TX_16X16, 11, 1.5),
-  VP10FwdTxfm2dParam(DCT_FLIPADST,  TX_16X16, 11, 1.5),
+  VP10FwdTxfm2dParam(FLIPADST_DCT, TX_16X16, 11, 1.5),
+  VP10FwdTxfm2dParam(DCT_FLIPADST, TX_16X16, 11, 1.5),
   VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 1.5),
   VP10FwdTxfm2dParam(ADST_FLIPADST, TX_16X16, 11, 1.5),
   VP10FwdTxfm2dParam(FLIPADST_ADST, TX_16X16, 11, 1.5),
-  VP10FwdTxfm2dParam(FLIPADST_DCT,  TX_32X32, 70, 7),
-  VP10FwdTxfm2dParam(DCT_FLIPADST,  TX_32X32, 70, 7),
+  VP10FwdTxfm2dParam(FLIPADST_DCT, TX_32X32, 70, 7),
+  VP10FwdTxfm2dParam(DCT_FLIPADST, TX_32X32, 70, 7),
   VP10FwdTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 70, 7),
   VP10FwdTxfm2dParam(ADST_FLIPADST, TX_32X32, 70, 7),
   VP10FwdTxfm2dParam(FLIPADST_ADST, TX_32X32, 70, 7),
 #endif
-  VP10FwdTxfm2dParam(DCT_DCT,   TX_4X4, 2, 0.2),
-  VP10FwdTxfm2dParam(ADST_DCT,  TX_4X4, 2, 0.2),
-  VP10FwdTxfm2dParam(DCT_ADST,  TX_4X4, 2, 0.2),
+  VP10FwdTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.2),
+  VP10FwdTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.2),
+  VP10FwdTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.2),
   VP10FwdTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.2),
-  VP10FwdTxfm2dParam(DCT_DCT,   TX_8X8, 5, 0.6),
-  VP10FwdTxfm2dParam(ADST_DCT,  TX_8X8, 5, 0.6),
-  VP10FwdTxfm2dParam(DCT_ADST,  TX_8X8, 5, 0.6),
+  VP10FwdTxfm2dParam(DCT_DCT, TX_8X8, 5, 0.6),
+  VP10FwdTxfm2dParam(ADST_DCT, TX_8X8, 5, 0.6),
+  VP10FwdTxfm2dParam(DCT_ADST, TX_8X8, 5, 0.6),
   VP10FwdTxfm2dParam(ADST_ADST, TX_8X8, 5, 0.6),
-  VP10FwdTxfm2dParam(DCT_DCT,   TX_16X16, 11, 1.5),
-  VP10FwdTxfm2dParam(ADST_DCT,  TX_16X16, 11, 1.5),
-  VP10FwdTxfm2dParam(DCT_ADST,  TX_16X16, 11, 1.5),
+  VP10FwdTxfm2dParam(DCT_DCT, TX_16X16, 11, 1.5),
+  VP10FwdTxfm2dParam(ADST_DCT, TX_16X16, 11, 1.5),
+  VP10FwdTxfm2dParam(DCT_ADST, TX_16X16, 11, 1.5),
   VP10FwdTxfm2dParam(ADST_ADST, TX_16X16, 11, 1.5),
-  VP10FwdTxfm2dParam(DCT_DCT,   TX_32X32, 70, 7),
-  VP10FwdTxfm2dParam(ADST_DCT,  TX_32X32, 70, 7),
-  VP10FwdTxfm2dParam(DCT_ADST,  TX_32X32, 70, 7),
+  VP10FwdTxfm2dParam(DCT_DCT, TX_32X32, 70, 7),
+  VP10FwdTxfm2dParam(ADST_DCT, TX_32X32, 70, 7),
+  VP10FwdTxfm2dParam(DCT_ADST, TX_32X32, 70, 7),
   VP10FwdTxfm2dParam(ADST_ADST, TX_32X32, 70, 7)
 };
 
-INSTANTIATE_TEST_CASE_P(
-    C, VP10FwdTxfm2d,
-    ::testing::ValuesIn(vp10_fwd_txfm2d_param_c));
+INSTANTIATE_TEST_CASE_P(C, VP10FwdTxfm2d,
+                        ::testing::ValuesIn(vp10_fwd_txfm2d_param_c));
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 }  // namespace
diff --git a/test/vp10_highbd_iht_test.cc b/test/vp10_highbd_iht_test.cc
index caab04c..b632b40 100644
--- a/test/vp10_highbd_iht_test.cc
+++ b/test/vp10_highbd_iht_test.cc
@@ -118,35 +118,32 @@
 
     txfm_ref_(input_, coeffs_, stride, tx_type_, bit_depth_);
     inv_txfm_ref_(coeffs_, output_ref_, stride, tx_type_, bit_depth_);
-    ASM_REGISTER_STATE_CHECK(inv_txfm_(coeffs_, output_, stride, tx_type_,
-                                       bit_depth_));
+    ASM_REGISTER_STATE_CHECK(
+        inv_txfm_(coeffs_, output_, stride, tx_type_, bit_depth_));
 
     for (int j = 0; j < num_coeffs_; ++j) {
       EXPECT_EQ(output_ref_[j], output_[j])
-          << "Not bit-exact result at index: " << j
-          << " At test block: " << i;
+          << "Not bit-exact result at index: " << j << " At test block: " << i;
     }
   }
 }
 
-TEST_P(VP10HighbdInvHTNxN, InvTransResultCheck) {
-  RunBitexactCheck();
-}
+TEST_P(VP10HighbdInvHTNxN, InvTransResultCheck) { RunBitexactCheck(); }
 
 using std::tr1::make_tuple;
 
 #if HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
-#define PARAM_LIST_4X4 &vp10_fwd_txfm2d_4x4_c, \
-             &vp10_inv_txfm2d_add_4x4_sse4_1,  \
-             &vp10_inv_txfm2d_add_4x4_c, 16
+#define PARAM_LIST_4X4                                     \
+  &vp10_fwd_txfm2d_4x4_c, &vp10_inv_txfm2d_add_4x4_sse4_1, \
+      &vp10_inv_txfm2d_add_4x4_c, 16
 
-#define PARAM_LIST_8X8 &vp10_fwd_txfm2d_8x8_c, \
-             &vp10_inv_txfm2d_add_8x8_sse4_1,  \
-             &vp10_inv_txfm2d_add_8x8_c, 64
+#define PARAM_LIST_8X8                                     \
+  &vp10_fwd_txfm2d_8x8_c, &vp10_inv_txfm2d_add_8x8_sse4_1, \
+      &vp10_inv_txfm2d_add_8x8_c, 64
 
-#define PARAM_LIST_16X16 &vp10_fwd_txfm2d_16x16_c, \
-             &vp10_inv_txfm2d_add_16x16_sse4_1,    \
-             &vp10_inv_txfm2d_add_16x16_c, 256
+#define PARAM_LIST_16X16                                       \
+  &vp10_fwd_txfm2d_16x16_c, &vp10_inv_txfm2d_add_16x16_sse4_1, \
+      &vp10_inv_txfm2d_add_16x16_c, 256
 
 const IHbdHtParam kArrayIhtParam[] = {
   // 16x16
@@ -214,9 +211,8 @@
 #endif
 };
 
-INSTANTIATE_TEST_CASE_P(
-    SSE4_1, VP10HighbdInvHTNxN,
-    ::testing::ValuesIn(kArrayIhtParam));
+INSTANTIATE_TEST_CASE_P(SSE4_1, VP10HighbdInvHTNxN,
+                        ::testing::ValuesIn(kArrayIhtParam));
 #endif  // HAVE_SSE4_1 && CONFIG_VP9_HIGHBITDEPTH
 
 }  // namespace
diff --git a/test/vp10_inv_txfm1d_test.cc b/test/vp10_inv_txfm1d_test.cc
index c024f2c..829eaa2 100644
--- a/test/vp10_inv_txfm1d_test.cc
+++ b/test/vp10_inv_txfm1d_test.cc
@@ -18,23 +18,23 @@
 namespace {
 const int txfm_type_num = 2;
 const int txfm_size_num = 5;
-const int txfm_size_ls[5] = {4, 8, 16, 32, 64};
+const int txfm_size_ls[5] = { 4, 8, 16, 32, 64 };
 
 const TxfmFunc fwd_txfm_func_ls[2][5] = {
-    {vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new,
-     vp10_fdct64_new},
-    {vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new,
-     NULL}};
+  { vp10_fdct4_new, vp10_fdct8_new, vp10_fdct16_new, vp10_fdct32_new,
+    vp10_fdct64_new },
+  { vp10_fadst4_new, vp10_fadst8_new, vp10_fadst16_new, vp10_fadst32_new, NULL }
+};
 
 const TxfmFunc inv_txfm_func_ls[2][5] = {
-    {vp10_idct4_new, vp10_idct8_new, vp10_idct16_new, vp10_idct32_new,
-     vp10_idct64_new},
-    {vp10_iadst4_new, vp10_iadst8_new, vp10_iadst16_new, vp10_iadst32_new,
-     NULL}};
+  { vp10_idct4_new, vp10_idct8_new, vp10_idct16_new, vp10_idct32_new,
+    vp10_idct64_new },
+  { vp10_iadst4_new, vp10_iadst8_new, vp10_iadst16_new, vp10_iadst32_new, NULL }
+};
 
 // the maximum stage number of fwd/inv 1d dct/adst txfm is 12
-const int8_t cos_bit[12] = {14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14};
-const int8_t range_bit[12] = {32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32};
+const int8_t cos_bit[12] = { 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 };
+const int8_t range_bit[12] = { 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 };
 
 TEST(vp10_inv_txfm1d, round_trip) {
   ACMRandom rnd(ACMRandom::DeterministicSeed());
diff --git a/test/vp10_inv_txfm2d_test.cc b/test/vp10_inv_txfm2d_test.cc
index 8f55f55..8cbca5a 100644
--- a/test/vp10_inv_txfm2d_test.cc
+++ b/test/vp10_inv_txfm2d_test.cc
@@ -43,12 +43,12 @@
     txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
     count_ = 500;
 
-    input_ = reinterpret_cast<int16_t *>
-        (vpx_memalign(16, sizeof(int16_t) * txfm2d_size_));
-    ref_input_ = reinterpret_cast<uint16_t *>
-        (vpx_memalign(16, sizeof(uint16_t) * txfm2d_size_));
-    output_ = reinterpret_cast<int32_t *>
-        (vpx_memalign(16, sizeof(int32_t) * txfm2d_size_));
+    input_ = reinterpret_cast<int16_t *>(
+        vpx_memalign(16, sizeof(int16_t) * txfm2d_size_));
+    ref_input_ = reinterpret_cast<uint16_t *>(
+        vpx_memalign(16, sizeof(uint16_t) * txfm2d_size_));
+    output_ = reinterpret_cast<int32_t *>(
+        vpx_memalign(16, sizeof(int32_t) * txfm2d_size_));
   }
 
   void RunRoundtripCheck() {
@@ -101,9 +101,9 @@
   TX_SIZE tx_size_;
   int txfm1d_size_;
   int txfm2d_size_;
-  int16_t* input_;
-  uint16_t* ref_input_;
-  int32_t* output_;
+  int16_t *input_;
+  uint16_t *ref_input_;
+  int32_t *output_;
 };
 
 TEST_P(VP10InvTxfm2d, RunRoundtripCheck) { RunRoundtripCheck(); }
@@ -149,9 +149,8 @@
   VP10InvTxfm2dParam(ADST_ADST, TX_32X32, 4, 0.4)
 };
 
-INSTANTIATE_TEST_CASE_P(
-    C, VP10InvTxfm2d,
-    ::testing::ValuesIn(vp10_inv_txfm2d_param));
+INSTANTIATE_TEST_CASE_P(C, VP10InvTxfm2d,
+                        ::testing::ValuesIn(vp10_inv_txfm2d_param));
 
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
diff --git a/test/vp10_inv_txfm_test.cc b/test/vp10_inv_txfm_test.cc
index 917e6e9..3469d198 100644
--- a/test/vp10_inv_txfm_test.cc
+++ b/test/vp10_inv_txfm_test.cc
@@ -51,14 +51,14 @@
 
  protected:
   void RunInvAccuracyCheck() {
-    tran_low_t *input  = new tran_low_t[txfm_size_];
+    tran_low_t *input = new tran_low_t[txfm_size_];
     tran_low_t *output = new tran_low_t[txfm_size_];
-    double *ref_input  = new double[txfm_size_];
+    double *ref_input = new double[txfm_size_];
     double *ref_output = new double[txfm_size_];
 
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     const int count_test_block = 5000;
-    for (int ti =  0; ti < count_test_block; ++ti) {
+    for (int ti = 0; ti < count_test_block; ++ti) {
       for (int ni = 0; ni < txfm_size_; ++ni) {
         input[ni] = rnd.Rand8() - rnd.Rand8();
         ref_input[ni] = static_cast<double>(input[ni]);
@@ -87,9 +87,8 @@
 };
 
 typedef std::tr1::tuple<IdctFunc, IdctFuncRef, int, int> IdctParam;
-class Vp10InvTxfm
-    : public TransTestBase,
-      public ::testing::TestWithParam<IdctParam> {
+class Vp10InvTxfm : public TransTestBase,
+                    public ::testing::TestWithParam<IdctParam> {
  public:
   virtual void SetUp() {
     fwd_txfm_ = GET_PARAM(0);
@@ -100,25 +99,19 @@
   virtual void TearDown() {}
 };
 
-TEST_P(Vp10InvTxfm, RunInvAccuracyCheck) {
-  RunInvAccuracyCheck();
-}
+TEST_P(Vp10InvTxfm, RunInvAccuracyCheck) { RunInvAccuracyCheck(); }
 
 INSTANTIATE_TEST_CASE_P(
     C, Vp10InvTxfm,
-    ::testing::Values(
-        IdctParam(&vp10_idct4_c, &reference_idct_1d, 4, 1),
-        IdctParam(&vp10_idct8_c, &reference_idct_1d, 8, 2),
-        IdctParam(&vp10_idct16_c, &reference_idct_1d, 16, 4),
-        IdctParam(&vp10_idct32_c, &reference_idct_1d, 32, 6))
-);
+    ::testing::Values(IdctParam(&vp10_idct4_c, &reference_idct_1d, 4, 1),
+                      IdctParam(&vp10_idct8_c, &reference_idct_1d, 8, 2),
+                      IdctParam(&vp10_idct16_c, &reference_idct_1d, 16, 4),
+                      IdctParam(&vp10_idct32_c, &reference_idct_1d, 32, 6)));
 
 typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
 typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
-typedef std::tr1::tuple<FwdTxfmFunc,
-                        InvTxfmFunc,
-                        InvTxfmFunc,
-                        TX_SIZE, int> PartialInvTxfmParam;
+typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, InvTxfmFunc, TX_SIZE, int>
+    PartialInvTxfmParam;
 const int kMaxNumCoeffs = 1024;
 class Vp10PartialIDctTest
     : public ::testing::TestWithParam<PartialInvTxfmParam> {
@@ -128,7 +121,7 @@
     ftxfm_ = GET_PARAM(0);
     full_itxfm_ = GET_PARAM(1);
     partial_itxfm_ = GET_PARAM(2);
-    tx_size_  = GET_PARAM(3);
+    tx_size_ = GET_PARAM(3);
     last_nonzero_ = GET_PARAM(4);
   }
 
@@ -146,21 +139,11 @@
   ACMRandom rnd(ACMRandom::DeterministicSeed());
   int size;
   switch (tx_size_) {
-    case TX_4X4:
-      size = 4;
-      break;
-    case TX_8X8:
-      size = 8;
-      break;
-    case TX_16X16:
-      size = 16;
-      break;
-    case TX_32X32:
-      size = 32;
-      break;
-    default:
-      FAIL() << "Wrong Size!";
-      break;
+    case TX_4X4: size = 4; break;
+    case TX_8X8: size = 8; break;
+    case TX_16X16: size = 16; break;
+    case TX_32X32: size = 32; break;
+    default: FAIL() << "Wrong Size!"; break;
   }
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@@ -186,11 +169,9 @@
     for (int i = 0; i < count_test_block; ++i) {
       // Initialize a test block with input range [-255, 255].
       if (i == 0) {
-        for (int j = 0; j < block_size; ++j)
-          input_extreme_block[j] = 255;
+        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = 255;
       } else if (i == 1) {
-        for (int j = 0; j < block_size; ++j)
-          input_extreme_block[j] = -255;
+        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = -255;
       } else {
         for (int j = 0; j < block_size; ++j) {
           input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255;
@@ -202,8 +183,8 @@
       // quantization with maximum allowed step sizes
       test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336;
       for (int j = 1; j < last_nonzero_; ++j)
-        test_coef_block1[get_scan(tx_size_, DCT_DCT, 0)->scan[j]]
-                         = (output_ref_block[j] / 1828) * 1828;
+        test_coef_block1[get_scan(tx_size_, DCT_DCT, 0)->scan[j]] =
+            (output_ref_block[j] / 1828) * 1828;
     }
 
     ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size));
@@ -212,8 +193,7 @@
     for (int j = 0; j < block_size; ++j) {
       const int diff = dst1[j] - dst2[j];
       const int error = diff * diff;
-      if (max_error < error)
-        max_error = error;
+      if (max_error < error) max_error = error;
     }
   }
 
@@ -225,21 +205,11 @@
   ACMRandom rnd(ACMRandom::DeterministicSeed());
   int size;
   switch (tx_size_) {
-    case TX_4X4:
-      size = 4;
-      break;
-    case TX_8X8:
-      size = 8;
-      break;
-    case TX_16X16:
-      size = 16;
-      break;
-    case TX_32X32:
-      size = 32;
-      break;
-    default:
-      FAIL() << "Wrong Size!";
-      break;
+    case TX_4X4: size = 4; break;
+    case TX_8X8: size = 8; break;
+    case TX_16X16: size = 16; break;
+    case TX_32X32: size = 32; break;
+    default: FAIL() << "Wrong Size!"; break;
   }
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
   DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
@@ -276,8 +246,7 @@
     for (int j = 0; j < block_size; ++j) {
       const int diff = dst1[j] - dst2[j];
       const int error = diff * diff;
-      if (max_error < error)
-        max_error = error;
+      if (max_error < error) max_error = error;
     }
   }
 
@@ -288,33 +257,18 @@
 
 INSTANTIATE_TEST_CASE_P(
     C, Vp10PartialIDctTest,
-    ::testing::Values(
-        make_tuple(&vp10_fdct32x32_c,
-                   &vp10_idct32x32_1024_add_c,
-                   &vp10_idct32x32_34_add_c,
-                   TX_32X32, 34),
-        make_tuple(&vp10_fdct32x32_c,
-                   &vp10_idct32x32_1024_add_c,
-                   &vp10_idct32x32_1_add_c,
-                   TX_32X32, 1),
-        make_tuple(&vp10_fdct16x16_c,
-                   &vp10_idct16x16_256_add_c,
-                   &vp10_idct16x16_10_add_c,
-                   TX_16X16, 10),
-        make_tuple(&vp10_fdct16x16_c,
-                   &vp10_idct16x16_256_add_c,
-                   &vp10_idct16x16_1_add_c,
-                   TX_16X16, 1),
-        make_tuple(&vp10_fdct8x8_c,
-                   &vp10_idct8x8_64_add_c,
-                   &vp10_idct8x8_12_add_c,
-                   TX_8X8, 12),
-        make_tuple(&vp10_fdct8x8_c,
-                   &vp10_idct8x8_64_add_c,
-                   &vp10_idct8x8_1_add_c,
-                   TX_8X8, 1),
-        make_tuple(&vp10_fdct4x4_c,
-                   &vp10_idct4x4_16_add_c,
-                   &vp10_idct4x4_1_add_c,
-                   TX_4X4, 1)));
+    ::testing::Values(make_tuple(&vp10_fdct32x32_c, &vp10_idct32x32_1024_add_c,
+                                 &vp10_idct32x32_34_add_c, TX_32X32, 34),
+                      make_tuple(&vp10_fdct32x32_c, &vp10_idct32x32_1024_add_c,
+                                 &vp10_idct32x32_1_add_c, TX_32X32, 1),
+                      make_tuple(&vp10_fdct16x16_c, &vp10_idct16x16_256_add_c,
+                                 &vp10_idct16x16_10_add_c, TX_16X16, 10),
+                      make_tuple(&vp10_fdct16x16_c, &vp10_idct16x16_256_add_c,
+                                 &vp10_idct16x16_1_add_c, TX_16X16, 1),
+                      make_tuple(&vp10_fdct8x8_c, &vp10_idct8x8_64_add_c,
+                                 &vp10_idct8x8_12_add_c, TX_8X8, 12),
+                      make_tuple(&vp10_fdct8x8_c, &vp10_idct8x8_64_add_c,
+                                 &vp10_idct8x8_1_add_c, TX_8X8, 1),
+                      make_tuple(&vp10_fdct4x4_c, &vp10_idct4x4_16_add_c,
+                                 &vp10_idct4x4_1_add_c, TX_4X4, 1)));
 }  // namespace
diff --git a/test/vp10_quantize_test.cc b/test/vp10_quantize_test.cc
index f8bbb25..e7365bb 100644
--- a/test/vp10_quantize_test.cc
+++ b/test/vp10_quantize_test.cc
@@ -21,20 +21,17 @@
 
 namespace {
 
-typedef void (*QuantizeFpFunc)(const tran_low_t *coeff_ptr, intptr_t count,
-                               int skip_block, const int16_t *zbin_ptr,
-                               const int16_t *round_ptr,
-                               const int16_t *quant_ptr,
-                               const int16_t *quant_shift_ptr,
-                               tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
-                               const int16_t *dequant_ptr, uint16_t *eob_ptr,
-                               const int16_t *scan, const int16_t *iscan,
-                               const int log_scale);
+typedef void (*QuantizeFpFunc)(
+    const tran_low_t *coeff_ptr, intptr_t count, int skip_block,
+    const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr,
+    const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr,
+    tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr,
+    const int16_t *scan, const int16_t *iscan, const int log_scale);
 
 struct QuantizeFuncParams {
   QuantizeFuncParams(QuantizeFpFunc qF = NULL, QuantizeFpFunc qRefF = NULL,
-                     int count = 16) : qFunc(qF), qFuncRef(qRefF),
-                                       coeffCount(count) {}
+                     int count = 16)
+      : qFunc(qF), qFuncRef(qRefF), coeffCount(count) {}
   QuantizeFpFunc qFunc;
   QuantizeFpFunc qFuncRef;
   int coeffCount;
@@ -90,28 +87,25 @@
         round_ptr[j] = (abs(rnd(roundFactorRange)) * dequant_ptr[j]) >> 7;
       }
 
-      quanFuncRef(coeff_ptr, count, skip_block, zbin_ptr,
-                  round_ptr, quant_ptr, quant_shift_ptr,
-                  ref_qcoeff_ptr, ref_dqcoeff_ptr, dequant_ptr,
-                  &ref_eob, scanOrder.scan, scanOrder.iscan,
-                  log_scale);
+      quanFuncRef(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
+                  quant_shift_ptr, ref_qcoeff_ptr, ref_dqcoeff_ptr, dequant_ptr,
+                  &ref_eob, scanOrder.scan, scanOrder.iscan, log_scale);
 
-      ASM_REGISTER_STATE_CHECK(quanFunc(coeff_ptr, count, skip_block, zbin_ptr,
-                                        round_ptr, quant_ptr, quant_shift_ptr,
-                                        qcoeff_ptr, dqcoeff_ptr, dequant_ptr,
-                                        &eob, scanOrder.scan, scanOrder.iscan,
-                                        log_scale));
+      ASM_REGISTER_STATE_CHECK(
+          quanFunc(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
+                   quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, &eob,
+                   scanOrder.scan, scanOrder.iscan, log_scale));
 
       for (int j = 0; j < count; ++j) {
-        err_count += (ref_qcoeff_ptr[j]  != qcoeff_ptr[j]) |
-            (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
-        EXPECT_EQ(ref_qcoeff_ptr[j], qcoeff_ptr[j])
-            << "qcoeff error: i = " << i << " j = " << j << "\n";
+        err_count += (ref_qcoeff_ptr[j] != qcoeff_ptr[j]) |
+                     (ref_dqcoeff_ptr[j] != dqcoeff_ptr[j]);
+        EXPECT_EQ(ref_qcoeff_ptr[j], qcoeff_ptr[j]) << "qcoeff error: i = " << i
+                                                    << " j = " << j << "\n";
         EXPECT_EQ(ref_dqcoeff_ptr[j], dqcoeff_ptr[j])
             << "dqcoeff error: i = " << i << " j = " << j << "\n";
       }
-      EXPECT_EQ(ref_eob, eob)
-          << "eob error: " << "i = " << i << "\n";
+      EXPECT_EQ(ref_eob, eob) << "eob error: "
+                              << "i = " << i << "\n";
       err_count += (ref_eob != eob);
       if (err_count && !err_count_total) {
         first_failure = i;
@@ -164,29 +158,22 @@
         round_ptr[j] = (abs(rnd(roundFactorRange)) * dequant_ptr[j]) >> 7;
       }
 
-      quanFuncRef(coeff_ptr, count, skip_block, zbin_ptr,
-                  round_ptr, quant_ptr, quant_shift_ptr,
-                  ref_qcoeff_ptr, ref_dqcoeff_ptr, dequant_ptr,
-                  &ref_eob, scanOrder.scan, scanOrder.iscan,
-                  log_scale);
+      quanFuncRef(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
+                  quant_shift_ptr, ref_qcoeff_ptr, ref_dqcoeff_ptr, dequant_ptr,
+                  &ref_eob, scanOrder.scan, scanOrder.iscan, log_scale);
 
-      ASM_REGISTER_STATE_CHECK(quanFunc(coeff_ptr, count, skip_block, zbin_ptr,
-                                        round_ptr, quant_ptr, quant_shift_ptr,
-                                        qcoeff_ptr, dqcoeff_ptr, dequant_ptr,
-                                        &eob, scanOrder.scan, scanOrder.iscan,
-                                        log_scale));
-      EXPECT_EQ(ref_eob, eob)
-          << "eob error: " << "i = " << i << "\n";
+      ASM_REGISTER_STATE_CHECK(
+          quanFunc(coeff_ptr, count, skip_block, zbin_ptr, round_ptr, quant_ptr,
+                   quant_shift_ptr, qcoeff_ptr, dqcoeff_ptr, dequant_ptr, &eob,
+                   scanOrder.scan, scanOrder.iscan, log_scale));
+      EXPECT_EQ(ref_eob, eob) << "eob error: "
+                              << "i = " << i << "\n";
     }
   }
 
-  virtual void SetUp() {
-    params_ = GetParam();
-  }
+  virtual void SetUp() { params_ = GetParam(); }
 
-  virtual void TearDown() {
-    libvpx_test::ClearSystemState();
-  }
+  virtual void TearDown() { libvpx_test::ClearSystemState(); }
 
   virtual ~VP10QuantizeTest() {}
 
@@ -208,12 +195,8 @@
   QuantizeFuncParams params_;
 };
 
-TEST_P(VP10QuantizeTest, BitExactCheck) {
-  RunQuantizeTest();
-}
-TEST_P(VP10QuantizeTest, EobVerify) {
-  RunEobTest();
-}
+TEST_P(VP10QuantizeTest, BitExactCheck) { RunQuantizeTest(); }
+TEST_P(VP10QuantizeTest, EobVerify) { RunEobTest(); }
 
 #if HAVE_SSE4_1
 INSTANTIATE_TEST_CASE_P(
diff --git a/test/vp10_txfm_test.cc b/test/vp10_txfm_test.cc
index 6b36126..f9055f1 100644
--- a/test/vp10_txfm_test.cc
+++ b/test/vp10_txfm_test.cc
@@ -13,12 +13,9 @@
 
 namespace libvpx_test {
 
-int get_txfm1d_size(TX_SIZE tx_size) {
-  return 1 << (tx_size + 2);
-}
+int get_txfm1d_size(TX_SIZE tx_size) { return 1 << (tx_size + 2); }
 
-void get_txfm1d_type(TX_TYPE txfm2d_type, TYPE_TXFM* type0,
-                     TYPE_TXFM* type1) {
+void get_txfm1d_type(TX_TYPE txfm2d_type, TYPE_TXFM *type0, TYPE_TXFM *type1) {
   switch (txfm2d_type) {
     case DCT_DCT:
       *type0 = TYPE_DCT;
@@ -68,7 +65,7 @@
 
 double invSqrt2 = 1 / pow(2, 0.5);
 
-void reference_dct_1d(const double* in, double* out, int size) {
+void reference_dct_1d(const double *in, double *out, int size) {
   for (int k = 0; k < size; ++k) {
     out[k] = 0;
     for (int n = 0; n < size; ++n) {
@@ -78,7 +75,7 @@
   }
 }
 
-void reference_adst_1d(const double* in, double* out, int size) {
+void reference_adst_1d(const double *in, double *out, int size) {
   for (int k = 0; k < size; ++k) {
     out[k] = 0;
     for (int n = 0; n < size; ++n) {
@@ -87,16 +84,16 @@
   }
 }
 
-void reference_hybrid_1d(double* in, double* out, int size, int type) {
+void reference_hybrid_1d(double *in, double *out, int size, int type) {
   if (type == TYPE_DCT)
     reference_dct_1d(in, out, size);
   else
     reference_adst_1d(in, out, size);
 }
 
-void reference_hybrid_2d(double* in, double* out, int size,
-                         int type0, int type1) {
-  double* tempOut = new double[size * size];
+void reference_hybrid_2d(double *in, double *out, int size, int type0,
+                         int type1) {
+  double *tempOut = new double[size * size];
 
   for (int r = 0; r < size; r++) {
     // out ->tempOut
@@ -123,7 +120,7 @@
   delete[] tempOut;
 }
 
-template<typename Type>
+template <typename Type>
 void fliplr(Type *dest, int stride, int length) {
   int i, j;
   for (i = 0; i < length; ++i) {
@@ -135,7 +132,7 @@
   }
 }
 
-template<typename Type>
+template <typename Type>
 void flipud(Type *dest, int stride, int length) {
   int i, j;
   for (j = 0; j < length; ++j) {
@@ -147,7 +144,7 @@
   }
 }
 
-template<typename Type>
+template <typename Type>
 void fliplrud(Type *dest, int stride, int length) {
   int i, j;
   for (i = 0; i < length / 2; ++i) {
diff --git a/test/vp10_txfm_test.h b/test/vp10_txfm_test.h
index fb9e12e..4b7d978 100644
--- a/test/vp10_txfm_test.h
+++ b/test/vp10_txfm_test.h
@@ -36,19 +36,18 @@
 
 int get_txfm1d_size(TX_SIZE tx_size);
 
-void get_txfm1d_type(TX_TYPE txfm2d_type, TYPE_TXFM* type0,
-                     TYPE_TXFM* type1);
+void get_txfm1d_type(TX_TYPE txfm2d_type, TYPE_TXFM *type0, TYPE_TXFM *type1);
 
-void reference_dct_1d(const double* in, double* out, int size);
+void reference_dct_1d(const double *in, double *out, int size);
 
-void reference_adst_1d(const double* in, double* out, int size);
+void reference_adst_1d(const double *in, double *out, int size);
 
-void reference_hybrid_1d(double* in, double* out, int size, int type);
+void reference_hybrid_1d(double *in, double *out, int size, int type);
 
-void reference_hybrid_2d(double* in, double* out, int size,
-                         int type0, int type1);
+void reference_hybrid_2d(double *in, double *out, int size, int type0,
+                         int type1);
 template <typename Type1, typename Type2>
-static double compute_avg_abs_error(const Type1* a, const Type2* b,
+static double compute_avg_abs_error(const Type1 *a, const Type2 *b,
                                     const int size) {
   double error = 0;
   for (int i = 0; i < size; i++) {
@@ -58,32 +57,34 @@
   return error;
 }
 
-template<typename Type>
+template <typename Type>
 void fliplr(Type *dest, int stride, int length);
 
-template<typename Type>
+template <typename Type>
 void flipud(Type *dest, int stride, int length);
 
-template<typename Type>
+template <typename Type>
 void fliplrud(Type *dest, int stride, int length);
 
-typedef void (*TxfmFunc)(const int32_t* in, int32_t* out, const int8_t* cos_bit,
-                         const int8_t* range_bit);
+typedef void (*TxfmFunc)(const int32_t *in, int32_t *out, const int8_t *cos_bit,
+                         const int8_t *range_bit);
 
-typedef void (*Fwd_Txfm2d_Func)(const int16_t*, int32_t*, int, int, int);
-typedef void (*Inv_Txfm2d_Func)(const int32_t*, uint16_t*, int, int, int);
+typedef void (*Fwd_Txfm2d_Func)(const int16_t *, int32_t *, int, int, int);
+typedef void (*Inv_Txfm2d_Func)(const int32_t *, uint16_t *, int, int, int);
 
 static const int bd = 10;
 static const int input_base = (1 << bd);
 
 #if CONFIG_VP9_HIGHBITDEPTH
 static const Fwd_Txfm2d_Func fwd_txfm_func_ls[TX_SIZES] = {
-    vp10_fwd_txfm2d_4x4_c, vp10_fwd_txfm2d_8x8_c, vp10_fwd_txfm2d_16x16_c,
-    vp10_fwd_txfm2d_32x32_c};
+  vp10_fwd_txfm2d_4x4_c, vp10_fwd_txfm2d_8x8_c, vp10_fwd_txfm2d_16x16_c,
+  vp10_fwd_txfm2d_32x32_c
+};
 
 static const Inv_Txfm2d_Func inv_txfm_func_ls[TX_SIZES] = {
-    vp10_inv_txfm2d_add_4x4_c, vp10_inv_txfm2d_add_8x8_c,
-    vp10_inv_txfm2d_add_16x16_c, vp10_inv_txfm2d_add_32x32_c};
+  vp10_inv_txfm2d_add_4x4_c, vp10_inv_txfm2d_add_8x8_c,
+  vp10_inv_txfm2d_add_16x16_c, vp10_inv_txfm2d_add_32x32_c
+};
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 }  // namespace libvpx_test
diff --git a/test/vp10_wedge_utils_test.cc b/test/vp10_wedge_utils_test.cc
index 9fa4849..57008c6 100644
--- a/test/vp10_wedge_utils_test.cc
+++ b/test/vp10_wedge_utils_test.cc
@@ -24,7 +24,7 @@
 #include "test/register_state_check.h"
 
 #define WEDGE_WEIGHT_BITS 6
-#define MAX_MASK_VALUE  (1 << (WEDGE_WEIGHT_BITS))
+#define MAX_MASK_VALUE (1 << (WEDGE_WEIGHT_BITS))
 
 using libvpx_test::ACMRandom;
 using libvpx_test::FunctionEquivalenceTest;
@@ -46,12 +46,9 @@
   ACMRandom rng_;
 };
 
-static void equiv_blend_residuals(int16_t *r,
-                                  const int16_t *r0,
-                                  const int16_t *r1,
-                                  const uint8_t *m,
-                                  int N) {
-  for (int i = 0 ; i < N ; i++) {
+static void equiv_blend_residuals(int16_t *r, const int16_t *r0,
+                                  const int16_t *r1, const uint8_t *m, int N) {
+  for (int i = 0; i < N; i++) {
     const int32_t m0 = m[i];
     const int32_t m1 = MAX_MASK_VALUE - m0;
     const int16_t R = m0 * r0[i] + m1 * r1[i];
@@ -62,12 +59,10 @@
   }
 }
 
-static uint64_t equiv_sse_from_residuals(const int16_t *r0,
-                                         const int16_t *r1,
-                                         const uint8_t *m,
-                                         int N) {
+static uint64_t equiv_sse_from_residuals(const int16_t *r0, const int16_t *r1,
+                                         const uint8_t *m, int N) {
   uint64_t acc = 0;
-  for (int i = 0 ; i < N ; i++) {
+  for (int i = 0; i < N; i++) {
     const int32_t m0 = m[i];
     const int32_t m1 = MAX_MASK_VALUE - m0;
     const int16_t R = m0 * r0[i] + m1 * r1[i];
@@ -89,8 +84,8 @@
   DECLARE_ALIGNED(32, int16_t, r_tst[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       s[i] = rng_.Rand8();
       m[i] = rng_(MAX_MASK_VALUE + 1);
     }
@@ -99,7 +94,7 @@
     const int h = 1 << (rng_(MAX_SB_SIZE_LOG2 + 1 - 3) + 3);
     const int N = w * h;
 
-    for (int j = 0 ; j < N ; j++) {
+    for (int j = 0; j < N; j++) {
       p0[j] = clamp(s[j] + rng_(33) - 16, 0, UINT8_MAX);
       p1[j] = clamp(s[j] + rng_(33) - 16, 0, UINT8_MAX);
     }
@@ -112,8 +107,7 @@
     vpx_subtract_block(h, w, r_ref, w, s, w, p, w);
     equiv_blend_residuals(r_tst, r0, r1, m, N);
 
-    for (int i = 0 ; i < N ; ++i)
-      ASSERT_EQ(r_ref[i], r_tst[i]);
+    for (int i = 0; i < N; ++i) ASSERT_EQ(r_ref[i], r_tst[i]);
 
     uint64_t ref_sse = vpx_sum_squares_i16(r_ref, N);
     uint64_t tst_sse = equiv_sse_from_residuals(r0, r1, m, N);
@@ -122,12 +116,10 @@
   }
 }
 
-static uint64_t sse_from_residuals(const int16_t *r0,
-                                   const int16_t *r1,
-                                   const uint8_t *m,
-                                   int N) {
+static uint64_t sse_from_residuals(const int16_t *r0, const int16_t *r1,
+                                   const uint8_t *m, int N) {
   uint64_t acc = 0;
-  for (int i = 0 ; i < N ; i++) {
+  for (int i = 0; i < N; i++) {
     const int32_t m0 = m[i];
     const int32_t m1 = MAX_MASK_VALUE - m0;
     const int32_t r = m0 * r0[i] + m1 * r1[i];
@@ -142,17 +134,16 @@
   DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       r1[i] = rng_(2 * INT8_MAX - 2 * INT8_MIN + 1) + 2 * INT8_MIN;
       d[i] = rng_(2 * INT8_MAX - 2 * INT8_MIN + 1) + 2 * INT8_MIN;
       m[i] = rng_(MAX_MASK_VALUE + 1);
     }
 
-    const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
+    const int N = 64 * (rng_(MAX_SB_SQUARE / 64) + 1);
 
-    for (int i = 0 ; i < N ; i++)
-      r0[i] = r1[i] + d[i];
+    for (int i = 0; i < N; i++) r0[i] = r1[i] + d[i];
 
     const uint64_t ref_res = sse_from_residuals(r0, r1, m, N);
     const uint64_t tst_res = vp10_wedge_sse_from_residuals(r1, d, m, N);
@@ -165,9 +156,7 @@
 // vp10_wedge_sse_from_residuals - optimizations
 //////////////////////////////////////////////////////////////////////////////
 
-typedef uint64_t (*FSSE)(const int16_t *r1,
-                         const int16_t *d,
-                         const uint8_t *m,
+typedef uint64_t (*FSSE)(const int16_t *r1, const int16_t *d, const uint8_t *m,
                          int N);
 typedef libvpx_test::FuncParam<FSSE> TestFuncsFSSE;
 
@@ -181,14 +170,14 @@
   DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       r1[i] = rng_(2 * kInt13Max + 1) - kInt13Max;
       d[i] = rng_(2 * kInt13Max + 1) - kInt13Max;
       m[i] = rng_(MAX_MASK_VALUE + 1);
     }
 
-    const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
+    const int N = 64 * (rng_(MAX_SB_SQUARE / 64) + 1);
 
     const uint64_t ref_res = params_.ref_func(r1, d, m, N);
     uint64_t tst_res;
@@ -203,27 +192,22 @@
   DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     if (rng_(2)) {
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-        r1[i] = kInt13Max;
+      for (int i = 0; i < MAX_SB_SQUARE; ++i) r1[i] = kInt13Max;
     } else {
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-        r1[i] = -kInt13Max;
+      for (int i = 0; i < MAX_SB_SQUARE; ++i) r1[i] = -kInt13Max;
     }
 
     if (rng_(2)) {
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-        d[i] = kInt13Max;
+      for (int i = 0; i < MAX_SB_SQUARE; ++i) d[i] = kInt13Max;
     } else {
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-        d[i] = -kInt13Max;
+      for (int i = 0; i < MAX_SB_SQUARE; ++i) d[i] = -kInt13Max;
     }
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-      m[i] = MAX_MASK_VALUE;
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) m[i] = MAX_MASK_VALUE;
 
-    const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
+    const int N = 64 * (rng_(MAX_SB_SQUARE / 64) + 1);
 
     const uint64_t ref_res = params_.ref_func(r1, d, m, N);
     uint64_t tst_res;
@@ -236,9 +220,8 @@
 #if HAVE_SSE2
 INSTANTIATE_TEST_CASE_P(
     SSE2, WedgeUtilsSSEOptTest,
-    ::testing::Values(
-        TestFuncsFSSE(vp10_wedge_sse_from_residuals_c,
-                      vp10_wedge_sse_from_residuals_sse2)));
+    ::testing::Values(TestFuncsFSSE(vp10_wedge_sse_from_residuals_c,
+                                    vp10_wedge_sse_from_residuals_sse2)));
 
 #endif  // HAVE_SSE2
 
@@ -246,10 +229,7 @@
 // vp10_wedge_sign_from_residuals
 //////////////////////////////////////////////////////////////////////////////
 
-typedef int (*FSign)(const int16_t *ds,
-                     const uint8_t *m,
-                     int N,
-                     int64_t limit);
+typedef int (*FSign)(const int16_t *ds, const uint8_t *m, int N, int64_t limit);
 typedef libvpx_test::FuncParam<FSign> TestFuncsFSign;
 
 class WedgeUtilsSignOptTest : public FunctionEquivalenceTest<FSign> {
@@ -264,23 +244,23 @@
   DECLARE_ALIGNED(32, int16_t, ds[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       r0[i] = rng_(2 * kInt13Max + 1) - kInt13Max;
       r1[i] = rng_(2 * kInt13Max + 1) - kInt13Max;
       m[i] = rng_(MAX_MASK_VALUE + 1);
     }
 
     const int maxN = VPXMIN(kMaxSize, MAX_SB_SQUARE);
-    const int N = 64 * (rng_(maxN/64 - 1) + 1);
+    const int N = 64 * (rng_(maxN / 64 - 1) + 1);
 
     int64_t limit;
     limit = (int64_t)vpx_sum_squares_i16(r0, N);
     limit -= (int64_t)vpx_sum_squares_i16(r1, N);
     limit *= (1 << WEDGE_WEIGHT_BITS) / 2;
 
-    for (int i = 0 ; i < N ; i++)
-      ds[i] = clamp(r0[i]*r0[i] - r1[i]*r1[i], INT16_MIN, INT16_MAX);
+    for (int i = 0; i < N; i++)
+      ds[i] = clamp(r0[i] * r0[i] - r1[i] * r1[i], INT16_MIN, INT16_MAX);
 
     const int ref_res = params_.ref_func(ds, m, N, limit);
     int tst_res;
@@ -296,47 +276,46 @@
   DECLARE_ALIGNED(32, int16_t, ds[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
     switch (rng_(4)) {
-    case 0:
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
-        r0[i] = 0;
-        r1[i] = kInt13Max;
-      }
-      break;
-    case 1:
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
-        r0[i] = kInt13Max;
-        r1[i] = 0;
-      }
-      break;
-    case 2:
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
-        r0[i] = 0;
-        r1[i] = -kInt13Max;
-      }
-      break;
-    default:
-      for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
-        r0[i] = -kInt13Max;
-        r1[i] = 0;
-      }
-      break;
+      case 0:
+        for (int i = 0; i < MAX_SB_SQUARE; ++i) {
+          r0[i] = 0;
+          r1[i] = kInt13Max;
+        }
+        break;
+      case 1:
+        for (int i = 0; i < MAX_SB_SQUARE; ++i) {
+          r0[i] = kInt13Max;
+          r1[i] = 0;
+        }
+        break;
+      case 2:
+        for (int i = 0; i < MAX_SB_SQUARE; ++i) {
+          r0[i] = 0;
+          r1[i] = -kInt13Max;
+        }
+        break;
+      default:
+        for (int i = 0; i < MAX_SB_SQUARE; ++i) {
+          r0[i] = -kInt13Max;
+          r1[i] = 0;
+        }
+        break;
     }
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-      m[i] = MAX_MASK_VALUE;
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) m[i] = MAX_MASK_VALUE;
 
     const int maxN = VPXMIN(kMaxSize, MAX_SB_SQUARE);
-    const int N = 64 * (rng_(maxN/64 - 1) + 1);
+    const int N = 64 * (rng_(maxN / 64 - 1) + 1);
 
     int64_t limit;
     limit = (int64_t)vpx_sum_squares_i16(r0, N);
     limit -= (int64_t)vpx_sum_squares_i16(r1, N);
     limit *= (1 << WEDGE_WEIGHT_BITS) / 2;
 
-    for (int i = 0 ; i < N ; i++)
-      ds[i] = clamp(r0[i]*r0[i] - r1[i]*r1[i], INT16_MIN, INT16_MAX);
+    for (int i = 0; i < N; i++)
+      ds[i] = clamp(r0[i] * r0[i] - r1[i] * r1[i], INT16_MIN, INT16_MAX);
 
     const int ref_res = params_.ref_func(ds, m, N, limit);
     int tst_res;
@@ -350,9 +329,8 @@
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, WedgeUtilsSignOptTest,
-    ::testing::Values(
-      TestFuncsFSign(vp10_wedge_sign_from_residuals_c,
-                     vp10_wedge_sign_from_residuals_sse2)));
+    ::testing::Values(TestFuncsFSign(vp10_wedge_sign_from_residuals_c,
+                                     vp10_wedge_sign_from_residuals_sse2)));
 
 #endif  // HAVE_SSE2
 
@@ -360,10 +338,7 @@
 // vp10_wedge_compute_delta_squares
 //////////////////////////////////////////////////////////////////////////////
 
-typedef void (*FDS)(int16_t *d,
-                    const int16_t *a,
-                    const int16_t *b,
-                    int N);
+typedef void (*FDS)(int16_t *d, const int16_t *a, const int16_t *b, int N);
 typedef libvpx_test::FuncParam<FDS> TestFuncsFDS;
 
 class WedgeUtilsDeltaSquaresOptTest : public FunctionEquivalenceTest<FDS> {
@@ -377,13 +352,13 @@
   DECLARE_ALIGNED(32, int16_t, d_ref[MAX_SB_SQUARE]);
   DECLARE_ALIGNED(32, int16_t, d_tst[MAX_SB_SQUARE]);
 
-  for (int iter = 0 ; iter < kIterations && !HasFatalFailure(); ++iter) {
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i) {
+  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
       a[i] = rng_.Rand16();
       b[i] = rng_(2 * INT16_MAX + 1) - INT16_MAX;
     }
 
-    const int N = 64 * (rng_(MAX_SB_SQUARE/64) + 1);
+    const int N = 64 * (rng_(MAX_SB_SQUARE / 64) + 1);
 
     memset(&d_ref, INT16_MAX, sizeof(d_ref));
     memset(&d_tst, INT16_MAX, sizeof(d_tst));
@@ -391,8 +366,7 @@
     params_.ref_func(d_ref, a, b, N);
     ASM_REGISTER_STATE_CHECK(params_.tst_func(d_tst, a, b, N));
 
-    for (int i = 0 ; i < MAX_SB_SQUARE ; ++i)
-      ASSERT_EQ(d_ref[i], d_tst[i]);
+    for (int i = 0; i < MAX_SB_SQUARE; ++i) ASSERT_EQ(d_ref[i], d_tst[i]);
   }
 }
 
@@ -400,9 +374,8 @@
 
 INSTANTIATE_TEST_CASE_P(
     SSE2, WedgeUtilsDeltaSquaresOptTest,
-    ::testing::Values(
-      TestFuncsFDS(vp10_wedge_compute_delta_squares_c,
-                   vp10_wedge_compute_delta_squares_sse2)));
+    ::testing::Values(TestFuncsFDS(vp10_wedge_compute_delta_squares_c,
+                                   vp10_wedge_compute_delta_squares_sse2)));
 
 #endif  // HAVE_SSE2
 
diff --git a/test/webm_video_source.h b/test/webm_video_source.h
index 8258756..5371361 100644
--- a/test/webm_video_source.h
+++ b/test/webm_video_source.h
@@ -25,30 +25,23 @@
 class WebMVideoSource : public CompressedVideoSource {
  public:
   explicit WebMVideoSource(const std::string &file_name)
-      : file_name_(file_name),
-        vpx_ctx_(new VpxInputContext()),
-        webm_ctx_(new WebmInputContext()),
-        buf_(NULL),
-        buf_sz_(0),
-        frame_(0),
-        end_of_file_(false) {
-  }
+      : file_name_(file_name), vpx_ctx_(new VpxInputContext()),
+        webm_ctx_(new WebmInputContext()), buf_(NULL), buf_sz_(0), frame_(0),
+        end_of_file_(false) {}
 
   virtual ~WebMVideoSource() {
-    if (vpx_ctx_->file != NULL)
-      fclose(vpx_ctx_->file);
+    if (vpx_ctx_->file != NULL) fclose(vpx_ctx_->file);
     webm_free(webm_ctx_);
     delete vpx_ctx_;
     delete webm_ctx_;
   }
 
-  virtual void Init() {
-  }
+  virtual void Init() {}
 
   virtual void Begin() {
     vpx_ctx_->file = OpenTestDataFile(file_name_);
     ASSERT_TRUE(vpx_ctx_->file != NULL) << "Input file open failed. Filename: "
-        << file_name_;
+                                        << file_name_;
 
     ASSERT_EQ(file_is_webm(webm_ctx_, vpx_ctx_), 1) << "file is not WebM";
 
@@ -81,9 +74,7 @@
     } while (!webm_ctx_->is_key_frame && !end_of_file_);
   }
 
-  virtual const uint8_t *cxdata() const {
-    return end_of_file_ ? NULL : buf_;
-  }
+  virtual const uint8_t *cxdata() const { return end_of_file_ ? NULL : buf_; }
   virtual size_t frame_size() const { return buf_sz_; }
   virtual unsigned int frame_number() const { return frame_; }
 
diff --git a/test/y4m_test.cc b/test/y4m_test.cc
index a555329..000bab6 100644
--- a/test/y4m_test.cc
+++ b/test/y4m_test.cc
@@ -22,7 +22,7 @@
 
 using std::string;
 
-static const unsigned int kWidth  = 160;
+static const unsigned int kWidth = 160;
 static const unsigned int kHeight = 90;
 static const unsigned int kFrames = 10;
 
@@ -34,24 +34,24 @@
 };
 
 const Y4mTestParam kY4mTestVectors[] = {
-  {"park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420,
-    "e5406275b9fc6bb3436c31d4a05c1cab"},
-  {"park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422,
-    "284a47a47133b12884ec3a14e959a0b6"},
-  {"park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444,
-    "90517ff33843d85de712fd4fe60dbed0"},
-  {"park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016,
-    "63f21f9f717d8b8631bd2288ee87137b"},
-  {"park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216,
-    "48ab51fb540aed07f7ff5af130c9b605"},
-  {"park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416,
-    "067bfd75aa85ff9bae91fa3e0edd1e3e"},
-  {"park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016,
-    "9e6d8f6508c6e55625f6b697bc461cef"},
-  {"park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216,
-    "b239c6b301c0b835485be349ca83a7e3"},
-  {"park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416,
-    "5a6481a550821dab6d0192f5c63845e9"},
+  { "park_joy_90p_8_420.y4m", 8, VPX_IMG_FMT_I420,
+    "e5406275b9fc6bb3436c31d4a05c1cab" },
+  { "park_joy_90p_8_422.y4m", 8, VPX_IMG_FMT_I422,
+    "284a47a47133b12884ec3a14e959a0b6" },
+  { "park_joy_90p_8_444.y4m", 8, VPX_IMG_FMT_I444,
+    "90517ff33843d85de712fd4fe60dbed0" },
+  { "park_joy_90p_10_420.y4m", 10, VPX_IMG_FMT_I42016,
+    "63f21f9f717d8b8631bd2288ee87137b" },
+  { "park_joy_90p_10_422.y4m", 10, VPX_IMG_FMT_I42216,
+    "48ab51fb540aed07f7ff5af130c9b605" },
+  { "park_joy_90p_10_444.y4m", 10, VPX_IMG_FMT_I44416,
+    "067bfd75aa85ff9bae91fa3e0edd1e3e" },
+  { "park_joy_90p_12_420.y4m", 12, VPX_IMG_FMT_I42016,
+    "9e6d8f6508c6e55625f6b697bc461cef" },
+  { "park_joy_90p_12_422.y4m", 12, VPX_IMG_FMT_I42216,
+    "b239c6b301c0b835485be349ca83a7e3" },
+  { "park_joy_90p_12_444.y4m", 12, VPX_IMG_FMT_I44416,
+    "5a6481a550821dab6d0192f5c63845e9" },
 };
 
 static void write_image_file(const vpx_image_t *img, FILE *file) {
@@ -60,10 +60,12 @@
     const unsigned char *buf = img->planes[plane];
     const int stride = img->stride[plane];
     const int bytes_per_sample = (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
-    const int h = (plane ? (img->d_h + img->y_chroma_shift) >>
-                   img->y_chroma_shift : img->d_h);
-    const int w = (plane ? (img->d_w + img->x_chroma_shift) >>
-                   img->x_chroma_shift : img->d_w);
+    const int h =
+        (plane ? (img->d_h + img->y_chroma_shift) >> img->y_chroma_shift
+               : img->d_h);
+    const int w =
+        (plane ? (img->d_w + img->x_chroma_shift) >> img->x_chroma_shift
+               : img->d_w);
     for (y = 0; y < h; ++y) {
       fwrite(buf, bytes_per_sample, w, file);
       buf += stride;
@@ -71,15 +73,12 @@
   }
 }
 
-class Y4mVideoSourceTest
-    : public ::testing::TestWithParam<Y4mTestParam>,
-      public ::libvpx_test::Y4mVideoSource {
+class Y4mVideoSourceTest : public ::testing::TestWithParam<Y4mTestParam>,
+                           public ::libvpx_test::Y4mVideoSource {
  protected:
   Y4mVideoSourceTest() : Y4mVideoSource("", 0, 0) {}
 
-  virtual ~Y4mVideoSourceTest() {
-    CloseSource();
-  }
+  virtual ~Y4mVideoSourceTest() { CloseSource(); }
 
   virtual void Init(const std::string &file_name, int limit) {
     file_name_ = file_name;
@@ -137,8 +136,7 @@
 INSTANTIATE_TEST_CASE_P(C, Y4mVideoSourceTest,
                         ::testing::ValuesIn(kY4mTestVectors));
 
-class Y4mVideoWriteTest
-    : public Y4mVideoSourceTest {
+class Y4mVideoWriteTest : public Y4mVideoSourceTest {
  protected:
   Y4mVideoWriteTest() {}
 
@@ -158,14 +156,12 @@
   // Writes out a y4m file and then reads it back
   void WriteY4mAndReadBack() {
     ASSERT_TRUE(input_file_ != NULL);
-    char buf[Y4M_BUFFER_SIZE] = {0};
-    const struct VpxRational framerate = {y4m_.fps_n, y4m_.fps_d};
+    char buf[Y4M_BUFFER_SIZE] = { 0 };
+    const struct VpxRational framerate = { y4m_.fps_n, y4m_.fps_d };
     tmpfile_ = new libvpx_test::TempOutFile;
     ASSERT_TRUE(tmpfile_->file() != NULL);
-    y4m_write_file_header(buf, sizeof(buf),
-                          kWidth, kHeight,
-                          &framerate, y4m_.vpx_fmt,
-                          y4m_.bit_depth);
+    y4m_write_file_header(buf, sizeof(buf), kWidth, kHeight, &framerate,
+                          y4m_.vpx_fmt, y4m_.bit_depth);
     fputs(buf, tmpfile_->file());
     for (unsigned int i = start_; i < limit_; i++) {
       y4m_write_frame_header(buf, sizeof(buf));
diff --git a/test/y4m_video_source.h b/test/y4m_video_source.h
index 03d9388..2682ddd 100644
--- a/test/y4m_video_source.h
+++ b/test/y4m_video_source.h
@@ -21,18 +21,10 @@
 // so that we can do actual file encodes.
 class Y4mVideoSource : public VideoSource {
  public:
-  Y4mVideoSource(const std::string &file_name,
-                  unsigned int start, int limit)
-      : file_name_(file_name),
-        input_file_(NULL),
-        img_(new vpx_image_t()),
-        start_(start),
-        limit_(limit),
-        frame_(0),
-        framerate_numerator_(0),
-        framerate_denominator_(0),
-        y4m_() {
-  }
+  Y4mVideoSource(const std::string &file_name, unsigned int start, int limit)
+      : file_name_(file_name), input_file_(NULL), img_(new vpx_image_t()),
+        start_(start), limit_(limit), frame_(0), framerate_numerator_(0),
+        framerate_denominator_(0), y4m_() {}
 
   virtual ~Y4mVideoSource() {
     vpx_img_free(img_.get());
diff --git a/test/yuv_video_source.h b/test/yuv_video_source.h
index 3c852b2..2cc81a0 100644
--- a/test/yuv_video_source.h
+++ b/test/yuv_video_source.h
@@ -25,19 +25,11 @@
 class YUVVideoSource : public VideoSource {
  public:
   YUVVideoSource(const std::string &file_name, vpx_img_fmt format,
-                 unsigned int width, unsigned int height,
-                 int rate_numerator, int rate_denominator,
-                 unsigned int start, int limit)
-      : file_name_(file_name),
-        input_file_(NULL),
-        img_(NULL),
-        start_(start),
-        limit_(limit),
-        frame_(0),
-        width_(0),
-        height_(0),
-        format_(VPX_IMG_FMT_NONE),
-        framerate_numerator_(rate_numerator),
+                 unsigned int width, unsigned int height, int rate_numerator,
+                 int rate_denominator, unsigned int start, int limit)
+      : file_name_(file_name), input_file_(NULL), img_(NULL), start_(start),
+        limit_(limit), frame_(0), width_(0), height_(0),
+        format_(VPX_IMG_FMT_NONE), framerate_numerator_(rate_numerator),
         framerate_denominator_(rate_denominator) {
     // This initializes format_, raw_size_, width_, height_ and allocates img.
     SetSize(width, height, format);
@@ -45,13 +37,11 @@
 
   virtual ~YUVVideoSource() {
     vpx_img_free(img_);
-    if (input_file_)
-      fclose(input_file_);
+    if (input_file_) fclose(input_file_);
   }
 
   virtual void Begin() {
-    if (input_file_)
-      fclose(input_file_);
+    if (input_file_) fclose(input_file_);
     input_file_ = OpenTestDataFile(file_name_);
     ASSERT_TRUE(input_file_ != NULL) << "Input file open failed. Filename: "
                                      << file_name_;
@@ -67,7 +57,7 @@
     FillFrame();
   }
 
-  virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL;  }
+  virtual vpx_image_t *img() const { return (frame_ < limit_) ? img_ : NULL; }
 
   // Models a stream where Timebase = 1/FPS, so pts == frame.
   virtual vpx_codec_pts_t pts() const { return frame_; }
@@ -93,32 +83,15 @@
       height_ = height;
       format_ = format;
       switch (format) {
-        case VPX_IMG_FMT_I420:
-          raw_size_ = width * height * 3 / 2;
-          break;
-        case VPX_IMG_FMT_I422:
-          raw_size_ = width * height * 2;
-          break;
-        case VPX_IMG_FMT_I440:
-          raw_size_ = width * height * 2;
-          break;
-        case VPX_IMG_FMT_I444:
-          raw_size_ = width * height * 3;
-          break;
-        case VPX_IMG_FMT_I42016:
-          raw_size_ = width * height * 3;
-          break;
-        case VPX_IMG_FMT_I42216:
-          raw_size_ = width * height * 4;
-          break;
-        case VPX_IMG_FMT_I44016:
-          raw_size_ = width * height * 4;
-          break;
-        case VPX_IMG_FMT_I44416:
-          raw_size_ = width * height * 6;
-          break;
-        default:
-          ASSERT_TRUE(0);
+        case VPX_IMG_FMT_I420: raw_size_ = width * height * 3 / 2; break;
+        case VPX_IMG_FMT_I422: raw_size_ = width * height * 2; break;
+        case VPX_IMG_FMT_I440: raw_size_ = width * height * 2; break;
+        case VPX_IMG_FMT_I444: raw_size_ = width * height * 3; break;
+        case VPX_IMG_FMT_I42016: raw_size_ = width * height * 3; break;
+        case VPX_IMG_FMT_I42216: raw_size_ = width * height * 4; break;
+        case VPX_IMG_FMT_I44016: raw_size_ = width * height * 4; break;
+        case VPX_IMG_FMT_I44416: raw_size_ = width * height * 6; break;
+        default: ASSERT_TRUE(0);
       }
     }
   }