skqp.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495
  1. /*
  2. * Copyright 2018 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. #include "tools/skqp/src/skqp.h"
  8. #include "gm/gm.h"
  9. #include "include/core/SkFontStyle.h"
  10. #include "include/core/SkGraphics.h"
  11. #include "include/core/SkStream.h"
  12. #include "include/core/SkSurface.h"
  13. #include "include/encode/SkPngEncoder.h"
  14. #include "include/gpu/GrContext.h"
  15. #include "include/gpu/GrContextOptions.h"
  16. #include "include/private/SkImageInfoPriv.h"
  17. #include "src/core/SkFontMgrPriv.h"
  18. #include "src/core/SkOSFile.h"
  19. #include "src/core/SkStreamPriv.h"
  20. #include "src/gpu/GrContextPriv.h"
  21. #include "src/utils/SkOSPath.h"
  22. #include "tests/Test.h"
  23. #include "tools/fonts/TestFontMgr.h"
  24. #include "tools/gpu/gl/GLTestContext.h"
  25. #include "tools/gpu/vk/VkTestContext.h"
  26. #include <limits.h>
  27. #include <algorithm>
  28. #include <cinttypes>
  29. #include <sstream>
  30. #include "tools/skqp/src/skqp_model.h"
  31. #define IMAGES_DIRECTORY_PATH "images"
  32. #define PATH_MAX_PNG "max.png"
  33. #define PATH_MIN_PNG "min.png"
  34. #define PATH_IMG_PNG "image.png"
  35. #define PATH_ERR_PNG "errors.png"
  36. #define PATH_MODEL "model"
  37. static constexpr char kRenderTestCSVReport[] = "out.csv";
  38. static constexpr char kRenderTestReportPath[] = "report.html";
  39. static constexpr char kRenderTestsPath[] = "skqp/rendertests.txt";
  40. static constexpr char kUnitTestReportPath[] = "unit_tests.txt";
  41. static constexpr char kUnitTestsPath[] = "skqp/unittests.txt";
  42. // Kind of like Python's readlines(), but without any allocation.
  43. // Calls f() on each line.
  44. // F is [](const char*, size_t) -> void
  45. template <typename F>
  46. static void readlines(const void* data, size_t size, F f) {
  47. const char* start = (const char*)data;
  48. const char* end = start + size;
  49. const char* ptr = start;
  50. while (ptr < end) {
  51. while (*ptr++ != '\n' && ptr < end) {}
  52. size_t len = ptr - start;
  53. f(start, len);
  54. start = ptr;
  55. }
  56. }
  57. static void get_unit_tests(SkQPAssetManager* mgr, std::vector<SkQP::UnitTest>* unitTests) {
  58. std::unordered_set<std::string> testset;
  59. auto insert = [&testset](const char* s, size_t l) {
  60. SkASSERT(l > 1) ;
  61. if (l > 0 && s[l - 1] == '\n') { // strip line endings.
  62. --l;
  63. }
  64. if (l > 0) { // only add non-empty strings.
  65. testset.insert(std::string(s, l));
  66. }
  67. };
  68. if (sk_sp<SkData> dat = mgr->open(kUnitTestsPath)) {
  69. readlines(dat->data(), dat->size(), insert);
  70. }
  71. for (const skiatest::Test& test : skiatest::TestRegistry::Range()) {
  72. if ((testset.empty() || testset.count(std::string(test.name)) > 0) && test.needsGpu) {
  73. unitTests->push_back(&test);
  74. }
  75. }
  76. auto lt = [](SkQP::UnitTest u, SkQP::UnitTest v) { return strcmp(u->name, v->name) < 0; };
  77. std::sort(unitTests->begin(), unitTests->end(), lt);
  78. }
  79. static void get_render_tests(SkQPAssetManager* mgr,
  80. std::vector<SkQP::GMFactory>* gmlist,
  81. std::unordered_map<std::string, int64_t>* gmThresholds) {
  82. auto insert = [gmThresholds](const char* s, size_t l) {
  83. SkASSERT(l > 1) ;
  84. if (l > 0 && s[l - 1] == '\n') { // strip line endings.
  85. --l;
  86. }
  87. if (l == 0) {
  88. return;
  89. }
  90. const char* end = s + l;
  91. const char* ptr = s;
  92. constexpr char kDelimeter = ',';
  93. while (ptr < end && *ptr != kDelimeter) { ++ptr; }
  94. if (ptr + 1 >= end) {
  95. SkASSERT(false); // missing delimeter
  96. return;
  97. }
  98. std::string key(s, ptr - s);
  99. ++ptr; // skip delimeter
  100. std::string number(ptr, end - ptr); // null-terminated copy.
  101. int64_t value = 0;
  102. if (1 != sscanf(number.c_str(), "%" SCNd64 , &value)) {
  103. SkASSERT(false); // Not a number
  104. return;
  105. }
  106. gmThresholds->insert({std::move(key), value}); // (*gmThresholds)[s] = value;
  107. };
  108. if (sk_sp<SkData> dat = mgr->open(kRenderTestsPath)) {
  109. readlines(dat->data(), dat->size(), insert);
  110. }
  111. using GmAndName = std::pair<SkQP::GMFactory, std::string>;
  112. std::vector<GmAndName> gmsWithNames;
  113. for (skiagm::GMFactory f : skiagm::GMRegistry::Range()) {
  114. std::string name = SkQP::GetGMName(f);
  115. if ((gmThresholds->empty() || gmThresholds->count(name) > 0)) {
  116. gmsWithNames.push_back(std::make_pair(f, std::move(name)));
  117. }
  118. }
  119. std::sort(gmsWithNames.begin(), gmsWithNames.end(),
  120. [](GmAndName u, GmAndName v) { return u.second < v.second; });
  121. gmlist->reserve(gmsWithNames.size());
  122. for (const GmAndName& gmn : gmsWithNames) {
  123. gmlist->push_back(gmn.first);
  124. }
  125. }
  126. static std::unique_ptr<sk_gpu_test::TestContext> make_test_context(SkQP::SkiaBackend backend) {
  127. using U = std::unique_ptr<sk_gpu_test::TestContext>;
  128. switch (backend) {
  129. case SkQP::SkiaBackend::kGL:
  130. return U(sk_gpu_test::CreatePlatformGLTestContext(kGL_GrGLStandard, nullptr));
  131. case SkQP::SkiaBackend::kGLES:
  132. return U(sk_gpu_test::CreatePlatformGLTestContext(kGLES_GrGLStandard, nullptr));
  133. #ifdef SK_VULKAN
  134. case SkQP::SkiaBackend::kVulkan:
  135. return U(sk_gpu_test::CreatePlatformVkTestContext(nullptr));
  136. #endif
  137. default:
  138. return nullptr;
  139. }
  140. }
  141. static GrContextOptions context_options(skiagm::GM* gm = nullptr) {
  142. GrContextOptions grContextOptions;
  143. grContextOptions.fAllowPathMaskCaching = true;
  144. grContextOptions.fDisableDriverCorrectnessWorkarounds = true;
  145. if (gm) {
  146. gm->modifyGrContextOptions(&grContextOptions);
  147. }
  148. return grContextOptions;
  149. }
  150. static std::vector<SkQP::SkiaBackend> get_backends() {
  151. std::vector<SkQP::SkiaBackend> result;
  152. SkQP::SkiaBackend backends[] = {
  153. #ifndef SK_BUILD_FOR_ANDROID
  154. SkQP::SkiaBackend::kGL, // Used for testing on desktop machines.
  155. #endif
  156. SkQP::SkiaBackend::kGLES,
  157. #ifdef SK_VULKAN
  158. SkQP::SkiaBackend::kVulkan,
  159. #endif
  160. };
  161. for (SkQP::SkiaBackend backend : backends) {
  162. std::unique_ptr<sk_gpu_test::TestContext> testCtx = make_test_context(backend);
  163. if (testCtx) {
  164. testCtx->makeCurrent();
  165. if (nullptr != testCtx->makeGrContext(context_options())) {
  166. result.push_back(backend);
  167. }
  168. }
  169. }
  170. SkASSERT_RELEASE(result.size() > 0);
  171. return result;
  172. }
  173. static void print_backend_info(const char* dstPath,
  174. const std::vector<SkQP::SkiaBackend>& backends) {
  175. #ifdef SK_ENABLE_DUMP_GPU
  176. SkFILEWStream out(dstPath);
  177. out.writeText("[\n");
  178. for (SkQP::SkiaBackend backend : backends) {
  179. if (std::unique_ptr<sk_gpu_test::TestContext> testCtx = make_test_context(backend)) {
  180. testCtx->makeCurrent();
  181. if (sk_sp<GrContext> ctx = testCtx->makeGrContext(context_options())) {
  182. SkString info = ctx->priv().dump();
  183. // remove null
  184. out.write(info.c_str(), info.size());
  185. out.writeText(",\n");
  186. }
  187. }
  188. }
  189. out.writeText("]\n");
  190. #endif
  191. }
  192. static void encode_png(const SkBitmap& src, const std::string& dst) {
  193. SkFILEWStream wStream(dst.c_str());
  194. SkPngEncoder::Options options;
  195. bool success = wStream.isValid() && SkPngEncoder::Encode(&wStream, src.pixmap(), options);
  196. SkASSERT_RELEASE(success);
  197. }
  198. static void write_to_file(const sk_sp<SkData>& src, const std::string& dst) {
  199. SkFILEWStream wStream(dst.c_str());
  200. bool success = wStream.isValid() && wStream.write(src->data(), src->size());
  201. SkASSERT_RELEASE(success);
  202. }
  203. ////////////////////////////////////////////////////////////////////////////////
  204. const char* SkQP::GetBackendName(SkQP::SkiaBackend b) {
  205. switch (b) {
  206. case SkQP::SkiaBackend::kGL: return "gl";
  207. case SkQP::SkiaBackend::kGLES: return "gles";
  208. case SkQP::SkiaBackend::kVulkan: return "vk";
  209. }
  210. return "";
  211. }
  212. std::string SkQP::GetGMName(SkQP::GMFactory f) {
  213. std::unique_ptr<skiagm::GM> gm(f ? f(nullptr) : nullptr);
  214. return std::string(gm ? gm->getName() : "");
  215. }
  216. const char* SkQP::GetUnitTestName(SkQP::UnitTest t) { return t->name; }
  217. SkQP::SkQP() {}
  218. SkQP::~SkQP() {}
  219. void SkQP::init(SkQPAssetManager* am, const char* reportDirectory) {
  220. SkASSERT_RELEASE(!fAssetManager);
  221. SkASSERT_RELEASE(am);
  222. fAssetManager = am;
  223. fReportDirectory = reportDirectory;
  224. SkGraphics::Init();
  225. gSkFontMgr_DefaultFactory = &ToolUtils::MakePortableFontMgr;
  226. /* If the file "skqp/rendertests.txt" does not exist or is empty, run all
  227. render tests. Otherwise only run tests mentioned in that file. */
  228. get_render_tests(fAssetManager, &fGMs, &fGMThresholds);
  229. /* If the file "skqp/unittests.txt" does not exist or is empty, run all gpu
  230. unit tests. Otherwise only run tests mentioned in that file. */
  231. get_unit_tests(fAssetManager, &fUnitTests);
  232. fSupportedBackends = get_backends();
  233. print_backend_info((fReportDirectory + "/grdump.txt").c_str(), fSupportedBackends);
  234. }
  235. std::tuple<SkQP::RenderOutcome, std::string> SkQP::evaluateGM(SkQP::SkiaBackend backend,
  236. SkQP::GMFactory gmFact) {
  237. SkASSERT_RELEASE(fAssetManager);
  238. static constexpr SkQP::RenderOutcome kError = {INT_MAX, INT_MAX, INT64_MAX};
  239. static constexpr SkQP::RenderOutcome kPass = {0, 0, 0};
  240. std::unique_ptr<sk_gpu_test::TestContext> testCtx = make_test_context(backend);
  241. if (!testCtx) {
  242. return std::make_tuple(kError, "Skia Failure: test context");
  243. }
  244. testCtx->makeCurrent();
  245. SkASSERT(gmFact);
  246. std::unique_ptr<skiagm::GM> gm(gmFact(nullptr));
  247. SkASSERT(gm);
  248. const char* const name = gm->getName();
  249. const SkISize size = gm->getISize();
  250. const int w = size.width();
  251. const int h = size.height();
  252. const SkImageInfo info =
  253. SkImageInfo::Make(w, h, skqp::kColorType, kPremul_SkAlphaType, nullptr);
  254. const SkSurfaceProps props(0, SkSurfaceProps::kLegacyFontHost_InitType);
  255. sk_sp<SkSurface> surf = SkSurface::MakeRenderTarget(
  256. testCtx->makeGrContext(context_options(gm.get())).get(),
  257. SkBudgeted::kNo, info, 0, &props);
  258. if (!surf) {
  259. return std::make_tuple(kError, "Skia Failure: gr-context");
  260. }
  261. gm->draw(surf->getCanvas());
  262. SkBitmap image;
  263. image.allocPixels(SkImageInfo::Make(w, h, skqp::kColorType, skqp::kAlphaType));
  264. // SkColorTypeBytesPerPixel should be constexpr, but is not.
  265. SkASSERT(SkColorTypeBytesPerPixel(skqp::kColorType) == sizeof(uint32_t));
  266. // Call readPixels because we need to compare pixels.
  267. if (!surf->readPixels(image.pixmap(), 0, 0)) {
  268. return std::make_tuple(kError, "Skia Failure: read pixels");
  269. }
  270. int64_t passingThreshold = fGMThresholds.empty() ? -1 : fGMThresholds[std::string(name)];
  271. if (-1 == passingThreshold) {
  272. return std::make_tuple(kPass, "");
  273. }
  274. skqp::ModelResult modelResult =
  275. skqp::CheckAgainstModel(name, image.pixmap(), fAssetManager);
  276. if (!modelResult.fErrorString.empty()) {
  277. return std::make_tuple(kError, std::move(modelResult.fErrorString));
  278. }
  279. fRenderResults.push_back(SkQP::RenderResult{backend, gmFact, modelResult.fOutcome});
  280. if (modelResult.fOutcome.fMaxError <= passingThreshold) {
  281. return std::make_tuple(kPass, "");
  282. }
  283. std::string imagesDirectory = fReportDirectory + "/" IMAGES_DIRECTORY_PATH;
  284. if (!sk_mkdir(imagesDirectory.c_str())) {
  285. SkDebugf("ERROR: sk_mkdir('%s');\n", imagesDirectory.c_str());
  286. return std::make_tuple(modelResult.fOutcome, "");
  287. }
  288. std::ostringstream tmp;
  289. tmp << imagesDirectory << '/' << SkQP::GetBackendName(backend) << '_' << name << '_';
  290. std::string imagesPathPrefix1 = tmp.str();
  291. tmp = std::ostringstream();
  292. tmp << imagesDirectory << '/' << PATH_MODEL << '_' << name << '_';
  293. std::string imagesPathPrefix2 = tmp.str();
  294. encode_png(image, imagesPathPrefix1 + PATH_IMG_PNG);
  295. encode_png(modelResult.fErrors, imagesPathPrefix1 + PATH_ERR_PNG);
  296. write_to_file(modelResult.fMaxPng, imagesPathPrefix2 + PATH_MAX_PNG);
  297. write_to_file(modelResult.fMinPng, imagesPathPrefix2 + PATH_MIN_PNG);
  298. return std::make_tuple(modelResult.fOutcome, "");
  299. }
  300. std::vector<std::string> SkQP::executeTest(SkQP::UnitTest test) {
  301. SkASSERT_RELEASE(fAssetManager);
  302. struct : public skiatest::Reporter {
  303. std::vector<std::string> fErrors;
  304. void reportFailed(const skiatest::Failure& failure) override {
  305. SkString desc = failure.toString();
  306. fErrors.push_back(std::string(desc.c_str(), desc.size()));
  307. }
  308. } r;
  309. GrContextOptions options;
  310. options.fDisableDriverCorrectnessWorkarounds = true;
  311. if (test->fContextOptionsProc) {
  312. test->fContextOptionsProc(&options);
  313. }
  314. test->proc(&r, options);
  315. fUnitTestResults.push_back(UnitTestResult{test, r.fErrors});
  316. return r.fErrors;
  317. }
  318. ////////////////////////////////////////////////////////////////////////////////
  319. static constexpr char kDocHead[] =
  320. "<!doctype html>\n"
  321. "<html lang=\"en\">\n"
  322. "<head>\n"
  323. "<meta charset=\"UTF-8\">\n"
  324. "<title>SkQP Report</title>\n"
  325. "<style>\n"
  326. "img { max-width:48%; border:1px green solid;\n"
  327. " image-rendering: pixelated;\n"
  328. " background-image:url('data:image/png;base64,iVBORw0KGgoA"
  329. "AAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAAAXNSR0IArs4c6QAAAAJiS0dEAP+H"
  330. "j8y/AAAACXBIWXMAAA7DAAAOwwHHb6hkAAAAB3RJTUUH3gUBEi4DGRAQYgAAAB1J"
  331. "REFUGNNjfMoAAVJQmokBDdBHgPE/lPFsYN0BABdaAwN6tehMAAAAAElFTkSuQmCC"
  332. "'); }\n"
  333. "</style>\n"
  334. "<script>\n"
  335. "function ce(t) { return document.createElement(t); }\n"
  336. "function ct(n) { return document.createTextNode(n); }\n"
  337. "function ac(u,v) { return u.appendChild(v); }\n"
  338. "function br(u) { ac(u, ce(\"br\")); }\n"
  339. "function ma(s, c) { var a = ce(\"a\"); a.href = s; ac(a, c); return a; }\n"
  340. "function f(backend, gm, e1, e2, e3) {\n"
  341. " var b = ce(\"div\");\n"
  342. " var x = ce(\"h2\");\n"
  343. " var t = backend + \"_\" + gm;\n"
  344. " ac(x, ct(t));\n"
  345. " ac(b, x);\n"
  346. " ac(b, ct(\"backend: \" + backend));\n"
  347. " br(b);\n"
  348. " ac(b, ct(\"gm name: \" + gm));\n"
  349. " br(b);\n"
  350. " ac(b, ct(\"maximum error: \" + e1));\n"
  351. " br(b);\n"
  352. " ac(b, ct(\"bad pixel counts: \" + e2));\n"
  353. " br(b);\n"
  354. " ac(b, ct(\"total error: \" + e3));\n"
  355. " br(b);\n"
  356. " var q = \"" IMAGES_DIRECTORY_PATH "/\" + backend + \"_\" + gm + \"_\";\n"
  357. " var p = \"" IMAGES_DIRECTORY_PATH "/" PATH_MODEL "_\" + gm + \"_\";\n"
  358. " var i = ce(\"img\");\n"
  359. " i.src = q + \"" PATH_IMG_PNG "\";\n"
  360. " i.alt = \"img\";\n"
  361. " ac(b, ma(i.src, i));\n"
  362. " i = ce(\"img\");\n"
  363. " i.src = q + \"" PATH_ERR_PNG "\";\n"
  364. " i.alt = \"err\";\n"
  365. " ac(b, ma(i.src, i));\n"
  366. " br(b);\n"
  367. " ac(b, ct(\"Expectation: \"));\n"
  368. " ac(b, ma(p + \"" PATH_MAX_PNG "\", ct(\"max\")));\n"
  369. " ac(b, ct(\" | \"));\n"
  370. " ac(b, ma(p + \"" PATH_MIN_PNG "\", ct(\"min\")));\n"
  371. " ac(b, ce(\"hr\"));\n"
  372. " b.id = backend + \":\" + gm;\n"
  373. " ac(document.body, b);\n"
  374. " l = ce(\"li\");\n"
  375. " ac(l, ct(\"[\" + e3 + \"] \"));\n"
  376. " ac(l, ma(\"#\" + backend +\":\"+ gm , ct(t)));\n"
  377. " ac(document.getElementById(\"toc\"), l);\n"
  378. "}\n"
  379. "function main() {\n";
  380. static constexpr char kDocMiddle[] =
  381. "}\n"
  382. "</script>\n"
  383. "</head>\n"
  384. "<body onload=\"main()\">\n"
  385. "<h1>SkQP Report</h1>\n";
  386. static constexpr char kDocTail[] =
  387. "<ul id=\"toc\"></ul>\n"
  388. "<hr>\n"
  389. "<p>Left image: test result<br>\n"
  390. "Right image: errors (white = no error, black = smallest error, red = biggest error; "
  391. "other errors are a color between black and red.)</p>\n"
  392. "<hr>\n"
  393. "</body>\n"
  394. "</html>\n";
  395. template <typename T>
  396. inline void write(SkWStream* wStream, const T& text) {
  397. wStream->write(text.c_str(), text.size());
  398. }
  399. void SkQP::makeReport() {
  400. SkASSERT_RELEASE(fAssetManager);
  401. int glesErrorCount = 0, vkErrorCount = 0, gles = 0, vk = 0;
  402. if (!sk_isdir(fReportDirectory.c_str())) {
  403. SkDebugf("Report destination does not exist: '%s'\n", fReportDirectory.c_str());
  404. return;
  405. }
  406. SkFILEWStream csvOut(SkOSPath::Join(fReportDirectory.c_str(), kRenderTestCSVReport).c_str());
  407. SkFILEWStream htmOut(SkOSPath::Join(fReportDirectory.c_str(), kRenderTestReportPath).c_str());
  408. SkASSERT_RELEASE(csvOut.isValid() && htmOut.isValid());
  409. htmOut.writeText(kDocHead);
  410. for (const SkQP::RenderResult& run : fRenderResults) {
  411. switch (run.fBackend) {
  412. case SkQP::SkiaBackend::kGLES: ++gles; break;
  413. case SkQP::SkiaBackend::kVulkan: ++vk; break;
  414. default: break;
  415. }
  416. const char* backendName = SkQP::GetBackendName(run.fBackend);
  417. std::string gmName = SkQP::GetGMName(run.fGM);
  418. const SkQP::RenderOutcome& outcome = run.fOutcome;
  419. auto str = SkStringPrintf("\"%s\",\"%s\",%d,%d,%" PRId64, backendName, gmName.c_str(),
  420. outcome.fMaxError, outcome.fBadPixelCount, outcome.fTotalError);
  421. write(&csvOut, SkStringPrintf("%s\n", str.c_str()));
  422. int64_t passingThreshold = fGMThresholds.empty() ? 0 : fGMThresholds[gmName];
  423. if (passingThreshold == -1 || outcome.fMaxError <= passingThreshold) {
  424. continue;
  425. }
  426. write(&htmOut, SkStringPrintf(" f(%s);\n", str.c_str()));
  427. switch (run.fBackend) {
  428. case SkQP::SkiaBackend::kGLES: ++glesErrorCount; break;
  429. case SkQP::SkiaBackend::kVulkan: ++vkErrorCount; break;
  430. default: break;
  431. }
  432. }
  433. htmOut.writeText(kDocMiddle);
  434. write(&htmOut, SkStringPrintf("<p>gles errors: %d (of %d)</br>\n"
  435. "vk errors: %d (of %d)</p>\n",
  436. glesErrorCount, gles, vkErrorCount, vk));
  437. htmOut.writeText(kDocTail);
  438. SkFILEWStream unitOut(SkOSPath::Join(fReportDirectory.c_str(), kUnitTestReportPath).c_str());
  439. SkASSERT_RELEASE(unitOut.isValid());
  440. for (const SkQP::UnitTestResult& result : fUnitTestResults) {
  441. unitOut.writeText(GetUnitTestName(result.fUnitTest));
  442. if (result.fErrors.empty()) {
  443. unitOut.writeText(" PASSED\n* * *\n");
  444. } else {
  445. write(&unitOut, SkStringPrintf(" FAILED (%u errors)\n", result.fErrors.size()));
  446. for (const std::string& err : result.fErrors) {
  447. write(&unitOut, err);
  448. unitOut.newline();
  449. }
  450. unitOut.writeText("* * *\n");
  451. }
  452. }
  453. }