create color test category of unittests to narrow down arm bug

unit_test/color_test.cc

 /*
  *  Copyright 2015 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 19 matching lines @@
 #define ERROR_J420 4
 #else
 #define ERROR_R 1
 #define ERROR_G 1
 #define ERROR_B 3
 #define ERROR_FULL 5
 #define ERROR_J420 3
 #endif
 
 #define TESTCS(TESTNAME, YUVTOARGB, ARGBTOYUV, HS1, HS, HN, DIFF)              \
-TEST_F(LibYUVConvertTest, TESTNAME) {                                          \
+TEST_F(LibYUVColorTest, TESTNAME) {                                            \
   const int kPixels = benchmark_width_ * benchmark_height_;                    \
   const int kHalfPixels = ((benchmark_width_ + 1) / 2) *                       \
       ((benchmark_height_ + HS1) / HS);                                        \
   align_buffer_64(orig_y, kPixels);                                            \
   align_buffer_64(orig_u, kHalfPixels);                                        \
   align_buffer_64(orig_v, kHalfPixels);                                        \
   align_buffer_64(orig_pixels, kPixels * 4);                                   \
   align_buffer_64(temp_y, kPixels);                                            \
   align_buffer_64(temp_u, kHalfPixels);                                        \
   align_buffer_64(temp_v, kHalfPixels);                                        \
@@ skipping 254 matching lines @@
 #elif defined(CLAMPMETHOD_MASK)
 static int RoundToByte(float f) {
   int i = ROUND(f);
   i =  ((-(i) >> 31) & (i));  // clamp to 0.
   return (((255 - (i)) >> 31) | (i)) & 255;  // clamp to 255.
 }
 #endif
 
 #define RANDOM256(s) ((s & 1) ? ((s >> 1) ^ 0xb8) : (s >> 1))
 
-TEST_F(LibYUVConvertTest, TestRoundToByte) {
+TEST_F(LibYUVColorTest, TestRoundToByte) {
   int allb = 0;
   int count = benchmark_width_ * benchmark_height_;
   for (int i = 0; i < benchmark_iterations_; ++i) {
     float f = (fastrand() & 255) * 3.14f - 260.f;
     for (int j = 0; j < count; ++j) {
       int b = RoundToByte(f);
       f += 0.91f;
       allb |= b;
     }
   }
   EXPECT_GE(allb, 0);
   EXPECT_LE(allb, 255);
 }
 
 static void YUVToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
   *r = RoundToByte((y - 16) * 1.164 - (v - 128) * -1.596);
   *g = RoundToByte((y - 16) * 1.164 - (u - 128) * 0.391 - (v - 128) * 0.813);
   *b = RoundToByte((y - 16) * 1.164 - (u - 128) * -2.018);
 }
 
 static void YUVJToRGBReference(int y, int u, int v, int* r, int* g, int* b) {
   *r = RoundToByte(y - (v - 128) * -1.40200);
   *g = RoundToByte(y - (u - 128) * 0.34414 - (v - 128) * 0.71414);
   *b = RoundToByte(y - (u - 128) * -1.77200);
 }
 
-TEST_F(LibYUVConvertTest, TestYUV) {
+TEST_F(LibYUVColorTest, TestYUV) {
   int r0, g0, b0, r1, g1, b1;
 
   // cyan (less red)
   YUVToRGBReference(240, 255, 0, &r0, &g0, &b0);
   EXPECT_EQ(56, r0);
   EXPECT_EQ(255, g0);
   EXPECT_EQ(255, b0);
 
   YUVToRGB(240, 255, 0, &r1, &g1, &b1);
   EXPECT_EQ(57, r1);
@@ skipping 25 matching lines @@
     EXPECT_NEAR(b0, b1, ERROR_B);
 
     YUVToRGBReference(i, 0, 255, &r0, &g0, &b0);
     YUVToRGB(i, 0, 255, &r1, &g1, &b1);
     EXPECT_NEAR(r0, r1, ERROR_R);
     EXPECT_NEAR(g0, g1, ERROR_G);
     EXPECT_NEAR(b0, b1, ERROR_B);
   }
 }
 
-TEST_F(LibYUVConvertTest, TestGreyYUV) {
+TEST_F(LibYUVColorTest, TestGreyYUV) {
   int r0, g0, b0, r1, g1, b1, r2, g2, b2;
 
   // black
   YUVToRGBReference(16, 128, 128, &r0, &g0, &b0);
   EXPECT_EQ(0, r0);
   EXPECT_EQ(0, g0);
   EXPECT_EQ(0, b0);
 
   YUVToRGB(16, 128, 128, &r1, &g1, &b1);
   EXPECT_EQ(0, r1);
@@ skipping 58 matching lines @@
   }
   printf("\nblue");
   for (i = 0; i < 256; ++i) {
     if (rh[i] || gh[i] || bh[i]) {
       printf("\t%8d", bh[i]);
     }
   }
   printf("\n");
 }
 
-TEST_F(LibYUVConvertTest, TestFullYUV) {
+TEST_F(LibYUVColorTest, TestFullYUV) {
   int rh[256] = { 0, }, gh[256] = { 0, }, bh[256] = { 0, };
   for (int u = 0; u < 256; ++u) {
     for (int v = 0; v < 256; ++v) {
       for (int y2 = 0; y2 < 256; ++y2) {
         int r0, g0, b0, r1, g1, b1;
         int y = RANDOM256(y2);
         YUVToRGBReference(y, u, v, &r0, &g0, &b0);
         YUVToRGB(y, u, v, &r1, &g1, &b1);
         EXPECT_NEAR(r0, r1, ERROR_R);
         EXPECT_NEAR(g0, g1, ERROR_G);
         EXPECT_NEAR(b0, b1, ERROR_B);
         ++rh[r1 - r0 + 128];
         ++gh[g1 - g0 + 128];
         ++bh[b1 - b0 + 128];
       }
     }
   }
   PrintHistogram(rh, gh, bh);
 }
 
-TEST_F(LibYUVConvertTest, TestFullYUVJ) {
+TEST_F(LibYUVColorTest, TestFullYUVJ) {
   int rh[256] = { 0, }, gh[256] = { 0, }, bh[256] = { 0, };
   for (int u = 0; u < 256; ++u) {
     for (int v = 0; v < 256; ++v) {
       for (int y2 = 0; y2 < 256; ++y2) {
         int r0, g0, b0, r1, g1, b1;
         int y = RANDOM256(y2);
         YUVJToRGBReference(y, u, v, &r0, &g0, &b0);
         YUVJToRGB(y, u, v, &r1, &g1, &b1);
         EXPECT_NEAR(r0, r1, 1);
         EXPECT_NEAR(g0, g1, 1);
         EXPECT_NEAR(b0, b1, 1);
         ++rh[r1 - r0 + 128];
         ++gh[g1 - g0 + 128];
         ++bh[b1 - b0 + 128];
       }
     }
   }
   PrintHistogram(rh, gh, bh);
 }
 
-TEST_F(LibYUVConvertTest, TestGreyYUVJ) {
+TEST_F(LibYUVColorTest, TestGreyYUVJ) {
   int r0, g0, b0, r1, g1, b1, r2, g2, b2;
 
   // black
   YUVJToRGBReference(0, 128, 128, &r0, &g0, &b0);
   EXPECT_EQ(0, r0);
   EXPECT_EQ(0, g0);
   EXPECT_EQ(0, b0);
 
   YUVJToRGB(0, 128, 128, &r1, &g1, &b1);
   EXPECT_EQ(0, r1);
@@ skipping 29 matching lines @@
     EXPECT_EQ(r0, r1);
     EXPECT_EQ(g0, g1);
     EXPECT_EQ(b0, b1);
     EXPECT_EQ(r0, r2);
     EXPECT_EQ(g0, g2);
     EXPECT_EQ(b0, b2);
   }
 }
 
 }  // namespace libyuv