EmptyPathTest.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTo.h"
#include "tests/Test.h"
#include <array>
#include <cstddef>

Go to the source code of this file.

Macros
#define	DIMENSION   32
#define	CX   (SkIntToScalar(DIMENSION) / 2)
#define	CY   (SkIntToScalar(DIMENSION) / 2)

Enumerations
enum	DrawCaps { kDontDrawCaps , kDrawCaps }

Functions
static void	drawAndTest (skiatest::Reporter *reporter, const SkPath &path, const SkPaint &paint, bool shouldDraw)
static void	iter_paint (skiatest::Reporter *reporter, const SkPath &path, bool shouldDraw, DrawCaps drawCaps)
static void	make_empty (SkPath *)
static void	make_M (SkPath *path)
static void	make_MM (SkPath *path)
static void	make_MZM (SkPath *path)
static void	make_L (SkPath *path)
static void	make_Q (SkPath *path)
static void	make_C (SkPath *path)
static void	test_emptydrawing (skiatest::Reporter *reporter)
	DEF_TEST (EmptyPath, reporter)

Macro Definition Documentation

CX

#define CX   (SkIntToScalar(DIMENSION) / 2)

Definition at line 113 of file EmptyPathTest.cpp.

CY

#define CY   (SkIntToScalar(DIMENSION) / 2)

Definition at line 114 of file EmptyPathTest.cpp.

DIMENSION

#define DIMENSION   32

Definition at line 22 of file EmptyPathTest.cpp.

Enumeration Type Documentation

DrawCaps

enum DrawCaps

Enumerator
kDontDrawCaps
kDrawCaps

Definition at line 67 of file EmptyPathTest.cpp.

              {
    kDontDrawCaps,
    kDrawCaps
};

Function Documentation

DEF_TEST()

DEF_TEST	(	EmptyPath	,
		reporter
	)

Definition at line 164 of file EmptyPathTest.cpp.

                              {
    test_emptydrawing(reporter);
}

drawAndTest()

static void drawAndTest ( skiatest::Reporter *  reporter, const SkPath &  path, const SkPaint &  paint, bool  shouldDraw  )

static

Definition at line 24 of file EmptyPathTest.cpp.

                                                               {
    SkBitmap bm;
    bm.allocN32Pixels(DIMENSION, DIMENSION);
    SkASSERT(DIMENSION*4 == bm.rowBytes()); // ensure no padding on each row
    bm.eraseColor(SK_ColorTRANSPARENT);
 
    SkCanvas canvas(bm);
    SkPaint p(paint);
    p.setColor(SK_ColorWHITE);
 
    canvas.drawPath(path, p);
 
    size_t count = DIMENSION * DIMENSION;
    const SkPMColor* ptr = bm.getAddr32(0, 0);
 
    SkPMColor andValue = ~0U;
    SkPMColor orValue = 0;
    for (size_t i = 0; i < count; ++i) {
        SkPMColor c = ptr[i];
        andValue &= c;
        orValue |= c;
    }
 
    // success means we drew everywhere or nowhere (depending on shouldDraw)
    bool success = shouldDraw ? (~0U == andValue) : (0 == orValue);
 
    if (!success) {
        const char* str;
        if (shouldDraw) {
            str = "Path expected to draw everywhere, but didn't. ";
        } else {
            str = "Path expected to draw nowhere, but did. ";
        }
        ERRORF(reporter, "%s style[%d] cap[%d] join[%d] antialias[%d]"
               " filltype[%d] ptcount[%d]", str, paint.getStyle(),
               paint.getStrokeCap(), paint.getStrokeJoin(),
               paint.isAntiAlias(), (int)path.getFillType(), path.countPoints());
// uncomment this if you want to step in to see the failure
//        canvas.drawPath(path, p);
    }
}

iter_paint()

static void iter_paint ( skiatest::Reporter *  reporter, const SkPath &  path, bool  shouldDraw, DrawCaps  drawCaps  )

