#include "dm/DMJsonWriter.h"
#include "dm/DMSrcSink.h"
#include "include/codec/SkCodec.h"
#include "include/codec/SkEncodedImageFormat.h"
#include "include/core/SkBBHFactory.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
#include "include/core/SkDocument.h"
#include "include/core/SkGraphics.h"
#include "src/base/SkHalf.h"
#include "src/base/SkLeanWindows.h"
#include "src/base/SkNoDestructor.h"
#include "src/base/SkSpinlock.h"
#include "src/base/SkTime.h"
#include "src/base/SkVx.h"
#include "src/core/SkChecksum.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkMD5.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkStringUtils.h"
#include "src/core/SkTHash.h"
#include "src/core/SkTaskGroup.h"
#include "src/utils/SkOSPath.h"
#include "tests/Test.h"
#include "tests/TestHarness.h"
#include "tools/AutoreleasePool.h"
#include "tools/CodecUtils.h"
#include "tools/HashAndEncode.h"
#include "tools/ProcStats.h"
#include "tools/Resources.h"
#include "tools/TestFontDataProvider.h"
#include "tools/ToolUtils.h"
#include "tools/flags/CommonFlags.h"
#include "tools/flags/CommonFlagsConfig.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/ios_utils.h"
#include "tools/trace/ChromeTracingTracer.h"
#include "tools/trace/EventTracingPriv.h"
#include "tools/trace/SkDebugfTracer.h"
#include <memory>
#include <vector>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <execinfo.h>

Classes
struct	Running

struct	Gold

struct	Gold::Hash

struct	TaggedSrc

struct	TaggedSink

struct	Task

struct	DMReporter

Macros
#define	SINK(t, sink, ...) if (config->getBackend().equals(t)) return new sink(__VA_ARGS__)

#define	VIA(t, via, ...) if (tag.equals(t)) return new via(__VA_ARGS__)

Functions
static	DEFINE_string (src, "tests gm skp mskp lottie rive svg image colorImage", "Source types to test.")

static	DEFINE_bool (nameByHash, false, "If true, write to FLAGS_writePath[0]/<hash>.png instead of " "to FLAGS_writePath[0]/<config>/<sourceType>/<sourceOptions>/<name>.png")

static	DEFINE_bool2 (pathOpsExtended, x, false, "Run extended pathOps tests.")

static	DEFINE_string (matrix, "1 0 0 1", "2x2 scale+skew matrix to apply or upright when using " "'matrix' or 'upright' in config.")

static	DEFINE_string (skip, "", "Space-separated config/src/srcOptions/name quadruples to skip. " "'_' matches anything. '~' negates the match. E.g. \n" "'--skip gpu skp _ _' will skip all SKPs drawn into the gpu config.\n" "'--skip gpu skp _ _ 8888 gm _ aarects' will also skip the aarects GM on 8888.\n" "'--skip ~8888 svg _ svgparse_' blocks non-8888 SVGs that contain \"svgparse_\" in " "the name.")

static	DEFINE_string2 (readPath, r, "", "If set check for equality with golden results in this directory.")

	DEFINE_string2 (writePath, w, "", "If set, write bitmaps here as .pngs.")

static	DEFINE_string (uninterestingHashesFile, "", "File containing a list of uninteresting hashes. If a result hashes to something in " "this list, no image is written for that result.")

static	DEFINE_int (shards, 1, "We're splitting source data into this many shards.")

static	DEFINE_int (shard, 0, "Which shard do I run?")

static	DEFINE_string (mskps, "", "Directory to read mskps from, or a single mskp file.")

static	DEFINE_bool (forceRasterPipeline, false, "sets gSkForceRasterPipelineBlitter")

static	DEFINE_bool (forceRasterPipelineHP, false, "sets gSkForceRasterPipelineBlitter and gForceHighPrecisionRasterPipeline")

static	DEFINE_bool (createProtected, false, "attempts to create a protected backend context")

static	DEFINE_string (bisect, "", "Pair of: SKP file to bisect, followed by an l/r bisect trail string (e.g., 'lrll'). The " "l/r trail specifies which half to keep at each step of a binary search through the SKP's " "paths. An empty string performs no bisect. Only the SkPaths are bisected; all other draws " "are thrown out. This is useful for finding a reduced repo case for path drawing bugs.")

static	DEFINE_bool (ignoreSigInt, false, "ignore SIGINT signals during test execution")

static	DEFINE_bool (checkF16, false, "Ensure that F16Norm pixels are clamped.")

static	DEFINE_string (colorImages, "", "List of images and/or directories to decode with color correction. " "A directory with no images is treated as a fatal error.")

static	DEFINE_bool2 (veryVerbose, V, false, "tell individual tests to be verbose.")

static	DEFINE_bool (cpu, true, "Run CPU-bound work?")

static	DEFINE_bool (gpu, true, "Run GPU-bound work?")

static	DEFINE_bool (graphite, true, "Run Graphite work?")

static	DEFINE_bool (neverYieldToWebGPU, false, "Run Graphite with never-yield context option.")

static	DEFINE_bool (dryRun, false, "just print the tests that would be run, without actually running them.")

static	DEFINE_string (images, "", "List of images and/or directories to decode. A directory with no images" " is treated as a fatal error.")

static	DEFINE_bool (simpleCodec, false, "Runs of a subset of the codec tests, " "with no scaling or subsetting, always using the canvas color type.")

static	DEFINE_string2 (match, m, nullptr, "[~][^]substring[$] [...] of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list entry,\n" "it is skipped unless some list entry starts with ~")

static	DEFINE_bool2 (quiet, q, false, "if true, don't print status updates.")

static	DEFINE_bool2 (verbose, v, false, "enable verbose output from the test driver.")

static	DEFINE_string (skps, "skps", "Directory to read skps from.")

static	DEFINE_string (lotties, "lotties", "Directory to read (Bodymovin) jsons from.")

static	DEFINE_string (svgs, "", "Directory to read SVGs from, or a single SVG file.")

static	DEFINE_int_2 (threads, j, -1, "Run threadsafe tests on a threadpool with this many extra threads, " "defaulting to one extra thread per core.")

static	DEFINE_string (key, "", "Space-separated key/value pairs to add to JSON identifying this builder.")

static	DEFINE_string (properties, "", "Space-separated key/value pairs to add to JSON identifying this run.")

static	DEFINE_bool (rasterize_pdf, false, "Rasterize PDFs when possible.")

