PathOpsExtendedTest.h File Reference

#include "include/core/SkBitmap.h"
#include "include/pathops/SkPathOps.h"
#include <cstddef>

Go to the source code of this file.

Classes
struct	TestDesc

Namespaces
namespace	skiatest

Functions
int	comparePaths (skiatest::Reporter *reporter, const char *filename, const SkPath &one, const SkPath &two, SkBitmap &bitmap)
int	comparePaths (skiatest::Reporter *reporter, const char *filename, const SkPath &one, const SkPath &two)
bool	drawAsciiPaths (const SkPath &one, const SkPath &two, bool drawPaths)
void	markTestFlakyForPathKit ()
void	showOp (const SkPathOp op)
bool	testPathOp (skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp, const char *testName)
bool	testPathOpCheck (skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp, const char *testName, bool checkFail)
bool	testPathOpFail (skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp, const char *testName)
bool	testPathOpFuzz (skiatest::Reporter *reporter, const SkPath &a, const SkPath &b, const SkPathOp, const char *testName)
bool	testSimplify (SkPath &path, bool useXor, SkPath &out, PathOpsThreadState &state, const char *pathStr)
bool	testSimplify (skiatest::Reporter *reporter, const SkPath &path, const char *filename)
bool	testSimplifyCheck (skiatest::Reporter *reporter, const SkPath &path, const char *filename, bool checkFail)
bool	testSimplifyFail (skiatest::Reporter *reporter, const SkPath &path, const char *filename)
bool	testSimplifyFuzz (skiatest::Reporter *reporter, const SkPath &path, const char *filename)
void	initializeTests (skiatest::Reporter *reporter, const char *testName)
void	RunTestSet (skiatest::Reporter *reporter, TestDesc tests[], size_t count, void(*firstTest)(skiatest::Reporter *, const char *filename), void(*skipTest)(skiatest::Reporter *, const char *filename), void(*stopTest)(skiatest::Reporter *, const char *filename), bool reverse)
void	ShowFunctionHeader (const char *name)
void	ShowPath (const SkPath &path, const char *pathName)
void	ShowOp (SkPathOp op, const char *pathOne, const char *pathTwo)

Function Documentation

comparePaths() [1/2]

int comparePaths ( skiatest::Reporter *  reporter, const char *  filename, const SkPath &  one, const SkPath &  two  )

inline

Definition at line 28 of file PathOpsExtendedTest.h.

                                                              {
    SkBitmap bitmap;
    return comparePaths(reporter, filename, one, two, bitmap);
}

comparePaths() [2/2]

int comparePaths	(	skiatest::Reporter *	reporter,
		const char *	filename,
		const SkPath &	one,
		const SkPath &	two,
		SkBitmap &	bitmap
	)

Definition at line 252 of file PathOpsExtendedTest.cpp.

                                             {
    int errors2x2;
    SkPath scaledOne, scaledTwo;
    (void) pathsDrawTheSame(one, two, bitmap, scaledOne, scaledTwo, errors2x2);
    if (errors2x2 == 0) {
        return 0;
    }
    const int MAX_ERRORS = 9;
    return errors2x2 > MAX_ERRORS ? errors2x2 : 0;
}

drawAsciiPaths()

bool drawAsciiPaths	(	const SkPath &	one,
		const SkPath &	two,
		bool	drawPaths
	)

Definition at line 205 of file PathOpsExtendedTest.cpp.

                                                                          {
    if (!drawPaths) {
        return true;
    }
    const SkRect& bounds1 = one.getBounds();
    const SkRect& bounds2 = two.getBounds();
    SkRect larger = bounds1;
    larger.join(bounds2);
    SkBitmap bits;
    char out[256];
    int bitWidth = SkScalarCeilToInt(larger.width()) + 2;
    if (bitWidth * 2 + 1 >= (int) sizeof(out)) {
        return false;
    }
    int bitHeight = SkScalarCeilToInt(larger.height()) + 2;
    if (bitHeight >= (int) sizeof(out)) {
        return false;
    }
    bits.allocN32Pixels(bitWidth * 2, bitHeight);
    SkCanvas canvas(bits);
    canvas.drawColor(SK_ColorWHITE);
    SkPaint paint;
    canvas.save();
    canvas.translate(-bounds1.fLeft + 1, -bounds1.fTop + 1);
    canvas.drawPath(one, paint);
    canvas.restore();
    canvas.save();
    canvas.translate(-bounds1.fLeft + 1 + bitWidth, -bounds1.fTop + 1);
    canvas.drawPath(two, paint);
    canvas.restore();
    for (int y = 0; y < bitHeight; ++y) {
        uint32_t* addr1 = bits.getAddr32(0, y);
        int x;
        char* outPtr = out;
        for (x = 0; x < bitWidth; ++x) {
            *outPtr++ = addr1[x] == (uint32_t) -1 ? '_' : 'x';
        }
        *outPtr++ = '|';
        for (x = bitWidth; x < bitWidth * 2; ++x) {
            *outPtr++ = addr1[x] == (uint32_t) -1 ? '_' : 'x';
        }
        *outPtr++ = '\0';
        SkDebugf("%s\n", out);
    }
    return true;
}

