src/third_party/skia/tests/EmptyPathTest.cpp

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkCanvas.h"
   9 #include "SkPath.h"
  10 #include "Test.h"
  11
  12 #define DIMENSION   32
  13
  14 static void drawAndTest(skiatest::Reporter* reporter, const SkPath& path,
  15                         const SkPaint& paint, bool shouldDraw) {
  16     SkBitmap bm;
  17     bm.allocN32Pixels(DIMENSION, DIMENSION);
  18     SkASSERT(DIMENSION*4 == bm.rowBytes()); // ensure no padding on each row
  19     bm.eraseColor(SK_ColorTRANSPARENT);
  20
  21     SkCanvas canvas(bm);
  22     SkPaint p(paint);
  23     p.setColor(SK_ColorWHITE);
  24
  25     canvas.drawPath(path, p);
  26
  27     size_t count = DIMENSION * DIMENSION;
  28     const SkPMColor* ptr = bm.getAddr32(0, 0);
  29
  30     SkPMColor andValue = ~0U;
  31     SkPMColor orValue = 0;
  32     for (size_t i = 0; i < count; ++i) {
  33         SkPMColor c = ptr[i];
  34         andValue &= c;
  35         orValue |= c;
  36     }
  37
  38     // success means we drew everywhere or nowhere (depending on shouldDraw)
  39     bool success = shouldDraw ? (~0U == andValue) : (0 == orValue);
  40
  41     if (!success) {
  42         const char* str;
  43         if (shouldDraw) {
  44             str = "Path expected to draw everywhere, but didn't. ";
  45         } else {
  46             str = "Path expected to draw nowhere, but did. ";
  47         }
  48         ERRORF(reporter, "%s style[%d] cap[%d] join[%d] antialias[%d]"
  49                " filltype[%d] ptcount[%d]", str, paint.getStyle(),
  50                paint.getStrokeCap(), paint.getStrokeJoin(),
  51                paint.isAntiAlias(), path.getFillType(), path.countPoints());
  52 // uncomment this if you want to step in to see the failure
  53 //        canvas.drawPath(path, p);
  54     }
  55 }
  56
  57 static void iter_paint(skiatest::Reporter* reporter, const SkPath& path, bool shouldDraw) {
  58     static const SkPaint::Cap gCaps[] = {
  59         SkPaint::kButt_Cap,
  60         SkPaint::kRound_Cap,
  61         SkPaint::kSquare_Cap
  62     };
  63     static const SkPaint::Join gJoins[] = {
  64         SkPaint::kMiter_Join,
  65         SkPaint::kRound_Join,
  66         SkPaint::kBevel_Join
  67     };
  68     static const SkPaint::Style gStyles[] = {
  69         SkPaint::kFill_Style,
  70         SkPaint::kStroke_Style,
  71         SkPaint::kStrokeAndFill_Style
  72     };
  73     for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
  74         for (size_t join = 0; join < SK_ARRAY_COUNT(gJoins); ++join) {
  75             for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
  76                 SkPaint paint;
  77                 paint.setStrokeWidth(SkIntToScalar(10));
  78
  79                 paint.setStrokeCap(gCaps[cap]);
  80                 paint.setStrokeJoin(gJoins[join]);
  81                 paint.setStyle(gStyles[style]);
  82
  83                 paint.setAntiAlias(false);
  84                 drawAndTest(reporter, path, paint, shouldDraw);
  85                 paint.setAntiAlias(true);
  86                 drawAndTest(reporter, path, paint, shouldDraw);
  87             }
  88         }
  89     }
  90 }
  91
  92 #define CX  (SkIntToScalar(DIMENSION) / 2)
  93 #define CY  (SkIntToScalar(DIMENSION) / 2)
  94
  95 static void make_empty(SkPath*) {}
  96 static void make_M(SkPath* path) { path->moveTo(CX, CY); }
  97 static void make_MM(SkPath* path) { path->moveTo(CX, CY); path->moveTo(CX, CY); }
  98 static void make_MZM(SkPath* path) { path->moveTo(CX, CY); path->close(); path->moveTo(CX, CY); }
  99 static void make_L(SkPath* path) { path->moveTo(CX, CY); path->lineTo(CX, CY); }
 100 static void make_Q(SkPath* path) { path->moveTo(CX, CY); path->quadTo(CX, CY, CX, CY); }
 101 static void make_C(SkPath* path) { path->moveTo(CX, CY); path->cubicTo(CX, CY, CX, CY, CX, CY); }
 102
 103 /*  Two invariants are tested: How does an empty/degenerate path draw?
 104  *  - if the path is drawn inverse, it should draw everywhere
 105  *  - if the path is drawn non-inverse, it should draw nowhere
 106  *
 107  *  Things to iterate on:
 108  *  - path (empty, degenerate line/quad/cubic w/ and w/o close
 109  *  - paint style
 110  *  - path filltype
 111  *  - path stroke variants (e.g. caps, joins, width)
 112  */
 113 static void test_emptydrawing(skiatest::Reporter* reporter) {
 114     static void (*gMakeProc[])(SkPath*) = {
 115         make_empty, make_M, make_MM, make_MZM, make_L, make_Q, make_C
 116     };
 117     static SkPath::FillType gFills[] = {
 118         SkPath::kWinding_FillType,
 119         SkPath::kEvenOdd_FillType,
 120         SkPath::kInverseWinding_FillType,
 121         SkPath::kInverseEvenOdd_FillType
 122     };
 123     for (int doClose = 0; doClose < 2; ++doClose) {
 124         for  (size_t i = 0; i < SK_ARRAY_COUNT(gMakeProc); ++i) {
 125             SkPath path;
 126             gMakeProc[i](&path);
 127             if (doClose) {
 128                 path.close();
 129             }
 130             for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
 131                 path.setFillType(gFills[fill]);
 132                 bool shouldDraw = path.isInverseFillType();
 133                 iter_paint(reporter, path, shouldDraw);
 134             }
 135         }
 136     }
 137 }
 138
 139 DEF_TEST(EmptyPath, reporter) {
 140     test_emptydrawing(reporter);
 141 }