static void	vlog (const char *fmt,...) SK_PRINTF_LIKE(1

static void	info (const char *fmt,...) SK_PRINTF_LIKE(1

static void	fail (const SkString &err)

static void	dump_json ()

static void	done (const char config, const char src, const char srcOptions, const char name)

static void	start (const char config, const char src, const char srcOptions, const char name)

static void	find_culprit ()

static constexpr int	max_of ()

template<typename... Rest>
static constexpr int	max_of (int x, Rest... rest)

static void	crash_handler (int sig)

static void	setup_crash_handler ()

static void	add_gold (JsonWriter::BitmapResult r)

static void	gather_gold ()

static void	gather_uninteresting_hashes ()

static bool	in_shard ()

static void	push_src (const char tag, ImplicitString options, Src inSrc)

static void	push_codec_src (Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType, float scale)

static void	push_android_codec_src (Path path, CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType, int sampleSize)

static void	push_image_gen_src (Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu)

static void	push_codec_srcs (Path path)

template<typename T >
void	gather_file_srcs (const CommandLineFlags::StringArray &flags, const char ext, const char src_name=nullptr)

static bool	gather_srcs ()

static void	push_sink (const SkCommandLineConfig &config, Sink *s)

static Sink *	create_sink (const GrContextOptions &grCtxOptions, const SkCommandLineConfig *config)

static Sink *	create_via (const SkString &tag, Sink *wrapped)

static bool	gather_sinks (const GrContextOptions &grCtxOptions, bool defaultConfigs)

static bool	match (const char needle, const char haystack)

static bool	should_skip (const char sink, const char src, const char srcOptions, const char name)

static void	gather_tests ()

static void	run_cpu_test (skiatest::Test test)

static void	run_ganesh_test (skiatest::Test test, const GrContextOptions &grCtxOptions)

static void	run_graphite_test (skiatest::Test test, skiatest::graphite::TestOptions &options)

TestHarness	CurrentTestHarness ()

int	main (int argc, char **argv)

Variables
bool	gSkForceRasterPipelineBlitter

bool	gForceHighPrecisionRasterPipeline

bool	gCreateProtectedContext

static FILE *	gVLog

static TArray< SkString > *	gFailures = new TArray<SkString>

static SkSpinlock	gMutex

static int	gPending

static int	gTotalCounts

static double	gLastUpdate

static SkNoDestructor< TArray< Running > >	gRunning

static void(*	previous_handler [max_of(SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTERM)+1])(int)

static THashSet< Gold, Gold::Hash > *	gGold = new THashSet<Gold, Gold::Hash>

static constexpr char	kNewline [] = "\n"

static THashSet< SkString > *	gUninterestingHashes = new THashSet<SkString>

static constexpr bool	kMemcpyOK = true

static TArray< TaggedSrc, kMemcpyOK > *	gSrcs = new TArray<TaggedSrc, kMemcpyOK>

static TArray< TaggedSink, kMemcpyOK > *	gSinks = new TArray<TaggedSink, kMemcpyOK>

static SkTaskGroup *	gDefinitelyThreadSafeWork = new SkTaskGroup

static SkTDArray< skiatest::Test > *	gCPUTests = new SkTDArray<skiatest::Test>

static SkTDArray< skiatest::Test > *	gCPUSerialTests = new SkTDArray<skiatest::Test>

static SkTDArray< skiatest::Test > *	gGaneshTests = new SkTDArray<skiatest::Test>

static SkTDArray< skiatest::Test > *	gGraphiteTests = new SkTDArray<skiatest::Test>

Macro Definition Documentation

◆ SINK

#define SINK	(	t,
		sink,
		...
	)	if (config->getBackend().equals(t)) return new sink(__VA_ARGS__)

◆ VIA

#define VIA	(	t,
		via,
		...
	)	if (tag.equals(t)) return new via(__VA_ARGS__)

Function Documentation

◆ add_gold()

static void add_gold ( JsonWriter::BitmapResult r )

static

Definition at line 445 of file DM.cpp.

                                               {
    gGold->add(Gold(r.config, r.sourceType, r.sourceOptions, r.name, r.md5));
}

◆ crash_handler()

static void crash_handler ( int sig )

static

Definition at line 383 of file DM.cpp.

                                       {
        SkAutoSpinlock lock(gMutex);
 
        info("\nCaught signal %d [%s] (%dMB RAM, peak %dMB), was running:\n",
             sig, strsignal(sig),
             sk_tools::getCurrResidentSetSizeMB(), sk_tools::getMaxResidentSetSizeMB());
 
        for (auto& task : *gRunning) {
            task.dump();
        }
        find_culprit();
 
    #if !defined(SK_BUILD_FOR_ANDROID)
        void* stack[128];
        int count = backtrace(stack, std::size(stack));
        char** symbols = backtrace_symbols(stack, count);
        info("\nStack trace:\n");
        for (int i = 0; i < count; i++) {
            info("    %s\n", symbols[i]);
        }
    #endif
        fflush(stdout);
 
        if (sig == SIGINT && FLAGS_ignoreSigInt) {
            info("Ignoring signal %d because of --ignoreSigInt.\n"
                 "This is probably a sign the bot is overloaded with work.\n", sig);
        } else {
            signal(sig, previous_handler[sig]);
            raise(sig);
        }
    }

◆ create_sink()

static Sink * create_sink	(	const GrContextOptions &	grCtxOptions,
		const SkCommandLineConfig *	config
	)

static

Definition at line 979 of file DM.cpp.

                                                                                                  {
    if (FLAGS_gpu) {
        if (const SkCommandLineConfigGpu* gpuConfig = config->asConfigGpu()) {
            GrContextFactory testFactory(grCtxOptions);
            if (!testFactory.get(gpuConfig->getContextType(), gpuConfig->getContextOverrides())) {
                info("WARNING: can not create GPU context for config '%s'. "
                     "GM tests will be skipped.\n", gpuConfig->getTag().c_str());
                return nullptr;
            }
            if (gpuConfig->getTestPersistentCache()) {
                return new GPUPersistentCacheTestingSink(gpuConfig, grCtxOptions);
            } else if (gpuConfig->getTestPrecompile()) {
                return new GPUPrecompileTestingSink(gpuConfig, grCtxOptions);
            } else if (gpuConfig->getUseDDLSink()) {
                return new GPUDDLSink(gpuConfig, grCtxOptions);
            } else if (gpuConfig->getSlug()) {
                return new GPUSlugSink(gpuConfig, grCtxOptions);
            } else if (gpuConfig->getSerializedSlug()) {
                return new GPUSerializeSlugSink(gpuConfig, grCtxOptions);
            } else if (gpuConfig->getRemoteSlug()) {
                return new GPURemoteSlugSink(gpuConfig, grCtxOptions);
            } else {
                return new GPUSink(gpuConfig, grCtxOptions);
            }
        }
    }
#if defined(SK_GRAPHITE)
    if (FLAGS_graphite) {
        if (const SkCommandLineConfigGraphite *graphiteConfig = config->asConfigGraphite()) {
#if defined(SK_ENABLE_PRECOMPILE)
            if (graphiteConfig->getTestPrecompile()) {
                return new GraphitePrecompileTestingSink(graphiteConfig);
            } else
#endif // SK_ENABLE_PRECOMPILE
            {
                return new GraphiteSink(graphiteConfig);
            }
        }
    }
#endif // SK_GRAPHITE
    if (const SkCommandLineConfigSvg* svgConfig = config->asConfigSvg()) {
        int pageIndex = svgConfig->getPageIndex();
        return new SVGSink(pageIndex);
    }
 
#define SINK(t, sink, ...) if (config->getBackend().equals(t)) return new sink(__VA_ARGS__)
 
    if (FLAGS_cpu) {
        SINK("r8",          RasterSink, kR8_unorm_SkColorType);
        SINK("565",         RasterSink, kRGB_565_SkColorType);
        SINK("4444",        RasterSink, kARGB_4444_SkColorType);
        SINK("8888",        RasterSink, kN32_SkColorType);
        SINK("rgba",        RasterSink, kRGBA_8888_SkColorType);
        SINK("bgra",        RasterSink, kBGRA_8888_SkColorType);
        SINK("rgbx",        RasterSink, kRGB_888x_SkColorType);
        SINK("1010102",     RasterSink, kRGBA_1010102_SkColorType);
        SINK("101010x",     RasterSink, kRGB_101010x_SkColorType);
        SINK("bgra1010102", RasterSink, kBGRA_1010102_SkColorType);
        SINK("bgr101010x",  RasterSink, kBGR_101010x_SkColorType);
        SINK("f16",         RasterSink, kRGBA_F16_SkColorType);
        SINK("f16norm",     RasterSink, kRGBA_F16Norm_SkColorType);
        SINK("f32",         RasterSink, kRGBA_F32_SkColorType);
        SINK("srgba",       RasterSink, kSRGBA_8888_SkColorType);
 
        SINK("pdf",         PDFSink, false, SK_ScalarDefaultRasterDPI);
        SINK("skp",         SKPSink);
        SINK("svg",         SVGSink);
        SINK("null",        NullSink);
        SINK("xps",         XPSSink);
        SINK("pdfa",        PDFSink, true,  SK_ScalarDefaultRasterDPI);
        SINK("pdf300",      PDFSink, false, 300);
        SINK("jsdebug",     DebugSink);
    }
#undef SINK
    return nullptr;
}

