Get rid of DEFINE_TESTCLASS_SHORT() macro.

tests/SkpSkGrTest.cpp

 #if !SK_SUPPORT_GPU
 #error "GPU support required"
 #endif
 
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #include "GrRenderTarget.h"
 #include "SkGpuDevice.h"
 #include "gl/GrGLDefines.h"
 
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "SkDevice.h"
 #include "SkCanvas.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkStream.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkRTConf.h"
 #include "SkRunnable.h"
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
 #include "SkThreadPool.h"
 #include "SkTime.h"
 #include "Test.h"
+#include "TestClassDef.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #define PATH_SLASH "\\"
     #define IN_DIR "D:\\9-30-13\\"
     #define OUT_DIR "D:\\skpSkGr\\11\\"
     #define LINE_FEED "\r\n"
 #else
     #define PATH_SLASH "/"
     #define IN_DIR "/usr/local/google/home/caryclark" PATH_SLASH "9-30-13-skp"
     #define OUT_DIR "/media/01CD75512A7F9EE0/4" PATH_SLASH
-    #define LINE_FEED \n"
+    #define LINE_FEED "\n"
 #endif
 
 #define PATH_STR_SIZE 512
 
 static const struct {
     int directory;
     const char* filename;
 } skipOverSkGr[] = {
     {1, "http___accuweather_com_.skp"},  // Couldn't convert bitmap to texture.http___absoku072_com_
 };
 
-static const size_t skipOverSkGrCount = 0; // SK_ARRAY_COUNT(skipOverSkGr);
+// static const size_t skipOverSkGrCount = 0; // SK_ARRAY_COUNT(skipOverSkGr);

[mtklein, 2014/01/02 17:51:07]

Let's revert everything related to this.  It looks like this is a debugging knob
that we're just making less convenient to use by commenting it out.

[tfarina, 2014/01/02 21:09:08]

Done.

 
 /////////////////////////////////////////
 
 class SkpSkGrThreadedRunnable;
 
 enum TestStep {
     kCompareBits,
     kEncodeFiles,
 };
 
