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 "SkCommandLineFlags.h" 12 #include "SkGraphics.h" 13 #include "SkOSFile.h" 14 #include "SkTArray.h" 15 #include "SkTemplates.h" 16 #include "SkThreadPool.h" 17 #include "SkTime.h" 18 #include "Test.h" 19 20 #if SK_SUPPORT_GPU 21 #include "GrContext.h" 22 #include "GrContextFactory.h" 23 #endif 24 25 using namespace skiatest; 26 27 DEFINE_string2(match, m, NULL, "[~][^]substring[$] [...] of test name to run.\n" \ 28 "Multiple matches may be separated by spaces.\n" \ 29 "~ causes a matching test to always be skipped\n" \ 30 "^ requires the start of the test to match\n" \ 31 "$ requires the end of the test to match\n" \ 32 "^ and $ requires an exact match\n" \ 33 "If a test does not match any list entry,\n" \ 34 "it is skipped unless some list entry starts with ~"); 35 DEFINE_bool2(extendedTest, x, false, "run extended tests for pathOps."); 36 DEFINE_bool2(leaks, l, false, "show leaked ref cnt'd objects."); 37 DEFINE_bool2(single, z, false, "run tests on a single thread internally."); 38 DEFINE_bool2(verbose, v, false, "enable verbose output from the test driver."); 39 DEFINE_bool2(veryVerbose, V, false, "tell individual tests to be verbose."); 40 DEFINE_bool(cpu, true, "whether or not to run CPU tests."); 41 DEFINE_bool(gpu, true, "whether or not to run GPU tests."); 42 DEFINE_int32(threads, SkThreadPool::kThreadPerCore, 43 "Run threadsafe tests on a threadpool with this many threads."); 44 45 // need to explicitly declare this, or we get some weird infinite loop llist 46 template TestRegistry* TestRegistry::gHead; 47 48 class Iter { 49 public: 50 Iter() { this->reset(); } 51 void reset() { fReg = TestRegistry::Head(); } 52 53 Test* next(Reporter* r) { 54 if (fReg) { 55 TestRegistry::Factory fact = fReg->factory(); 56 fReg = fReg->next(); 57 Test* test = fact(NULL); 58 test->setReporter(r); 59 return test; 60 } 61 return NULL; 62 } 63 64 private: 65 const TestRegistry* fReg; 66 }; 67 68 class DebugfReporter : public Reporter { 69 public: 70 explicit DebugfReporter(int total) : fDone(0), fTotal(total) {} 71 72 virtual bool allowExtendedTest() const SK_OVERRIDE { return FLAGS_extendedTest; } 73 virtual bool allowThreaded() const SK_OVERRIDE { return !FLAGS_single; } 74 virtual bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; } 75 76 protected: 77 virtual void onReportFailed(const SkString& desc) SK_OVERRIDE { 78 SkDebugf("\nFAILED: %s", desc.c_str()); 79 } 80 81 virtual void onEnd(Test* test) SK_OVERRIDE { 82 const int done = 1 + sk_atomic_inc(&fDone); 83 84 if (!test->passed()) { 85 SkDebugf("\n---- %s FAILED", test->getName()); 86 } 87 88 SkString prefix(kSkOverwriteLine); 89 SkString time; 90 if (FLAGS_verbose) { 91 prefix.printf("\n"); 92 time.printf("%5dms ", test->elapsedMs()); 93 } 94 SkDebugf("%s[%3d/%3d] %s%s", prefix.c_str(), done, fTotal, time.c_str(), test->getName()); 95 } 96 97 private: 98 int32_t fDone; // atomic 99 const int fTotal; 100 }; 101 102 // Deletes self when run. 103 class SkTestRunnable : public SkRunnable { 104 public: 105 // Takes ownership of test. 106 SkTestRunnable(Test* test, int32_t* failCount) : fTest(test), fFailCount(failCount) {} 107 108 virtual void run() { 109 fTest->run(); 110 if(!fTest->passed()) { 111 sk_atomic_inc(fFailCount); 112 } 113 SkDELETE(this); 114 } 115 116 private: 117 SkAutoTDelete<Test> fTest; 118 int32_t* fFailCount; 119 }; 120 121 static bool should_run(const char* testName, bool isGPUTest) { 122 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, testName)) { 123 return false; 124 } 125 if (!FLAGS_cpu && !isGPUTest) { 126 return false; 127 } 128 if (!FLAGS_gpu && isGPUTest) { 129 return false; 130 } 131 return true; 132 } 133 134 int tool_main(int argc, char** argv); 135 int tool_main(int argc, char** argv) { 136 SetupCrashHandler(); 137 SkCommandLineFlags::SetUsage(""); 138 SkCommandLineFlags::Parse(argc, argv); 139 140 #if SK_ENABLE_INST_COUNT 141 if (FLAGS_leaks) { 142 gPrintInstCount = true; 143 } 144 #endif 145 146 SkGraphics::Init(); 147 148 { 149 SkString header("Skia UnitTests:"); 150 if (!FLAGS_match.isEmpty()) { 151 header.appendf(" --match"); 152 for (int index = 0; index < FLAGS_match.count(); ++index) { 153 header.appendf(" %s", FLAGS_match[index]); 154 } 155 } 156 SkString tmpDir = Test::GetTmpDir(); 157 if (!tmpDir.isEmpty()) { 158 header.appendf(" --tmpDir %s", tmpDir.c_str()); 159 } 160 SkString resourcePath = GetResourcePath(); 161 if (!resourcePath.isEmpty()) { 162 header.appendf(" --resourcePath %s", resourcePath.c_str()); 163 } 164 #ifdef SK_DEBUG 165 header.append(" SK_DEBUG"); 166 #else 167 header.append(" SK_RELEASE"); 168 #endif 169 header.appendf(" skia_arch_width=%d", (int)sizeof(void*) * 8); 170 if (FLAGS_veryVerbose) { 171 header.appendf("\n"); 172 } 173 SkDebugf(header.c_str()); 174 } 175 176 177 // Count tests first. 178 int total = 0; 179 int toRun = 0; 180 Test* test; 181 182 Iter iter; 183 while ((test = iter.next(NULL/*reporter not needed*/)) != NULL) { 184 SkAutoTDelete<Test> owned(test); 185 if (should_run(test->getName(), test->isGPUTest())) { 186 toRun++; 187 } 188 total++; 189 } 190 191 // Now run them. 192 iter.reset(); 193 int32_t failCount = 0; 194 int skipCount = 0; 195 196 SkThreadPool threadpool(FLAGS_threads); 197 SkTArray<Test*> gpuTests; // Always passes ownership to an SkTestRunnable 198 199 DebugfReporter reporter(toRun); 200 for (int i = 0; i < total; i++) { 201 SkAutoTDelete<Test> test(iter.next(&reporter)); 202 if (!should_run(test->getName(), test->isGPUTest())) { 203 ++skipCount; 204 } else if (test->isGPUTest()) { 205 gpuTests.push_back() = test.detach(); 206 } else { 207 threadpool.add(SkNEW_ARGS(SkTestRunnable, (test.detach(), &failCount))); 208 } 209 } 210 211 #if SK_SUPPORT_GPU 212 // Give GPU tests a context factory if that makes sense on this machine. 213 GrContextFactory grContextFactory; 214 for (int i = 0; i < gpuTests.count(); i++) { 215 gpuTests[i]->setGrContextFactory(&grContextFactory); 216 } 217 #endif 218 219 // Run GPU tests on this thread. 220 for (int i = 0; i < gpuTests.count(); i++) { 221 SkNEW_ARGS(SkTestRunnable, (gpuTests[i], &failCount))->run(); 222 } 223 224 // Block until threaded tests finish. 225 threadpool.wait(); 226 227 if (FLAGS_verbose) { 228 SkDebugf("\nFinished %d tests, %d failures, %d skipped. (%d internal tests)", 229 toRun, failCount, skipCount, reporter.countTests()); 230 } 231 SkGraphics::Term(); 232 233 SkDebugf("\n"); 234 return (failCount == 0) ? 0 : 1; 235 } 236 237 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL) 238 int main(int argc, char * const argv[]) { 239 return tool_main(argc, (char**) argv); 240 } 241 #endif 242