◆ create_via()

static Sink * create_via	(	const SkString &	tag,
		Sink *	wrapped
	)

static

Definition at line 1056 of file DM.cpp.

                                                            {
#define VIA(t, via, ...) if (tag.equals(t)) return new via(__VA_ARGS__)
#ifdef TEST_VIA_SVG
    VIA("svg",       ViaSVG,               wrapped);
#endif
    VIA("serialize", ViaSerialization,     wrapped);
    VIA("pic",       ViaPicture,           wrapped);
    VIA("rtblend",   ViaRuntimeBlend,      wrapped);
 
    if (FLAGS_matrix.size() == 4) {
        SkMatrix m;
        m.reset();
        m.setScaleX((SkScalar)atof(FLAGS_matrix[0]));
        m.setSkewX ((SkScalar)atof(FLAGS_matrix[1]));
        m.setSkewY ((SkScalar)atof(FLAGS_matrix[2]));
        m.setScaleY((SkScalar)atof(FLAGS_matrix[3]));
        VIA("matrix",  ViaMatrix,  m, wrapped);
        VIA("upright", ViaUpright, m, wrapped);
    }
 
#undef VIA
 
    return nullptr;
}

◆ CurrentTestHarness()

TestHarness CurrentTestHarness ( )

Definition at line 1547 of file DM.cpp.

                                 {
    return TestHarness::kDM;
}

◆ DEFINE_bool() [1/13]

static DEFINE_bool	(	checkF16	,
		false	,
		"Ensure that F16Norm pixels are clamped."
	)

static

◆ DEFINE_bool() [2/13]

static DEFINE_bool	(	cpu	,
		true	,
		"Run CPU-bound work?"
	)

static

◆ DEFINE_bool() [3/13]

static DEFINE_bool	(	createProtected	,
		false	,
		"attempts to create a protected backend context"
	)

static

◆ DEFINE_bool() [4/13]

static DEFINE_bool	(	dryRun	,
		false	,
		"just print the tests that would be	run,
		without actually running them."
	)

static

◆ DEFINE_bool() [5/13]

static DEFINE_bool	(	forceRasterPipeline	,
		false	,
		"sets gSkForceRasterPipelineBlitter"
	)

static

◆ DEFINE_bool() [6/13]

static DEFINE_bool	(	forceRasterPipelineHP	,
		false	,
		"sets gSkForceRasterPipelineBlitter and gForceHighPrecisionRasterPipeline"
	)

static

◆ DEFINE_bool() [7/13]

static DEFINE_bool	(	gpu	,
		true	,
		"Run GPU-bound work?"
	)

static

◆ DEFINE_bool() [8/13]

static DEFINE_bool	(	graphite	,
		true	,
		"Run Graphite work?"
	)

static

◆ DEFINE_bool() [9/13]

static DEFINE_bool	(	ignoreSigInt	,
		false	,
		"ignore SIGINT signals during test execution"
	)

static

◆ DEFINE_bool() [10/13]

static DEFINE_bool	(	nameByHash	,
		false	,
		"If	true,
		write to FLAGS_writePath/< hash >.png instead of " "to FLAGS_writePath/< config >/< sourceType >/< sourceOptions >/< name >.png"	[0][0]
	)

static

◆ DEFINE_bool() [11/13]

static DEFINE_bool	(	neverYieldToWebGPU	,
		false	,
		"Run Graphite with never-yield context option."
	)

static

◆ DEFINE_bool() [12/13]

static DEFINE_bool	(	rasterize_pdf	,
		false	,
		"Rasterize PDFs when possible."
	)

static

◆ DEFINE_bool() [13/13]

static DEFINE_bool	(	simpleCodec	,
		false	,
		"Runs of a subset of the codec	tests,
		" "with no scaling or	subsetting,
		always using the canvas color type."
	)

static

◆ DEFINE_bool2() [1/4]

static DEFINE_bool2	(	pathOpsExtended	,
		x	,
		false	,
		"Run extended pathOps tests."
	)

static

◆ DEFINE_bool2() [2/4]

static DEFINE_bool2	(	quiet	,
		q	,
		false	,
		"if	true,
		don 't print status updates."
	)

static

◆ DEFINE_bool2() [3/4]

static DEFINE_bool2	(	verbose	,
		v	,
		false	,
		"enable verbose output from the test driver."
	)

static

◆ DEFINE_bool2() [4/4]

static DEFINE_bool2	(	veryVerbose	,
		V	,
		false	,
		"tell individual tests to be verbose."
	)

static

◆ DEFINE_int() [1/2]

static DEFINE_int	(	shard	,
		0	,
		"Which shard do I run?"
	)

static

◆ DEFINE_int() [2/2]

static DEFINE_int	(	shards	,
		1	,
		"We're splitting source data into this many shards."
	)

static

◆ DEFINE_int_2()

static DEFINE_int_2	(	threads	,
		j	,
		-	1,
		"Run threadsafe tests on a threadpool with this many extra	threads,
		" "defaulting to one extra thread per core."
	)

static

◆ DEFINE_string() [1/13]

static DEFINE_string	(	bisect	,
		""	,
		"Pair of: SKP file to	bisect,
		followed by an l/r bisect trail string(e.g., 'lrll'). The " "l/r trail specifies which half to keep at each step of a binary search through the SKP 's " "paths. An empty string performs no bisect. Only the SkPaths are bisected;all other draws " "are thrown out. This is useful for finding a reduced repo case for path drawing bugs."
	)

static

◆ DEFINE_string() [2/13]

static DEFINE_string	(	colorImages	,
		""	,
		"List of images and/or directories to decode with color correction. " "A directory with no images is treated as a fatal error."
	)

static

◆ DEFINE_string() [3/13]

static DEFINE_string	(	images	,
		""	,
		"List of images and/or directories to decode. A directory with no images" " is treated as a fatal error."
	)

static

◆ DEFINE_string() [4/13]

static DEFINE_string	(	key	,
		""	,
		"Space-separated key/value pairs to add to JSON identifying this builder."
	)

static

◆ DEFINE_string() [5/13]

static DEFINE_string	(	lotties	,
		"lotties"	,
		"Directory to read (Bodymovin) jsons from."
	)

static

◆ DEFINE_string() [6/13]

static DEFINE_string	(	matrix	,
		"1 0 0 1"	,
		"2x2 scale+skew matrix to apply or upright when using " "'matrix' or 'upright' in config."
	)

static

◆ DEFINE_string() [7/13]

static DEFINE_string	(	mskps	,
		""	,
		"Directory to read mskps	from,
		or a single mskp file."
	)

static

◆ DEFINE_string() [8/13]

static DEFINE_string	(	properties	,
		""	,
		"Space-separated key/value pairs to add to JSON identifying this run."
	)

static

◆ DEFINE_string() [9/13]