initializeTests()

void initializeTests	(	skiatest::Reporter *	reporter,
		const char *	testName
	)

Definition at line 650 of file PathOpsExtendedTest.cpp.

                                                                   {
    static SkMutex& mu = *(new SkMutex);
    if (reporter->verbose()) {
        SkAutoMutexExclusive lock(mu);
        sTestName = test;
        size_t testNameSize = strlen(test);
        SkFILEStream inFile("../../experimental/Intersection/op.htm");
        if (inFile.isValid()) {
            SkTDArray<char> inData;
            inData.resize((int) inFile.getLength());
            size_t inLen = inData.size();
            inFile.read(inData.begin(), inLen);
            inFile.close();
            char* insert = strstr(inData.begin(), marker);
            if (insert) {
                insert += sizeof(marker) - 1;
                const char* numLoc = insert + 4 /* indent spaces */ + testNameSize - 1;
                sTestNumber = atoi(numLoc) + 1;
            }
        }
    }
}

markTestFlakyForPathKit()

void markTestFlakyForPathKit

(

)

Definition at line 369 of file PathOpsExtendedTest.cpp.

                               {
    if (PathOpsDebug::gJson) {
        SkASSERT(!PathOpsDebug::gMarkJsonFlaky);
        PathOpsDebug::gMarkJsonFlaky = true;
    }
}

RunTestSet()

void RunTestSet	(	skiatest::Reporter *	reporter,
		TestDesc	tests[],
		size_t	count,
		void(*)(skiatest::Reporter *, const char *filename)	firstTest,
		void(*)(skiatest::Reporter *, const char *filename)	skipTest,
		void(*)(skiatest::Reporter *, const char *filename)	stopTest,
		bool	reverse
	)

Definition at line 691 of file PathOpsExtendedTest.cpp.

                                                                                          {
    size_t index;
    if (firstTest) {
        index = count - 1;
        while (index > 0 && tests[index].fun != firstTest) {
            --index;
        }
        (*tests[index].fun)(reporter, tests[index].str);
        if (tests[index].fun == stopTest) {
            return;
        }
    }
    index = reverse ? count - 1 : 0;
    size_t last = reverse ? 0 : count - 1;
    bool foundSkip = !skipTest;
    do {
        if (tests[index].fun == skipTest) {
            foundSkip = true;
        }
        if (foundSkip && tests[index].fun != firstTest) {
             (*tests[index].fun)(reporter, tests[index].str);
        }
        if (tests[index].fun == stopTest || index == last) {
            break;
        }
        index += reverse ? -1 : 1;
    } while (true);
}

ShowFunctionHeader()

void ShowFunctionHeader

(

const char *

name

)

showOp()

void showOp

(

const SkPathOp

op

)

Definition at line 107 of file PathOpsExtendedTest.cpp.

                               {
    switch (op) {
        case kDifference_SkPathOp:
            SkDebugf("op difference\n");
            break;
        case kIntersect_SkPathOp:
            SkDebugf("op intersect\n");
            break;
        case kUnion_SkPathOp:
            SkDebugf("op union\n");
            break;
        case kXOR_SkPathOp:
            SkDebugf("op xor\n");
            break;
        case kReverseDifference_SkPathOp:
            SkDebugf("op reverse difference\n");
            break;
        default:
            SkASSERT(0);
    }
}

ShowOp()

void ShowOp	(	SkPathOp	op,
		const char *	pathOne,
		const char *	pathTwo
	)

ShowPath()

void ShowPath	(	const SkPath &	path,
		const char *	pathName
	)

testPathOp()

bool testPathOp	(	skiatest::Reporter *	reporter,
		const SkPath &	a,
		const SkPath &	b,
		const	SkPathOp,
		const char *	testName
	)

Definition at line 618 of file PathOpsExtendedTest.cpp.

                                                      {
    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kYes, SkipAssert::kNo,
            ExpectMatch::kYes);
}

testPathOpCheck()

bool testPathOpCheck	(	skiatest::Reporter *	reporter,
		const SkPath &	a,
		const SkPath &	b,
		const	SkPathOp,
		const char *	testName,
		bool	checkFail
	)