@@ skipping 445 matching lines @@
                 return false;
             }
             if (c == ' ') {
                 result->fFilename[i++] = '\0';
                 break;
             }
             result->fFilename[i++] = c;
             SkASSERT(i < kMaxLength);
         } while (true);
         do {
-            SkAssertResult(reader.read(&c, 1) != 0);
+            //SkAssertResult(reader.read(&c, 1) != 0);

[mtklein, 2014/01/02 17:51:07]

This is not a no-op.  SkAssertResult always evaluates its argument, so you're
disabling the call to read here.  Please undo.

[tfarina, 2014/01/02 21:09:08]

Done.

[tfarina, 2014/01/02 21:09:08]

Done.

             if (c == ' ') {
                 break;
             }
             SkASSERT(c >= '0' && c <= '9');
             result->fPixelError = result->fPixelError * 10 + (c - '0');
         } while (true);
         bool minus = false;
         do {
             if (reader.read(&c, 1) == 0) {
                 break;
@@ skipping 37 matching lines @@
 };
 
 static bool initTest() {
 #if !defined SK_BUILD_FOR_WIN && !defined SK_BUILD_FOR_MAC
     SK_CONF_SET("images.jpeg.suppressDecoderWarnings", true);
     SK_CONF_SET("images.png.suppressDecoderWarnings", true);
 #endif
     return make_out_dirs();
 }
 
-static void SkpSkGrTest(skiatest::Reporter* reporter) {
+DEF_TEST(SkpSkGr, reporter) {
     SkTArray<TestResult, true> errors;
     if (!initTest()) {
         return;
     }
     SkpSkGrThreadState state;
     state.init(0);
     int smallCount = 0;
     for (int dirNo = 1; dirNo <= 100; ++dirNo) {
         SkString pictDir = make_in_dir_name(dirNo);
         SkASSERT(pictDir.size());
         if (reporter->verbose()) {
             SkDebugf("dirNo=%d\n", dirNo);
         }
         SkOSFile::Iter iter(pictDir.c_str(), "skp");
         SkString filename;
         int testCount = 0;
         PreParser preParser(dirNo);
         SkFILEWStream statusStream(makeStatusString(dirNo).c_str());
         while (iter.next(&filename)) {
-            for (size_t index = 0; index < skipOverSkGrCount; ++index) {
-                if (skipOverSkGr[index].directory == dirNo
-                        && strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
-                    goto skipOver;
-                }
-            }
+//             for (size_t index = 0; index < skipOverSkGrCount; ++index) {
+//                 if (skipOverSkGr[index].directory == dirNo
+//                         && strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
+//                     goto skipOver;
+//                 }
+//             }
             if (preParser.match(filename, &statusStream, &state.fResult)) {
                 addError(&state);
                 ++testCount;
                 goto checkEarlyExit;
             }
             if (state.fSmallestError > 5000000) {
                 goto breakOut;
             }
             {
                 TestResult& result = state.fResult;
@@ skipping 10 matching lines @@
                 } else if (++smallCount > 10000) {
                     goto breakOut;
                 }
             }
             ++testCount;
             if (reporter->verbose()) {
                 if (testCount % 100 == 0) {
                     SkDebugf("#%d\n", testCount);
                 }
             }
-    skipOver:
-            reporter->bumpTestCount();
+//     skipOver:
+//             reporter->bumpTestCount();
     checkEarlyExit:
             if (1 && testCount == 20) {
                 break;
             }
         }
     }
 breakOut:
     if (reporter->verbose()) {
         for (int index = 0; index < state.fFoundCount; ++index) {
             SkDebugf("%d %s %d\n", state.fDirsFound[index], state.fFilesFound[index],
@@ skipping 19 matching lines @@
         }
     }
 }
 
 static void testSkGrMain(SkpSkGrThreadState* data) {
     data->fResult.testOne();
     bumpCount(data->fReporter, false);
     data->fReporter->bumpTestCount();
 }
 
-static void SkpSkGrThreadedTest(skiatest::Reporter* reporter) {
+DEF_TEST(SkpSkGrThreaded, reporter) {
     if (!initTest()) {
         return;
     }
     int threadCount = reporter->allowThreaded() ? 3 : 1;
     SkpSkGrThreadedTestRunner testRunner(reporter, threadCount);
     for (int dirIndex = 1; dirIndex <= 100; ++dirIndex) {
         SkString pictDir = make_in_dir_name(dirIndex);
         if (pictDir.size() == 0) {
             continue;
         }
         SkOSFile::Iter iter(pictDir.c_str(), "skp");
         SkString filename;
         while (iter.next(&filename)) {
             SkString pngName = make_png_name(filename.c_str());
             SkString oldPng = make_filepath(dirIndex, outSkDir, pngName.c_str());
             SkString newPng = make_filepath(dirIndex, outGrDir, pngName.c_str());
             if (sk_exists(oldPng.c_str()) && sk_exists(newPng.c_str())) {
                 bumpCount(reporter, true);
                 continue;
             }
-            for (size_t index = 0; index < skipOverSkGrCount; ++index) {
-                if (skipOverSkGr[index].directory == dirIndex
-                        && strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
-                    bumpCount(reporter, true);
-                    goto skipOver;
-                }
-            }
+//             for (size_t index = 0; index < skipoverskgrcount; ++index) {
+//                 if (skipoverskgr[index].directory == dirindex
+//                         && strcmp(filename.c_str(), skipoverskgr[index].filename) == 0) {
+//                     bumpcount(reporter, true);
+//                     goto skipover;
+//                 }
+//             }
             *testRunner.fRunnables.append() = SkNEW_ARGS(SkpSkGrThreadedRunnable,
                     (&testSkGrMain, dirIndex, filename.c_str(), &testRunner));
-    skipOver:
-            ;
+//     skipOver:
+//             ;
         }
     }
     testRunner.render();
     SkpSkGrThreadState& max = testRunner.fRunnables[0]->fState;
     for (int dirIndex = 2; dirIndex <= 100; ++dirIndex) {
         SkpSkGrThreadState& state = testRunner.fRunnables[dirIndex - 1]->fState;
         for (int index = 0; index < state.fFoundCount; ++index) {
             int maxIdx = max.fFoundCount;
             if (maxIdx < kMaxFiles) {
                 max.fError[maxIdx] = state.fError[index];
@@ skipping 15 matching lines @@
     TestResult encoder;
     encoder.fTestStep = kEncodeFiles;
     for (int index = 0; index < max.fFoundCount; ++index) {
         encoder.fDirNo = max.fDirsFound[index];
         strcpy(encoder.fFilename, max.fFilesFound[index]);
         encoder.testOne();
         SkDebugf("+");
     }
 }
 
-static void SkpSkGrOneOffTest(skiatest::Reporter* reporter) {
+DEF_TEST(SkpSkGrOneOff, reporter) {
     if (!initTest()) {
         return;
     }
     int testIndex = 166;
     int dirIndex = skipOverSkGr[testIndex - 166].directory;
     SkString pictDir = make_in_dir_name(dirIndex);
     if (pictDir.size() == 0) {
         return;
     }
     SkString filename(skipOverSkGr[testIndex - 166].filename);
     TestResult::Test(dirIndex, filename.c_str(), kCompareBits, reporter->verbose());
     TestResult::Test(dirIndex, filename.c_str(), kEncodeFiles, reporter->verbose());
 }
-
-#include "TestClassDef.h"
-DEFINE_TESTCLASS_SHORT(SkpSkGrTest)
-
-DEFINE_TESTCLASS_SHORT(SkpSkGrOneOffTest)
-
-DEFINE_TESTCLASS_SHORT(SkpSkGrThreadedTest)