static DEFINE_string	(	skip	,
		""	,
		"Space-separated config/src/srcOptions/name quadruples to skip. " "'_' matches anything. '~' negates the match. E.g. \n" "'--skip gpu skp _ _' will skip all SKPs drawn into the gpu config.\n" "'--skip gpu skp _ _ 8888 gm _ aarects' will also skip the aarects GM on 8888.\n" "'--skip ~8888 svg _ svgparse_' blocks non-8888 SVGs that contain \"svgparse_\" in " "the name."
	)

static

◆ DEFINE_string() [10/13]

static DEFINE_string	(	skps	,
		"skps"	,
		"Directory to read skps from."
	)

static

◆ DEFINE_string() [11/13]

static DEFINE_string	(	src	,
		"tests gm skp mskp lottie rive svg image colorImage"	,
		"Source types to test."
	)

static

◆ DEFINE_string() [12/13]

static DEFINE_string	(	svgs	,
		""	,
		"Directory to read SVGs	from,
		or a single SVG file."
	)

static

◆ DEFINE_string() [13/13]

static DEFINE_string	(	uninterestingHashesFile	,
		""	,
		"File containing a list of uninteresting hashes. If a result hashes to something in " "this	list,
		no image is written for that result."
	)

static

◆ DEFINE_string2() [1/3]

static DEFINE_string2	(	match	,
		m	,
		nullptr	,
		"substring of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list	entry[~][^][$][...],
		\n" "it is skipped unless some list entry starts with ~"
	)

static

◆ DEFINE_string2() [2/3]

static DEFINE_string2	(	readPath	,
		r	,
		""	,
		"If set check for equality with golden results in this directory."
	)

static

◆ DEFINE_string2() [3/3]

DEFINE_string2	(	writePath	,
		w	,
		""	,
		"If	set,
		write bitmaps here as .pngs."
	)

◆ done()

static void done	(	const char *	config,
		const char *	src,
		const char *	srcOptions,
		const char *	name
	)

static

Definition at line 263 of file DM.cpp.

                                                                                                {
    SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
    bool updateDueToProgress;
    double lastUpdate;
    int totalCounts;
    int pending;
    {
        SkAutoSpinlock lock(gMutex);
        for (int i = 0; i < gRunning->size(); i++) {
            if (gRunning->at(i).id == id) {
                gRunning->removeShuffle(i);
                break;
            }
        }
        --gPending;
        updateDueToProgress = gPending % 500 == 0;
        lastUpdate = gLastUpdate;
        totalCounts = gTotalCounts;
        pending = gPending;
    }
    vlog("[%d/%d] %s done\n", totalCounts - pending, totalCounts, id.c_str());
 
    // We write out dm.json file and print out a progress update every once in a while.
    // Notice this also handles the final dm.json and progress update when pending == 0.
    double now = SkTime::GetNSecs();
    bool updateDueToTime = now - lastUpdate > 4e9;
    if (updateDueToProgress || updateDueToTime) {
        dump_json();
 
        int curr = sk_tools::getCurrResidentSetSizeMB(),
            peak = sk_tools::getMaxResidentSetSizeMB();
 
        SkAutoSpinlock lock(gMutex);
 
        // Since multiple threads can call `done`, it's possible that another thread has raced with
        // this one and printed an update since we did our progress check above. We detect this case
        // by checking to see if `gLastUpdate` has changed; if so, we don't need to print anything.
        if (lastUpdate == gLastUpdate) {
            info("\n[%d/%d] %dMB RAM, %dMB peak, %d queued, %d threads:\n\t%s  done\n",
                 gTotalCounts - gPending, gTotalCounts,
                 curr, peak, gPending - gRunning->size(), gRunning->size() + 1, id.c_str());
            for (auto& task : *gRunning) {
                task.dump();
            }
            gLastUpdate = now;
        }
    }
}

◆ dump_json()

static void dump_json ( )

static

Definition at line 250 of file DM.cpp.

                        {
    if (!FLAGS_writePath.isEmpty()) {
        JsonWriter::DumpJson(FLAGS_writePath[0], FLAGS_key, FLAGS_properties);
    }
}

◆ fail()

static void fail ( const SkString & err )

static

Definition at line 234 of file DM.cpp.

                                      {
    static SkSpinlock mutex;
    SkAutoSpinlock lock(mutex);
    SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
    gFailures->push_back(err);
}

◆ find_culprit()

static void find_culprit ( )

static

Definition at line 319 of file DM.cpp.

                           {
    // Assumes gMutex is locked.
    SkThreadID thisThread = SkGetThreadID();
    for (auto& task : *gRunning) {
        if (task.thread == thisThread) {
            info("Likely culprit:\n");
            task.dump();
        }
    }
}

◆ gather_file_srcs()

template<typename T >

void gather_file_srcs	(	const CommandLineFlags::StringArray &	flags,
		const char *	ext,
		const char *	src_name = `nullptr`
	)

Definition at line 890 of file DM.cpp.

                                                                               {
    if (!src_name) {
        // With the exception of Lottie files, the source name is the extension.
        src_name = ext;
    }
 
    for (int i = 0; i < flags.size(); i++) {
        const char* path = flags[i];
        if (sk_isdir(path)) {
            SkOSFile::Iter it(path, ext);
            for (SkString file; it.next(&file); ) {
                push_src(src_name, "", new T(SkOSPath::Join(path, file.c_str())));
            }
        } else {
            push_src(src_name, "", new T(path));
        }
    }
}

◆ gather_gold()

static void gather_gold ( )

static

Definition at line 449 of file DM.cpp.

                          {
    if (!FLAGS_readPath.isEmpty()) {
        SkString path(FLAGS_readPath[0]);
        path.append("/dm.json");
        if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
            fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
        }
    }
}

◆ gather_sinks()

static bool gather_sinks	(	const GrContextOptions &	grCtxOptions,
		bool	defaultConfigs
	)

static

Definition at line 1081 of file DM.cpp.

                                                                                    {
    if (FLAGS_src.size() == 1 && FLAGS_src.contains("tests")) {
        // If we're just running tests skip trying to accumulate sinks. The 'justOneRect' test
        // can fail for protected contexts.
        return true;
    }
 
    SkCommandLineConfigArray configs;
    ParseConfigs(FLAGS_config, &configs);
    AutoreleasePool pool;
    for (int i = 0; i < configs.size(); i++) {
        const SkCommandLineConfig& config = *configs[i];
        Sink* sink = create_sink(grCtxOptions, &config);
        if (sink == nullptr) {
            info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
                 config.getTag().c_str());
            continue;
        }
 
        // The command line config already parsed out the via-style color space. Apply it here.
        sink->setColorSpace(config.refColorSpace());
 
        const TArray<SkString>& parts = config.getViaParts();
        for (int j = parts.size(); j-- > 0;) {
            const SkString& part = parts[j];
            Sink* next = create_via(part, sink);
            if (next == nullptr) {
                info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
                     part.c_str());
                delete sink;
                sink = nullptr;
                break;
            }
            sink = next;
        }
        if (sink) {
            push_sink(config, sink);
        }
    }
 
    // If no configs were requested (just running tests, perhaps?), then we're okay.
    if (configs.size() == 0 ||
        // If we're using the default configs, we're okay.
        defaultConfigs ||
        // Otherwise, make sure that all specified configs have become sinks.
        configs.size() == gSinks->size()) {
        return true;
    }
    return false;
}

◆ gather_srcs()

static bool gather_srcs ( )

static

