Add --threads to tests binary, to run non-GPU tests on multiple cores.

tests/Test.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 
-#include "SkTLazy.h"
+#include "SkString.h"
+#include "SkTArray.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "gl/SkNativeGLContext.h"
 #else
 class GrContext;
 #endif
 
 SK_DEFINE_INST_COUNT(skiatest::Reporter)
 
 using namespace skiatest;
 
-Reporter::Reporter()
-    : fTestCount(0) {
-    this->resetReporting();
-}
-
-void Reporter::resetReporting() {
-    fCurrTest = NULL;
-    fTestCount = 0;
-    sk_bzero(fResultCount, sizeof(fResultCount));
+Reporter::Reporter() : fTestCount(0) {
 }
 
 void Reporter::startTest(Test* test) {
-    SkASSERT(NULL == fCurrTest);
-    fCurrTest = test;
+    this->bumpTestCount();
     this->onStart(test);
-    fTestCount += 1;
-    fCurrTestSuccess = true;    // we're optimistic
 }
 
 void Reporter::report(const char desc[], Result result) {
-    if (NULL == desc) {
-        desc = "<no description>";
-    }
-    this->onReport(desc, result);
-    fResultCount[result] += 1;
-    if (kFailed == result) {
-        fCurrTestSuccess = false;
-    }
+    this->onReport(desc ? desc : "<no description>", result);
 }
 
 void Reporter::endTest(Test* test) {
-    SkASSERT(test == fCurrTest);
     this->onEnd(test);
-    fCurrTest = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-Test::Test() : fReporter(NULL) {}
+Test::Test() : fReporter(NULL), fPassed(true) {}
 
 Test::~Test() {
     SkSafeUnref(fReporter);
 }
 
 void Test::setReporter(Reporter* r) {
     SkRefCnt_SafeAssign(fReporter, r);
 }
 
 const char* Test::getName() {
     if (fName.size() == 0) {
         this->onGetName(&fName);
     }
     return fName.c_str();
 }
 
-bool Test::run() {
+namespace {
+    class LocalReporter : public Reporter {
+    public:
+        LocalReporter() {}
+
+        int failure_size() const { return fFailures.count(); }
+        const char* failure(int i) const { return fFailures[i].c_str(); }
+
+    protected:
+        void onReport(const char desc[], Result result) SK_OVERRIDE {
+            if (kFailed == result) {
+                fFailures.push_back().set(desc);
+            }
+        }
+
+    private:
+        SkTArray<SkString> fFailures;
+    };
+}  // namespace
+
+void Test::run() {
+    // Run the test.
+    LocalReporter local;
+    this->onRun(&local);

[scroggo, 2013/04/17 17:34:52]

Does anyone depend on the ordering between onRun and startTest?

[mtklein, 2013/04/17 18:13:59]

Nope.  Actually, this is a good point.  Moving the fReporter->startTest(this)
call earlier will make any extra SkDebugf calls the test may make make more
sense.

+    fPassed = local.failure_size() == 0;
+
+    // Now all at once pretend the test is running for the benefit of fReporter.
     fReporter->startTest(this);
-    this->onRun(fReporter);
+    for (int i = 0; i < local.failure_size(); i++) {
+      fReporter->report(local.failure(i), Reporter::kFailed);
+    }
     fReporter->endTest(this);
-    return fReporter->getCurrSuccess();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 GrContextFactory gGrContextFactory;
 #endif
 
 GrContextFactory* GpuTest::GetGrContextFactory() {
 #if SK_SUPPORT_GPU
     return &gGrContextFactory;
 #else
     return NULL;
 #endif
 }
 
 void GpuTest::DestroyContexts() {
 #if SK_SUPPORT_GPU
     gGrContextFactory.destroyContexts();
 #endif
 }