skia2/tests/skia_test.cpp
halcanary 87f3ba4847 Simplify skiatest framework.
skiatest::Test class is now a simple struct.  Some
functionalty, such as counting errors or timing is now
handled elsewhere.

skiatest:Reporter is now a simpler abstract class.  The two
implementations handle test errors.

DM and pathops_unittest updated.

Review URL: https://codereview.chromium.org/830513004
2015-01-20 09:30:20 -08:00

238 lines
6.4 KiB
C++

/*
* 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 "CrashHandler.h"
#include "OverwriteLine.h"
#include "Resources.h"
#include "SkCommonFlags.h"
#include "SkGraphics.h"
#include "SkInstCnt.h"
#include "SkOSFile.h"
#include "SkRunnable.h"
#include "SkTArray.h"
#include "SkTaskGroup.h"
#include "SkTemplates.h"
#include "SkThread.h"
#include "SkTime.h"
#include "Test.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrContextFactory.h"
#endif
using namespace skiatest;
DEFINE_bool2(extendedTest, x, false, "run extended tests for pathOps.");
// need to explicitly declare this, or we get some weird infinite loop llist
template TestRegistry* TestRegistry::gHead;
// The threads report back to this object when they are done.
class Status {
public:
explicit Status(int total)
: fDone(0), fTestCount(0), fFailCount(0), fTotal(total) {}
// Threadsafe.
void endTest(const char* testName,
bool success,
SkMSec elapsed,
int testCount) {
const int done = 1 + sk_atomic_inc(&fDone);
for (int i = 0; i < testCount; ++i) {
sk_atomic_inc(&fTestCount);
}
if (!success) {
SkDebugf("\n---- %s FAILED", testName);
}
SkString prefix(kSkOverwriteLine);
SkString time;
if (FLAGS_verbose) {
prefix.printf("\n");
time.printf("%5dms ", elapsed);
}
SkDebugf("%s[%3d/%3d] %s%s", prefix.c_str(), done, fTotal, time.c_str(),
testName);
}
void reportFailure() { sk_atomic_inc(&fFailCount); }
int32_t testCount() { return fTestCount; }
int32_t failCount() { return fFailCount; }
private:
int32_t fDone; // atomic
int32_t fTestCount; // atomic
int32_t fFailCount; // atomic
const int fTotal;
};
// Deletes self when run.
class SkTestRunnable : public SkRunnable {
public:
SkTestRunnable(const Test& test,
Status* status,
GrContextFactory* grContextFactory = NULL)
: fTest(test), fStatus(status), fGrContextFactory(grContextFactory) {}
virtual void run() {
struct TestReporter : public skiatest::Reporter {
public:
TestReporter() : fError(false), fTestCount(0) {}
void bumpTestCount() SK_OVERRIDE { ++fTestCount; }
bool allowExtendedTest() const SK_OVERRIDE {
return FLAGS_extendedTest;
}
bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
void reportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
SkDebugf("\nFAILED: %s", failure.toString().c_str());
fError = true;
}
bool fError;
int fTestCount;
} reporter;
const SkMSec start = SkTime::GetMSecs();
fTest.proc(&reporter, fGrContextFactory);
SkMSec elapsed = SkTime::GetMSecs() - start;
if (reporter.fError) {
fStatus->reportFailure();
}
fStatus->endTest(fTest.name, !reporter.fError, elapsed,
reporter.fTestCount);
SkDELETE(this);
}
private:
Test fTest;
Status* fStatus;
GrContextFactory* fGrContextFactory;
};
static bool should_run(const char* testName, bool isGPUTest) {
if (SkCommandLineFlags::ShouldSkip(FLAGS_match, testName)) {
return false;
}
if (!FLAGS_cpu && !isGPUTest) {
return false;
}
if (!FLAGS_gpu && isGPUTest) {
return false;
}
return true;
}
int test_main();
int test_main() {
SetupCrashHandler();
#if SK_ENABLE_INST_COUNT
if (FLAGS_leaks) {
gPrintInstCount = true;
}
#endif
SkAutoGraphics ag;
{
SkString header("Skia UnitTests:");
if (!FLAGS_match.isEmpty()) {
header.appendf(" --match");
for (int index = 0; index < FLAGS_match.count(); ++index) {
header.appendf(" %s", FLAGS_match[index]);
}
}
SkString tmpDir = skiatest::GetTmpDir();
if (!tmpDir.isEmpty()) {
header.appendf(" --tmpDir %s", tmpDir.c_str());
}
SkString resourcePath = GetResourcePath();
if (!resourcePath.isEmpty()) {
header.appendf(" --resourcePath %s", resourcePath.c_str());
}
#ifdef SK_DEBUG
header.append(" SK_DEBUG");
#else
header.append(" SK_RELEASE");
#endif
header.appendf(" skia_arch_width=%d", (int)sizeof(void*) * 8);
if (FLAGS_veryVerbose) {
header.appendf("\n");
}
SkDebugf(header.c_str());
}
// Count tests first.
int total = 0;
int toRun = 0;
for (const TestRegistry* iter = TestRegistry::Head(); iter;
iter = iter->next()) {
const Test& test = iter->factory();
if (should_run(test.name, test.needsGpu)) {
toRun++;
}
total++;
}
// Now run them.
int skipCount = 0;
SkTaskGroup::Enabler enabled(FLAGS_threads);
SkTaskGroup cpuTests;
SkTArray<const Test*> gpuTests;
Status status(toRun);
for (const TestRegistry* iter = TestRegistry::Head(); iter;
iter = iter->next()) {
const Test& test = iter->factory();
if (!should_run(test.name, test.needsGpu)) {
++skipCount;
} else if (test.needsGpu) {
gpuTests.push_back(&test);
} else {
cpuTests.add(SkNEW_ARGS(SkTestRunnable, (test, &status)));
}
}
GrContextFactory* grContextFactoryPtr = NULL;
#if SK_SUPPORT_GPU
// Give GPU tests a context factory if that makes sense on this machine.
GrContextFactory grContextFactory;
grContextFactoryPtr = &grContextFactory;
#endif
// Run GPU tests on this thread.
for (int i = 0; i < gpuTests.count(); i++) {
SkNEW_ARGS(SkTestRunnable, (*gpuTests[i], &status, grContextFactoryPtr))
->run();
}
// Block until threaded tests finish.
cpuTests.wait();
if (FLAGS_verbose) {
SkDebugf(
"\nFinished %d tests, %d failures, %d skipped. "
"(%d internal tests)",
toRun, status.failCount(), skipCount, status.testCount());
}
SkDebugf("\n");
return (status.failCount() == 0) ? 0 : 1;
}
#if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
int main(int argc, char** argv) {
SkCommandLineFlags::Parse(argc, argv);
return test_main();
}
#endif