Definition at line 911 of file DM.cpp.

                          {
    for (const skiagm::GMFactory& f : skiagm::GMRegistry::Range()) {
        push_src("gm", "", new GMSrc(f));
    }
 
    gather_file_srcs<SKPSrc>(FLAGS_skps, "skp");
    gather_file_srcs<MSKPSrc>(FLAGS_mskps, "mskp");
#if defined(SK_ENABLE_SKOTTIE)
    gather_file_srcs<SkottieSrc>(FLAGS_lotties, "json", "lottie");
#endif
#if defined(SK_ENABLE_SVG)
    gather_file_srcs<SVGSrc>(FLAGS_svgs, "svg");
#endif
    if (!FLAGS_bisect.isEmpty()) {
        // An empty l/r trail string will draw all the paths.
        push_src("bisect", "",
                 new BisectSrc(FLAGS_bisect[0], FLAGS_bisect.size() > 1 ? FLAGS_bisect[1] : ""));
    }
 
    TArray<SkString> images;
    if (!CommonFlags::CollectImages(FLAGS_images, &images)) {
        return false;
    }
 
    for (const SkString& image : images) {
        push_codec_srcs(image);
    }
 
    TArray<SkString> colorImages;
    if (!CommonFlags::CollectImages(FLAGS_colorImages, &colorImages)) {
        return false;
    }
 
    for (const SkString& colorImage : colorImages) {
        push_src("colorImage", "decode_native", new ColorCodecSrc(colorImage, false));
        push_src("colorImage", "decode_to_dst", new ColorCodecSrc(colorImage,  true));
    }
 
    return true;
}

◆ gather_tests()

static void gather_tests ( )

static

Definition at line 1475 of file DM.cpp.

                           {
    if (!FLAGS_src.contains("tests")) {
        return;
    }
    for (const skiatest::Test& test : skiatest::TestRegistry::Range()) {
        if (!in_shard()) {
            continue;
        }
        if (CommandLineFlags::ShouldSkip(FLAGS_match, test.fName)) {
            continue;
        }
        if (test.fTestType == TestType::kGanesh && FLAGS_gpu) {
            gGaneshTests->push_back(test);
        } else if (test.fTestType == TestType::kGraphite && FLAGS_graphite) {
            gGraphiteTests->push_back(test);
        } else if (test.fTestType == TestType::kCPU && FLAGS_cpu) {
            gCPUTests->push_back(test);
        } else if (test.fTestType == TestType::kCPUSerial && FLAGS_cpu) {
            gCPUSerialTests->push_back(test);
        }
    }
}

◆ gather_uninteresting_hashes()

static void gather_uninteresting_hashes ( )

static

Definition at line 469 of file DM.cpp.

                                          {
    if (!FLAGS_uninterestingHashesFile.isEmpty()) {
        sk_sp<SkData> data(SkData::MakeFromFileName(FLAGS_uninterestingHashesFile[0]));
        if (!data) {
            info("WARNING: unable to read uninteresting hashes from %s\n",
                 FLAGS_uninterestingHashesFile[0]);
            return;
        }
 
        // Copy to a string to make sure SkStrSplit has a terminating \0 to find.
        SkString contents((const char*)data->data(), data->size());
 
        TArray<SkString> hashes;
        SkStrSplit(contents.c_str(), kNewline, &hashes);
        for (const SkString& hash : hashes) {
            gUninterestingHashes->add(hash);
        }
        info("FYI: loaded %d distinct uninteresting hashes from %d lines\n",
             gUninterestingHashes->count(), hashes.size());
    }
}

◆ in_shard()

static bool in_shard ( )

static

Definition at line 507 of file DM.cpp.

                       {
    static int N = 0;
    return N++ % FLAGS_shards == FLAGS_shard;
}

◆ info()

static void static void info	(	const char *	fmt,
			...
	)

static

Definition at line 213 of file DM.cpp.

                                       {
    va_list args;
    va_start(args, fmt);
 
    if (gVLog) {
        va_list vlogArgs;
        va_copy(vlogArgs, args);
        vfprintf(gVLog, fmt, vlogArgs);
        fflush(gVLog);
        va_end(vlogArgs);
    }
 
    if (!FLAGS_quiet) {
        vprintf(fmt, args);
    }
 
    va_end(args);
}

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 1553 of file DM.cpp.

                                {
#if defined(__MSVC_RUNTIME_CHECKS)
    _RTC_SetErrorFunc(RuntimeCheckErrorFunc);
#endif
#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_HAS_HEIF_LIBRARY)
    android::ProcessState::self()->startThreadPool();
#endif
    CommandLineFlags::Parse(argc, argv);
 
    initializeEventTracingForTools();
 
#if !defined(SK_BUILD_FOR_GOOGLE3) && defined(SK_BUILD_FOR_IOS)
    cd_Documents();
#endif
    setbuf(stdout, nullptr);
    setup_crash_handler();
 
    skiatest::SetFontTestDataDirectory();
 
    gSkForceRasterPipelineBlitter     = FLAGS_forceRasterPipelineHP || FLAGS_forceRasterPipeline;
    gForceHighPrecisionRasterPipeline = FLAGS_forceRasterPipelineHP;
    gCreateProtectedContext           = FLAGS_createProtected;
 
    // The bots like having a verbose.log to upload, so always touch the file even if --verbose.
    if (!FLAGS_writePath.isEmpty()) {
        sk_mkdir(FLAGS_writePath[0]);
        gVLog = fopen(SkOSPath::Join(FLAGS_writePath[0], "verbose.log").c_str(), "w");
    }
    if (FLAGS_verbose) {
        gVLog = stderr;
    }
 
    skiatest::graphite::TestOptions graphiteOptions;
    if (FLAGS_neverYieldToWebGPU) {
        graphiteOptions.fNeverYieldToWebGPU = true;
    }
 
    GrContextOptions grCtxOptions;
    CommonFlags::SetCtxOptions(&grCtxOptions);
 
    dump_json();  // It's handy for the bots to assume this is ~never missing.
 
    SkGraphics::Init();
#if defined(SK_ENABLE_SVG)
    SkGraphics::SetOpenTypeSVGDecoderFactory(SkSVGOpenTypeSVGDecoder::Make);
#endif
    SkTaskGroup::Enabler enabled(FLAGS_threads);
    CodecUtils::RegisterAllAvailable();
 
    if (nullptr == GetResourceAsData("images/color_wheel.png")) {
        info("Some resources are missing.  Do you need to set --resourcePath?\n");
    }
    gather_gold();
    gather_uninteresting_hashes();
 
    if (!gather_srcs()) {
        return 1;
    }
    bool defaultConfigs = true;
    for (int i = 0; i < argc; i++) {
        if (strcmp(argv[i], "--config") == 0) {
            defaultConfigs = false;
            break;
        }
    }
    if (!gather_sinks(grCtxOptions, defaultConfigs)) {
        return 1;
    }
    gather_tests();
    int testCount = gCPUTests->size() + gCPUSerialTests->size() +
                    gGaneshTests->size() + gGraphiteTests->size();
    gPending = gSrcs->size() * gSinks->size() + testCount;
    gTotalCounts = gPending;
    gLastUpdate = SkTime::GetNSecs();
    info("%d srcs * %d sinks + %d tests == %d tasks\n",
         gSrcs->size(), gSinks->size(), testCount,
         gPending);
 
    // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
    // However, execute all CPU-serial tests first so that they don't have races with parallel tests
    for (skiatest::Test& test : *gCPUSerialTests) { run_cpu_test(test); }
 
    SkTaskGroup parallel;
    TArray<Task> serial;
 
    for (TaggedSink& sink : *gSinks) {
        for (TaggedSrc& src : *gSrcs) {
            if (src->veto(sink->flags()) ||
                should_skip(sink.tag.c_str(), src.tag.c_str(),
                            src.options.c_str(), src->name().c_str())) {
                SkAutoSpinlock lock(gMutex);
                gPending--;
                continue;
            }
 
            Task task(src, sink);
            if (src->serial() || sink->serial()) {
                serial.push_back(task);
            } else {
                parallel.add([task] { Task::Run(task); });
            }
        }
    }
    for (skiatest::Test& test : *gCPUTests) {
        parallel.add([test] { run_cpu_test(test); });
    }
 
    // With the parallel work running, run serial tasks and tests here on main thread.
    for (Task& task : serial) { Task::Run(task); }
    for (skiatest::Test& test : *gGaneshTests) { run_ganesh_test(test, grCtxOptions); }
    for (skiatest::Test& test : *gGraphiteTests) { run_graphite_test(test, graphiteOptions); }
 
    // Wait for any remaining parallel work to complete (including any spun off of serial tasks).
    parallel.wait();
    gDefinitelyThreadSafeWork->wait();
 
    // At this point we're back in single-threaded land.
 
    // We'd better have run everything.
    SkASSERT(gPending == 0);
    // Make sure we've flushed all our results to disk.
    dump_json();
 
    if (!gFailures->empty()) {
        info("Failures:\n");
        for (const SkString& fail : *gFailures) {
            info("\t%s\n", fail.c_str());
        }
        info("%d failures\n", gFailures->size());
        return 1;
    }
 
    SkGraphics::PurgeAllCaches();
    info("Finished!\n");
 
    return 0;
}

