PathOpsThreeWayTest.cpp File Reference

#include "include/core/SkTypes.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTDArray.h"
#include "src/pathops/SkIntersections.h"
#include "src/pathops/SkPathOpsCubic.h"
#include "src/pathops/SkPathOpsLine.h"
#include "src/pathops/SkPathOpsPoint.h"
#include "tests/PathOpsTestCommon.h"
#include "tests/Test.h"
#include <array>

Go to the source code of this file.

Classes
struct	Curve
struct	TestSet

Functions
static void	testSetTest (skiatest::Reporter *reporter, int index)
	DEF_TEST (PathOpsThreeWay, reporter)
	DEF_TEST (PathOpsThreeWayOneOff, reporter)

Variables
static const Curve	testSet0 []
static const Curve	testSet1 []
static const struct TestSet	testSets []
static const int	testSetsCount = (int) std::size(testSets)

Function Documentation

DEF_TEST() [1/2]

DEF_TEST	(	PathOpsThreeWay	,
		reporter
	)

Definition at line 81 of file PathOpsThreeWayTest.cpp.

                                    {
    for (int index = 0; index < testSetsCount; ++index) {
        testSetTest(reporter, index);
        reporter->bumpTestCount();
    }
}

DEF_TEST() [2/2]

DEF_TEST	(	PathOpsThreeWayOneOff	,
		reporter
	)

Definition at line 88 of file PathOpsThreeWayTest.cpp.

                                          {
    int index = 0;
    testSetTest(reporter, index);
}

testSetTest()

static void testSetTest ( skiatest::Reporter *  reporter, int  index  )

static

Definition at line 49 of file PathOpsThreeWayTest.cpp.

                                                               {
    const TestSet& testSet = testSets[index];
    int testCount = testSet.testCount;
    SkASSERT(testCount > 1);
    SkTDArray<SkIntersections> combos;
    for (int outer = 0; outer < testCount - 1; ++outer) {
        const Curve& oTest = testSet.tests[outer];
        for (int inner = outer + 1; inner < testCount; ++inner) {
            const Curve& iTest = testSet.tests[inner];
            SkIntersections* i = combos.append();
            sk_bzero(i, sizeof(SkIntersections));
            SkDLine oLine = {{ oTest.curve.fPts[0], oTest.curve.fPts[1] }};
            SkDLine iLine = {{ iTest.curve.fPts[0], iTest.curve.fPts[1] }};
            SkDCubic iCurve, oCurve;
            iCurve.debugSet(iTest.curve.fPts);
            oCurve.debugSet(oTest.curve.fPts);
            if (oTest.ptCount == 1 && iTest.ptCount == 1) {
                i->intersect(oLine, iLine);
            } else if (oTest.ptCount == 1 && iTest.ptCount == 4) {
                i->intersect(iCurve, oLine);
            } else if (oTest.ptCount == 4 && iTest.ptCount == 1) {
                i->intersect(oCurve, iLine);
            } else if (oTest.ptCount == 4 && iTest.ptCount == 4) {
                i->intersect(oCurve, iCurve);
            } else {
                SkASSERT(0);
            }
//            i->dump();
        }
    }
}

Variable Documentation

testSet0

const Curve testSet0[]

static

Initial value:

= {  
    {4, {{{134,11414}, {131.990234,11414}, {130.32666,11415.4824}, {130.042755,11417.4131}}} },
    {4, {{{130.042755,11417.4131}, {130.233124,11418.3193}, {131.037079,11419}, {132,11419}}} },
    {4, {{{132,11419}, {130.895432,11419}, {130,11418.1045}, {130,11417}}} },
}

Definition at line 26 of file PathOpsThreeWayTest.cpp.

                                {  // extracted from skpClip2
    {4, {{{134,11414}, {131.990234,11414}, {130.32666,11415.4824}, {130.042755,11417.4131}}} },
    {4, {{{130.042755,11417.4131}, {130.233124,11418.3193}, {131.037079,11419}, {132,11419}}} },
    {4, {{{132,11419}, {130.895432,11419}, {130,11418.1045}, {130,11417}}} },
};

testSet1

const Curve testSet1[]

static

Initial value:

= {  
    {4, {{{3,4}, {1,5}, {4,3}, {6,4}}} },
    {1, {{{6,4}, {3,4}}} },
    {4, {{{3,4}, {4,6}, {4,3}, {5,1}}} },
    {1, {{{5,1}, {3,4}}} },
}

Definition at line 32 of file PathOpsThreeWayTest.cpp.

                                {  // extracted from cubicOp85i
    {4, {{{3,4}, {1,5}, {4,3}, {6,4}}} },
    {1, {{{6,4}, {3,4}}} },
    {4, {{{3,4}, {4,6}, {4,3}, {5,1}}} },
    {1, {{{5,1}, {3,4}}} },
};

testSets

const struct TestSet testSets[]

static

Initial value:

= {
    { testSet0, (int) std::size(testSet0) },
    { testSet1, (int) std::size(testSet1) },
}

testSetsCount

const int testSetsCount = (int) std::size(testSets)

static

Definition at line 47 of file PathOpsThreeWayTest.cpp.