static

Definition at line 72 of file EmptyPathTest.cpp.

                                          {
    static const SkPaint::Cap gCaps[] = {
        SkPaint::kButt_Cap,
        SkPaint::kRound_Cap,
        SkPaint::kSquare_Cap
    };
    static const SkPaint::Join gJoins[] = {
        SkPaint::kMiter_Join,
        SkPaint::kRound_Join,
        SkPaint::kBevel_Join
    };
    static const SkPaint::Style gStyles[] = {
        SkPaint::kFill_Style,
        SkPaint::kStroke_Style,
        SkPaint::kStrokeAndFill_Style
    };
    for (size_t cap = 0; cap < std::size(gCaps); ++cap) {
        for (size_t join = 0; join < std::size(gJoins); ++join) {
            for (size_t style = 0; style < std::size(gStyles); ++style) {
                if (drawCaps && SkPaint::kButt_Cap != gCaps[cap]
                        && SkPaint::kFill_Style != gStyles[style]) {
                    continue;
                }
 
                SkPaint paint;
                paint.setStrokeWidth(SkIntToScalar(10));
 
                paint.setStrokeCap(gCaps[cap]);
                paint.setStrokeJoin(gJoins[join]);
                paint.setStyle(gStyles[style]);
 
                paint.setAntiAlias(false);
                drawAndTest(reporter, path, paint, shouldDraw);
                paint.setAntiAlias(true);
                drawAndTest(reporter, path, paint, shouldDraw);
            }
        }
    }
}

make_C()

static void make_C ( SkPath *  path )

static

Definition at line 122 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY).cubicTo(CX, CY, CX, CY, CX, CY); }

make_empty()

static void make_empty ( SkPath *  )

static

Definition at line 116 of file EmptyPathTest.cpp.

{}

make_L()

static void make_L ( SkPath *  path )

static

Definition at line 120 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY).lineTo(CX, CY); }

make_M()

static void make_M ( SkPath *  path )

static

Definition at line 117 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY); }

make_MM()

static void make_MM ( SkPath *  path )

static

Definition at line 118 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY).moveTo(CX, CY); }

make_MZM()

static void make_MZM ( SkPath *  path )

static

Definition at line 119 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY).close().moveTo(CX, CY); }

make_Q()

static void make_Q ( SkPath *  path )

static

Definition at line 121 of file EmptyPathTest.cpp.

{ path->moveTo(CX, CY).quadTo(CX, CY, CX, CY); }

test_emptydrawing()

static void test_emptydrawing ( skiatest::Reporter *  reporter )

static

Definition at line 134 of file EmptyPathTest.cpp.

                                                          {
    static void (*gMakeProc[])(SkPath*) = {
        make_empty, make_M, make_MM, make_MZM, make_L, make_Q, make_C
    };
    static SkPathFillType gFills[] = {
        SkPathFillType::kWinding,
        SkPathFillType::kEvenOdd,
        SkPathFillType::kInverseWinding,
        SkPathFillType::kInverseEvenOdd
    };
    for (int doClose = 0; doClose < 2; ++doClose) {
        for  (size_t i = 0; i < std::size(gMakeProc); ++i) {
            SkPath path;
            gMakeProc[i](&path);
            if (doClose) {
                path.close();
            }
            /* zero length segments and close following moves draw round and square caps */
            bool allowCaps = make_L == gMakeProc[i] || make_Q == gMakeProc[i]
                    || make_C == gMakeProc[i] || make_MZM == gMakeProc[i];
            allowCaps |= SkToBool(doClose);
            for (size_t fill = 0; fill < std::size(gFills); ++fill) {
                path.setFillType(gFills[fill]);
                bool shouldDraw = path.isInverseFillType();
                iter_paint(reporter, path, shouldDraw, allowCaps ? kDrawCaps : kDontDrawCaps);
            }
        }
    }
}