◆ match()

static bool match	(	const char *	needle,
		const char *	haystack
	)

static

Definition at line 1132 of file DM.cpp.

                                                            {
    if ('~' == needle[0]) {
        return !match(needle + 1, haystack);
    }
    if (0 == strcmp("_", needle)) {
        return true;
    }
    return nullptr != strstr(haystack, needle);
}

◆ max_of() [1/2]

static constexpr int max_of ( )

staticconstexpr

Definition at line 375 of file DM.cpp.

375{ return 0; }

◆ max_of() [2/2]

template<typename... Rest>

static constexpr int max_of	(	int	x,
		Rest...	rest
	)

staticconstexpr

Definition at line 377 of file DM.cpp.

                                                     {
        return x > max_of(rest...) ? x : max_of(rest...);
    }

◆ push_android_codec_src()

static void push_android_codec_src	(	Path	path,
		CodecSrc::DstColorType	dstColorType,
		SkAlphaType	dstAlphaType,
		int	sampleSize
	)

static

Definition at line 587 of file DM.cpp.

                                                  {
    SkString folder;
    folder.append("scaled_codec");
 
    switch (dstColorType) {
        case CodecSrc::kGrayscale_Always_DstColorType:
            folder.append("_kGray8");
            break;
        case CodecSrc::kNonNative8888_Always_DstColorType:
            folder.append("_kNonNative");
            break;
        default:
            break;
    }
 
    switch (dstAlphaType) {
        case kPremul_SkAlphaType:
            folder.append("_premul");
            break;
        case kUnpremul_SkAlphaType:
            folder.append("_unpremul");
            break;
        default:
            break;
    }
 
    if (1 != sampleSize) {
        folder.appendf("_%.3f", 1.0f / (float) sampleSize);
    }
 
    AndroidCodecSrc* src = new AndroidCodecSrc(path, dstColorType, dstAlphaType, sampleSize);
    push_src("image", folder, src);
}

◆ push_codec_src()

static void push_codec_src	(	Path	path,
		CodecSrc::Mode	mode,
		CodecSrc::DstColorType	dstColorType,
		SkAlphaType	dstAlphaType,
		float	scale
	)

static

Definition at line 523 of file DM.cpp.

                                               {
    if (FLAGS_simpleCodec) {
        const bool simple = CodecSrc::kCodec_Mode == mode || CodecSrc::kAnimated_Mode == mode;
        if (!simple || dstColorType != CodecSrc::kGetFromCanvas_DstColorType || scale != 1.0f) {
            // Only decode in the simple case.
            return;
        }
    }
    SkString folder;
    switch (mode) {
        case CodecSrc::kCodec_Mode:
            folder.append("codec");
            break;
        case CodecSrc::kCodecZeroInit_Mode:
            folder.append("codec_zero_init");
            break;
        case CodecSrc::kScanline_Mode:
            folder.append("scanline");
            break;
        case CodecSrc::kStripe_Mode:
            folder.append("stripe");
            break;
        case CodecSrc::kCroppedScanline_Mode:
            folder.append("crop");
            break;
        case CodecSrc::kSubset_Mode:
            folder.append("codec_subset");
            break;
        case CodecSrc::kAnimated_Mode:
            folder.append("codec_animated");
            break;
    }
 
    switch (dstColorType) {
        case CodecSrc::kGrayscale_Always_DstColorType:
            folder.append("_kGray8");
            break;
        case CodecSrc::kNonNative8888_Always_DstColorType:
            folder.append("_kNonNative");
            break;
        default:
            break;
    }
 
    switch (dstAlphaType) {
        case kPremul_SkAlphaType:
            folder.append("_premul");
            break;
        case kUnpremul_SkAlphaType:
            folder.append("_unpremul");
            break;
        default:
            break;
    }
 
    if (1.0f != scale) {
        folder.appendf("_%.3f", scale);
    }
 
    CodecSrc* src = new CodecSrc(path, mode, dstColorType, dstAlphaType, scale);
    push_src("image", folder, src);
}

◆ push_codec_srcs()

static void push_codec_srcs ( Path path )

static

