disable scale color tests

unit_test/scale_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(LibYUVScaleTest, TESTNAME) {                                            \
+TEST_F(LibYUVScaleTest, DISABLED_ ## 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 193 matching lines @@
   *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(LibYUVScaleTest, ScaleTestYUV) {
+TEST_F(LibYUVScaleTest, DISABLED_ScaleTestYUV) {
   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(LibYUVScaleTest, ScaleTestGreyYUV) {
+TEST_F(LibYUVScaleTest, DISABLED_ScaleTestGreyYUV) {
   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(LibYUVScaleTest, ScaleTestFullYUV) {
+TEST_F(LibYUVScaleTest, DISABLED_ScaleTestFullYUV) {
   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];
       }
     }
   }
   ScalePrintHistogram(rh, gh, bh);
 }
 
-TEST_F(LibYUVScaleTest, ScaleTestFullYUVJ) {
+TEST_F(LibYUVScaleTest, DISABLED_ScaleTestFullYUVJ) {
   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];
       }
     }
   }
   ScalePrintHistogram(rh, gh, bh);
 }
 
-TEST_F(LibYUVScaleTest, ScaleTestGreyYUVJ) {
+TEST_F(LibYUVScaleTest, DISABLED_ScaleTestGreyYUVJ) {
   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