skiatest Namespace Reference

Namespaces
namespace	graphite

Classes
struct	Failure
class	Reporter
class	ReporterContext
struct	Test
class	Timer

Typedefs
using	ContextType = skgpu::ContextType
using	CPUTestProc = void(*)(Reporter *)
using	GaneshTestProc = void(*)(Reporter *, const GrContextOptions &)
using	GaneshContextOptionsProc = void(*)(GrContextOptions *)
using	GraphiteTestProc = void(*)(Reporter *, const graphite::TestOptions &)
using	GraphiteContextOptionsProc = void(*)(skgpu::graphite::ContextOptions *)
using	TestRegistry = sk_tools::Registry< Test >
using	GpuContextType = nullptr_t
typedef void	GrContextTestFn(Reporter *, const sk_gpu_test::ContextInfo &)
typedef bool	ContextTypeFilterFn(GpuContextType)

Enumerations
enum class	TestType : uint8_t { kCPU , kCPUSerial , kGanesh , kGraphite }

Functions
bool	IsGLContextType (skgpu::ContextType type)
bool	IsVulkanContextType (skgpu::ContextType type)
bool	IsMetalContextType (skgpu::ContextType type)
bool	IsDirect3DContextType (skgpu::ContextType type)
bool	IsDawnContextType (skgpu::ContextType type)
bool	IsMockContextType (skgpu::ContextType type)
void	RunWithGaneshTestContexts (GrContextTestFn *testFn, ContextTypeFilterFn *filter, Reporter *reporter, const GrContextOptions &options)
SkString	GetTmpDir ()
bool	IsGLContextType (GpuContextType)
bool	IsVulkanContextType (GpuContextType)
bool	IsMetalContextType (GpuContextType)
bool	IsDawnContextType (GpuContextType)
bool	IsDirect3DContextType (GpuContextType)
bool	IsMockContextType (GpuContextType)
static bool	vk_has_physical_devices ()
static bool	skip_context (skgpu::ContextType contextType)
static	DEFINE_string (fontTestDataPath, "", "Path to extracted data from googlefonts_testdata CIPD file.")
void	SetFontTestDataDirectory ()

Variables
static constexpr auto	kNativeGLType = skgpu::ContextType::kGLES

Typedef Documentation

ContextType

using skiatest::ContextType = typedef skgpu::ContextType

Definition at line 271 of file gm_bindings.cpp.

ContextTypeFilterFn

typedef bool skiatest::ContextTypeFilterFn(GpuContextType)

Definition at line 214 of file Test.h.

CPUTestProc

using skiatest::CPUTestProc = typedef void (*)(Reporter*)

Definition at line 113 of file Test.h.

GaneshContextOptionsProc

using skiatest::GaneshContextOptionsProc = typedef void (*)(GrContextOptions*)

Definition at line 115 of file Test.h.

GaneshTestProc

using skiatest::GaneshTestProc = typedef void (*)(Reporter*, const GrContextOptions&)

Definition at line 114 of file Test.h.

GpuContextType

using skiatest::GpuContextType = typedef nullptr_t

Definition at line 210 of file Test.h.

GraphiteContextOptionsProc

using skiatest::GraphiteContextOptionsProc = typedef void (*)(skgpu::graphite::ContextOptions*)

Definition at line 117 of file Test.h.

GraphiteTestProc

using skiatest::GraphiteTestProc = typedef void (*)(Reporter*, const graphite::TestOptions&)

Definition at line 116 of file Test.h.

GrContextTestFn

typedef void skiatest::GrContextTestFn(Reporter *, const sk_gpu_test::ContextInfo &)

Definition at line 213 of file Test.h.

TestRegistry

using skiatest::TestRegistry = typedef sk_tools::Registry<Test>

Definition at line 205 of file Test.h.

Enumeration Type Documentation

TestType

enum class skiatest::TestType : uint8_t

strong

Enumerator
kCPU
kCPUSerial
kGanesh
kGraphite

Definition at line 17 of file TestType.h.

: uint8_t { kCPU, kCPUSerial, kGanesh, kGraphite };

Function Documentation

DEFINE_string()

