Home | History | Annotate | Download | only in tests 
      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 "SkColorPriv.h"
     10 #include "SkColorShader.h"
     11 #include "SkGradientShader.h"
     12 #include "SkShader.h"
     13 #include "SkSurface.h"
     14 #include "SkTemplates.h"
     15 #include "SkTLazy.h"
     16 #include "Test.h"
     17 
     18 // https://code.google.com/p/chromium/issues/detail?id=448299
     19 // Giant (inverse) matrix causes overflow when converting/computing using 32.32
     20 // Before the fix, we would assert (and then crash).
     21 static void test_big_grad(skiatest::Reporter* reporter) {
     22     const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
     23     const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
     24     SkPaint paint;
     25     paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
     26                                                  SkShader::kClamp_TileMode));
     27 
     28     SkBitmap bm;
     29     bm.allocN32Pixels(2000, 1);
     30     SkCanvas c(bm);
     31 
     32     const SkScalar affine[] = {
     33         1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f
     34     };
     35     SkMatrix matrix;
     36     matrix.setAffine(affine);
     37     c.concat(matrix);
     38 
     39     c.drawPaint(paint);
     40 }
     41 
     42 struct GradRec {
     43     int             fColorCount;
     44     const SkColor*  fColors;
     45     const SkScalar* fPos;
     46     const SkPoint*  fPoint;   // 2
     47     const SkScalar* fRadius; // 2
     48     SkShader::TileMode fTileMode;
     49 
     50     void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
     51                    SkShader::GradientInfo* info,
     52                    SkShader::GradientType gt) const {
     53         SkAutoTMalloc<SkColor> colorStorage(fColorCount);
     54         SkAutoTMalloc<SkScalar> posStorage(fColorCount);
     55 
     56         info->fColorCount = fColorCount;
     57         info->fColors = colorStorage;
     58         info->fColorOffsets = posStorage.get();
     59         REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt);
     60 
     61         REPORTER_ASSERT(reporter, info->fColorCount == fColorCount);
     62         REPORTER_ASSERT(reporter,
     63                         !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
     64         REPORTER_ASSERT(reporter,
     65                         !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
     66         REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
     67     }
     68 };
     69 
     70 
     71 static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const GradRec&) {
     72     sk_sp<SkShader> s(SkShader::MakeEmptyShader());
     73     REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
     74 }
     75 
     76 static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) {
     77     sk_sp<SkShader> s(new SkColorShader(rec.fColors[0]));
     78     REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
     79 
     80     SkShader::GradientInfo info;
     81     info.fColors = nullptr;
     82     info.fColorCount = 0;
     83     s->asAGradient(&info);
     84     REPORTER_ASSERT(reporter, 1 == info.fColorCount);
     85 }
     86 
     87 static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
     88                             const GradRec& checkRec) {
     89     sk_sp<SkShader> s(SkGradientShader::MakeLinear(buildRec.fPoint, buildRec.fColors, buildRec.fPos,
     90                                                    buildRec.fColorCount, buildRec.fTileMode));
     91 
     92     SkShader::GradientInfo info;
     93     checkRec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
     94     REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
     95 }
     96 
     97 static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
     98                             const GradRec& checkRec) {
     99     sk_sp<SkShader> s(SkGradientShader::MakeRadial(buildRec.fPoint[0], buildRec.fRadius[0],
    100                                                    buildRec.fColors, buildRec.fPos,
    101                                                    buildRec.fColorCount, buildRec.fTileMode));
    102 
    103     SkShader::GradientInfo info;
    104     checkRec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
    105     REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
    106     REPORTER_ASSERT(reporter, info.fRadius[0] == checkRec.fRadius[0]);
    107 }
    108 
    109 static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
    110                            const GradRec& checkRec) {
    111     sk_sp<SkShader> s(SkGradientShader::MakeSweep(buildRec.fPoint[0].fX, buildRec.fPoint[0].fY,
    112                                                   buildRec.fColors, buildRec.fPos,
    113                                                   buildRec.fColorCount));
    114 
    115     SkShader::GradientInfo info;
    116     checkRec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
    117     REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
    118 }
    119 
    120 static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
    121                              const GradRec& checkRec) {
    122     sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(buildRec.fPoint[0],
    123                                                             buildRec.fRadius[0],
    124                                                             buildRec.fPoint[1],
    125                                                             buildRec.fRadius[1],
    126                                                             buildRec.fColors,
    127                                                             buildRec.fPos,
    128                                                             buildRec.fColorCount,
    129                                                             buildRec.fTileMode));
    130 
    131     SkShader::GradientInfo info;
    132     checkRec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
    133     REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
    134     REPORTER_ASSERT(reporter, !memcmp(info.fRadius, checkRec.fRadius, 2 * sizeof(SkScalar)));
    135 }
    136 
    137 // Ensure that repeated color gradients behave like drawing a single color
    138 static void TestConstantGradient(skiatest::Reporter*) {
    139     const SkPoint pts[] = {
    140         { 0, 0 },
    141         { SkIntToScalar(10), 0 }
    142     };
    143     SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
    144     const SkScalar pos[] = { 0, SK_Scalar1 };
    145     SkPaint paint;
    146     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
    147     SkBitmap outBitmap;
    148     outBitmap.allocN32Pixels(10, 1);
    149     SkCanvas canvas(outBitmap);
    150     canvas.drawPaint(paint);
    151     for (int i = 0; i < 10; i++) {
    152         // The following is commented out because it currently fails
    153         // Related bug: https://code.google.com/p/skia/issues/detail?id=1098
    154 
    155         // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
    156     }
    157 }
    158 
    159 typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&, const GradRec&);
    160 
    161 static void TestGradientShaders(skiatest::Reporter* reporter) {
    162     static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
    163     static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
    164     static const SkPoint gPts[] = {
    165         { 0, 0 },
    166         { SkIntToScalar(10), SkIntToScalar(20) }
    167     };
    168     static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) };
    169 
    170     GradRec rec;
    171     rec.fColorCount = SK_ARRAY_COUNT(gColors);
    172     rec.fColors = gColors;
    173     rec.fPos = gPos;
    174     rec.fPoint = gPts;
    175     rec.fRadius = gRad;
    176     rec.fTileMode = SkShader::kClamp_TileMode;
    177 
    178     static const GradProc gProcs[] = {
    179         none_gradproc,
    180         color_gradproc,
    181         linear_gradproc,
    182         radial_gradproc,
    183         sweep_gradproc,
    184         conical_gradproc,
    185     };
    186 
    187     for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
    188         gProcs[i](reporter, rec, rec);
    189     }
    190 }
    191 
    192 static void TestGradientOptimization(skiatest::Reporter* reporter) {
    193     static const struct {
    194         GradProc fProc;
    195         bool     fIsClampRestricted;
    196     } gProcInfo[] = {
    197         { linear_gradproc , false },
    198         { radial_gradproc , false },
    199         { sweep_gradproc  , true  }, // sweep is funky in that it always pretends to be kClamp.
    200         { conical_gradproc, false },
    201     };
    202 
    203     static const SkColor   gC_00[] = { 0xff000000, 0xff000000 };
    204     static const SkColor   gC_01[] = { 0xff000000, 0xffffffff };
    205     static const SkColor   gC_11[] = { 0xffffffff, 0xffffffff };
    206     static const SkColor  gC_001[] = { 0xff000000, 0xff000000, 0xffffffff };
    207     static const SkColor  gC_011[] = { 0xff000000, 0xffffffff, 0xffffffff };
    208     static const SkColor gC_0011[] = { 0xff000000, 0xff000000, 0xffffffff, 0xffffffff };
    209 
    210     static const SkScalar   gP_01[] = { 0, 1 };
    211     static const SkScalar  gP_001[] = { 0,   0, 1 };
    212     static const SkScalar  gP_011[] = { 0,   1, 1 };
    213     static const SkScalar  gP_0x1[] = { 0, .5f, 1 };
    214     static const SkScalar gP_0011[] = { 0, 0, 1, 1 };
    215 
    216     static const SkPoint    gPts[] = { {0, 0}, {1, 1} };
    217     static const SkScalar gRadii[] = { 1, 2 };
    218 
    219     static const struct {
    220         const SkColor*  fCol;
    221         const SkScalar* fPos;
    222         int             fCount;
    223 
    224         const SkColor*  fExpectedCol;
    225         const SkScalar* fExpectedPos;
    226         int             fExpectedCount;
    227         bool            fRequiresNonClamp;
    228     } gTests[] = {
    229         { gC_001,  gP_001, 3,  gC_01,  gP_01, 2, false },
    230         { gC_001,  gP_011, 3,  gC_00,  gP_01, 2, true  },
    231         { gC_001,  gP_0x1, 3, gC_001, gP_0x1, 3, false },
    232         { gC_001, nullptr, 3, gC_001, gP_0x1, 3, false },
    233 
    234         { gC_011,  gP_001, 3,  gC_11,  gP_01, 2, true  },
    235         { gC_011,  gP_011, 3,  gC_01,  gP_01, 2, false },
    236         { gC_011,  gP_0x1, 3, gC_011, gP_0x1, 3, false },
    237         { gC_011, nullptr, 3, gC_011, gP_0x1, 3, false },
    238 
    239         { gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false },
    240     };
    241 
    242     const SkShader::TileMode modes[] = {
    243         SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode,
    244         // TODO: add kDecal_TileMode when it is implemented
    245     };
    246     for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) {
    247         for (auto mode : modes) {
    248             if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) {
    249                 continue;
    250             }
    251 
    252             for (size_t t = 0; t < SK_ARRAY_COUNT(gTests); ++t) {
    253                 GradRec rec;
    254                 rec.fColorCount = gTests[t].fCount;
    255                 rec.fColors     = gTests[t].fCol;
    256                 rec.fPos        = gTests[t].fPos;
    257                 rec.fTileMode   = static_cast<SkShader::TileMode>(mode);
    258                 rec.fPoint      = gPts;
    259                 rec.fRadius     = gRadii;
    260 
    261                 GradRec expected = rec;
    262                 if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) {
    263                     expected.fColorCount = gTests[t].fExpectedCount;
    264                     expected.fColors     = gTests[t].fExpectedCol;
    265                     expected.fPos        = gTests[t].fExpectedPos;
    266                 }
    267 
    268                 gProcInfo[i].fProc(reporter, rec, expected);
    269             }
    270         }
    271     }
    272 }
    273 
    274 static void test_nearly_vertical(skiatest::Reporter* reporter) {
    275     auto surface(SkSurface::MakeRasterN32Premul(200, 200));
    276 
    277     const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
    278     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
    279     const SkScalar pos[] = { 0, 1 };
    280     SkPaint paint;
    281     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
    282 
    283     surface->getCanvas()->drawPaint(paint);
    284 }
    285 
    286 static void test_vertical(skiatest::Reporter* reporter) {
    287     auto surface(SkSurface::MakeRasterN32Premul(200, 200));
    288 
    289     const SkPoint pts[] = {{ 100, 50 }, { 100, 50 }};
    290     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
    291     const SkScalar pos[] = { 0, 1 };
    292     SkPaint paint;
    293     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
    294 
    295     surface->getCanvas()->drawPaint(paint);
    296 }
    297 
    298 // A linear gradient interval can, due to numerical imprecision (likely in the divide)
    299 // finish an interval with the final fx not landing outside of [p0...p1].
    300 // The old code had an assert which this test triggered.
    301 // We now explicitly clamp the resulting fx value.
    302 static void test_linear_fuzz(skiatest::Reporter* reporter) {
    303     auto surface(SkSurface::MakeRasterN32Premul(1300, 630));
    304 
    305     const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }};
    306     const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
    307     const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
    308 
    309     SkPaint paint;
    310     paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
    311 
    312     SkRect r = {0, 83, 1254, 620};
    313     surface->getCanvas()->drawRect(r, paint);
    314 }
    315 
    316 // https://bugs.chromium.org/p/skia/issues/detail?id=5023
    317 // We should still shade pixels for which the radius is exactly 0.
    318 static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
    319     auto surface(SkSurface::MakeRasterN32Premul(5, 5));
    320     surface->getCanvas()->clear(SK_ColorRED);
    321 
    322     const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
    323     SkPaint p;
    324     p.setShader(SkGradientShader::MakeTwoPointConical(
    325         SkPoint::Make(2.5f, 2.5f), 0,
    326         SkPoint::Make(3.0f, 3.0f), 10,
    327         colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
    328     surface->getCanvas()->drawPaint(p);
    329 
    330     // r == 0 for the center pixel.
    331     // verify that we draw it (no red bleed)
    332     SkPMColor centerPMColor;
    333     surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), &centerPMColor, sizeof(SkPMColor), 2, 2);
    334     REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0);
    335 }
    336 
    337 // http://crbug.com/599458
    338 static void test_clamping_overflow(skiatest::Reporter*) {
    339     SkPaint p;
    340     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
    341     const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
    342 
    343     p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
    344 
    345     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
    346     surface->getCanvas()->scale(100, 100);
    347     surface->getCanvas()->drawPaint(p);
    348 
    349     const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
    350     p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
    351     surface->getCanvas()->drawPaint(p);
    352 
    353     // Passes if we don't trigger asserts.
    354 }
    355 
    356 // http://crbug.com/636194
    357 static void test_degenerate_linear(skiatest::Reporter*) {
    358     SkPaint p;
    359     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
    360     const SkPoint pts[] = {
    361         SkPoint::Make(-46058024627067344430605278824628224.0f, 0),
    362         SkPoint::Make(SK_ScalarMax, 0)
    363     };
    364 
    365     p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
    366     sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
    367     surface->getCanvas()->drawPaint(p);
    368 
    369     // Passes if we don't trigger asserts.
    370 }
    371 
    372 // "Interesting" fuzzer values.
    373 static void test_linear_fuzzer(skiatest::Reporter*) {
    374     static const SkColor gColors0[] = { 0x30303030, 0x30303030 };
    375     static const SkColor gColors1[] = { 0x30303030, 0x30303030, 0x30303030 };
    376 
    377     static const SkScalar gPos1[]   = { 0, 0, 1 };
    378 
    379     static const SkScalar gMatrix0[9] = {
    380         6.40969056e-10f, 0              , 6.40969056e-10f,
    381         0              , 4.42539023e-39f, 6.40969056e-10f,
    382         0              , 0              , 1
    383     };
    384     static const SkScalar gMatrix1[9] = {
    385         -2.75294113f    , 6.40969056e-10f,  6.40969056e-10f,
    386          6.40969056e-10f, 6.40969056e-10f, -3.32810161e+24f,
    387          6.40969056e-10f, 6.40969056e-10f,  0
    388     };
    389     static const SkScalar gMatrix2[9] = {
    390         7.93481258e+17f, 6.40969056e-10f, 6.40969056e-10f,
    391         6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f,
    392         6.40969056e-10f, 6.40969056e-10f, 0.688235283f
    393     };
    394     static const SkScalar gMatrix3[9] = {
    395         1.89180674e+11f,     6.40969056e-10f, 6.40969056e-10f,
    396         6.40969056e-10f,     6.40969056e-10f, 6.40969056e-10f,
    397         6.40969056e-10f, 11276.0469f        , 8.12524808e+20f
    398     };
    399 
    400     static const struct {
    401         SkPoint            fPts[2];
    402         const SkColor*     fColors;
    403         const SkScalar*    fPos;
    404         int                fCount;
    405         SkShader::TileMode fTileMode;
    406         uint32_t           fFlags;
    407         const SkScalar*    fLocalMatrix;
    408         const SkScalar*    fGlobalMatrix;
    409     } gConfigs[] = {
    410         {
    411             {{0, -2.752941f}, {0, 0}},
    412             gColors0,
    413             nullptr,
    414             SK_ARRAY_COUNT(gColors0),
    415             SkShader::kClamp_TileMode,
    416             0,
    417             gMatrix0,
    418             nullptr
    419         },
    420         {
    421             {{4.42539023e-39f, -4.42539023e-39f}, {9.78041162e-15f, 4.42539023e-39f}},
    422             gColors1,
    423             gPos1,
    424             SK_ARRAY_COUNT(gColors1),
    425             SkShader::kClamp_TileMode,
    426             0,
    427             nullptr,
    428             gMatrix1
    429         },
    430         {
    431             {{4.42539023e-39f, 6.40969056e-10f}, {6.40969056e-10f, 1.49237238e-19f}},
    432             gColors1,
    433             gPos1,
    434             SK_ARRAY_COUNT(gColors1),
    435             SkShader::kClamp_TileMode,
    436             0,
    437             nullptr,
    438             gMatrix2
    439         },
    440         {
    441             {{6.40969056e-10f, 6.40969056e-10f}, {6.40969056e-10f, -0.688235283f}},
    442             gColors0,
    443             nullptr,
    444             SK_ARRAY_COUNT(gColors0),
    445             SkShader::kClamp_TileMode,
    446             0,
    447             gMatrix3,
    448             nullptr
    449         },
    450     };
    451 
    452     sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
    453     SkColorSpace* colorSpaces[] = {
    454         nullptr,     // hits the legacy gradient impl
    455         srgb.get(),  // triggers 4f/raster-pipeline
    456     };
    457 
    458     SkPaint paint;
    459 
    460     for (auto colorSpace : colorSpaces) {
    461 
    462         sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::Make(100, 100,
    463                                                                            kN32_SkColorType,
    464                                                                            kPremul_SkAlphaType,
    465                                                                            sk_ref_sp(colorSpace)));
    466         SkCanvas* canvas = surface->getCanvas();
    467 
    468         for (const auto& config : gConfigs) {
    469             SkAutoCanvasRestore acr(canvas, false);
    470             SkTLazy<SkMatrix> localMatrix;
    471             if (config.fLocalMatrix) {
    472                 localMatrix.init();
    473                 localMatrix.get()->set9(config.fLocalMatrix);
    474             }
    475 
    476             paint.setShader(SkGradientShader::MakeLinear(config.fPts,
    477                                                          config.fColors,
    478                                                          config.fPos,
    479                                                          config.fCount,
    480                                                          config.fTileMode,
    481                                                          config.fFlags,
    482                                                          localMatrix.getMaybeNull()));
    483             if (config.fGlobalMatrix) {
    484                 SkMatrix m;
    485                 m.set9(config.fGlobalMatrix);
    486                 canvas->save();
    487                 canvas->concat(m);
    488             }
    489 
    490             canvas->drawPaint(paint);
    491         }
    492     }
    493 }
    494 
    495 static void test_sweep_fuzzer(skiatest::Reporter*) {
    496     static const SkColor gColors0[] = { 0x30303030, 0x30303030, 0x30303030 };
    497     static const SkScalar   gPos0[] = { -47919293023455565225163489280.0f, 0, 1 };
    498     static const SkScalar gMatrix0[9] = {
    499         1.12116716e-13f,  0              ,  8.50489682e+16f,
    500         4.1917041e-41f ,  3.51369881e-23f, -2.54344271e-26f,
    501         9.61111907e+17f, -3.35263808e-29f, -1.35659403e+14f
    502     };
    503     static const struct {
    504         SkPoint            fCenter;
    505         const SkColor*     fColors;
    506         const SkScalar*    fPos;
    507         int                fCount;
    508         const SkScalar*    fGlobalMatrix;
    509     } gConfigs[] = {
    510         {
    511             { 0, 0 },
    512             gColors0,
    513             gPos0,
    514             SK_ARRAY_COUNT(gColors0),
    515             gMatrix0
    516         },
    517     };
    518 
    519     sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100);
    520     SkCanvas* canvas = surface->getCanvas();
    521     SkPaint paint;
    522 
    523     for (const auto& config : gConfigs) {
    524         paint.setShader(SkGradientShader::MakeSweep(config.fCenter.x(),
    525                                                     config.fCenter.y(),
    526                                                     config.fColors,
    527                                                     config.fPos,
    528                                                     config.fCount));
    529 
    530         SkAutoCanvasRestore acr(canvas, false);
    531         if (config.fGlobalMatrix) {
    532             SkMatrix m;
    533             m.set9(config.fGlobalMatrix);
    534             canvas->save();
    535             canvas->concat(m);
    536         }
    537         canvas->drawPaint(paint);
    538     }
    539 }
    540 
    541 DEF_TEST(Gradient, reporter) {
    542     TestGradientShaders(reporter);
    543     TestGradientOptimization(reporter);
    544     TestConstantGradient(reporter);
    545     test_big_grad(reporter);
    546     test_nearly_vertical(reporter);
    547     test_vertical(reporter);
    548     test_linear_fuzz(reporter);
    549     test_two_point_conical_zero_radius(reporter);
    550     test_clamping_overflow(reporter);
    551     test_degenerate_linear(reporter);
    552     test_linear_fuzzer(reporter);
    553     test_sweep_fuzzer(reporter);
    554 }
    555