Definition at line 717 of file DM.cpp.

                                       {
    sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
    if (!encoded) {
        info("Couldn't read %s.", path.c_str());
        return;
    }
    std::unique_ptr<SkCodec> codec = SkCodec::MakeFromData(encoded);
    if (nullptr == codec) {
        info("Couldn't create codec for %s.", path.c_str());
        return;
    }
 
    // native scaling is only supported by WEBP and JPEG
    bool supportsNativeScaling = false;
 
    TArray<CodecSrc::Mode> nativeModes;
    nativeModes.push_back(CodecSrc::kCodec_Mode);
    nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
    switch (codec->getEncodedFormat()) {
        case SkEncodedImageFormat::kJPEG:
            nativeModes.push_back(CodecSrc::kScanline_Mode);
            nativeModes.push_back(CodecSrc::kStripe_Mode);
            nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
            supportsNativeScaling = true;
            break;
        case SkEncodedImageFormat::kWEBP:
            nativeModes.push_back(CodecSrc::kSubset_Mode);
            supportsNativeScaling = true;
            break;
        case SkEncodedImageFormat::kDNG:
            break;
        default:
            nativeModes.push_back(CodecSrc::kScanline_Mode);
            break;
    }
 
    TArray<CodecSrc::DstColorType> colorTypes;
    colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
    colorTypes.push_back(CodecSrc::kNonNative8888_Always_DstColorType);
    switch (codec->getInfo().colorType()) {
        case kGray_8_SkColorType:
            colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
            break;
        default:
            break;
    }
 
    TArray<SkAlphaType> alphaModes;
    alphaModes.push_back(kPremul_SkAlphaType);
    if (codec->getInfo().alphaType() != kOpaque_SkAlphaType) {
        alphaModes.push_back(kUnpremul_SkAlphaType);
    }
 
    for (CodecSrc::Mode mode : nativeModes) {
        for (CodecSrc::DstColorType colorType : colorTypes) {
            for (SkAlphaType alphaType : alphaModes) {
                // Only test kCroppedScanline_Mode when the alpha type is premul.  The test is
                // slow and won't be interestingly different with different alpha types.
                if (CodecSrc::kCroppedScanline_Mode == mode &&
                        kPremul_SkAlphaType != alphaType) {
                    continue;
                }
 
                push_codec_src(path, mode, colorType, alphaType, 1.0f);
 
                // Skip kNonNative on different native scales.  It won't be interestingly
                // different.
                if (supportsNativeScaling &&
                        CodecSrc::kNonNative8888_Always_DstColorType == colorType) {
                    // Native Scales
                    // SkJpegCodec natively supports scaling to the following:
                    for (auto scale : { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f }) {
                        push_codec_src(path, mode, colorType, alphaType, scale);
                    }
                }
            }
        }
    }
 
    {
        std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
        if (frameInfos.size() > 1) {
            for (auto dstCT : { CodecSrc::kNonNative8888_Always_DstColorType,
                    CodecSrc::kGetFromCanvas_DstColorType }) {
                for (auto at : { kUnpremul_SkAlphaType, kPremul_SkAlphaType }) {
                    push_codec_src(path, CodecSrc::kAnimated_Mode, dstCT, at, 1.0f);
                }
            }
            for (float scale : { .5f, .33f }) {
                push_codec_src(path, CodecSrc::kAnimated_Mode, CodecSrc::kGetFromCanvas_DstColorType,
                               kPremul_SkAlphaType, scale);
            }
        }
 
    }
 
    if (FLAGS_simpleCodec) {
        return;
    }
 
    const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
    for (int sampleSize : sampleSizes) {
        for (CodecSrc::DstColorType colorType : colorTypes) {
            for (SkAlphaType alphaType : alphaModes) {
                // We can exercise all of the kNonNative support code in the swizzler with just a
                // few sample sizes.  Skip the rest.
                if (CodecSrc::kNonNative8888_Always_DstColorType == colorType && sampleSize > 3) {
                    continue;
                }
 
                push_android_codec_src(path, colorType, alphaType, sampleSize);
            }
        }
    }
 
    const char* ext = strrchr(path.c_str(), '.');
    if (ext) {
        ext++;
 
        static const char* const rawExts[] = {
            "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
            "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
        };
        for (const char* rawExt : rawExts) {
            if (0 == strcmp(rawExt, ext)) {
                // RAW is not supported by image generator (skbug.com/5079) or BRD.
                return;
            }
        }
 
#ifdef SK_ENABLE_ANDROID_UTILS
        static const char* const brdExts[] = {
            "jpg", "jpeg", "png", "webp",
            "JPG", "JPEG", "PNG", "WEBP",
        };
        for (const char* brdExt : brdExts) {
            if (0 == strcmp(brdExt, ext)) {
                bool gray = codec->getInfo().colorType() == kGray_8_SkColorType;
                push_brd_srcs(path, gray);
                break;
            }
        }
#endif
    }
 
    // Push image generator GPU test.
    push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
 
    // Push image generator CPU tests.
    for (SkAlphaType alphaType : alphaModes) {
        push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
 
#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
        if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
            SkEncodedImageFormat::kWBMP != codec->getEncodedFormat() &&
            kUnpremul_SkAlphaType != alphaType)
        {
            push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
        }
#elif defined(SK_BUILD_FOR_WIN)
        if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
            SkEncodedImageFormat::kWBMP != codec->getEncodedFormat())
        {
            push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
        }
#elif defined(SK_ENABLE_NDK_IMAGES)
        push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
#endif
    }
}

◆ push_image_gen_src()

static void push_image_gen_src	(	Path	path,
		ImageGenSrc::Mode	mode,
		SkAlphaType	alphaType,
		bool	isGpu
	)

static

Definition at line 622 of file DM.cpp.

{
    SkString folder;
    switch (mode) {
        case ImageGenSrc::kCodec_Mode:
            folder.append("gen_codec");
            break;
        case ImageGenSrc::kPlatform_Mode:
            folder.append("gen_platform");
            break;
    }
 
    if (isGpu) {
        folder.append("_gpu");
    } else {
        switch (alphaType) {
            case kOpaque_SkAlphaType:
                folder.append("_opaque");
                break;
            case kPremul_SkAlphaType:
                folder.append("_premul");
                break;
            case kUnpremul_SkAlphaType:
                folder.append("_unpremul");
                break;
            default:
                break;
        }
    }
 
    ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
    push_src("image", folder, src);
}

◆ push_sink()

static void push_sink	(	const SkCommandLineConfig &	config,
		Sink *	s
	)

static

Definition at line 952 of file DM.cpp.

                                                                  {
    std::unique_ptr<Sink> sink(s);
 
    // Try a simple Src as a canary.  If it fails, skip this sink.
    struct : public Src {
        Result draw(SkCanvas* c, skiatest::graphite::GraphiteTestContext*) const override {
            c->drawRect(SkRect::MakeWH(1,1), SkPaint());
            return Result::Ok();
        }
        SkISize size() const override { return SkISize::Make(16, 16); }
        Name name() const override { return "justOneRect"; }
    } justOneRect;
 
    SkBitmap bitmap;
    SkDynamicMemoryWStream stream;
    SkString log;
    Result result = sink->draw(justOneRect, &bitmap, &stream, &log);
    if (result.isFatal()) {
        info("Could not run %s: %s\n", config.getTag().c_str(), result.c_str());
        exit(1);
    }
 
    TaggedSink& ts = gSinks->push_back();
    ts.reset(sink.release());  // NOLINT(misc-uniqueptr-reset-release)
    ts.tag = config.getTag();
}

◆ push_src()

static void push_src	(	const char *	tag,
		ImplicitString	options,
		Src *	inSrc
	)

static

Definition at line 512 of file DM.cpp.

                                                                          {
    std::unique_ptr<Src> src(inSrc);
    if (in_shard() && FLAGS_src.contains(tag) &&
        !CommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
        TaggedSrc& s = gSrcs->push_back();
        s.reset(src.release());  // NOLINT(misc-uniqueptr-reset-release)
        s.tag = tag;
        s.options = options;
    }
}

◆ run_cpu_test()

static void run_cpu_test ( skiatest::Test test )

static

Definition at line 1508 of file DM.cpp.

                                            {
    DMReporter reporter;
    if (!FLAGS_dryRun && !should_skip("_", "tests", "_", test.fName)) {
        skiatest::ReporterContext ctx(&reporter, SkString(test.fName));
        start("unit", "test", "", test.fName);
        test.cpu(&reporter);
    }
    done("unit", "test", "", test.fName);
}

◆ run_ganesh_test()

static void run_ganesh_test	(	skiatest::Test	test,
		const GrContextOptions &	grCtxOptions
	)

static

Definition at line 1518 of file DM.cpp.

                                                                                     {
    DMReporter reporter;
    if (!FLAGS_dryRun && !should_skip("_", "tests", "_", test.fName)) {
        AutoreleasePool pool;
        GrContextOptions options = grCtxOptions;
        test.modifyGrContextOptions(&options);
 
        skiatest::ReporterContext ctx(&reporter, SkString(test.fName));
        start("unit", "test", "", test.fName);
        test.ganesh(&reporter, options);
    }
    done("unit", "test", "", test.fName);
}

◆ run_graphite_test()

static void run_graphite_test	(	skiatest::Test	test,
		skiatest::graphite::TestOptions &	options
	)

static