static skiatest::DEFINE_string ( fontTestDataPath  , ""  , "Path to extracted data from googlefonts_testdata CIPD file."    )

static

GetTmpDir()

SkString skiatest::GetTmpDir

(

)

Definition at line 53 of file Test.cpp.

                             {
    if (!FLAGS_tmpDir.isEmpty()) {
        return SkString(FLAGS_tmpDir[0]);
    }
#ifdef SK_BUILD_FOR_ANDROID
    const char* environmentVariable = "TMPDIR";
    const char* defaultValue = "/data/local/tmp";
#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX)
    const char* environmentVariable = "TMPDIR";
    const char* defaultValue = "/tmp";
#elif defined(SK_BUILD_FOR_WIN)
    const char* environmentVariable = "TEMP";
    const char* defaultValue = nullptr;
#else
    const char* environmentVariable = nullptr;
    const char* defaultValue = nullptr;
#endif
    const char* tmpdir = environmentVariable ? getenv(environmentVariable) : nullptr;
    return SkString(tmpdir ? tmpdir : defaultValue);
}

IsDawnContextType() [1/2]

bool skiatest::IsDawnContextType ( GpuContextType  )

extern

IsDawnContextType() [2/2]

bool skiatest::IsDawnContextType

(

skgpu::ContextType

type

)

Definition at line 65 of file DMGpuTestProcs.cpp.

                                              {
#if defined(SK_GRAPHITE)
    return skgpu::graphite::ContextTypeBackend(type) == skgpu::BackendApi::kDawn;
#else
    return false;
#endif
}

IsDirect3DContextType() [1/2]

bool skiatest::IsDirect3DContextType ( GpuContextType  )

extern

IsDirect3DContextType() [2/2]

bool skiatest::IsDirect3DContextType

(

skgpu::ContextType

type

)

Definition at line 57 of file DMGpuTestProcs.cpp.

                                                  {
#if defined(SK_GANESH)
    return skgpu::ganesh::ContextTypeBackend(type) == GrBackendApi::kDirect3D;
#else
    return false;
#endif
}

IsGLContextType() [1/2]

bool skiatest::IsGLContextType ( GpuContextType  )

extern

IsGLContextType() [2/2]

bool skiatest::IsGLContextType

(

skgpu::ContextType

type

)

Definition at line 29 of file DMGpuTestProcs.cpp.

                                            {
#if defined(SK_GANESH)
    return skgpu::ganesh::ContextTypeBackend(type) == GrBackendApi::kOpenGL;
#else
    return false;
#endif
}

IsMetalContextType() [1/2]

bool skiatest::IsMetalContextType ( GpuContextType  )

extern

IsMetalContextType() [2/2]

bool skiatest::IsMetalContextType

(

skgpu::ContextType

type

)

Definition at line 47 of file DMGpuTestProcs.cpp.

                                               {
#if defined(SK_GANESH)
    return skgpu::ganesh::ContextTypeBackend(type) == GrBackendApi::kMetal;
#elif defined(SK_GRAPHITE)
    return skgpu::graphite::ContextTypeBackend(type) == BackendApi::kMetal;
#else
    return false;
#endif
}

IsMockContextType() [1/2]

bool skiatest::IsMockContextType ( GpuContextType  )

extern

IsMockContextType() [2/2]

bool skiatest::IsMockContextType

(

skgpu::ContextType

type

)

Definition at line 73 of file DMGpuTestProcs.cpp.

                                              {
    return type == skgpu::ContextType::kMock;
}

IsVulkanContextType() [1/2]

bool skiatest::IsVulkanContextType ( GpuContextType  )

extern

IsVulkanContextType() [2/2]

bool skiatest::IsVulkanContextType

(

skgpu::ContextType

type

)

Definition at line 37 of file DMGpuTestProcs.cpp.

                                                {
#if defined(SK_GANESH)
    return skgpu::ganesh::ContextTypeBackend(type) == GrBackendApi::kVulkan;
#elif defined(SK_GRAPHITE)
    return skgpu::graphite::ContextTypeBackend(type) == BackendApi::kVulkan;
#else
    return false;
#endif
}

RunWithGaneshTestContexts()

