/* * Copyright 2021 Google LLC * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "tests/Test.h" #if defined(SK_GRAPHITE) #include "include/core/SkCanvas.h" #include "include/core/SkShader.h" #include "include/effects/SkRuntimeEffect.h" #include "include/gpu/graphite/Surface.h" #include "include/gpu/graphite/precompile/Precompile.h" #include "include/gpu/graphite/precompile/PrecompileShader.h" #include "src/base/SkRandom.h" #include "src/gpu/graphite/ContextPriv.h" #include "src/gpu/graphite/ContextUtils.h" #include "src/gpu/graphite/DrawContext.h" #include "src/gpu/graphite/GraphicsPipelineDesc.h" #include "src/gpu/graphite/KeyContext.h" #include "src/gpu/graphite/KeyHelpers.h" #include "src/gpu/graphite/PaintParams.h" #include "src/gpu/graphite/PipelineData.h" #include "src/gpu/graphite/PrecompileContextPriv.h" #include "src/gpu/graphite/RecorderPriv.h" #include "src/gpu/graphite/RenderPassDesc.h" #include "src/gpu/graphite/Renderer.h" #include "src/gpu/graphite/ResourceProvider.h" #include "src/gpu/graphite/RuntimeEffectDictionary.h" #include "src/gpu/graphite/ShaderCodeDictionary.h" #include "src/gpu/graphite/TextureInfoPriv.h" #include "src/gpu/graphite/UniquePaintParamsID.h" #include "src/gpu/graphite/precompile/PaintOptionsPriv.h" #include "tools/graphite/GraphiteTestContext.h" #include "tools/graphite/UniqueKeyUtils.h" #include "tests/graphite/precompile/PaintParamsTestUtils.h" // Set this to 1 for more expansive (aka far slower) local testing #define EXPANDED_SET 0 constexpr uint32_t kDefaultSeed = 0; using namespace skgpu::graphite; using namespace skiatest::graphite; namespace { //-------------------------------------------------------------------------------------------------- // Helpers //-------------------------------------------------------------------------------------------------- sk_sp get_precompile_draw_context(const skgpu::graphite::Caps* caps, Context* context) { std::unique_ptr drawRecorder = context->makeRecorder(); ResourceProvider* resourceProvider = drawRecorder->priv().resourceProvider(); constexpr SkISize drawSize = {128, 128}; const SkColorInfo colorInfo = SkColorInfo(kRGBA_8888_SkColorType, kPremul_SkAlphaType, SkColorSpace::MakeSRGB()); TextureInfo texInfo = caps->getDefaultSampledTextureInfo(colorInfo.colorType(), skgpu::Mipmapped::kNo, skgpu::Protected::kNo, skgpu::Renderable::kYes); sk_sp target = TextureProxy::Make(caps, resourceProvider, drawSize, texInfo, "PrecompileTarget", skgpu::Budgeted::kYes); return DrawContext::Make(caps, std::move(target), drawSize, colorInfo, {}); } void log_run(const char* label, uint32_t seed, ShaderType s, BlenderType bm, ColorFilterType cf, MaskFilterType mf, ImageFilterType imageFilter, ClipType clipType, DrawTypeFlags drawTypeFlags) { SkDebugf("%s:\n" "//------------------------\n" "uint32_t seed = %u;\n" "ShaderType shaderType = %s;\n" "BlenderType blenderType = %s;\n" "ColorFilterType colorFilterType = %s;\n" "MaskFilterType maskFilterType = %s;\n" "ImageFilterType imageFilterType = %s;\n" "ClipType clipType = %s;\n" "DrawTypeFlags drawTypeFlags = %s;\n" "//-----------------------\n", label, seed, ToStr(s), ToStr(bm), ToStr(cf), ToStr(mf), ToStr(imageFilter), ToStr(clipType), ToStr(drawTypeFlags)); } #ifdef SK_DEBUG void dump_keys(PrecompileContext* precompileContext, const std::vector& needleKeys, const std::vector& hayStackKeys, const char* needleName, const char* haystackName) { SkDebugf("-------------------------- %zu %s pipelines\n", needleKeys.size(), needleName); int count = 0; for (const skgpu::UniqueKey& k : needleKeys) { bool found = std::find(hayStackKeys.begin(), hayStackKeys.end(), k) != hayStackKeys.end(); GraphicsPipelineDesc originalPipelineDesc; RenderPassDesc originalRenderPassDesc; UniqueKeyUtils::ExtractKeyDescs(precompileContext, k, &originalPipelineDesc, &originalRenderPassDesc); SkString label; label.appendf("--- %s key %d (%s in %s):\n", needleName, count++, found ? "found" : "not-found", haystackName); k.dump(label.c_str()); UniqueKeyUtils::DumpDescs(precompileContext, originalPipelineDesc, originalRenderPassDesc); } } #endif void check_draw(skiatest::Reporter* reporter, Context* context, PrecompileContext* precompileContext, skiatest::graphite::GraphiteTestContext* testContext, Recorder* recorder, const SkPaint& paint, DrawTypeFlags dt, ClipType clipType, sk_sp clipShader) { static const DrawData kDrawData; std::vector precompileKeys, drawKeys; UniqueKeyUtils::FetchUniqueKeys(precompileContext, &precompileKeys); precompileContext->priv().globalCache()->resetGraphicsPipelines(); { // TODO: vary the colorType of the target surface too SkImageInfo ii = SkImageInfo::Make(16, 16, kBGRA_8888_SkColorType, kPremul_SkAlphaType); SkSurfaceProps props; if (dt == DrawTypeFlags::kBitmapText_LCD || dt == DrawTypeFlags::kSDFText_LCD) { props = SkSurfaceProps(/* flags= */ 0x0, SkPixelGeometry::kRGB_H_SkPixelGeometry); } sk_sp surf = SkSurfaces::RenderTarget(recorder, ii, skgpu::Mipmapped::kNo, &props); SkCanvas* canvas = surf->getCanvas(); // NOTE: The specific coordinates for the clip[R]Rect and draw[R]Rect calls are chosen to // avoid geometrically combining the clip into the geometry, and to avoid covering the // render target entirely, both of which would simplify the pipeline required. switch (clipType) { case ClipType::kNone: break; case ClipType::kShader: SkASSERT(clipShader); canvas->clipShader(clipShader, SkClipOp::kIntersect); break; case ClipType::kShader_Diff: SkASSERT(clipShader); canvas->clipShader(clipShader, SkClipOp::kDifference); break; case ClipType::kAnalytic: canvas->clipRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(1, 1, 15, 15), 5, 5)); break; case ClipType::kAnalyticAndShader: SkASSERT(clipShader); canvas->clipRRect(SkRRect::MakeRectXY(SkRect::MakeXYWH(1, 1, 15, 15), 5, 5)); canvas->clipShader(clipShader, SkClipOp::kIntersect); break; } ExecuteDraw(canvas, paint, kDrawData, dt); std::unique_ptr recording = recorder->snap(); context->insertRecording({ recording.get() }); testContext->syncedSubmit(context); } UniqueKeyUtils::FetchUniqueKeys(precompileContext, &drawKeys); // Actually using the SkPaint with the specified type of draw shouldn't have added // any additional pipelines int missingPipelines = 0; for (const skgpu::UniqueKey& k : drawKeys) { bool found = std::find(precompileKeys.begin(), precompileKeys.end(), k) != precompileKeys.end(); if (!found) { ++missingPipelines; } } REPORTER_ASSERT(reporter, missingPipelines == 0, "precompile pipelines: %zu draw pipelines: %zu - %d missing from precompile", precompileKeys.size(), drawKeys.size(), missingPipelines); #ifdef SK_DEBUG if (missingPipelines) { dump_keys(precompileContext, drawKeys, precompileKeys, "draw", "precompile"); dump_keys(precompileContext, precompileKeys, drawKeys, "precompile", "draw"); } #endif // SK_DEBUG } // This subtest compares the output of paintParams.toKey() (applied to an SkPaint) and // PaintOptions::buildCombinations (applied to a matching PaintOptions). The actual check // performed is that the UniquePaintParamsID created by paintParams.toKey() is contained in the // set of IDs generated by buildCombinations. [[maybe_unused]] void extract_vs_build_subtest(skiatest::Reporter* reporter, Context* context, DrawContext* drawContext, skiatest::graphite::GraphiteTestContext* /* testContext */, const KeyContext& precompileKeyContext, Recorder* recorder, const SkPaint& paint, const PaintOptions& paintOptions, ShaderType s, BlenderType bm, ColorFilterType cf, MaskFilterType mf, ImageFilterType imageFilter, ClipType clipType, sk_sp clipShader, DrawTypeFlags dt, uint32_t seed, SkRandom* rand, bool verbose) { PipelineDataGatherer paramsGatherer(Layout::kMetal); for (bool withPrimitiveBlender: {false, true}) { sk_sp primitiveBlender; if (withPrimitiveBlender) { if (dt != DrawTypeFlags::kDrawVertices) { // Only drawVertices calls need a primitive blender continue; } primitiveBlender = SkBlender::Mode(SkBlendMode::kSrcOver); } constexpr Coverage coverageOptions[3] = { Coverage::kNone, Coverage::kSingleChannel, Coverage::kLCD }; Coverage coverage = coverageOptions[rand->nextULessThan(3)]; // In the normal API this modification happens in SkDevice::clipShader() // All clipShaders get wrapped in a CTMShader sk_sp modifiedClipShader = clipShader ? as_SB(clipShader)->makeWithCTM(SkMatrix::I()) : nullptr; if (clipType == ClipType::kShader_Diff && modifiedClipShader) { // The CTMShader gets further wrapped in a ColorFilterShader for kDifference clips modifiedClipShader = modifiedClipShader->makeWithColorFilter( SkColorFilters::Blend(0xFFFFFFFF, SkBlendMode::kSrcOut)); } bool hasAnalyticClip = clipType == ClipType::kAnalytic || clipType == ClipType::kAnalyticAndShader; NonMSAAClip clipData; if (hasAnalyticClip) { clipData.fAnalyticClip.fBounds = SkRect::MakeWH(15, 15); clipData.fAnalyticClip.fRadius = 5; } PaintParams paintParams{paint, primitiveBlender.get()}; ShadingParams shadingParams{recorder->priv().caps(), paintParams, clipData, modifiedClipShader.get(), coverage, TextureFormat::kRGBA8}; paramsGatherer.resetForDraw(); KeyContext keyContext(recorder, drawContext, precompileKeyContext.floatStorageManager(), precompileKeyContext.paintParamsKeyBuilder(), ¶msGatherer, {}, precompileKeyContext.dstColorInfo(), KeyGenFlags::kDisableSamplingOptimization, paintParams.color()); auto keyResult = shadingParams.toKey(keyContext); UniquePaintParamsID paintID = keyResult.has_value() ? std::get<0>(*keyResult) : UniquePaintParamsID::Invalid(); RenderPassDesc unusedRenderPassDesc; std::vector precompileIDs; paintOptions.priv().buildCombinations(precompileKeyContext, hasAnalyticClip ? DrawTypeFlags::kAnalyticClip : DrawTypeFlags::kNone, withPrimitiveBlender, coverage, unusedRenderPassDesc, [&precompileIDs](UniquePaintParamsID id, DrawTypeFlags, bool /* withPrimitiveBlender */, Coverage, const RenderPassDesc&) { precompileIDs.push_back(id); }); if (verbose) { SkDebugf("Precompilation generated %zu unique keys\n", precompileIDs.size()); } // Although we've gathered both sets of uniforms (i.e., from the paint // params and the precompilation paths) we can't compare the two since the // precompilation path may have generated multiple sets // and the last one created may not be the one that matches the paint // params' set. Additionally, for runtime effects we just skip gathering // the uniforms in the precompilation path. // The specific key generated by paintParams.toKey() should be one of the // combinations generated by the combination system. auto result = std::find(precompileIDs.begin(), precompileIDs.end(), paintID); if (result == precompileIDs.end()) { log_run("Failure on case", seed, s, bm, cf, mf, imageFilter, clipType, dt); } #ifdef SK_DEBUG if (result == precompileIDs.end()) { SkDebugf("From paint: "); precompileKeyContext.dict()->dump(precompileKeyContext.caps(), paintID); SkDebugf("From combination builder [%d]:", static_cast(precompileIDs.size())); for (auto iter: precompileIDs) { precompileKeyContext.dict()->dump(precompileKeyContext.caps(), iter); } } #endif REPORTER_ASSERT(reporter, result != precompileIDs.end()); } } // This subtest verifies that, given an equivalent SkPaint and PaintOptions, the // Precompile system will, at least, generate all the pipelines a real draw would generate. void precompile_vs_real_draws_subtest(skiatest::Reporter* reporter, Context* context, PrecompileContext* precompileContext, skiatest::graphite::GraphiteTestContext* testContext, Recorder* recorder, const SkPaint& paint, const PaintOptions& paintOptions, ClipType clipType, sk_sp clipShader, DrawTypeFlags dt, bool useSKPShader, bool /* verbose */) { GlobalCache* globalCache = precompileContext->priv().globalCache(); globalCache->resetGraphicsPipelines(); const skgpu::graphite::Caps* caps = context->priv().caps(); const SkColorType kColorType = kBGRA_8888_SkColorType; static const RenderPassProperties kDepth_Stencil_4 { DepthStencilFlags::kDepthStencil, kColorType, /* dstColorSpace= */ nullptr, /* requiresMSAA= */ true }; static const RenderPassProperties kDepth_1 { DepthStencilFlags::kDepth, kColorType, /* dstColorSpace= */ nullptr, /* requiresMSAA= */ false }; TextureInfo textureInfo = caps->getDefaultSampledTextureInfo(kColorType, skgpu::Mipmapped::kNo, skgpu::Protected::kNo, skgpu::Renderable::kYes); const bool msaaSupported = caps->getCompatibleMSAASampleCount(textureInfo) > SampleCount::k1; bool vello = false; #ifdef SK_ENABLE_VELLO_SHADERS vello = caps->computeSupport(); #endif // Using Vello skips using MSAA for complex paths. Additionally, Intel Macs avoid MSAA // in favor of path rendering. const RenderPassProperties* pathProperties = (msaaSupported && !vello) ? &kDepth_Stencil_4 : &kDepth_1; DrawTypeFlags combinedDrawType = dt; if (clipType == ClipType::kAnalytic || clipType == ClipType::kAnalyticAndShader) { combinedDrawType = static_cast( static_cast(dt) | static_cast(DrawTypeFlags::kAnalyticClip)); } int before = globalCache->numGraphicsPipelines(); Precompile(precompileContext, paintOptions, combinedDrawType, dt == DrawTypeFlags::kNonSimpleShape ? SkSpan(pathProperties, 1) : SkSpan(&kDepth_1, 1)); if (useSKPShader) { // The skp draws a rect w/ a default SkPaint and RGBA dst color type PaintOptions skpPaintOptions; Precompile(precompileContext, skpPaintOptions, DrawTypeFlags::kNonAAFillRect, {{ { kDepth_1.fDSFlags, kRGBA_8888_SkColorType, kDepth_1.fDstCS, kDepth_1.fRequiresMSAA } }}); } int after = globalCache->numGraphicsPipelines(); REPORTER_ASSERT(reporter, before == 0); REPORTER_ASSERT(reporter, after > before); check_draw(reporter, context, precompileContext, testContext, recorder, paint, dt, clipType, clipShader); } void run_test(skiatest::Reporter* reporter, Context* context, DrawContext* drawContext, PrecompileContext* precompileContext, skiatest::graphite::GraphiteTestContext* testContext, const KeyContext& precompileKeyContext, ShaderType s, BlenderType bm, ColorFilterType cf, MaskFilterType mf, ImageFilterType imageFilter, ClipType clipType, DrawTypeFlags dt, uint32_t seed, bool verbose) { SkRandom rand(seed); std::unique_ptr recorder = context->makeRecorder(); sk_sp clipShader; sk_sp clipShaderOption; if (clipType == ClipType::kShader || clipType == ClipType::kShader_Diff || clipType == ClipType::kAnalyticAndShader) { std::tie(clipShader, clipShaderOption) = CreateClipShader(&rand, recorder.get()); SkASSERT(!clipShader == !clipShaderOption); } bool reqSKP = false; auto [paint, paintOptions] = CreateRandomPaint(&rand, recorder.get(), s, bm, cf, mf, imageFilter, &reqSKP); // The PaintOptions' clipShader can be handled here while the SkPaint's clipShader handling // must be performed later (in paintParams.toKey() or when an SkCanvas is accessible for // a SkCanvas::clipShader call). paintOptions.priv().setClipShaders({{clipShaderOption}}); extract_vs_build_subtest(reporter, context, drawContext, testContext, precompileKeyContext, recorder.get(), paint, paintOptions, s, bm, cf, mf, imageFilter, clipType, clipShader, dt, seed, &rand, verbose); precompile_vs_real_draws_subtest(reporter, context, precompileContext, testContext, recorder.get(), paint, paintOptions, clipType, clipShader, dt, reqSKP, verbose); } } // anonymous namespace DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS(PaintParamsKeyTestReduced, reporter, context, testContext, true, CtsEnforcement::kNever) { const skgpu::graphite::Caps* caps = context->priv().caps(); std::unique_ptr precompileContext = context->makePrecompileContext(); // Currently, we just use this as a valid parameter for keyContext (will hit asserts otherwise) sk_sp precompileDrawContext = get_precompile_draw_context(caps, context); FloatStorageManager floatStorageManager; ShaderCodeDictionary* dict = context->priv().shaderCodeDictionary(); PaintParamsKeyBuilder builder(dict); PipelineDataGatherer gatherer(Layout::kMetal); sk_sp rtDict = sk_make_sp(); KeyContext keyContext(caps, &floatStorageManager, &builder, &gatherer, dict, rtDict, SkColorInfo(kRGBA_8888_SkColorType, kPremul_SkAlphaType, SkColorSpace::MakeSRGB())); #if 1 //---------------------- uint32_t seed = std::time(nullptr) % std::numeric_limits::max(); SkRandom rand(seed); ShaderType shaderType = static_cast(rand.nextULessThan(static_cast(ShaderType::kLast) + 1)); BlenderType blenderType = static_cast(rand.nextULessThan(static_cast(BlenderType::kLast) + 1)); ColorFilterType colorFilterType = static_cast( rand.nextULessThan(static_cast(ColorFilterType::kLast) + 1)); MaskFilterType maskFilterType = MaskFilterType::kNone; if (rand.nextBool()) { maskFilterType = static_cast( rand.nextULessThan(static_cast(MaskFilterType::kLast) + 1)); } ImageFilterType imageFilterType = ImageFilterType::kNone; // random_imagefiltertype(&rand); ClipType clipType = ClipType::kNone; if (rand.nextBool()) { clipType = static_cast(rand.nextULessThan(static_cast(ClipType::kLast) + 1)); } DrawTypeFlags drawTypeFlags = RandomDrawType(&rand); //---------------------- #else //------------------------ uint32_t seed = 0; ShaderType shaderType = ShaderType::kYUVImage; BlenderType blenderType = BlenderType::kPorterDuff; ColorFilterType colorFilterType = ColorFilterType::kNone; MaskFilterType maskFilterType = MaskFilterType::kNone; ImageFilterType imageFilterType = ImageFilterType::kNone; ClipType clipType = ClipType::kNone; DrawTypeFlags drawTypeFlags = DrawTypeFlags::kBitmapText_Mask; //----------------------- #endif SkString logMsg("Running "); logMsg += BackendApiToStr(context->backend()); log_run(logMsg.c_str(), seed, shaderType, blenderType, colorFilterType, maskFilterType, imageFilterType, clipType, drawTypeFlags); run_test(reporter, context, precompileDrawContext.get(), precompileContext.get(), testContext, keyContext, shaderType, blenderType, colorFilterType, maskFilterType, imageFilterType, clipType, drawTypeFlags, seed, /* verbose= */ true); } // This is intended to be a smoke test for the agreement between the two ways of creating a // PaintParamsKey: // via paintParams.toKey() (i.e., from an SkPaint) // and via the pre-compilation system // // TODO: keep this as a smoke test but add a fuzzer that reuses all the helpers // TODO(b/306174708): enable in SkQP (if it's feasible) DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS(PaintParamsKeyTest, reporter, context, testContext, true, CtsEnforcement::kNever) { const skgpu::graphite::Caps* caps = context->priv().caps(); std::unique_ptr precompileContext = context->makePrecompileContext(); // Currently, we just use this as a valid parameter for keyContext (will hit asserts otherwise) sk_sp precompileDrawContext = get_precompile_draw_context(caps, context); FloatStorageManager floatStorageManager; ShaderCodeDictionary* dict = context->priv().shaderCodeDictionary(); PaintParamsKeyBuilder builder(dict); PipelineDataGatherer gatherer(Layout::kMetal); sk_sp rtDict = sk_make_sp(); KeyContext precompileKeyContext(caps, &floatStorageManager, &builder, &gatherer, dict, rtDict, SkColorInfo(kRGBA_8888_SkColorType, kPremul_SkAlphaType, SkColorSpace::MakeSRGB())); ShaderType shaders[] = { ShaderType::kImage, ShaderType::kRadialGradient, ShaderType::kSolidColor, ShaderType::kYUVImage, #if EXPANDED_SET ShaderType::kNone, ShaderType::kBlend, ShaderType::kColorFilter, ShaderType::kCoordClamp, ShaderType::kConicalGradient, ShaderType::kLinearGradient, ShaderType::kLocalMatrix, ShaderType::kPerlinNoise, ShaderType::kPicture, ShaderType::kRuntime, ShaderType::kSweepGradient, ShaderType::kWorkingColorSpace, #endif }; BlenderType blenders[] = { BlenderType::kPorterDuff, BlenderType::kShaderBased, BlenderType::kRuntime, #if EXPANDED_SET BlenderType::kNone, BlenderType::kArithmetic, #endif }; ColorFilterType colorFilters[] = { ColorFilterType::kBlendMode, ColorFilterType::kMatrix, #if EXPANDED_SET ColorFilterType::kNone, ColorFilterType::kColorSpaceXform, ColorFilterType::kCompose, ColorFilterType::kGaussian, ColorFilterType::kHighContrast, ColorFilterType::kHSLAMatrix, ColorFilterType::kLerp, ColorFilterType::kLighting, ColorFilterType::kLinearToSRGB, ColorFilterType::kLuma, ColorFilterType::kOverdraw, ColorFilterType::kRuntime, ColorFilterType::kSRGBToLinear, ColorFilterType::kTable, ColorFilterType::kWorkingFormat, #endif }; MaskFilterType maskFilters[] = { MaskFilterType::kNone, #if EXPANDED_SET MaskFilterType::kBlur, #endif }; ImageFilterType imageFilters[] = { ImageFilterType::kNone, #if EXPANDED_SET ImageFilterType::kArithmetic, ImageFilterType::kBlendMode, ImageFilterType::kRuntimeBlender, ImageFilterType::kBlur, ImageFilterType::kColorFilter, ImageFilterType::kDisplacement, ImageFilterType::kLighting, ImageFilterType::kMatrixConvolution, ImageFilterType::kMorphology, #endif }; ClipType clips[] = { ClipType::kNone, ClipType::kAnalytic, #if EXPANDED_SET ClipType::kShader, // w/ a SkClipOp::kIntersect ClipType::kShader_Diff, // w/ a SkClipOp::kDifference ClipType::kAnalyticAndShader, // w/ a SkClipOp::kIntersect #endif }; static const DrawTypeFlags kDrawTypeFlags[] = { DrawTypeFlags::kBitmapText_Mask, DrawTypeFlags::kBitmapText_LCD, DrawTypeFlags::kBitmapText_Color, DrawTypeFlags::kSDFText, DrawTypeFlags::kSDFText_LCD, DrawTypeFlags::kDrawVertices, DrawTypeFlags::kCircularArc, DrawTypeFlags::kAnalyticRRect, DrawTypeFlags::kPerEdgeAAQuad, DrawTypeFlags::kNonAAFillRect, DrawTypeFlags::kNonSimpleShape, }; #if EXPANDED_SET size_t kExpected = std::size(shaders) * std::size(blenders) * std::size(colorFilters) * std::size(maskFilters) * std::size(imageFilters) * std::size(clips) * std::size(kDrawTypeFlags); int current = 0; #endif for (auto shader : shaders) { for (auto blender : blenders) { for (auto cf : colorFilters) { for (auto mf : maskFilters) { for (auto imageFilter : imageFilters) { for (auto clip : clips) { for (DrawTypeFlags dt : kDrawTypeFlags) { #if EXPANDED_SET SkDebugf("%d/%zu\n", current, kExpected); ++current; #endif run_test(reporter, context, precompileDrawContext.get(), precompileContext.get(), testContext, precompileKeyContext, shader, blender, cf, mf, imageFilter, clip, dt, kDefaultSeed, /* verbose= */ false); } } } } } } } #if EXPANDED_SET SkASSERT(current == (int) kExpected); #endif } #endif // SK_GRAPHITE