Definition at line 1532 of file DM.cpp.

                                                                                       {
    DMReporter reporter;
    if (!FLAGS_dryRun && !should_skip("_", "tests", "_", test.fName)) {
        AutoreleasePool pool;
        test.modifyGraphiteContextOptions(&options.fContextOptions);
 
        skiatest::ReporterContext ctx(&reporter, SkString(test.fName));
        start("unit", "test", "", test.fName);
        test.graphite(&reporter, options);
    }
    done("unit", "test", "", test.fName);
}

◆ setup_crash_handler()

static void setup_crash_handler ( )

static

Definition at line 415 of file DM.cpp.

                                      {
        const int kSignals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM };
        for (int sig : kSignals) {
            previous_handler[sig] = signal(sig, crash_handler);
        }
    }

◆ should_skip()

static bool should_skip	(	const char *	sink,
		const char *	src,
		const char *	srcOptions,
		const char *	name
	)

static

Definition at line 1142 of file DM.cpp.

                                                                  {
    for (int i = 0; i < FLAGS_skip.size() - 3; i += 4) {
        if (match(FLAGS_skip[i+0], sink) &&
            match(FLAGS_skip[i+1], src) &&
            match(FLAGS_skip[i+2], srcOptions) &&
            match(FLAGS_skip[i+3], name)) {
            return true;
        }
    }
    return false;
}

◆ start()

static void start	(	const char *	config,
		const char *	src,
		const char *	srcOptions,
		const char *	name
	)

static

Definition at line 312 of file DM.cpp.

                                                                                                 {
    SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
    vlog("\tstart %s\n", id.c_str());
    SkAutoSpinlock lock(gMutex);
    gRunning->push_back({id,SkGetThreadID()});
}

◆ vlog()

static void static void vlog	(	const char *	fmt,
			...
	)

static

Definition at line 201 of file DM.cpp.

                                       {
    if (gVLog) {
        va_list args;
        va_start(args, fmt);
        vfprintf(gVLog, fmt, args);
        fflush(gVLog);
        va_end(args);
    }
}

Variable Documentation

◆ gCPUSerialTests

SkTDArray<skiatest::Test>* gCPUSerialTests = new SkTDArray<skiatest::Test>

static

Definition at line 1471 of file DM.cpp.

◆ gCPUTests

SkTDArray<skiatest::Test>* gCPUTests = new SkTDArray<skiatest::Test>

static

Definition at line 1470 of file DM.cpp.

◆ gCreateProtectedContext

bool gCreateProtectedContext

extern

Definition at line 45 of file GrContextFactory.cpp.

◆ gDefinitelyThreadSafeWork

SkTaskGroup* gDefinitelyThreadSafeWork = new SkTaskGroup

static

Definition at line 1157 of file DM.cpp.

◆ gFailures

TArray<SkString>* gFailures = new TArray<SkString>

static

Definition at line 232 of file DM.cpp.

◆ gForceHighPrecisionRasterPipeline

bool gForceHighPrecisionRasterPipeline

extern

Definition at line 29 of file SkRasterPipeline.cpp.

◆ gGaneshTests

SkTDArray<skiatest::Test>* gGaneshTests = new SkTDArray<skiatest::Test>

static

Definition at line 1472 of file DM.cpp.

◆ gGold

THashSet<Gold, Gold::Hash>* gGold = new THashSet<Gold, Gold::Hash>

static

Definition at line 443 of file DM.cpp.

◆ gGraphiteTests

SkTDArray<skiatest::Test>* gGraphiteTests = new SkTDArray<skiatest::Test>

static

Definition at line 1473 of file DM.cpp.

◆ gLastUpdate

double gLastUpdate

static

Definition at line 260 of file DM.cpp.

◆ gMutex

SkSpinlock gMutex

static

Definition at line 257 of file DM.cpp.

◆ gPending

int gPending

static

Definition at line 258 of file DM.cpp.

◆ gRunning

SkNoDestructor<TArray<Running> > gRunning

static

Definition at line 261 of file DM.cpp.

◆ gSinks

TArray<TaggedSink, kMemcpyOK>* gSinks = new TArray<TaggedSink, kMemcpyOK>

static

Definition at line 505 of file DM.cpp.

◆ gSkForceRasterPipelineBlitter

bool gSkForceRasterPipelineBlitter

extern

Definition at line 44 of file SkBlitter.cpp.

44{false};

◆ gSrcs

TArray<TaggedSrc, kMemcpyOK>* gSrcs = new TArray<TaggedSrc, kMemcpyOK>

static

Definition at line 504 of file DM.cpp.

◆ gTotalCounts

int gTotalCounts

static

Definition at line 259 of file DM.cpp.

◆ gUninterestingHashes

THashSet<SkString>* gUninterestingHashes = new THashSet<SkString>

static

Definition at line 467 of file DM.cpp.

◆ gVLog

FILE* gVLog

static

Definition at line 197 of file DM.cpp.

◆ kMemcpyOK

constexpr bool kMemcpyOK = true

staticconstexpr

Definition at line 502 of file DM.cpp.

◆ kNewline

constexpr char kNewline[] = "\n"

staticconstexpr

Definition at line 464 of file DM.cpp.

◆ previous_handler

void(* previous_handler[max_of(SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTERM)+1])(int) ( int )

static

Definition at line 381 of file DM.cpp.

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ SINK

◆ VIA

Function Documentation

◆ add_gold()

◆ crash_handler()

◆ create_sink()

◆ create_via()

◆ CurrentTestHarness()

◆ DEFINE_bool() [1/13]

◆ DEFINE_bool() [2/13]

◆ DEFINE_bool() [3/13]

◆ DEFINE_bool() [4/13]

◆ DEFINE_bool() [5/13]

◆ DEFINE_bool() [6/13]

◆ DEFINE_bool() [7/13]

◆ DEFINE_bool() [8/13]

◆ DEFINE_bool() [9/13]

◆ DEFINE_bool() [10/13]

◆ DEFINE_bool() [11/13]

◆ DEFINE_bool() [12/13]

◆ DEFINE_bool() [13/13]

◆ DEFINE_bool2() [1/4]

◆ DEFINE_bool2() [2/4]

◆ DEFINE_bool2() [3/4]

◆ DEFINE_bool2() [4/4]

◆ DEFINE_int() [1/2]

◆ DEFINE_int() [2/2]

◆ DEFINE_int_2()

◆ DEFINE_string() [1/13]

◆ DEFINE_string() [2/13]

◆ DEFINE_string() [3/13]

◆ DEFINE_string() [4/13]

◆ DEFINE_string() [5/13]

◆ DEFINE_string() [6/13]

◆ DEFINE_string() [7/13]

◆ DEFINE_string() [8/13]

◆ DEFINE_string() [9/13]

◆ DEFINE_string() [10/13]

◆ DEFINE_string() [11/13]

◆ DEFINE_string() [12/13]

◆ DEFINE_string() [13/13]

◆ DEFINE_string2() [1/3]

◆ DEFINE_string2() [2/3]

◆ DEFINE_string2() [3/3]

◆ done()

◆ dump_json()

◆ fail()

◆ find_culprit()

◆ gather_file_srcs()

◆ gather_gold()

◆ gather_sinks()

◆ gather_srcs()

◆ gather_tests()

◆ gather_uninteresting_hashes()

◆ in_shard()

◆ info()

◆ main()

◆ match()

◆ max_of() [1/2]

◆ max_of() [2/2]

◆ push_android_codec_src()

◆ push_codec_src()

◆ push_codec_srcs()

◆ push_image_gen_src()

◆ push_sink()

◆ push_src()

◆ run_cpu_test()

◆ run_ganesh_test()

◆ run_graphite_test()

◆ setup_crash_handler()

◆ should_skip()

◆ start()

◆ vlog()

Variable Documentation

◆ gCPUSerialTests