void skiatest::RunWithGaneshTestContexts	(	GrContextTestFn *	testFn,
		ContextTypeFilterFn *	filter,
		Reporter *	reporter,
		const GrContextOptions &	options
	)

Definition at line 77 of file DMGpuTestProcs.cpp.

                                                                                    {
#if defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC)
    static constexpr auto kNativeGLType = skgpu::ContextType::kGL;
#else
    static constexpr auto kNativeGLType = skgpu::ContextType::kGLES;
#endif
 
    for (int typeInt = 0; typeInt < skgpu::kContextTypeCount; ++typeInt) {
        skgpu::ContextType contextType = static_cast<skgpu::ContextType>(typeInt);
        // Use "native" instead of explicitly trying OpenGL and OpenGL ES. Do not use GLES on
        // desktop since tests do not account for not fixing http://skbug.com/2809
        if (contextType == skgpu::ContextType::kGL ||
            contextType == skgpu::ContextType::kGLES) {
            if (contextType != kNativeGLType) {
                continue;
            }
        }
        // We destroy the factory and its associated contexts after each test. This is due to the
        // fact that the command buffer sits on top of the native GL windowing (cgl, wgl, ...) but
        // also tracks which of its contexts is current above that API and gets tripped up if the
        // native windowing API is used directly outside of the command buffer code.
        GrContextFactory factory(options);
        ContextInfo ctxInfo = factory.getContextInfo(contextType);
        if (filter && !(*filter)(contextType)) {
            continue;
        }
 
        ReporterContext ctx(reporter, SkString(skgpu::ContextTypeName(contextType)));
        if (ctxInfo.directContext()) {
            (*testFn)(reporter, ctxInfo);
            // In case the test changed the current context make sure we move it back before
            // calling flush.
            ctxInfo.testContext()->makeCurrent();
            // Sync so any release/finished procs get called.
            ctxInfo.directContext()->flushAndSubmit(GrSyncCpu::kYes);
        }
    }
}

SetFontTestDataDirectory()

void skiatest::SetFontTestDataDirectory

(

)

Set font test data directory. Overrides the location of the extracted googlefonts_testdata CIPD archive.

Definition at line 25 of file TestFontDataProvider.cpp.

                                {
    if (FLAGS_fontTestDataPath.isEmpty()) {
        return;
    }
    if (strlen(FLAGS_fontTestDataPath[0])) {
        gFontTestDataBasePath = FLAGS_fontTestDataPath[0];
    }
}

skip_context()

static bool skiatest::skip_context ( skgpu::ContextType  contextType )

static

Definition at line 76 of file skqp_GpuTestProcs.cpp.

                                                       {
    // Use "native" instead of explicitly trying both OpenGL and OpenGL ES.
    if (contextType == skgpu::ContextType::kGL || contextType == skgpu::ContextType::kGLES) {
        if (contextType != kNativeGLType) {
            return true;
        }
    }
 
    // The Android CDD (https://source.android.com/compatibility/12/android-12-cdd.pdf) does not
    // require Vulkan, but if it enumerates at least one VkPhysicalDevice then it is expected that
    // Vulkan is supported
    if (contextType == skgpu::ContextType::kVulkan && !vk_has_physical_devices()) {
        return true;
    }
    return false;
}

vk_has_physical_devices()

static bool skiatest::vk_has_physical_devices ( )

static

Definition at line 48 of file skqp_GpuTestProcs.cpp.

                                      {
    static bool supported = false;
#ifdef SK_VULKAN
    static std::once_flag flag;
    std::call_once(flag, []() {
        // We could create a VkInstance and call vkEnumeratePhysicalDevices devices directly, but
        // CreatePlatformVkTestContext is already configured to do that and will return nullptr if
        // there are no available devices.
        std::unique_ptr<TestContext> testCtx(sk_gpu_test::CreatePlatformVkTestContext(nullptr));
        if (testCtx) {
            supported = true;
        }
    });
#endif
    return supported;
}

Variable Documentation

kNativeGLType

constexpr auto skiatest::kNativeGLType = skgpu::ContextType::kGLES

staticconstexpr

Definition at line 69 of file skqp_GpuTestProcs.cpp.