static void fuzz763_1(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
path.setFillType((SkPath::FillType) 0);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0xbcb63000), SkBits2Float(0xb6b6b6b7), SkBits2Float(0x38b6b6b6), SkBits2Float(0xafb63a5a), SkBits2Float(0xca000087), SkBits2Float(0xe93ae9e9)); // -0.0222397f, -5.44529e-06f, 8.71247e-05f, -3.31471e-10f, -2.09719e+06f, -1.41228e+25f
path.quadTo(SkBits2Float(0xb6007fb6), SkBits2Float(0xb69fb6b6), SkBits2Float(0xe9e964b6), SkBits2Float(0xe9e9e9e9)); // -1.91478e-06f, -4.75984e-06f, -3.52694e+25f, -3.5348e+25f
path.quadTo(SkBits2Float(0xb6b6b8b7), SkBits2Float(0xb60000b6), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e92064)); // -5.44553e-06f, -1.90739e-06f, -5.44529e-06f, -3.52291e+25f
path.quadTo(SkBits2Float(0x000200e9), SkBits2Float(0xe9e9d100), SkBits2Float(0xe93ae9e9), SkBits2Float(0xe964b6e9)); // 1.83997e-40f, -3.53333e+25f, -1.41228e+25f, -1.72812e+25f
path.quadTo(SkBits2Float(0x40b6e9e9), SkBits2Float(0xe9b60000), SkBits2Float(0x00b6b8e9), SkBits2Float(0xe9000001)); // 5.71605f, -2.75031e+25f, 1.67804e-38f, -9.67141e+24f
path.quadTo(SkBits2Float(0xe9d3b6b2), SkBits2Float(0x40404540), SkBits2Float(0x803d4043), SkBits2Float(0xe9e9e9ff)); // -3.19933e+25f, 3.00423f, -5.62502e-39f, -3.53481e+25f
path.cubicTo(SkBits2Float(0x00000000), SkBits2Float(0xe8b3b6b6), SkBits2Float(0xe90a0003), SkBits2Float(0x4040403c), SkBits2Float(0x803d4040), SkBits2Float(0xe9e80900)); // 0, -6.78939e+24f, -1.0427e+25f, 3.00392f, -5.62501e-39f, -3.50642e+25f
path.quadTo(SkBits2Float(0xe9e910e9), SkBits2Float(0xe9e93ae9), SkBits2Float(0x0000b6b6), SkBits2Float(0xb6b6aab6)); // -3.52199e+25f, -3.52447e+25f, 6.55443e-41f, -5.4439e-06f
path.moveTo(SkBits2Float(0xe9e92064), SkBits2Float(0xe9e9d106)); // -3.52291e+25f, -3.53334e+25f
path.quadTo(SkBits2Float(0xe9e93ae9), SkBits2Float(0x0000abb6), SkBits2Float(0xb6b6bdb6), SkBits2Float(0xe92064b6)); // -3.52447e+25f, 6.15983e-41f, -5.44611e-06f, -1.2119e+25f
path.quadTo(SkBits2Float(0x0000e9e9), SkBits2Float(0xb6b6b6e9), SkBits2Float(0x05ffff05), SkBits2Float(0xe9ea06e9)); // 8.39112e-41f, -5.44532e-06f, 2.40738e-35f, -3.53652e+25f
path.quadTo(SkBits2Float(0xe93ae9e9), SkBits2Float(0x02007fe9), SkBits2Float(0xb8b7b600), SkBits2Float(0xe9e9b6b6)); // -1.41228e+25f, 9.44066e-38f, -8.76002e-05f, -3.53178e+25f
path.quadTo(SkBits2Float(0xe9e9e9b6), SkBits2Float(0xedb6b6b6), SkBits2Float(0x5a38a1b6), SkBits2Float(0xe93ae9e9)); // -3.53479e+25f, -7.06839e+27f, 1.29923e+16f, -1.41228e+25f
path.quadTo(SkBits2Float(0x0000b6b6), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e9e9b6), SkBits2Float(0xe9e9e954)); // 6.55443e-41f, -5.44529e-06f, -3.53479e+25f, -3.53477e+25f
path.quadTo(SkBits2Float(0xb6e9e93a), SkBits2Float(0x375837ff), SkBits2Float(0xceb6b6b6), SkBits2Float(0x0039e94f)); // -6.97109e-06f, 1.28876e-05f, -1.53271e+09f, 5.31832e-39f
path.quadTo(SkBits2Float(0xe9e9e9e9), SkBits2Float(0xe9e6e9e9), SkBits2Float(0xb6b641b6), SkBits2Float(0xede9e9e9)); // -3.5348e+25f, -3.48947e+25f, -5.43167e-06f, -9.0491e+27f
path.moveTo(SkBits2Float(0xb6b6e9e9), SkBits2Float(0xb6b60000)); // -5.45125e-06f, -5.42402e-06f
path.moveTo(SkBits2Float(0xe9b6b6b6), SkBits2Float(0xe9b6b8e9)); // -2.76109e+25f, -2.76122e+25f
path.close();
path.moveTo(SkBits2Float(0xe9b6b6b6), SkBits2Float(0xe9b6b8e9)); // -2.76109e+25f, -2.76122e+25f
path.quadTo(SkBits2Float(0xe93ae9e9), SkBits2Float(0xe964b6e9), SkBits2Float(0x0000203a), SkBits2Float(0xb6000000)); // -1.41228e+25f, -1.72812e+25f, 1.15607e-41f, -1.90735e-06f
path.moveTo(SkBits2Float(0x64b6b6b6), SkBits2Float(0xe9e9e900)); // 2.69638e+22f, -3.53475e+25f
path.quadTo(SkBits2Float(0xb6b6b6e9), SkBits2Float(0xb6b6b6b6), SkBits2Float(0xe9e9b6ce), SkBits2Float(0xe9e93ae9)); // -5.44532e-06f, -5.44529e-06f, -3.53179e+25f, -3.52447e+25f
testSimplifyFuzz(reporter, path, filename);
}
void onDrawContent(SkCanvas* canvas) override {
test_huge_stroke(canvas); return;
canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
SkPaint paint;
paint.setAntiAlias(true);
if (true) {
canvas->drawColor(SK_ColorBLACK);
paint.setTextSize(24);
paint.setColor(SK_ColorWHITE);
canvas->translate(10, 30);
static const SkBlurStyle gStyle[] = {
kNormal_SkBlurStyle,
kInner_SkBlurStyle,
kOuter_SkBlurStyle,
kSolid_SkBlurStyle,
};
for (int x = 0; x < 5; x++) {
SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4));
for (int y = 0; y < 10; y++) {
if (x) {
paint.setMaskFilter(SkBlurMaskFilter::Make(gStyle[x - 1], sigma));
}
canvas->drawString("Title Bar", x*SkIntToScalar(100), y*SkIntToScalar(30), paint);
sigma *= 0.75f;
}
}
return;
}
paint.setColor(SK_ColorBLUE);
#if 1
SkPath p;
float r = rand.nextUScalar1() + 0.5f;
SkScalar x = 0, y = 0;
p.moveTo(x, y);
#if 0
p.cubicTo(x-75*r, y+75*r, x-40*r, y+125*r, x, y+85*r);
p.cubicTo(x+40*r, y+125*r, x+75*r, y+75*r, x, y);
#else
p.cubicTo(x+75*r, y+75*r, x+40*r, y+125*r, x, y+85*r);
p.cubicTo(x-40*r, y+125*r, x-75*r, y+75*r, x, y);
#endif
p.close();
fPath = p;
fPath.offset(100, 0);
#endif
fPath.setFillType(SkPath::kWinding_FillType);
drawSet(canvas, &paint);
canvas->translate(0, fPath.getBounds().height() * 5 / 4);
fPath.setFillType(SkPath::kEvenOdd_FillType);
drawSet(canvas, &paint);
}
static void fuzz763_2s(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
path.setFillType((SkPath::FillType) 0);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0x76773011), SkBits2Float(0x5d66fe78), SkBits2Float(0xbbeeff66), SkBits2Float(0x637677a2), SkBits2Float(0x205266fe), SkBits2Float(0xec296fdf)); // 1.25339e+33f, 1.0403e+18f, -0.00729363f, 4.54652e+21f, 1.78218e-19f, -8.19347e+26f
path.lineTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.close();
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.quadTo(SkBits2Float(0xec4eecec), SkBits2Float(0x6e6f10ec), SkBits2Float(0xb6b6ecf7), SkBits2Float(0xb6b6b6b6)); // -1.00063e+27f, 1.84968e+28f, -5.45161e-06f, -5.44529e-06f
path.moveTo(SkBits2Float(0x002032b8), SkBits2Float(0xecfeb6b6)); // 2.95693e-39f, -2.46344e+27f
path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
path.cubicTo(SkBits2Float(0x1616ece4), SkBits2Float(0xdf020018), SkBits2Float(0x77772965), SkBits2Float(0x1009db73), SkBits2Float(0x80ececec), SkBits2Float(0xf7ffffff)); // 1.21917e-25f, -9.36751e+18f, 5.01303e+33f, 2.71875e-29f, -2.17582e-38f, -1.03846e+34f
path.lineTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
path.close();
path.moveTo(SkBits2Float(0x73737300), SkBits2Float(0x73735273)); // 1.9288e+31f, 1.9278e+31f
path.conicTo(SkBits2Float(0xec0700ec), SkBits2Float(0xecececec), SkBits2Float(0xececccec), SkBits2Float(0x772965ec), SkBits2Float(0x77777377)); // -6.52837e+26f, -2.2914e+27f, -2.29019e+27f, 3.4358e+33f, 5.0189e+33f
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.quadTo(SkBits2Float(0x29ec02ec), SkBits2Float(0x1009ecec), SkBits2Float(0x80ececec), SkBits2Float(0xf7ffffff)); // 1.0481e-13f, 2.7201e-29f, -2.17582e-38f, -1.03846e+34f
path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.conicTo(SkBits2Float(0xff003aff), SkBits2Float(0xdbec2300), SkBits2Float(0xecececec), SkBits2Float(0x6fdf6052), SkBits2Float(0x41ecec29)); // -1.70448e+38f, -1.32933e+17f, -2.2914e+27f, 1.38263e+29f, 29.6153f
path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.quadTo(SkBits2Float(0xecf76e6f), SkBits2Float(0xeccfddec), SkBits2Float(0xecececcc), SkBits2Float(0x66000066)); // -2.39301e+27f, -2.01037e+27f, -2.2914e+27f, 1.51118e+23f
path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.cubicTo(SkBits2Float(0x772965df), SkBits2Float(0x77777377), SkBits2Float(0x77777876), SkBits2Float(0x665266fe), SkBits2Float(0xecececdf), SkBits2Float(0x0285806e)); // 3.4358e+33f, 5.0189e+33f, 5.0193e+33f, 2.48399e+23f, -2.2914e+27f, 1.96163e-37f
path.lineTo(SkBits2Float(0xecececeb), SkBits2Float(0xecec0700)); // -2.2914e+27f, -2.28272e+27f
path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.lineTo(SkBits2Float(0x65ecfaec), SkBits2Float(0xde777729)); // 1.39888e+23f, -4.45794e+18f
path.conicTo(SkBits2Float(0x74777777), SkBits2Float(0x66fe7876), SkBits2Float(0xecdf6660), SkBits2Float(0x726eecec), SkBits2Float(0x29d610ec)); // 7.84253e+31f, 6.00852e+23f, -2.16059e+27f, 4.73241e+30f, 9.50644e-14f
path.lineTo(SkBits2Float(0xfe817477), SkBits2Float(0xdf665266)); // -8.60376e+37f, -1.65964e+19f
path.close();
path.moveTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f
path.quadTo(SkBits2Float(0x003affec), SkBits2Float(0xec2300ef), SkBits2Float(0xecececdb), SkBits2Float(0xcfececec)); // 5.41827e-39f, -7.88237e+26f, -2.2914e+27f, -7.9499e+09f
path.lineTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f
path.close();
path.moveTo(SkBits2Float(0xd0ecec10), SkBits2Float(0x6e6eecdb)); // -3.17991e+10f, 1.84859e+28f
path.quadTo(SkBits2Float(0xecccec80), SkBits2Float(0xfa66ecec), SkBits2Float(0x66fa0000), SkBits2Float(0x772965df)); // -1.9819e+27f, -2.99758e+35f, 5.90296e+23f, 3.4358e+33f
path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f
path.close();
path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f
path.cubicTo(SkBits2Float(0xecececec), SkBits2Float(0xfe66eaec), SkBits2Float(0xecdf1452), SkBits2Float(0x806eecec), SkBits2Float(0x10ececec), SkBits2Float(0xec000000)); // -2.2914e+27f, -7.67356e+37f, -2.15749e+27f, -1.01869e-38f, 9.34506e-29f, -6.1897e+26f
path.lineTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f
path.close();
path.moveTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f
path.cubicTo(SkBits2Float(0x52668062), SkBits2Float(0x2965df66), SkBits2Float(0x77777377), SkBits2Float(0x76777773), SkBits2Float(0x1697fe78), SkBits2Float(0xeebfff00)); // 2.47499e+11f, 5.1042e-14f, 5.0189e+33f, 1.2548e+33f, 2.4556e-25f, -2.971e+28f
path.lineTo(SkBits2Float(0x77777790), SkBits2Float(0x00807677)); // 5.01923e+33f, 1.17974e-38f
path.close();
testSimplifyFuzz(reporter, path, filename);
}
static void fuzz_x2(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0x1931204a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a08ff), SkBits2Float(0x4a4a4a34), SkBits2Float(0x4a4a4a4a)); // 9.15721e-24f, 1.14845e-12f, 3.31014e+06f, 3.31014e+06f, 3.31432e+06f, 3.31432e+06f
path.moveTo(SkBits2Float(0x000010a1), SkBits2Float(0x19312000)); // 5.96533e-42f, 9.15715e-24f
path.cubicTo(SkBits2Float(0x4a6a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa14a4a4a), SkBits2Float(0x08ff2ba1), SkBits2Float(0x08ff4a4a), SkBits2Float(0x4a344a4a)); // 3.83861e+06f, 3.31432e+06f, -6.85386e-19f, 1.53575e-33f, 1.53647e-33f, 2.95387e+06f
path.cubicTo(SkBits2Float(0x4a4a4a4a), SkBits2Float(0x4a4a4a4a), SkBits2Float(0x2ba1a14a), SkBits2Float(0x4e4a08ff), SkBits2Float(0x4a4a4a4a), SkBits2Float(0xa1a181ff)); // 3.31432e+06f, 3.31432e+06f, 1.14845e-12f, 8.47397e+08f, 3.31432e+06f, -1.09442e-18f
testSimplify(reporter, path, filename);
}
static void draw_path(SkScalar size, SkCanvas* canvas, SkPaint paint) {
SkScalar c = 0.551915024494f * size;
SkPath path;
path.moveTo(0.0f, size);
path.cubicTo(c, size, size, c, size, 0.0f);
path.cubicTo(size, -c, c, -size, 0.0f, -size);
path.cubicTo(-c, -size, -size, -c, -size, 0.0f);
path.cubicTo(-size, c, -c, size, 0.0f, size);
canvas->drawPath(path, paint);
}
static void fuzz_x3(skiatest::Reporter* reporter, const char* filename) {
SkPath path;
path.setFillType(SkPath::kWinding_FillType);
path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
path.cubicTo(SkBits2Float(0x92743420), SkBits2Float(0x74747474), SkBits2Float(0x0f747c74), SkBits2Float(0xff538565), SkBits2Float(0x74744374), SkBits2Float(0x20437474)); // -7.70571e-28f, 7.74708e+31f, 1.20541e-29f, -2.8116e+38f, 7.74102e+31f, 1.65557e-19f
path.conicTo(SkBits2Float(0x7474926d), SkBits2Float(0x7c747474), SkBits2Float(0x00170f74), SkBits2Float(0x3a7410d7), SkBits2Float(0x3a3a3a3a)); // 7.7508e+31f, 5.07713e+36f, 2.11776e-39f, 0.000931037f, 0.000710401f
path.quadTo(SkBits2Float(0x203a3a3a), SkBits2Float(0x7459f43a), SkBits2Float(0x74747474), SkBits2Float(0x2043ad6e)); // 1.57741e-19f, 6.90724e+31f, 7.74708e+31f, 1.65745e-19f
path.conicTo(SkBits2Float(0x7474b374), SkBits2Float(0x74747474), SkBits2Float(0x0f747c74), SkBits2Float(0xff537065), SkBits2Float(0x74744374)); // 7.75488e+31f, 7.74708e+31f, 1.20541e-29f, -2.81051e+38f, 7.74102e+31f
path.cubicTo(SkBits2Float(0x3a3a3a3a), SkBits2Float(0x3a2c103a), SkBits2Float(0x7474263a), SkBits2Float(0x74976507), SkBits2Float(0x000000ff), SkBits2Float(0x00000000)); // 0.000710401f, 0.00065637f, 7.7374e+31f, 9.59578e+31f, 3.57331e-43f, 0
testSimplifyFuzz(reporter, path, filename);
}
/* Generated on a Mac with:
* paint.setTypeface(SkTypeface::CreateByName("Hiragino Maru Gothic Pro"));
* const unsigned char hyphen[] = { 0xE3, 0x83, 0xBC };
* paint.getTextPath(hyphen, SK_ARRAY_COUNT(hyphen), 400, 80, &textPath);
*/
static SkPath hiragino_maru_gothic_pro_dash() {
SkPath path;
path.moveTo(488, 55.1f);
path.cubicTo(490.5f, 55.1f, 491.9f, 53.5f, 491.9f, 50.8f);
path.cubicTo(491.9f, 48.2f, 490.5f, 46.3f, 487.9f, 46.3f);
path.lineTo(412, 46.3f);
path.cubicTo(409.4f, 46.3f, 408, 48.2f, 408, 50.8f);
path.cubicTo(408, 53.5f, 409.4f, 55.1f, 411.9f, 55.1f);
path.lineTo(488, 55.1f);
path.close();
return path;
}
static void PathOpsSimplifyFailTest(skiatest::Reporter* reporter) {
for (int index = 0; index < (int) (13 * nonFinitePtsCount * finitePtsCount); ++index) {
SkPath path;
int i = (int) (index % nonFinitePtsCount);
int f = (int) (index % finitePtsCount);
int g = (int) ((f + 1) % finitePtsCount);
switch (index % 13) {
case 0: path.lineTo(nonFinitePts[i]); break;
case 1: path.quadTo(nonFinitePts[i], nonFinitePts[i]); break;
case 2: path.quadTo(nonFinitePts[i], finitePts[f]); break;
case 3: path.quadTo(finitePts[f], nonFinitePts[i]); break;
case 4: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[f]); break;
case 5: path.cubicTo(finitePts[f], nonFinitePts[i], finitePts[f]); break;
case 6: path.cubicTo(finitePts[f], finitePts[f], nonFinitePts[i]); break;
case 7: path.cubicTo(nonFinitePts[i], nonFinitePts[i], finitePts[f]); break;
case 8: path.cubicTo(nonFinitePts[i], finitePts[f], nonFinitePts[i]); break;
case 9: path.cubicTo(finitePts[f], nonFinitePts[i], nonFinitePts[i]); break;
case 10: path.cubicTo(nonFinitePts[i], nonFinitePts[i], nonFinitePts[i]); break;
case 11: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[g]); break;
case 12: path.moveTo(nonFinitePts[i]); break;
}
SkPath result;
result.setFillType(SkPath::kWinding_FillType);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, !success);
REPORTER_ASSERT(reporter, result.isEmpty());
REPORTER_ASSERT(reporter, result.getFillType() == SkPath::kWinding_FillType);
reporter->bumpTestCount();
}
if (sizeof(reporter) == 4) {
return;
}
for (int index = 0; index < (int) (11 * finitePtsCount); ++index) {
SkPath path;
int f = (int) (index % finitePtsCount);
int g = (int) ((f + 1) % finitePtsCount);
switch (index % 11) {
case 0: path.lineTo(finitePts[f]); break;
case 1: path.quadTo(finitePts[f], finitePts[f]); break;
case 2: path.quadTo(finitePts[f], finitePts[g]); break;
case 3: path.quadTo(finitePts[g], finitePts[f]); break;
case 4: path.cubicTo(finitePts[f], finitePts[f], finitePts[f]); break;
case 5: path.cubicTo(finitePts[f], finitePts[f], finitePts[g]); break;
case 6: path.cubicTo(finitePts[f], finitePts[g], finitePts[f]); break;
case 7: path.cubicTo(finitePts[f], finitePts[g], finitePts[g]); break;
case 8: path.cubicTo(finitePts[g], finitePts[f], finitePts[f]); break;
case 9: path.cubicTo(finitePts[g], finitePts[f], finitePts[g]); break;
case 10: path.moveTo(finitePts[f]); break;
}
SkPath result;
result.setFillType(SkPath::kWinding_FillType);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, success);
REPORTER_ASSERT(reporter, result.getFillType() != SkPath::kWinding_FillType);
reporter->bumpTestCount();
}
}
static SkPath make_path() {
SkPath path;
int numOps = R(30);
for (int i = 0; i < numOps; ++i) {
switch (R(6)) {
case 0:
path.moveTo(make_scalar(), make_scalar());
break;
case 1:
path.lineTo(make_scalar(), make_scalar());
break;
case 2:
path.quadTo(make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
case 3:
path.conicTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
case 4:
path.cubicTo(make_scalar(), make_scalar(), make_scalar(),
make_scalar(), make_scalar(), make_scalar());
break;
case 5:
default:
path.arcTo(make_scalar(), make_scalar(), make_scalar(), make_scalar(), make_scalar());
break;
}
}
path.close();
return path;
}
static SkPoint AddMoveDegenCubicClose(SkPath& path, SkPoint& startPt) {
SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
path.moveTo(moveToPt);
path.cubicTo(moveToPt, moveToPt, moveToPt);
path.close();
return moveToPt;
}
virtual void onDrawContent(SkCanvas* canvas) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(0xFF8888FF);
SkRect r = { 0, 0, SK_Scalar1, SK_Scalar1 };
canvas->concat(fMatrix);
canvas->drawRect(r, paint);
paint.setColor(SK_ColorBLACK);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(0);
paint.setStrokeCap(SkPaint::kRound_Cap);
SkPath path;
path.moveTo(fPts[0]);
path.cubicTo(fPts[1], fPts[2], fPts[3]);
canvas->drawPath(path, paint);
paint.setColor(SK_ColorRED);
paint.setStrokeWidth(0);
canvas->drawLine(0, 0, SK_Scalar1, SK_Scalar1, paint);
paint.setColor(SK_ColorBLUE);
paint.setStrokeWidth(SK_Scalar1 / 60);
for (int i = 0; i < 50; i++) {
SkScalar x = i * SK_Scalar1 / 49;
canvas->drawPoint(x, SkEvalCubicInterval(&fPts[1], x), paint);
}
paint.setStrokeWidth(SK_Scalar1 / 20);
paint.setColor(SK_ColorGREEN);
canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, &fPts[1], paint);
}
static SkPoint AddCubic(SkPath& path, SkPoint& startPt) {
SkPoint t1Pt = startPt + SkPoint::Make(15*SK_Scalar1, 5*SK_Scalar1);
SkPoint t2Pt = startPt + SkPoint::Make(25*SK_Scalar1, 5*SK_Scalar1);
SkPoint endPt = startPt + SkPoint::Make(40*SK_Scalar1, 0);
path.cubicTo(t1Pt, t2Pt, endPt);
return endPt;
}
void draw(SkCanvas* canvas) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkPath path;
path.moveTo(0, -10);
for (int i = 0; i < 128; i += 16) {
SkScalar c = i * 0.5f;
path.cubicTo( 10 + c, -10 - i, 10 + i, -10 - c, 10 + i, 0);
path.cubicTo( 14 + i, 14 + c, 14 + c, 14 + i, 0, 14 + i);
path.cubicTo(-18 - c, 18 + i, -18 - i, 18 + c, -18 - i, 0);
path.cubicTo(-22 - i, -22 - c, -22 - c, -22 - i, 0, -22 - i);
}
path.offset(128, 128);
canvas->drawPath(path, paint);
}
static void testCubics() {
SkPath path;
path.moveTo(2,0);
path.cubicTo(2,3, 1,1, 0,0);
path.close();
test(path);
}
SkPath SubsetVerbs::getSubsetPath() const {
SkPath result;
result.setFillType(fPath.getFillType());
if (!fSelected.count()) {
return result;
}
SkPath::RawIter iter(fPath);
uint8_t verb;
SkPoint pts[4];
int verbIndex = 0;
bool addMoveTo = true;
bool addLineTo = false;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
bool enabled = SkPath::kLine_Verb <= verb && verb <= SkPath::kCubic_Verb
? fSelected[verbIndex++] : false;
if (enabled) {
if (addMoveTo) {
result.moveTo(pts[0]);
addMoveTo = false;
} else if (addLineTo) {
result.lineTo(pts[0]);
addLineTo = false;
}
}
switch (verb) {
case SkPath::kMove_Verb:
break;
case SkPath::kLine_Verb:
if (enabled) {
result.lineTo(pts[1]);
}
break;
case SkPath::kQuad_Verb:
if (enabled) {
result.quadTo(pts[1], pts[2]);
}
break;
case SkPath::kConic_Verb:
if (enabled) {
result.conicTo(pts[1], pts[2], iter.conicWeight());
}
break;
case SkPath::kCubic_Verb:
if (enabled) {
result.cubicTo(pts[1], pts[2], pts[3]);
}
break;
case SkPath::kClose_Verb:
result.close();
addMoveTo = true;
addLineTo = false;
continue;
default:
SkDEBUGFAIL("bad verb");
return result;
}
addLineTo = !enabled;
}
return result;
}
void onDraw(SkCanvas* canvas) override {
SkPath path;
SkRandom rand;
int scale = 300;
for (int i = 0; i < 4; ++i) {
// get the random values deterministically
SkScalar randoms[12];
for (int index = 0; index < (int) SK_ARRAY_COUNT(randoms); ++index) {
randoms[index] = rand.nextUScalar1();
}
path.lineTo(randoms[0] * scale, randoms[1] * scale);
path.quadTo(randoms[2] * scale, randoms[3] * scale,
randoms[4] * scale, randoms[5] * scale);
path.cubicTo(randoms[6] * scale, randoms[7] * scale,
randoms[8] * scale, randoms[9] * scale,
randoms[10] * scale, randoms[11] * scale);
}
path.setFillType(SkPath::kEvenOdd_FillType);
path.offset(SkIntToScalar(20), SkIntToScalar(20));
test_hittest(canvas, path);
canvas->translate(SkIntToScalar(scale), 0);
path.setFillType(SkPath::kWinding_FillType);
test_hittest(canvas, path);
}
void SkTestFont::init(const SkScalar* pts, const unsigned char* verbs) {
fPaths = new SkPath*[fCharCodesCount];
for (unsigned index = 0; index < fCharCodesCount; ++index) {
SkPath* path = new SkPath;
SkPath::Verb verb;
while ((verb = (SkPath::Verb)*verbs++) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb:
path->moveTo(pts[0], pts[1]);
pts += 2;
break;
case SkPath::kLine_Verb:
path->lineTo(pts[0], pts[1]);
pts += 2;
break;
case SkPath::kQuad_Verb:
path->quadTo(pts[0], pts[1], pts[2], pts[3]);
pts += 4;
break;
case SkPath::kCubic_Verb:
path->cubicTo(pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]);
pts += 6;
break;
case SkPath::kClose_Verb: path->close(); break;
default: SkDEBUGFAIL("bad verb"); return;
}
}
// This should make SkPath::getBounds() queries threadsafe.
path->updateBoundsCache();
fPaths[index] = path;
}
}
static void test_flattening(skiatest::Reporter* reporter) {
SkPath p;
static const SkPoint pts[] = {
{ 0, 0 },
{ SkIntToScalar(10), SkIntToScalar(10) },
{ SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },
{ 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }
};
p.moveTo(pts[0]);
p.lineTo(pts[1]);
p.quadTo(pts[2], pts[3]);
p.cubicTo(pts[4], pts[5], pts[6]);
SkWriter32 writer(100);
p.flatten(writer);
size_t size = writer.size();
SkAutoMalloc storage(size);
writer.flatten(storage.get());
SkReader32 reader(storage.get(), size);
SkPath p1;
REPORTER_ASSERT(reporter, p1 != p);
p1.unflatten(reader);
REPORTER_ASSERT(reporter, p1 == p);
}
static int cubic_proc(const FT_Vector* pt0, const FT_Vector* pt1,
const FT_Vector* pt2, void* ctx) {
SkPath* path = (SkPath*)ctx;
path->cubicTo(SkFDot6ToScalar(pt0->x), -SkFDot6ToScalar(pt0->y),
SkFDot6ToScalar(pt1->x), -SkFDot6ToScalar(pt1->y),
SkFDot6ToScalar(pt2->x), -SkFDot6ToScalar(pt2->y));
return 0;
}
void onOnceBeforeDraw() override {
{
SkPath* bigQuad = &fPaths.push_back();
bigQuad->moveTo(0, 0);
bigQuad->quadTo(kWidth/2, kHeight, kWidth, 0);
}
{
SkPath* degenBigQuad = &fPaths.push_back();
SkScalar yPos = kHeight / 2 + 10;
degenBigQuad->moveTo(0, yPos);
degenBigQuad->quadTo(0, yPos, kWidth, yPos);
}
{
SkPath* bigCubic = &fPaths.push_back();
bigCubic->moveTo(0, 0);
bigCubic->cubicTo(0, kHeight,
kWidth, kHeight,
kWidth, 0);
}
{
SkPath* degenBigCubic = &fPaths.push_back();
SkScalar yPos = kHeight / 2;
degenBigCubic->moveTo(0, yPos);
degenBigCubic->cubicTo(0, yPos,
0, yPos,
kWidth, yPos);
}
{
SkPath* bigConic = &fPaths.push_back();
bigConic->moveTo(0, 0);
bigConic->conicTo(kWidth/2, kHeight, kWidth, 0, .5);
}
{
SkPath* degenBigConic = &fPaths.push_back();
SkScalar yPos = kHeight / 2 - 10;
degenBigConic->moveTo(0, yPos);
degenBigConic->conicTo(0, yPos, kWidth, yPos, .5);
}
}
void mbe_curve_to(mbe_t *canvas, co_aix x1, co_aix y1,
co_aix x2, co_aix y2,
co_aix x3, co_aix y3) {
SkPath *subpath = canvas->subpath;
subpath->cubicTo(CO_AIX_2_SKSCALAR(x1), CO_AIX_2_SKSCALAR(y1),
CO_AIX_2_SKSCALAR(x2), CO_AIX_2_SKSCALAR(y2),
CO_AIX_2_SKSCALAR(x3), CO_AIX_2_SKSCALAR(y3));
}
SkPath SubsetContours::getSubsetPath() const {
SkPath result;
result.setFillType(fPath.getFillType());
if (!fSelected.count()) {
return result;
}
SkPath::RawIter iter(fPath);
uint8_t verb;
SkPoint pts[4];
int contourCount = 0;
bool enabled = fSelected[0];
bool addMoveTo = true;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
if (enabled && addMoveTo) {
result.moveTo(pts[0]);
addMoveTo = false;
}
switch (verb) {
case SkPath::kMove_Verb:
break;
case SkPath::kLine_Verb:
if (enabled) {
result.lineTo(pts[1]);
}
break;
case SkPath::kQuad_Verb:
if (enabled) {
result.quadTo(pts[1], pts[2]);
}
break;
case SkPath::kConic_Verb:
if (enabled) {
result.conicTo(pts[1], pts[2], iter.conicWeight());
}
break;
case SkPath::kCubic_Verb:
if (enabled) {
result.cubicTo(pts[1], pts[2], pts[3]);
}
break;
case SkPath::kClose_Verb:
if (enabled) {
result.close();
}
if (++contourCount >= fSelected.count()) {
break;
}
enabled = fSelected[contourCount];
addMoveTo = true;
continue;
default:
SkDEBUGFAIL("bad verb");
return result;
}
}
return result;
}
static SkPoint AddMoveCubicClose(SkPath& path, SkPoint& startPt) {
SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
SkPoint t1Pt = moveToPt + SkPoint::Make(15*SK_Scalar1, 5*SK_Scalar1);
SkPoint t2Pt = moveToPt + SkPoint::Make(25*SK_Scalar1, 5*SK_Scalar1);
SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
path.moveTo(moveToPt);
path.cubicTo(t1Pt, t2Pt, endPt);
path.close();
return endPt;
}
static void test_bigcubic() {
SkPath path;
path.moveTo(64, 3);
path.cubicTo(-329936, -100000000, -329936, 100000000, 1153, 330003);
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkCanvas> canvas(SkCanvas::NewRasterN32(640, 480));
canvas.get()->drawPath(path, paint);
}
static void test_bigcubic() {
SkPath path;
path.moveTo(64, 3);
path.cubicTo(-329936, -100000000, -329936, 100000000, 1153, 330003);
SkPaint paint;
paint.setAntiAlias(true);
auto surface(SkSurface::MakeRasterN32Premul(640, 480));
surface->getCanvas()->drawPath(path, paint);
}
DEF_TEST(cubic_scan_error_crbug_844457_and_845489, reporter) {
auto surface(SkSurface::MakeRasterN32Premul(100, 100));
SkCanvas* canvas = surface->getCanvas();
SkPaint p;
SkPath path;
path.moveTo(-30/64.0, -31/64.0);
path.cubicTo(-31/64.0, -31/64,-31/64.0, -31/64,-31/64.0, 100);
path.lineTo(100, 100);
canvas->drawPath(path, p);
// May need to define SK_RASTERIZE_EVEN_ROUNDING to trigger the need for this test
path.reset();
path.moveTo(-30/64.0f, -31/64.0f + 1/256.0f);
path.cubicTo(-31/64.0f + 1/256.0f, -31/64.0f + 1/256.0f,
-31/64.0f + 1/256.0f, -31/64.0f + 1/256.0f,
-31/64.0f + 1/256.0f, 100);
path.lineTo(100, 100);
canvas->drawPath(path, p);
}
static void stroke_cubic(const SkPoint pts[4]) {
SkPath path;
path.moveTo(pts[0]);
path.cubicTo(pts[1], pts[2], pts[3]);
SkPaint paint;
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SK_Scalar1 * 2);
SkPath fill;
paint.getFillPath(path, &fill);
}
static void failOne(skiatest::Reporter* reporter, int index) {
SkPath path;
int i = (int) (index % nonFinitePtsCount);
int f = (int) (index % finitePtsCount);
int g = (int) ((f + 1) % finitePtsCount);
switch (index % 13) {
case 0: path.lineTo(nonFinitePts[i]); break;
case 1: path.quadTo(nonFinitePts[i], nonFinitePts[i]); break;
case 2: path.quadTo(nonFinitePts[i], finitePts[f]); break;
case 3: path.quadTo(finitePts[f], nonFinitePts[i]); break;
case 4: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[f]); break;
case 5: path.cubicTo(finitePts[f], nonFinitePts[i], finitePts[f]); break;
case 6: path.cubicTo(finitePts[f], finitePts[f], nonFinitePts[i]); break;
case 7: path.cubicTo(nonFinitePts[i], nonFinitePts[i], finitePts[f]); break;
case 8: path.cubicTo(nonFinitePts[i], finitePts[f], nonFinitePts[i]); break;
case 9: path.cubicTo(finitePts[f], nonFinitePts[i], nonFinitePts[i]); break;
case 10: path.cubicTo(nonFinitePts[i], nonFinitePts[i], nonFinitePts[i]); break;
case 11: path.cubicTo(nonFinitePts[i], finitePts[f], finitePts[g]); break;
case 12: path.moveTo(nonFinitePts[i]); break;
}
SkPath result;
result.setFillType(SkPath::kWinding_FillType);
bool success = Simplify(path, &result);
REPORTER_ASSERT(reporter, !success);
REPORTER_ASSERT(reporter, result.isEmpty());
REPORTER_ASSERT(reporter, result.getFillType() == SkPath::kWinding_FillType);
reporter->bumpTestCount();
}
SkPath cubicPath(SkPoint p1, SkPoint p2) {
SkASSERT(p1.y() == p2.y());
SkPath path;
path.moveTo(p1);
SkPoint p3 = SkPoint::Make((p1.x() + p2.x()) / 3.0f, p1.y() * 0.7f);
SkPoint p4 = SkPoint::Make(2.0f*(p1.x() + p2.x()) / 3.0f, p1.y() * 1.5f);
path.cubicTo(p3, p4, p2);
return path;
}
static void test_bigcubic(skiatest::Reporter* reporter) {
#ifdef SK_SCALAR_IS_FLOAT
SkPath path;
path.moveTo(64, 3);
path.cubicTo(-329936, -100000000, -329936, 100000000, 1153, 330003);
SkPaint paint;
paint.setAntiAlias(true);
SkAutoTUnref<SkCanvas> canvas(new_canvas(640, 480));
canvas.get()->drawPath(path, paint);
#endif
}