1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "CrashHandler.h"
9 #include "OverwriteLine.h"
10 #include "Resources.h"
11 #include "SkAtomics.h"
12 #include "SkCommonFlags.h"
13 #include "SkGraphics.h"
14 #include "SkOSFile.h"
15 #include "SkPathOpsDebug.h"
16 #include "SkTArray.h"
17 #include "SkTaskGroup.h"
18 #include "SkTemplates.h"
19 #include "SkTime.h"
20 #include "Test.h"
21
22 #if SK_SUPPORT_GPU
23 #include "GrContext.h"
24 #include "GrContextFactory.h"
25 #endif
26
27 using namespace skiatest;
28 using namespace sk_gpu_test;
29
30 DEFINE_bool2(dumpOp, d, false, "dump the pathOps to a file to recover mid-crash.");
31 DEFINE_bool2(extendedTest, x, false, "run extended tests for pathOps.");
32 DEFINE_bool2(runFail, f, false, "check for success on tests known to fail.");
33 DEFINE_bool2(verifyOp, y, false, "compare the pathOps result against a region.");
34
35 #if DEBUG_COIN
36 DEFINE_bool2(coinTest, c, false, "detect unused coincidence algorithms.");
37 #endif
38
39 // need to explicitly declare this, or we get some weird infinite loop llist
40 template TestRegistry* TestRegistry::gHead;
41 void (*gVerboseFinalize)() = nullptr;
42
43 // The threads report back to this object when they are done.
44 class Status {
45 public:
Status(int total)46 explicit Status(int total)
47 : fDone(0), fTestCount(0), fFailCount(0), fTotal(total) {}
48 // Threadsafe.
endTest(const char * testName,bool success,SkMSec elapsed,int testCount)49 void endTest(const char* testName,
50 bool success,
51 SkMSec elapsed,
52 int testCount) {
53 const int done = 1 + sk_atomic_inc(&fDone);
54 for (int i = 0; i < testCount; ++i) {
55 sk_atomic_inc(&fTestCount);
56 }
57 if (!success) {
58 SkDebugf("\n---- %s FAILED", testName);
59 }
60
61 SkString prefix(kSkOverwriteLine);
62 SkString time;
63 if (FLAGS_verbose) {
64 prefix.printf("\n");
65 time.printf("%5dms ", elapsed);
66 }
67 SkDebugf("%s[%3d/%3d] %s%s", prefix.c_str(), done, fTotal, time.c_str(),
68 testName);
69 }
70
reportFailure()71 void reportFailure() { sk_atomic_inc(&fFailCount); }
72
testCount()73 int32_t testCount() { return fTestCount; }
failCount()74 int32_t failCount() { return fFailCount; }
75
76 private:
77 int32_t fDone; // atomic
78 int32_t fTestCount; // atomic
79 int32_t fFailCount; // atomic
80 const int fTotal;
81 };
82
83 class SkTestRunnable {
84 public:
SkTestRunnable(const Test & test,Status * status,GrContextFactory * grContextFactory=nullptr)85 SkTestRunnable(const Test& test,
86 Status* status,
87 GrContextFactory* grContextFactory = nullptr)
88 : fTest(test), fStatus(status), fGrContextFactory(grContextFactory) {}
89
operator ()()90 void operator()() {
91 struct TestReporter : public skiatest::Reporter {
92 public:
93 TestReporter() : fStats(nullptr), fError(false), fTestCount(0) {}
94 void bumpTestCount() override { ++fTestCount; }
95 bool allowExtendedTest() const override {
96 return FLAGS_extendedTest;
97 }
98 bool verbose() const override { return FLAGS_veryVerbose; }
99 void reportFailed(const skiatest::Failure& failure) override {
100 SkDebugf("\nFAILED: %s", failure.toString().c_str());
101 fError = true;
102 }
103 void* stats() const override { return fStats; }
104 void* fStats;
105 bool fError;
106 int fTestCount;
107 } reporter;
108
109 const Timer timer;
110 fTest.proc(&reporter, fGrContextFactory);
111 SkMSec elapsed = timer.elapsedMsInt();
112 if (reporter.fError) {
113 fStatus->reportFailure();
114 }
115 fStatus->endTest(fTest.name, !reporter.fError, elapsed,
116 reporter.fTestCount);
117 }
118
119 private:
120 Test fTest;
121 Status* fStatus;
122 GrContextFactory* fGrContextFactory;
123 };
124
should_run(const char * testName,bool isGPUTest)125 static bool should_run(const char* testName, bool isGPUTest) {
126 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, testName)) {
127 return false;
128 }
129 if (!FLAGS_cpu && !isGPUTest) {
130 return false;
131 }
132 if (!FLAGS_gpu && isGPUTest) {
133 return false;
134 }
135 return true;
136 }
137
main(int argc,char ** argv)138 int main(int argc, char** argv) {
139 SkCommandLineFlags::Parse(argc, argv);
140 #if DEBUG_DUMP_VERIFY
141 SkPathOpsDebug::gDumpOp = FLAGS_dumpOp;
142 SkPathOpsDebug::gVerifyOp = FLAGS_verifyOp;
143 #endif
144 SkPathOpsDebug::gRunFail = FLAGS_runFail;
145 SkPathOpsDebug::gVeryVerbose = FLAGS_veryVerbose;
146 SetupCrashHandler();
147
148 SkAutoGraphics ag;
149
150 {
151 SkString header("Skia UnitTests:");
152 if (!FLAGS_match.isEmpty()) {
153 header.appendf(" --match");
154 for (int index = 0; index < FLAGS_match.count(); ++index) {
155 header.appendf(" %s", FLAGS_match[index]);
156 }
157 }
158 SkString tmpDir = skiatest::GetTmpDir();
159 if (!tmpDir.isEmpty()) {
160 header.appendf(" --tmpDir %s", tmpDir.c_str());
161 }
162 SkString resourcePath = GetResourcePath();
163 if (!resourcePath.isEmpty()) {
164 header.appendf(" --resourcePath %s", resourcePath.c_str());
165 }
166 #if DEBUG_COIN
167 if (FLAGS_coinTest) {
168 header.appendf(" -c");
169 }
170 #endif
171 if (FLAGS_dumpOp) {
172 header.appendf(" -d");
173 }
174 #ifdef SK_DEBUG
175 if (FLAGS_runFail) {
176 header.appendf(" -f");
177 }
178 #endif
179 if (FLAGS_verbose) {
180 header.appendf(" -v");
181 }
182 if (FLAGS_veryVerbose) {
183 header.appendf(" -V");
184 }
185 if (FLAGS_extendedTest) {
186 header.appendf(" -x");
187 }
188 if (FLAGS_verifyOp) {
189 header.appendf(" -y");
190 }
191 #ifdef SK_DEBUG
192 header.append(" SK_DEBUG");
193 #else
194 header.append(" SK_RELEASE");
195 #endif
196 if (FLAGS_veryVerbose) {
197 header.appendf("\n");
198 }
199 SkDebugf("%s", header.c_str());
200 }
201
202
203 // Count tests first.
204 int total = 0;
205 int toRun = 0;
206
207 for (const TestRegistry* iter = TestRegistry::Head(); iter;
208 iter = iter->next()) {
209 const Test& test = iter->factory();
210 if (should_run(test.name, test.needsGpu)) {
211 toRun++;
212 }
213 total++;
214 }
215
216 // Now run them.
217 int skipCount = 0;
218
219 SkTaskGroup::Enabler enabled(FLAGS_threads);
220 SkTaskGroup cpuTests;
221 SkTArray<const Test*> gpuTests;
222
223 Status status(toRun);
224 for (const TestRegistry* iter = TestRegistry::Head(); iter;
225 iter = iter->next()) {
226 const Test& test = iter->factory();
227 if (!should_run(test.name, test.needsGpu)) {
228 ++skipCount;
229 } else if (test.needsGpu) {
230 gpuTests.push_back(&test);
231 } else {
232 cpuTests.add(SkTestRunnable(test, &status));
233 }
234 }
235
236 GrContextFactory* grContextFactoryPtr = nullptr;
237 #if SK_SUPPORT_GPU
238 // Give GPU tests a context factory if that makes sense on this machine.
239 GrContextFactory grContextFactory;
240 grContextFactoryPtr = &grContextFactory;
241
242 #endif
243
244 // Run GPU tests on this thread.
245 for (int i = 0; i < gpuTests.count(); i++) {
246 SkTestRunnable(*gpuTests[i], &status, grContextFactoryPtr)();
247 }
248
249 // Block until threaded tests finish.
250 cpuTests.wait();
251
252 if (FLAGS_verbose) {
253 SkDebugf(
254 "\nFinished %d tests, %d failures, %d skipped. "
255 "(%d internal tests)",
256 toRun, status.failCount(), skipCount, status.testCount());
257 if (gVerboseFinalize) {
258 (*gVerboseFinalize)();
259 }
260 }
261
262 SkDebugf("\n");
263 #if DEBUG_COIN
264 if (FLAGS_coinTest) {
265 SkPathOpsDebug::DumpCoinDict();
266 }
267 #endif
268
269 return (status.failCount() == 0) ? 0 : 1;
270 }
271