PathOpsQuadReduceOrderTest.cpp File Reference

#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkMath.h"
#include "src/pathops/SkPathOpsQuad.h"
#include "src/pathops/SkReduceOrder.h"
#include "tests/PathOpsQuadIntersectionTestData.h"
#include "tests/PathOpsTestCommon.h"
#include "tests/Test.h"
#include <array>
#include <cstddef>

Go to the source code of this file.

Functions
static void	oneOffTest (skiatest::Reporter *reporter)
static void	standardTestCases (skiatest::Reporter *reporter)
	DEF_TEST (PathOpsReduceOrderQuad, reporter)

Variables
static const QuadPts	testSet []
static const size_t	testSetCount = std::size(testSet)

Function Documentation

DEF_TEST()

DEF_TEST	(	PathOpsReduceOrderQuad	,
		reporter
	)

Definition at line 77 of file PathOpsQuadReduceOrderTest.cpp.

                                           {
    oneOffTest(reporter);
    standardTestCases(reporter);
}

oneOffTest()

static void oneOffTest ( skiatest::Reporter *  reporter )

static

Definition at line 26 of file PathOpsQuadReduceOrderTest.cpp.

                                                   {
    for (size_t index = 0; index < testSetCount; ++index) {
        const QuadPts& q = testSet[index];
        SkDQuad quad;
        quad.debugSet(q.fPts);
        SkReduceOrder reducer;
        SkDEBUGCODE(int result = ) reducer.reduce(quad);
        SkASSERT(result == 3);
    }
}

standardTestCases()

static void standardTestCases ( skiatest::Reporter *  reporter )

static

Definition at line 37 of file PathOpsQuadReduceOrderTest.cpp.

                                                          {
    size_t index;
    SkReduceOrder reducer;
    int order;
    enum {
        RunAll,
        RunQuadraticLines,
        RunQuadraticModLines,
        RunNone
    } run = RunAll;
    int firstTestIndex = 0;
#if 0
    run = RunQuadraticLines;
    firstTestIndex = 1;
#endif
    int firstQuadraticLineTest = run == RunAll ? 0 : run == RunQuadraticLines ? firstTestIndex
            : SK_MaxS32;
    int firstQuadraticModLineTest = run == RunAll ? 0 : run == RunQuadraticModLines ? firstTestIndex
            : SK_MaxS32;
 
    for (index = firstQuadraticLineTest; index < quadraticLines_count; ++index) {
        const QuadPts& q = quadraticLines[index];
        SkDQuad quad;
        quad.debugSet(q.fPts);
        order = reducer.reduce(quad);
        if (order != 2) {
            SkDebugf("[%d] line quad order=%d\n", (int) index, order);
        }
    }
    for (index = firstQuadraticModLineTest; index < quadraticModEpsilonLines_count; ++index) {
        const QuadPts& q = quadraticModEpsilonLines[index];
        SkDQuad quad;
        quad.debugSet(q.fPts);
        order = reducer.reduce(quad);
        if (order != 2 && order != 3) {  // FIXME: data probably is not good
            SkDebugf("[%d] line mod quad order=%d\n", (int) index, order);
        }
    }
}

Variable Documentation

testSet

const QuadPts testSet[]

static

Initial value:

= {
    {{{1, 1}, {2, 2}, {1, 1.000003}}},
    {{{1, 0}, {2, 6}, {3, 0}}}
}

Definition at line 19 of file PathOpsQuadReduceOrderTest.cpp.

                                 {
    {{{1, 1}, {2, 2}, {1, 1.000003}}},
    {{{1, 0}, {2, 6}, {3, 0}}}
};

testSetCount

const size_t testSetCount = std::size(testSet)

static

Definition at line 24 of file PathOpsQuadReduceOrderTest.cpp.