skqp.cpp File Reference

#include "tools/skqp/src/skqp.h"
#include "gm/gm.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
#include "src/core/SkOSFile.h"
#include "src/utils/SkOSPath.h"
#include "tests/Test.h"
#include "tests/TestHarness.h"
#include "tools/Resources.h"
#include "tools/fonts/FontToolUtils.h"
#include <algorithm>
#include <regex>

Go to the source code of this file.

Functions
static std::vector< SkQP::UnitTest >	get_unit_tests (int enforcedAndroidAPILevel)
static std::vector< SkQP::SkSLErrorTest >	get_sksl_error_tests (SkQPAssetManager *assetManager, int enforcedAndroidAPILevel)
TestHarness	CurrentTestHarness ()
template<typename T >
void	write (SkWStream *wStream, const T &text)

Variables
static constexpr char	kUnitTestReportPath [] = "unit_tests.txt"
static const std::pair< std::regex, CtsEnforcement >	sExclusionRulesForSkSLTests []

Function Documentation

CurrentTestHarness()

TestHarness CurrentTestHarness

(

)

Definition at line 108 of file skqp.cpp.

                                 {
    return TestHarness::kSkQP;
}

get_sksl_error_tests()

static std::vector< SkQP::SkSLErrorTest > get_sksl_error_tests ( SkQPAssetManager *  assetManager, int  enforcedAndroidAPILevel  )

static

Definition at line 70 of file skqp.cpp.

                                                                                          {
    std::vector<SkQP::SkSLErrorTest> skslErrorTests;
    auto iterateFn = [&](const char* directory, const char* extension) {
        std::vector<std::string> paths = assetManager->iterateDir(directory, extension);
        for (const std::string& path : paths) {
            SkString name = SkOSPath::Basename(path.c_str());
            for (auto& exclusionEntry : sExclusionRulesForSkSLTests) {
                if (std::regex_match(name.c_str(), exclusionEntry.first) &&
                    exclusionEntry.second.eval(enforcedAndroidAPILevel) ==
                            CtsEnforcement::RunMode::kSkip) {
                    continue;
                }
            }
            sk_sp<SkData> shaderText = GetResourceAsData(path.c_str());
            if (!shaderText) {
                continue;
            }
            skslErrorTests.push_back({
                name.c_str(),
                std::string(static_cast<const char*>(shaderText->data()), shaderText->size())
            });
        }
    };
 
    // Android only supports runtime shaders, not fragment shaders, color filters or blenders.
    iterateFn("sksl/errors/", ".rts");
    iterateFn("sksl/runtime_errors/", ".rts");
 
    auto lt = [](const SkQP::SkSLErrorTest& a, const SkQP::SkSLErrorTest& b) {
        return a.name < b.name;
    };
    std::sort(skslErrorTests.begin(), skslErrorTests.end(), lt);
    return skslErrorTests;
}

get_unit_tests()

static std::vector< SkQP::UnitTest > get_unit_tests ( int  enforcedAndroidAPILevel )

static

Definition at line 43 of file skqp.cpp.

                                                                           {
    std::vector<SkQP::UnitTest> unitTests;
    for (const skiatest::Test& test : skiatest::TestRegistry::Range()) {
        const auto ctsMode = test.fCTSEnforcement.eval(enforcedAndroidAPILevel);
        if (ctsMode != CtsEnforcement::RunMode::kSkip) {
            SkASSERTF(test.fTestType != skiatest::TestType::kCPU,
                      "Non-GPU test was included in SkQP: %s\n", test.fName);
            unitTests.push_back(&test);
        }
    }
    auto lt = [](SkQP::UnitTest u, SkQP::UnitTest v) { return strcmp(u->fName, v->fName) < 0; };
    std::sort(unitTests.begin(), unitTests.end(), lt);
    return unitTests;
}

write()

template<typename T >

void write ( SkWStream *  wStream, const T &  text  )

inline

Definition at line 188 of file skqp.cpp.

                                                     {
    wStream->write(text.c_str(), text.size());
}

Variable Documentation

kUnitTestReportPath

constexpr char kUnitTestReportPath[] = "unit_tests.txt"

staticconstexpr

Definition at line 40 of file skqp.cpp.

sExclusionRulesForSkSLTests

const std::pair<std::regex, CtsEnforcement> sExclusionRulesForSkSLTests[]

static

Initial value:

= {
        
        {std::regex(".*ES3.*"), CtsEnforcement::kNever}}

SkSL error tests are used by CTS to verify that Android's RuntimeShader API fails when certain shader programs are compiled. Unlike unit tests these error tests are defined in resource files not source code. As such, we are unable to mark each test with a CtsEnforcement value. This list of exclusion rules excludes tests based on their file name so that we can have some form of control for which Android version an SkSL error test is expected to run.

Definition at line 65 of file skqp.cpp.

                                                                               {
        // disable all ES3 tests until AGSL supports it.
        {std::regex(".*ES3.*"), CtsEnforcement::kNever}};