break up unittests into categories

unit_test/convert_test.cc

 /*
  *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS. All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 14 matching lines @@
 #include "libyuv/row.h"
 #include "libyuv/video_common.h"
 #include "../unit_test/unit_test.h"
 
 namespace libyuv {
 
 #define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a))
 
 #define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,           \
                        FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF)   \
-TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                        \
+TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                 \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u,                                                       \
                   SUBSAMPLE(kWidth, SRC_SUBSAMP_X) *                           \
                   SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF);                    \
   align_buffer_64(src_v,                                                       \
                   SUBSAMPLE(kWidth, SRC_SUBSAMP_X) *                           \
                   SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF);                    \
   align_buffer_64(dst_y_c, kWidth * kHeight);                                  \
@@ skipping 123 matching lines @@
 TESTPLANARTOP(I411, 4, 1, I420, 2, 2)
 TESTPLANARTOP(I420, 2, 2, I422, 2, 1)
 TESTPLANARTOP(I420, 2, 2, I444, 1, 1)
 TESTPLANARTOP(I420, 2, 2, I411, 4, 1)
 TESTPLANARTOP(I420, 2, 2, I420Mirror, 2, 2)
 TESTPLANARTOP(I422, 2, 1, I422, 2, 1)
 TESTPLANARTOP(I444, 1, 1, I444, 1, 1)
 
 #define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,          \
                        FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF)   \
-TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                        \
+TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                 \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u,                                                       \
                   SUBSAMPLE(kWidth, SRC_SUBSAMP_X) *                           \
                   SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF);                    \
   align_buffer_64(src_v,                                                       \
                   SUBSAMPLE(kWidth, SRC_SUBSAMP_X) *                           \
                   SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF);                    \
   align_buffer_64(dst_y_c, kWidth * kHeight);                                  \
@@ skipping 87 matching lines @@
                     benchmark_width_, _Invert, -, 0)                           \
     TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,              \
                     FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,                          \
                     benchmark_width_, _Opt, +, 0)
 
 TESTPLANARTOBP(I420, 2, 2, NV12, 2, 2)
 TESTPLANARTOBP(I420, 2, 2, NV21, 2, 2)
 
 #define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y,         \
                          FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \
-TEST_F(libyuvTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                        \
+TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) {                 \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_uv, 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) *               \
                   SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF);                    \
   align_buffer_64(dst_y_c, kWidth * kHeight);                                  \
   align_buffer_64(dst_u_c,                                                     \
                   SUBSAMPLE(kWidth, SUBSAMP_X) *                               \
                   SUBSAMPLE(kHeight, SUBSAMP_Y));                              \
   align_buffer_64(dst_v_c,                                                     \
@@ skipping 106 matching lines @@
                      FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,                         \
                      benchmark_width_, _Opt, +, 0)
 
 TESTBIPLANARTOP(NV12, 2, 2, I420, 2, 2)
 TESTBIPLANARTOP(NV21, 2, 2, I420, 2, 2)
 
 #define ALIGNINT(V, ALIGN) (((V) + (ALIGN) - 1) / (ALIGN) * (ALIGN))
 
 #define TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,  \
                        YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C)         \
-TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) {                                 \
+TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                          \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                     \
   const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                        \
   const int kSizeUV =                                                          \
     SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y);              \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u, kSizeUV + OFF);                                       \
   align_buffer_64(src_v, kSizeUV + OFF);                                       \
   align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF);                       \
   align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF);                     \
@@ skipping 88 matching lines @@
 TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1, 2, ARGB, 4)
 TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1, 1, ARGB, 4)
 TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1, 1, ARGB, 4)
 TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1, 0, ARGB, 4)
 TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1, 0, ARGB, 4)
 TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1, 0, ARGB, 4)
 TESTPLANARTOB(J420, 2, 2, J400, 1, 1, 1, 0, ARGB, 4)
 
 #define TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
                        YALIGN, W1280, DIFF, N, NEG, OFF, ATTEN)                \
-TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) {                                 \
+TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                          \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                     \
   const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                        \
   const int kSizeUV =                                                          \
     SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y);              \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u, kSizeUV + OFF);                                       \
   align_buffer_64(src_v, kSizeUV + OFF);                                       \
   align_buffer_64(src_a, kWidth * kHeight + OFF);                              \
   align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF);                       \
@@ skipping 53 matching lines @@
     TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,     \
         YALIGN, benchmark_width_, DIFF, _Opt, +, 0, 0)                         \
     TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,     \
         YALIGN, benchmark_width_, DIFF, _Premult, +, 0, 1)
 
 TESTQPLANARTOB(I420Alpha, 2, 2, ARGB, 4, 4, 1, 2)
 TESTQPLANARTOB(I420Alpha, 2, 2, ABGR, 4, 4, 1, 2)
 
 #define TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,       \
                          W1280, DIFF, N, NEG, OFF)                             \
-TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##N) {                                 \
+TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) {                          \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kStrideB = kWidth * BPP_B;                                         \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_uv,                                                      \
                   SUBSAMPLE(kWidth, SUBSAMP_X) *                               \
                   SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF);                    \
   align_buffer_64(dst_argb_c, kStrideB * kHeight);                             \
   align_buffer_64(dst_argb_opt, kStrideB * kHeight);                           \
   for (int i = 0; i < kHeight; ++i)                                            \
@@ skipping 59 matching lines @@
                      benchmark_width_, DIFF, _Invert, -, 0)                    \
     TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B,           \
                      benchmark_width_, DIFF, _Opt, +, 0)
 
 TESTBIPLANARTOB(NV12, 2, 2, ARGB, 4, 2)
 TESTBIPLANARTOB(NV21, 2, 2, ARGB, 4, 2)
 TESTBIPLANARTOB(NV12, 2, 2, RGB565, 2, 9)
 
 #define TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \
                        W1280, DIFF, N, NEG, OFF)                               \
-TEST_F(libyuvTest, FMT_A##To##FMT_PLANAR##N) {                                 \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) {                          \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                     \
   const int kStride =                                                          \
       (SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMP_X * 8 * BPP_A + 7) / 8;          \
   align_buffer_64(src_argb, kStride * kHeight + OFF);                          \
   align_buffer_64(dst_y_c, kWidth * kHeight);                                  \
   align_buffer_64(dst_u_c,                                                     \
                   SUBSAMPLE(kWidth, SUBSAMP_X) *                               \
                   SUBSAMPLE(kHeight, SUBSAMP_Y));                              \
   align_buffer_64(dst_v_c,                                                     \
@@ skipping 97 matching lines @@
 TESTATOPLANAR(ARGB, 4, 1, I444, 1, 1, 2)
 TESTATOPLANAR(YUY2, 2, 1, I420, 2, 2, 2)
 TESTATOPLANAR(UYVY, 2, 1, I420, 2, 2, 2)
 TESTATOPLANAR(YUY2, 2, 1, I422, 2, 1, 2)
 TESTATOPLANAR(UYVY, 2, 1, I422, 2, 1, 2)
 TESTATOPLANAR(I400, 1, 1, I420, 2, 2, 2)
 TESTATOPLANAR(J400, 1, 1, J420, 2, 2, 2)
 
 #define TESTATOBIPLANARI(FMT_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y,       \
                        W1280, N, NEG, OFF)                                     \
-TEST_F(libyuvTest, FMT_A##To##FMT_PLANAR##N) {                                 \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) {                          \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kStride = (kWidth * 8 * BPP_A + 7) / 8;                            \
   align_buffer_64(src_argb, kStride * kHeight + OFF);                          \
   align_buffer_64(dst_y_c, kWidth * kHeight);                                  \
   align_buffer_64(dst_uv_c,                                                    \
                   SUBSAMPLE(kWidth, SUBSAMP_X) * 2 *                           \
                   SUBSAMPLE(kHeight, SUBSAMP_Y));                              \
   align_buffer_64(dst_y_opt, kWidth * kHeight);                                \
   align_buffer_64(dst_uv_opt,                                                  \
@@ skipping 63 matching lines @@
                      benchmark_width_, _Opt, +, 0)
 
 TESTATOBIPLANAR(ARGB, 4, NV12, 2, 2)
 TESTATOBIPLANAR(ARGB, 4, NV21, 2, 2)
 TESTATOBIPLANAR(YUY2, 2, NV12, 2, 2)
 TESTATOBIPLANAR(UYVY, 2, NV12, 2, 2)
 
 #define TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                            \
                   FMT_B, BPP_B, STRIDE_B, HEIGHT_B,                            \
                   W1280, DIFF, N, NEG, OFF)                                    \
-TEST_F(libyuvTest, FMT_A##To##FMT_B##N) {                                      \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##N) {                               \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;         \
   const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;         \
   const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;  \
   const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;  \
   align_buffer_64(src_argb, kStrideA * kHeightA + OFF);                        \
   align_buffer_64(dst_argb_c, kStrideB * kHeightB);                            \
   align_buffer_64(dst_argb_opt, kStrideB * kHeightB);                          \
   for (int i = 0; i < kStrideA * kHeightA; ++i) {                              \
@@ skipping 21 matching lines @@
     }                                                                          \
   }                                                                            \
   EXPECT_LE(max_diff, DIFF);                                                   \
   free_aligned_buffer_64(src_argb);                                            \
   free_aligned_buffer_64(dst_argb_c);                                          \
   free_aligned_buffer_64(dst_argb_opt);                                        \
 }
 
 #define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                       \
                        FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF)                 \
-TEST_F(libyuvTest, FMT_A##To##FMT_B##_Random) {                                \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##_Random) {                         \
   for (int times = 0; times < benchmark_iterations_; ++times) {                \
     const int kWidth = (fastrand() & 63) + 1;                                  \
     const int kHeight = (fastrand() & 31) + 1;                                 \
     const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;       \
     const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;       \
     const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\
     const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\
     align_buffer_page_end(src_argb, kStrideA * kHeightA);                      \
     align_buffer_page_end(dst_argb_c, kStrideB * kHeightB);                    \
     align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB);                  \
@@ skipping 69 matching lines @@
 TESTATOB(I400, 1, 1, 1, ARGB, 4, 4, 1, 0)
 TESTATOB(J400, 1, 1, 1, ARGB, 4, 4, 1, 0)
 TESTATOB(I400, 1, 1, 1, I400, 1, 1, 1, 0)
 TESTATOB(J400, 1, 1, 1, J400, 1, 1, 1, 0)
 TESTATOB(I400, 1, 1, 1, I400Mirror, 1, 1, 1, 0)
 TESTATOB(ARGB, 4, 4, 1, ARGBMirror, 4, 4, 1, 0)
 
 #define TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                           \
                    FMT_B, BPP_B, STRIDE_B, HEIGHT_B,                           \
                    W1280, DIFF, N, NEG, OFF)                                   \
-TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither##N) {                              \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither##N) {                       \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;         \
   const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;         \
   const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;  \
   const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;  \
   align_buffer_64(src_argb, kStrideA * kHeightA + OFF);                        \
   align_buffer_64(dst_argb_c, kStrideB * kHeightB);                            \
   align_buffer_64(dst_argb_opt, kStrideB * kHeightB);                          \
   for (int i = 0; i < kStrideA * kHeightA; ++i) {                              \
@@ skipping 21 matching lines @@
     }                                                                          \
   }                                                                            \
   EXPECT_LE(max_diff, DIFF);                                                   \
   free_aligned_buffer_64(src_argb);                                            \
   free_aligned_buffer_64(dst_argb_c);                                          \
   free_aligned_buffer_64(dst_argb_opt);                                        \
 }
 
 #define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                      \
                        FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF)                 \
-TEST_F(libyuvTest, FMT_A##To##FMT_B##Dither_Random) {                          \
+TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither_Random) {                   \
   for (int times = 0; times < benchmark_iterations_; ++times) {                \
     const int kWidth = (fastrand() & 63) + 1;                                  \
     const int kHeight = (fastrand() & 31) + 1;                                 \
     const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;       \
     const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B;       \
     const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\
     const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\
     align_buffer_page_end(src_argb, kStrideA * kHeightA);                      \
     align_buffer_page_end(dst_argb_c, kStrideB * kHeightB);                    \
     align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB);                  \
@@ skipping 40 matching lines @@
     TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                               \
                FMT_B, BPP_B, STRIDE_B, HEIGHT_B,                               \
                benchmark_width_, DIFF, _Opt, +, 0)                             \
     TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A,                          \
                     FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF)
 
 TESTATOBD(ARGB, 4, 4, 1, RGB565, 2, 2, 1, 0)
 
 #define TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A,                          \
                  W1280, N, NEG, OFF)                                           \
-TEST_F(libyuvTest, FMT_ATOB##_Symetric##N) {                                   \
+TEST_F(LibYUVConvertTest, FMT_ATOB##_Symetric##N) {                            \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = benchmark_height_;                                       \
   const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A;         \
   const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;  \
   align_buffer_64(src_argb, kStrideA * kHeightA + OFF);                        \
   align_buffer_64(dst_argb_c, kStrideA * kHeightA);                            \
   align_buffer_64(dst_argb_opt, kStrideA * kHeightA);                          \
   for (int i = 0; i < kStrideA * kHeightA; ++i) {                              \
     src_argb[i + OFF] = (fastrand() & 0xff);                                   \
   }                                                                            \
@@ skipping 33 matching lines @@
              benchmark_width_, _Unaligned, +, 1)                               \
     TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A,                              \
              benchmark_width_, _Opt, +, 0)
 
 TESTSYM(ARGBToARGB, 4, 4, 1)
 TESTSYM(ARGBToBGRA, 4, 4, 1)
 TESTSYM(ARGBToABGR, 4, 4, 1)
 TESTSYM(BGRAToARGB, 4, 4, 1)
 TESTSYM(ABGRToARGB, 4, 4, 1)
 
-TEST_F(libyuvTest, Test565) {
+TEST_F(LibYUVConvertTest, Test565) {
   SIMD_ALIGNED(uint8 orig_pixels[256][4]);
   SIMD_ALIGNED(uint8 pixels565[256][2]);
 
   for (int i = 0; i < 256; ++i) {
     for (int j = 0; j < 4; ++j) {
       orig_pixels[i][j] = i;
     }
   }
   ARGBToRGB565(&orig_pixels[0][0], 0, &pixels565[0][0], 0, 256, 1);
   uint32 checksum = HashDjb2(&pixels565[0][0], sizeof(pixels565), 5381);
   EXPECT_EQ(610919429u, checksum);
 }
 
 #ifdef HAVE_JPEG
-TEST_F(libyuvTest, ValidateJpeg) {
+TEST_F(LibYUVConvertTest, ValidateJpeg) {
   const int kOff = 10;
   const int kMinJpeg = 64;
   const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ?
     benchmark_width_ * benchmark_height_ : kMinJpeg;
   const int kSize = kImageSize + kOff;
   align_buffer_page_end(orig_pixels, kSize);
 
   // No SOI or EOI. Expect fail.
   memset(orig_pixels, 0, kSize);
   EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
 
   // Test special value that matches marker start.
   memset(orig_pixels, 0xff, kSize);
   EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
 
   // EOI, SOI. Expect pass.
   orig_pixels[0] = 0xff;
   orig_pixels[1] = 0xd8;  // SOI.
   orig_pixels[kSize - kOff + 0] = 0xff;
   orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
   for (int times = 0; times < benchmark_iterations_; ++times) {
     EXPECT_TRUE(ValidateJpeg(orig_pixels, kSize));
   }
   free_aligned_buffer_page_end(orig_pixels);
 }
 
-TEST_F(libyuvTest, ValidateJpegLarge) {
+TEST_F(LibYUVConvertTest, ValidateJpegLarge) {
   const int kOff = 10;
   const int kMinJpeg = 64;
   const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ?
     benchmark_width_ * benchmark_height_ : kMinJpeg;
   const int kSize = kImageSize + kOff;
   const int kMultiple = 10;
   const int kBufSize = kImageSize * kMultiple + kOff;
   align_buffer_page_end(orig_pixels, kBufSize);
 
   // No SOI or EOI. Expect fail.
   memset(orig_pixels, 0, kBufSize);
   EXPECT_FALSE(ValidateJpeg(orig_pixels, kBufSize));
 
   // EOI, SOI. Expect pass.
   orig_pixels[0] = 0xff;
   orig_pixels[1] = 0xd8;  // SOI.
   orig_pixels[kSize - kOff + 0] = 0xff;
   orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
   for (int times = 0; times < benchmark_iterations_; ++times) {
     EXPECT_TRUE(ValidateJpeg(orig_pixels, kBufSize));
   }
   free_aligned_buffer_page_end(orig_pixels);
 }
 
-TEST_F(libyuvTest, InvalidateJpeg) {
+TEST_F(LibYUVConvertTest, InvalidateJpeg) {
   const int kOff = 10;
   const int kMinJpeg = 64;
   const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ?
     benchmark_width_ * benchmark_height_ : kMinJpeg;
   const int kSize = kImageSize + kOff;
   align_buffer_page_end(orig_pixels, kSize);
 
   // NULL pointer. Expect fail.
   EXPECT_FALSE(ValidateJpeg(NULL, kSize));
 
@@ skipping 17 matching lines @@
   // EOI but no SOI. Expect fail.
   orig_pixels[0] = 0;
   orig_pixels[1] = 0;
   orig_pixels[kSize - kOff + 0] = 0xff;
   orig_pixels[kSize - kOff + 1] = 0xd9;  // EOI.
   EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize));
 
   free_aligned_buffer_page_end(orig_pixels);
 }
 
-TEST_F(libyuvTest, FuzzJpeg) {
+TEST_F(LibYUVConvertTest, FuzzJpeg) {
   // SOI but no EOI. Expect fail.
   for (int times = 0; times < benchmark_iterations_; ++times) {
     const int kSize = fastrand() % 5000 + 2;
     align_buffer_page_end(orig_pixels, kSize);
     MemRandomize(orig_pixels, kSize);
 
     // Add SOI so frame will be scanned.
     orig_pixels[0] = 0xff;
     orig_pixels[1] = 0xd8;  // SOI.
     orig_pixels[kSize - 1] = 0xff;
     ValidateJpeg(orig_pixels, kSize);  // Failure normally expected.
     free_aligned_buffer_page_end(orig_pixels);
   }
 }
 
-TEST_F(libyuvTest, MJPGToI420) {
+TEST_F(LibYUVConvertTest, MJPGToI420) {
   const int kOff = 10;
   const int kMinJpeg = 64;
   const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ?
     benchmark_width_ * benchmark_height_ : kMinJpeg;
   const int kSize = kImageSize + kOff;
   align_buffer_page_end(orig_pixels, kSize);
   align_buffer_page_end(dst_y_opt, benchmark_width_ * benchmark_height_);
   align_buffer_page_end(dst_u_opt,
                         SUBSAMPLE(benchmark_width_, 2) *
                         SUBSAMPLE(benchmark_height_, 2));
@@ skipping 18 matching lines @@
     // Expect failure because image is not really valid.
     EXPECT_EQ(1, ret);
   }
 
   free_aligned_buffer_page_end(dst_y_opt);
   free_aligned_buffer_page_end(dst_u_opt);
   free_aligned_buffer_page_end(dst_v_opt);
   free_aligned_buffer_page_end(orig_pixels);
 }
 
-TEST_F(libyuvTest, MJPGToARGB) {
+TEST_F(LibYUVConvertTest, MJPGToARGB) {
   const int kOff = 10;
   const int kMinJpeg = 64;
   const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ?
     benchmark_width_ * benchmark_height_ : kMinJpeg;
   const int kSize = kImageSize + kOff;
   align_buffer_page_end(orig_pixels, kSize);
   align_buffer_page_end(dst_argb_opt, benchmark_width_ * benchmark_height_ * 4);
 
   // EOI, SOI to make MJPG appear valid.
   memset(orig_pixels, 0, kSize);
@@ skipping 10 matching lines @@
     // Expect failure because image is not really valid.
     EXPECT_EQ(1, ret);
   }
 
   free_aligned_buffer_page_end(dst_argb_opt);
   free_aligned_buffer_page_end(orig_pixels);
 }
 
 #endif  // HAVE_JPEG
 
-TEST_F(libyuvTest, CropNV12) {
+TEST_F(LibYUVConvertTest, CropNV12) {
   const int SUBSAMP_X = 2;
   const int SUBSAMP_Y = 2;
   const int kWidth = benchmark_width_;
   const int kHeight = benchmark_height_;
   const int crop_y =
     ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1;
   const int kDestWidth = benchmark_width_;
   const int kDestHeight = benchmark_height_ - crop_y * 2;
   const int sample_size = kWidth * kHeight +
     SUBSAMPLE(kWidth, SUBSAMP_X) *
@@ skipping 71 matching lines @@
   }
   free_aligned_buffer_64(dst_y);
   free_aligned_buffer_64(dst_u);
   free_aligned_buffer_64(dst_v);
   free_aligned_buffer_64(dst_y_2);
   free_aligned_buffer_64(dst_u_2);
   free_aligned_buffer_64(dst_v_2);
   free_aligned_buffer_64(src_y);
 }
 
-TEST_F(libyuvTest, HaveJPEG) {
+TEST_F(LibYUVConvertTest, HaveJPEG) {
 #ifdef HAVE_JPEG
   printf("JPEG enabled\n.");
 #else
   printf("JPEG disabled\n.");
 #endif
 }
 
-TEST_F(libyuvTest, TestYToARGB) {
+TEST_F(LibYUVConvertTest, TestYToARGB) {
   uint8 y[32];
   uint8 expectedg[32];
   for (int i = 0; i < 32; ++i) {
     y[i] = i * 5 + 17;
     expectedg[i] = static_cast<int>((y[i] - 16) * 1.164f + 0.5f);
   }
   uint8 argb[32 * 4];
   YToARGB(y, 0, argb, 0, 32, 1);
 
   for (int i = 0; i < 32; ++i) {
     printf("%2d %d: %d <-> %d,%d,%d,%d\n", i, y[i], expectedg[i],
            argb[i * 4 + 0],
            argb[i * 4 + 1],
            argb[i * 4 + 2],
            argb[i * 4 + 3]);
   }
   for (int i = 0; i < 32; ++i) {
     EXPECT_EQ(expectedg[i], argb[i * 4 + 0]);
   }
 }
 
 static const uint8 kNoDither4x4[16] = {
   0, 0, 0, 0,
   0, 0, 0, 0,
   0, 0, 0, 0,
   0, 0, 0, 0,
 };
 
-TEST_F(libyuvTest, TestNoDither) {
+TEST_F(LibYUVConvertTest, TestNoDither) {
   align_buffer_64(src_argb, benchmark_width_ * benchmark_height_ * 4);
   align_buffer_64(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
   align_buffer_64(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
   MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4);
   MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
   MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
   ARGBToRGB565(src_argb, benchmark_width_ * 4,
                dst_rgb565, benchmark_width_ * 2,
                benchmark_width_, benchmark_height_);
   ARGBToRGB565Dither(src_argb, benchmark_width_ * 4,
                      dst_rgb565dither, benchmark_width_ * 2,
                      kNoDither4x4, benchmark_width_, benchmark_height_);
   for (int i = 0; i < benchmark_width_ * benchmark_height_ * 2; ++i) {
     EXPECT_EQ(dst_rgb565[i], dst_rgb565dither[i]);
   }
 
   free_aligned_buffer_64(src_argb);
   free_aligned_buffer_64(dst_rgb565);
   free_aligned_buffer_64(dst_rgb565dither);
 }
 
 // Ordered 4x4 dither for 888 to 565.  Values from 0 to 7.
 static const uint8 kDither565_4x4[16] = {
   0, 4, 1, 5,
   6, 2, 7, 3,
   1, 5, 0, 4,
   7, 3, 6, 2,
 };
 
-TEST_F(libyuvTest, TestDither) {
+TEST_F(LibYUVConvertTest, TestDither) {
   align_buffer_64(src_argb, benchmark_width_ * benchmark_height_ * 4);
   align_buffer_64(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
   align_buffer_64(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
   align_buffer_64(dst_argb, benchmark_width_ * benchmark_height_ * 4);
   align_buffer_64(dst_argbdither, benchmark_width_ * benchmark_height_ * 4);
   MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4);
   MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2);
   MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2);
   MemRandomize(dst_argb, benchmark_width_ * benchmark_height_ * 4);
   MemRandomize(dst_argbdither, benchmark_width_ * benchmark_height_ * 4);
@@ skipping 15 matching lines @@
   }
   free_aligned_buffer_64(src_argb);
   free_aligned_buffer_64(dst_rgb565);
   free_aligned_buffer_64(dst_rgb565dither);
   free_aligned_buffer_64(dst_argb);
   free_aligned_buffer_64(dst_argbdither);
 }
 
 #define TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \
                        YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C)         \
-TEST_F(libyuvTest, FMT_PLANAR##To##FMT_B##Dither##N) {                         \
+TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##Dither##N) {                  \
   const int kWidth = ((W1280) > 0) ? (W1280) : 1;                              \
   const int kHeight = ALIGNINT(benchmark_height_, YALIGN);                     \
   const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN);                        \
   const int kSizeUV =                                                          \
     SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y);              \
   align_buffer_64(src_y, kWidth * kHeight + OFF);                              \
   align_buffer_64(src_u, kSizeUV + OFF);                                       \
   align_buffer_64(src_v, kSizeUV + OFF);                                       \
   align_buffer_64(dst_argb_c, kStrideB * kHeight + OFF);                       \
   align_buffer_64(dst_argb_opt, kStrideB * kHeight + OFF);                     \
@@ skipping 57 matching lines @@
     TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,     \
         YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, BPP_C)        \
     TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,     \
         YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C)           \
     TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN,     \
         YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C)
 
 TESTPLANARTOBD(I420, 2, 2, RGB565, 2, 2, 1, 9, ARGB, 4)
 
 #define TESTPTOB(NAME, UYVYTOI420, UYVYTONV12)                                 \
-TEST_F(libyuvTest, NAME) {                                                     \
+TEST_F(LibYUVConvertTest, NAME) {                                              \
   const int kWidth = benchmark_width_;                                         \
   const int kHeight = benchmark_height_;                                       \
                                                                                \
   align_buffer_64(orig_uyvy,                                                   \
                   4 * SUBSAMPLE(kWidth, 2) * kHeight);                         \
   align_buffer_64(orig_y, kWidth * kHeight);                                   \
   align_buffer_64(orig_u,                                                      \
                   SUBSAMPLE(kWidth, 2) *                                       \
                   SUBSAMPLE(kHeight, 2));                                      \
   align_buffer_64(orig_v,                                                      \
@@ skipping 50 matching lines @@
   free_aligned_buffer_64(dst_y_orig);                                          \
   free_aligned_buffer_64(dst_uv_orig);                                         \
   free_aligned_buffer_64(dst_y);                                               \
   free_aligned_buffer_64(dst_uv);                                              \
 }
 
 TESTPTOB(TestYUY2ToNV12, YUY2ToI420, YUY2ToNV12)
 TESTPTOB(TestUYVYToNV12, UYVYToI420, UYVYToNV12)
 
 }  // namespace libyuv