Definition at line 624 of file PathOpsExtendedTest.cpp.

                                                                      {
    return innerPathOp(reporter, a, b, shapeOp, testName, checkFail ?
            ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
}

testPathOpFail()

bool testPathOpFail	(	skiatest::Reporter *	reporter,
		const SkPath &	a,
		const SkPath &	b,
		const	SkPathOp,
		const char *	testName
	)

Definition at line 636 of file PathOpsExtendedTest.cpp.

                                                               {
    SkPath orig;
    orig.lineTo(54, 43);
    SkPath out = orig;
    if (Op(a, b, shapeOp, &out) ) {
        SkDebugf("%s test is expected to fail\n", __FUNCTION__);
        REPORTER_ASSERT(reporter, 0);
        return false;
    }
    SkASSERT(out == orig);
    return true;
}

testPathOpFuzz()

bool testPathOpFuzz	(	skiatest::Reporter *	reporter,
		const SkPath &	a,
		const SkPath &	b,
		const	SkPathOp,
		const char *	testName
	)

Definition at line 630 of file PathOpsExtendedTest.cpp.

                                                      {
    return innerPathOp(reporter, a, b, shapeOp, testName, ExpectSuccess::kFlaky, SkipAssert::kYes,
            ExpectMatch::kFlaky);
}

testSimplify() [1/2]

bool testSimplify	(	skiatest::Reporter *	reporter,
		const SkPath &	path,
		const char *	filename
	)

Definition at line 526 of file PathOpsExtendedTest.cpp.

                                                                                        {
    return inner_simplify(reporter, path, filename, ExpectSuccess::kYes, SkipAssert::kNo,
            ExpectMatch::kYes);
}

testSimplify() [2/2]

bool testSimplify	(	SkPath &	path,
		bool	useXor,
		SkPath &	out,
		PathOpsThreadState &	state,
		const char *	pathStr
	)

Definition at line 376 of file PathOpsExtendedTest.cpp.

                                       {
    static SkMutex& simplifyDebugOut = *(new SkMutex);
    SkPathFillType fillType = useXor ? SkPathFillType::kEvenOdd : SkPathFillType::kWinding;
    path.setFillType(fillType);
    state.fReporter->bumpTestCount();
    if (!Simplify(path, &out)) {
        SkDebugf("%s did not expect failure\n", __FUNCTION__);
        REPORTER_ASSERT(state.fReporter, 0);
        return false;
    }
    if (!state.fReporter->verbose()) {
        return true;
    }
    int result = comparePaths(state.fReporter, nullptr, path, out, *state.fBitmap);
    if (result) {
        SkAutoMutexExclusive autoM(simplifyDebugOut);
        std::string str;
        const char* pathPrefix = nullptr;
        const char* nameSuffix = nullptr;
        if (fillType == SkPathFillType::kEvenOdd) {
            pathPrefix = "    path.setFillType(SkPathFillType::kEvenOdd);\n";
            nameSuffix = "x";
        }
        const char testFunction[] = "testSimplify(reporter, path);";
        appendTest(pathStr, pathPrefix, nameSuffix, testFunction, false, str);
        SkDebugf("%s", str.c_str());
        REPORTER_ASSERT(state.fReporter, 0);
    }
    state.fReporter->bumpTestCount();
    return result == 0;
}

testSimplifyCheck()

bool testSimplifyCheck	(	skiatest::Reporter *	reporter,
		const SkPath &	path,
		const char *	filename,
		bool	checkFail
	)

Definition at line 536 of file PathOpsExtendedTest.cpp.

                        {
    return inner_simplify(reporter, path, filename, checkFail ?
            ExpectSuccess::kYes : ExpectSuccess::kNo, SkipAssert::kNo, ExpectMatch::kNo);
}

testSimplifyFail()

bool testSimplifyFail	(	skiatest::Reporter *	reporter,
		const SkPath &	path,
		const char *	filename
	)

Definition at line 542 of file PathOpsExtendedTest.cpp.

                                                                                            {
    return inner_simplify(reporter, path, filename,
            ExpectSuccess::kNo, SkipAssert::kYes, ExpectMatch::kNo);
}

testSimplifyFuzz()

bool testSimplifyFuzz	(	skiatest::Reporter *	reporter,
		const SkPath &	path,
		const char *	filename
	)

Definition at line 531 of file PathOpsExtendedTest.cpp.

                                                                                            {
    return inner_simplify(reporter, path, filename, ExpectSuccess::kFlaky, SkipAssert::kYes,
            ExpectMatch::kFlaky);
}