src/third_party/skia/tests/PathOpsOpTest.cpp

   1 /*
   2  * Copyright 2012 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 #include "PathOpsExtendedTest.h"
   8 #include "PathOpsTestCommon.h"
   9
  10 #define TEST(name) { name, #name }
  11
  12 static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) {
  13     SkPath path, pathB;
  14     path.setFillType(SkPath::kWinding_FillType);
  15     path.moveTo(0,1);
  16     path.cubicTo(0,2, 1,0, 1,0);
  17     path.close();
  18     pathB.setFillType(SkPath::kWinding_FillType);
  19     pathB.moveTo(0,1);
  20     pathB.cubicTo(0,1, 1,0, 2,0);
  21     pathB.close();
  22     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  23 }
  24
  25 static void cubicOp2d(skiatest::Reporter* reporter, const char* filename) {
  26     SkPath path, pathB;
  27     path.setFillType(SkPath::kWinding_FillType);
  28     path.moveTo(0,2);
  29     path.cubicTo(0,1, 1,0, 1,0);
  30     path.close();
  31     pathB.setFillType(SkPath::kWinding_FillType);
  32     pathB.moveTo(0,1);
  33     pathB.cubicTo(0,1, 2,0, 1,0);
  34     pathB.close();
  35     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  36 }
  37
  38 static void cubicOp3d(skiatest::Reporter* reporter, const char* filename) {
  39     SkPath path, pathB;
  40     path.setFillType(SkPath::kWinding_FillType);
  41     path.moveTo(0,1);
  42     path.cubicTo(2,3, 1,0, 1,0);
  43     path.close();
  44     pathB.setFillType(SkPath::kWinding_FillType);
  45     pathB.moveTo(0,1);
  46     pathB.cubicTo(0,1, 1,0, 3,2);
  47     pathB.close();
  48     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  49 }
  50
  51 static void cubicOp5d(skiatest::Reporter* reporter, const char* filename) {
  52     SkPath path, pathB;
  53     path.setFillType(SkPath::kWinding_FillType);
  54     path.moveTo(0,1);
  55     path.cubicTo(0,2, 1,0, 2,0);
  56     path.close();
  57     pathB.setFillType(SkPath::kWinding_FillType);
  58     pathB.moveTo(0,1);
  59     pathB.cubicTo(0,2, 1,0, 2,0);
  60     pathB.close();
  61     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  62 }
  63
  64 static void cubicOp6d(skiatest::Reporter* reporter, const char* filename) {
  65     SkPath path, pathB;
  66     path.setFillType(SkPath::kWinding_FillType);
  67     path.moveTo(0,1);
  68     path.cubicTo(0,6, 1,0, 3,0);
  69     path.close();
  70     pathB.setFillType(SkPath::kWinding_FillType);
  71     pathB.moveTo(0,1);
  72     pathB.cubicTo(0,3, 1,0, 6,0);
  73     pathB.close();
  74     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  75 }
  76
  77 static void cubicOp7d(skiatest::Reporter* reporter, const char* filename) {
  78     SkPath path, pathB;
  79     path.setFillType(SkPath::kWinding_FillType);
  80     path.moveTo(0,1);
  81     path.cubicTo(3,4, 1,0, 3,0);
  82     path.close();
  83     pathB.setFillType(SkPath::kWinding_FillType);
  84     pathB.moveTo(0,1);
  85     pathB.cubicTo(0,3, 1,0, 4,3);
  86     pathB.close();
  87     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
  88 }
  89
  90 static void cubicOp8d(skiatest::Reporter* reporter, const char* filename) {
  91     SkPath path, pathB;
  92     path.setFillType(SkPath::kWinding_FillType);
  93     path.moveTo(0,1);
  94     path.cubicTo(0,5, 1,0, 4,0);
  95     path.close();
  96     pathB.setFillType(SkPath::kWinding_FillType);
  97     pathB.moveTo(0,1);
  98     pathB.cubicTo(0,4, 1,0, 5,0);
  99     pathB.close();
 100     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 101 }
 102
 103 static void cubicOp9d(skiatest::Reporter* reporter, const char* filename) {
 104     SkPath path, pathB;
 105     path.setFillType(SkPath::kWinding_FillType);
 106     path.moveTo(0,1);
 107     path.cubicTo(1,6, 1,0, 2,1);
 108     path.close();
 109     pathB.setFillType(SkPath::kWinding_FillType);
 110     pathB.moveTo(0,1);
 111     pathB.cubicTo(1,2, 1,0, 6,1);
 112     pathB.close();
 113     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 114 }
 115
 116 static void quadOp9d(skiatest::Reporter* reporter, const char* filename) {
 117     SkPath path, pathB;
 118     path.setFillType(SkPath::kWinding_FillType);
 119     path.moveTo(0,1);
 120     path.quadTo(1,6, 1.5f,1);
 121     path.quadTo(1.5f,0.5f, 2,1);
 122     path.close();
 123     pathB.setFillType(SkPath::kWinding_FillType);
 124     pathB.moveTo(0,1);
 125     pathB.quadTo(1,2, 1.4f,1);
 126     pathB.quadTo(3,0.4f, 6,1);
 127     pathB.close();
 128     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 129 }
 130
 131 static void lineOp9d(skiatest::Reporter* reporter, const char* filename) {
 132     SkPath path, pathB;
 133     path.setFillType(SkPath::kWinding_FillType);
 134     path.moveTo(0,1);
 135     path.lineTo(1,6);
 136     path.lineTo(1.5f,1);
 137     path.lineTo(1.8f,0.8f);
 138     path.lineTo(2,1);
 139     path.close();
 140     pathB.setFillType(SkPath::kWinding_FillType);
 141     pathB.moveTo(0,1);
 142     pathB.lineTo(1,2);
 143     pathB.lineTo(1.4f,1);
 144     pathB.lineTo(3,0.4f);
 145     pathB.lineTo(6,1);
 146     pathB.close();
 147     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 148 }
 149
 150 static void cubicOp1i(skiatest::Reporter* reporter, const char* filename) {
 151     SkPath path, pathB;
 152     path.setFillType(SkPath::kWinding_FillType);
 153     path.moveTo(0,1);
 154     path.cubicTo(1,2, 1,0, 2,1);
 155     path.close();
 156     pathB.setFillType(SkPath::kWinding_FillType);
 157     pathB.moveTo(0,1);
 158     pathB.cubicTo(1,2, 1,0, 2,1);
 159     pathB.close();
 160     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 161 }
 162
 163 static void cubicOp10d(skiatest::Reporter* reporter, const char* filename) {
 164     SkPath path, pathB;
 165     path.setFillType(SkPath::kWinding_FillType);
 166     path.moveTo(0,1);
 167     path.cubicTo(1,3, 1,0, 4,1);
 168     path.close();
 169     pathB.setFillType(SkPath::kWinding_FillType);
 170     pathB.moveTo(0,1);
 171     pathB.cubicTo(1,4, 1,0, 3,1);
 172     pathB.close();
 173     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 174 }
 175
 176 static void cubicOp11d(skiatest::Reporter* reporter, const char* filename) {
 177     SkPath path, pathB;
 178     path.setFillType(SkPath::kWinding_FillType);
 179     path.moveTo(0,1);
 180     path.cubicTo(3,4, 1,0, 5,1);
 181     path.close();
 182     pathB.setFillType(SkPath::kWinding_FillType);
 183     pathB.moveTo(0,1);
 184     pathB.cubicTo(1,5, 1,0, 4,3);
 185     pathB.close();
 186     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 187 }
 188
 189 static void cubicOp12d(skiatest::Reporter* reporter, const char* filename) {
 190     SkPath path, pathB;
 191     path.setFillType(SkPath::kWinding_FillType);
 192     path.moveTo(0,1);
 193     path.cubicTo(1,6, 1,0, 1,0);
 194     path.close();
 195     pathB.setFillType(SkPath::kWinding_FillType);
 196     pathB.moveTo(0,1);
 197     pathB.cubicTo(0,1, 1,0, 6,1);
 198     pathB.close();
 199     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 200 }
 201
 202 static void cubicOp13d(skiatest::Reporter* reporter, const char* filename) {
 203     SkPath path, pathB;
 204     path.setFillType(SkPath::kWinding_FillType);
 205     path.moveTo(0,1);
 206     path.cubicTo(4,5, 1,0, 5,3);
 207     path.close();
 208     pathB.setFillType(SkPath::kWinding_FillType);
 209     pathB.moveTo(0,1);
 210     pathB.cubicTo(3,5, 1,0, 5,4);
 211     pathB.close();
 212     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 213 }
 214
 215 static void cubicOp14d(skiatest::Reporter* reporter, const char* filename) {
 216     SkPath path, pathB;
 217     path.setFillType(SkPath::kWinding_FillType);
 218     path.moveTo(0,1);
 219     path.cubicTo(0,2, 2,0, 2,1);
 220     path.close();
 221     pathB.setFillType(SkPath::kWinding_FillType);
 222     pathB.moveTo(0,2);
 223     pathB.cubicTo(1,2, 1,0, 2,0);
 224     pathB.close();
 225     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 226 }
 227
 228 static void cubicOp15d(skiatest::Reporter* reporter, const char* filename) {
 229     SkPath path, pathB;
 230     path.setFillType(SkPath::kWinding_FillType);
 231     path.moveTo(0,1);
 232     path.cubicTo(3,6, 2,0, 2,1);
 233     path.close();
 234     pathB.setFillType(SkPath::kWinding_FillType);
 235     pathB.moveTo(0,2);
 236     pathB.cubicTo(1,2, 1,0, 6,3);
 237     pathB.close();
 238     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 239 }
 240
 241 static void cubicOp16d(skiatest::Reporter* reporter, const char* filename) {
 242     SkPath path, pathB;
 243     path.setFillType(SkPath::kWinding_FillType);
 244     path.moveTo(0,2);
 245     path.cubicTo(0,1, 3,0, 1,0);
 246     path.close();
 247     pathB.setFillType(SkPath::kWinding_FillType);
 248     pathB.moveTo(0,3);
 249     pathB.cubicTo(0,1, 2,0, 1,0);
 250     pathB.close();
 251     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 252 }
 253
 254 static void cubicOp17d(skiatest::Reporter* reporter, const char* filename) {
 255     SkPath path, pathB;
 256     path.setFillType(SkPath::kWinding_FillType);
 257     path.moveTo(0,2);
 258     path.cubicTo(0,2, 4,0, 2,1);
 259     path.close();
 260     pathB.setFillType(SkPath::kWinding_FillType);
 261     pathB.moveTo(0,4);
 262     pathB.cubicTo(1,2, 2,0, 2,0);
 263     pathB.close();
 264     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 265 }
 266
 267 static void cubicOp18d(skiatest::Reporter* reporter, const char* filename) {
 268     SkPath path, pathB;
 269     path.setFillType(SkPath::kWinding_FillType);
 270     path.moveTo(0,1);
 271     path.cubicTo(3,5, 2,0, 2,1);
 272     path.close();
 273     pathB.setFillType(SkPath::kWinding_FillType);
 274     pathB.moveTo(0,2);
 275     pathB.cubicTo(1,2, 1,0, 5,3);
 276     pathB.close();
 277     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 278 }
 279
 280 static void cubicOp19i(skiatest::Reporter* reporter, const char* filename) {
 281     SkPath path, pathB;
 282     path.setFillType(SkPath::kWinding_FillType);
 283     path.moveTo(0,2);
 284     path.cubicTo(0,1, 2,1, 6,2);
 285     path.close();
 286     pathB.setFillType(SkPath::kWinding_FillType);
 287     pathB.moveTo(1,2);
 288     pathB.cubicTo(2,6, 2,0, 1,0);
 289     pathB.close();
 290     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 291 }
 292
 293 static void cubicOp20d(skiatest::Reporter* reporter, const char* filename) {
 294     SkPath path, pathB;
 295     path.setFillType(SkPath::kWinding_FillType);
 296     path.moveTo(0,1);
 297     path.cubicTo(0,1, 6,0, 2,1);
 298     path.close();
 299     pathB.setFillType(SkPath::kWinding_FillType);
 300     pathB.moveTo(0,6);
 301     pathB.cubicTo(1,2, 1,0, 1,0);
 302     pathB.close();
 303     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 304 }
 305
 306 static void cubicOp21d(skiatest::Reporter* reporter, const char* filename) {
 307     SkPath path, pathB;
 308     path.setFillType(SkPath::kWinding_FillType);
 309     path.moveTo(0,1);
 310     path.cubicTo(0,1, 2,1, 6,5);
 311     path.close();
 312     pathB.setFillType(SkPath::kWinding_FillType);
 313     pathB.moveTo(1,2);
 314     pathB.cubicTo(5,6, 1,0, 1,0);
 315     pathB.close();
 316     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 317 }
 318
 319 static void cubicOp22d(skiatest::Reporter* reporter, const char* filename) {
 320     SkPath path, pathB;
 321     path.setFillType(SkPath::kWinding_FillType);
 322     path.moveTo(0,1);
 323     path.cubicTo(2,3, 3,0, 2,1);
 324     path.close();
 325     pathB.setFillType(SkPath::kWinding_FillType);
 326     pathB.moveTo(0,3);
 327     pathB.cubicTo(1,2, 1,0, 3,2);
 328     pathB.close();
 329     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 330 }
 331
 332 static void cubicOp23d(skiatest::Reporter* reporter, const char* filename) {
 333     SkPath path, pathB;
 334     path.setFillType(SkPath::kWinding_FillType);
 335     path.moveTo(0,1);
 336     path.cubicTo(1,2, 4,0, 2,1);
 337     path.close();
 338     pathB.setFillType(SkPath::kWinding_FillType);
 339     pathB.moveTo(0,4);
 340     pathB.cubicTo(1,2, 1,0, 2,1);
 341     pathB.close();
 342     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 343 }
 344
 345 static void cubicOp24d(skiatest::Reporter* reporter, const char* filename) {
 346     SkPath path, pathB;
 347     path.setFillType(SkPath::kWinding_FillType);
 348     path.moveTo(0,1);
 349     path.cubicTo(1,2, 2,0, 3,2);
 350     path.close();
 351     pathB.setFillType(SkPath::kWinding_FillType);
 352     pathB.moveTo(0,2);
 353     pathB.cubicTo(2,3, 1,0, 2,1);
 354     pathB.close();
 355     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 356 }
 357
 358 static void testIntersect1(skiatest::Reporter* reporter, const char* filename) {
 359     SkPath one, two;
 360     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 361     two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
 362     testPathOp(reporter, one, two, kIntersect_PathOp, filename);
 363 }
 364
 365 static void testUnion1(skiatest::Reporter* reporter, const char* filename) {
 366     SkPath one, two;
 367     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 368     two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
 369     testPathOp(reporter, one, two, kUnion_PathOp, filename);
 370 }
 371
 372 static void testDiff1(skiatest::Reporter* reporter, const char* filename) {
 373     SkPath one, two;
 374     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 375     two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
 376     testPathOp(reporter, one, two, kDifference_PathOp, filename);
 377 }
 378
 379 static void testXor1(skiatest::Reporter* reporter, const char* filename) {
 380     SkPath one, two;
 381     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 382     two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
 383     testPathOp(reporter, one, two, kXOR_PathOp, filename);
 384 }
 385
 386 static void testIntersect2(skiatest::Reporter* reporter, const char* filename) {
 387     SkPath one, two;
 388     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 389     two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
 390     testPathOp(reporter, one, two, kIntersect_PathOp, filename);
 391 }
 392
 393 static void testUnion2(skiatest::Reporter* reporter, const char* filename) {
 394     SkPath one, two;
 395     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 396     two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
 397     testPathOp(reporter, one, two, kUnion_PathOp, filename);
 398 }
 399
 400 static void testDiff2(skiatest::Reporter* reporter, const char* filename) {
 401     SkPath one, two;
 402     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 403     two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
 404     testPathOp(reporter, one, two, kDifference_PathOp, filename);
 405 }
 406
 407 static void testXor2(skiatest::Reporter* reporter, const char* filename) {
 408     SkPath one, two;
 409     one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
 410     two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
 411     testPathOp(reporter, one, two, kXOR_PathOp, filename);
 412 }
 413
 414 static void testOp1d(skiatest::Reporter* reporter, const char* filename) {
 415     SkPath path, pathB;
 416     path.setFillType(SkPath::kWinding_FillType);
 417     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 418     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 419     pathB.setFillType(SkPath::kWinding_FillType);
 420     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 421     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 422     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 423 }
 424
 425 static void testOp2d(skiatest::Reporter* reporter, const char* filename) {
 426     SkPath path, pathB;
 427     path.setFillType(SkPath::kWinding_FillType);
 428     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 429     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 430     pathB.setFillType(SkPath::kEvenOdd_FillType);
 431     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 432     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 433     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 434 }
 435
 436 static void testOp3d(skiatest::Reporter* reporter, const char* filename) {
 437     SkPath path, pathB;
 438     path.setFillType(SkPath::kWinding_FillType);
 439     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 440     path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
 441     pathB.setFillType(SkPath::kWinding_FillType);
 442     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 443     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 444     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 445 }
 446
 447 static void testOp1u(skiatest::Reporter* reporter, const char* filename) {
 448     SkPath path, pathB;
 449     path.setFillType(SkPath::kWinding_FillType);
 450     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 451     path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
 452     pathB.setFillType(SkPath::kWinding_FillType);
 453     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 454     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 455     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
 456 }
 457
 458 static void testOp4d(skiatest::Reporter* reporter, const char* filename) {
 459     SkPath path, pathB;
 460     path.setFillType(SkPath::kWinding_FillType);
 461     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 462     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
 463     pathB.setFillType(SkPath::kWinding_FillType);
 464     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 465     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 466     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 467 }
 468
 469 static void testOp5d(skiatest::Reporter* reporter, const char* filename) {
 470     SkPath path, pathB;
 471     path.setFillType(SkPath::kEvenOdd_FillType);
 472     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 473     path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
 474     pathB.setFillType(SkPath::kEvenOdd_FillType);
 475     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 476     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 477     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 478 }
 479
 480 static void testOp6d(skiatest::Reporter* reporter, const char* filename) {
 481     SkPath path, pathB;
 482     path.setFillType(SkPath::kEvenOdd_FillType);
 483     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 484     path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
 485     pathB.setFillType(SkPath::kWinding_FillType);
 486     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 487     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 488     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 489 }
 490
 491 static void testOp7d(skiatest::Reporter* reporter, const char* filename) {
 492     SkPath path, pathB;
 493     path.setFillType(SkPath::kEvenOdd_FillType);
 494     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 495     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 496     pathB.setFillType(SkPath::kEvenOdd_FillType);
 497     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 498     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
 499     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 500 }
 501
 502 static void testOp2u(skiatest::Reporter* reporter, const char* filename) {
 503     SkPath path, pathB;
 504     path.setFillType(SkPath::kEvenOdd_FillType);
 505     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 506     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
 507     pathB.setFillType(SkPath::kWinding_FillType);
 508     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
 509     pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
 510     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
 511 }
 512
 513 static void testOp8d(skiatest::Reporter* reporter, const char* filename) {
 514     SkPath path, pathB;
 515     path.addRect(0, 0, 640, 480);
 516     pathB.moveTo(577330, 1971.72f);
 517     pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
 518     pathB.close();
 519     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 520 }
 521 static void cubicOp25i(skiatest::Reporter* reporter, const char* filename) {
 522     SkPath path, pathB;
 523     path.setFillType(SkPath::kWinding_FillType);
 524     path.moveTo(0,1);
 525     path.cubicTo(2,4, 5,0, 3,2);
 526     path.close();
 527     pathB.setFillType(SkPath::kWinding_FillType);
 528     pathB.moveTo(0,5);
 529     pathB.cubicTo(2,3, 1,0, 4,2);
 530     pathB.close();
 531     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 532 }
 533
 534 static void cubicOp26d(skiatest::Reporter* reporter, const char* filename) {
 535     SkPath path, pathB;
 536     path.setFillType(SkPath::kWinding_FillType);
 537     path.moveTo(0,1);
 538     path.cubicTo(3,4, 4,0, 3,2);
 539     path.close();
 540     pathB.setFillType(SkPath::kWinding_FillType);
 541     pathB.moveTo(0,4);
 542     pathB.cubicTo(2,3, 1,0, 4,3);
 543     pathB.close();
 544     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 545 }
 546
 547 static void cubicOp27d(skiatest::Reporter* reporter, const char* filename) {
 548     SkPath path, pathB;
 549     path.setFillType(SkPath::kWinding_FillType);
 550     path.moveTo(0,1);
 551     path.cubicTo(3,6, 1,0, 5,2);
 552     path.close();
 553     pathB.setFillType(SkPath::kWinding_FillType);
 554     pathB.moveTo(0,1);
 555     pathB.cubicTo(2,5, 1,0, 6,3);
 556     pathB.close();
 557     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 558 }
 559
 560 static void cubicOp28u(skiatest::Reporter* reporter, const char* filename) {
 561     SkPath path, pathB;
 562     path.setFillType(SkPath::kWinding_FillType);
 563     path.moveTo(0,1);
 564     path.cubicTo(1,4, 6,0, 3,2);
 565     path.close();
 566     pathB.setFillType(SkPath::kWinding_FillType);
 567     pathB.moveTo(0,6);
 568     pathB.cubicTo(2,3, 1,0, 4,1);
 569     pathB.close();
 570     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
 571 }
 572
 573 static void cubicOp29d(skiatest::Reporter* reporter, const char* filename) {
 574     SkPath path, pathB;
 575     path.setFillType(SkPath::kWinding_FillType);
 576     path.moveTo(0,1);
 577     path.cubicTo(2,5, 6,0, 4,2);
 578     path.close();
 579     pathB.setFillType(SkPath::kWinding_FillType);
 580     pathB.moveTo(0,6);
 581     pathB.cubicTo(2,4, 1,0, 5,2);
 582     pathB.close();
 583     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 584 }
 585
 586 static void cubicOp30d(skiatest::Reporter* reporter, const char* filename) {
 587     SkPath path, pathB;
 588     path.setFillType(SkPath::kWinding_FillType);
 589     path.moveTo(0,1);
 590     path.cubicTo(2,5, 6,0, 5,3);
 591     path.close();
 592     pathB.setFillType(SkPath::kWinding_FillType);
 593     pathB.moveTo(0,6);
 594     pathB.cubicTo(3,5, 1,0, 5,2);
 595     pathB.close();
 596     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 597 }
 598
 599 static void cubicOp31d(skiatest::Reporter* reporter, const char* filename) {
 600     SkPath path, pathB;
 601     path.setFillType(SkPath::kWinding_FillType);
 602     path.moveTo(0,2);
 603     path.cubicTo(0,3, 2,1, 4,0);
 604     path.close();
 605     pathB.setFillType(SkPath::kWinding_FillType);
 606     pathB.moveTo(1,2);
 607     pathB.cubicTo(0,4, 2,0, 3,0);
 608     pathB.close();
 609     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 610 }
 611
 612 static void cubicOp31u(skiatest::Reporter* reporter, const char* filename) {
 613     SkPath path, pathB;
 614     path.setFillType(SkPath::kWinding_FillType);
 615     path.moveTo(0,2);
 616     path.cubicTo(0,3, 2,1, 4,0);
 617     path.close();
 618     pathB.setFillType(SkPath::kWinding_FillType);
 619     pathB.moveTo(1,2);
 620     pathB.cubicTo(0,4, 2,0, 3,0);
 621     pathB.close();
 622     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
 623 }
 624
 625 static void cubicOp31x(skiatest::Reporter* reporter, const char* filename) {
 626     SkPath path, pathB;
 627     path.setFillType(SkPath::kWinding_FillType);
 628     path.moveTo(0,2);
 629     path.cubicTo(0,3, 2,1, 4,0);
 630     path.close();
 631     pathB.setFillType(SkPath::kWinding_FillType);
 632     pathB.moveTo(1,2);
 633     pathB.cubicTo(0,4, 2,0, 3,0);
 634     pathB.close();
 635     testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
 636 }
 637
 638 static void cubicOp32d(skiatest::Reporter* reporter, const char* filename) {
 639     SkPath path, pathB;
 640     path.setFillType(SkPath::kWinding_FillType);
 641     path.moveTo(0,1);
 642     path.cubicTo(1,2, 6,0, 3,1);
 643     path.close();
 644     pathB.setFillType(SkPath::kWinding_FillType);
 645     pathB.moveTo(0,6);
 646     pathB.cubicTo(1,3, 1,0, 2,1);
 647     pathB.close();
 648     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 649 }
 650
 651 static void cubicOp33i(skiatest::Reporter* reporter, const char* filename) {
 652     SkPath path, pathB;
 653     path.setFillType(SkPath::kWinding_FillType);
 654     path.moveTo(0,1);
 655     path.cubicTo(1,2, 6,0, 3,1);
 656     path.close();
 657     pathB.setFillType(SkPath::kWinding_FillType);
 658     pathB.moveTo(0,6);
 659     pathB.cubicTo(1,3, 1,0, 2,1);
 660     pathB.close();
 661     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 662 }
 663
 664 static void cubicOp34d(skiatest::Reporter* reporter, const char* filename) {
 665     SkPath path, pathB;
 666     path.setFillType(SkPath::kWinding_FillType);
 667     path.moveTo(0,1);
 668     path.cubicTo(3,5, 2,1, 3,1);
 669     path.close();
 670     pathB.setFillType(SkPath::kWinding_FillType);
 671     pathB.moveTo(1,2);
 672     pathB.cubicTo(1,3, 1,0, 5,3);
 673     pathB.close();
 674     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 675 }
 676
 677 static void cubicOp35d(skiatest::Reporter* reporter, const char* filename) {
 678     SkPath path, pathB;
 679     path.setFillType(SkPath::kWinding_FillType);
 680     path.moveTo(0,1);
 681     path.cubicTo(1,5, 2,1, 4,0);
 682     path.close();
 683     pathB.setFillType(SkPath::kWinding_FillType);
 684     pathB.moveTo(1,2);
 685     pathB.cubicTo(0,4, 1,0, 5,1);
 686     pathB.close();
 687     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 688 }
 689
 690 static void cubicOp36u(skiatest::Reporter* reporter, const char* filename) {
 691     SkPath path, pathB;
 692     path.setFillType(SkPath::kWinding_FillType);
 693     path.moveTo(0,1);
 694     path.cubicTo(1,6, 2,0, 5,1);
 695     path.close();
 696     pathB.setFillType(SkPath::kWinding_FillType);
 697     pathB.moveTo(0,2);
 698     pathB.cubicTo(1,5, 1,0, 6,1);
 699     pathB.close();
 700     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
 701 }
 702
 703 static void cubicOp37d(skiatest::Reporter* reporter, const char* filename) {
 704     SkPath path, pathB;
 705     path.setFillType(SkPath::kWinding_FillType);
 706     path.moveTo(0,1);
 707     path.cubicTo(2,6, 6,1, 4,3);
 708     path.close();
 709     pathB.setFillType(SkPath::kWinding_FillType);
 710     pathB.moveTo(1,6);
 711     pathB.cubicTo(3,4, 1,0, 6,2);
 712     pathB.close();
 713     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 714 }
 715
 716 // this fails to detect a cubic/cubic intersection
 717 // the slight overlap is missed when the cubics are approximated by quadratics
 718 // and the subsequent line/cubic intersection also (correctly) misses the intersection
 719 // if the line/cubic was a matching line/approx.quadratic then the missing intersection
 720 // could have been detected
 721 static void cubicOp38d(skiatest::Reporter* reporter, const char* filename) {
 722     SkPath path, pathB;
 723     path.setFillType(SkPath::kWinding_FillType);
 724     path.moveTo(0,1);
 725     path.cubicTo(0,6, 3,2, 4,1);
 726     path.close();
 727     pathB.setFillType(SkPath::kWinding_FillType);
 728     pathB.moveTo(2,3);
 729     pathB.cubicTo(1,4, 1,0, 6,0);
 730     pathB.close();
 731     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 732 }
 733
 734 static void cubicOp39d(skiatest::Reporter* reporter, const char* filename) {
 735     SkPath path, pathB;
 736     path.setFillType(SkPath::kWinding_FillType);
 737     path.moveTo(0,1);
 738     path.cubicTo(2,3, 5,1, 4,3);
 739     path.close();
 740     pathB.setFillType(SkPath::kWinding_FillType);
 741     pathB.moveTo(1,5);
 742     pathB.cubicTo(3,4, 1,0, 3,2);
 743     pathB.close();
 744     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 745 }
 746
 747 static void cubicOp40d(skiatest::Reporter* reporter, const char* filename) {
 748     SkPath path, pathB;
 749     path.setFillType(SkPath::kWinding_FillType);
 750     path.moveTo(0,1);
 751     path.cubicTo(1,5, 3,2, 4,2);
 752     path.close();
 753     pathB.setFillType(SkPath::kWinding_FillType);
 754     pathB.moveTo(2,3);
 755     pathB.cubicTo(2,4, 1,0, 5,1);
 756     pathB.close();
 757     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 758 }
 759
 760 static void cubicOp41i(skiatest::Reporter* reporter, const char* filename) {
 761     SkPath path, pathB;
 762     path.setFillType(SkPath::kWinding_FillType);
 763     path.moveTo(0,1);
 764     path.cubicTo(2,6, 4,3, 6,4);
 765     path.close();
 766     pathB.setFillType(SkPath::kWinding_FillType);
 767     pathB.moveTo(3,4);
 768     pathB.cubicTo(4,6, 1,0, 6,2);
 769     pathB.close();
 770     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
 771 }
 772
 773 static void cubicOp42d(skiatest::Reporter* reporter, const char* filename) {
 774     SkPath path, pathB;
 775     path.setFillType(SkPath::kWinding_FillType);
 776     path.moveTo(0,1);
 777     path.cubicTo(1,2, 6,5, 5,4);
 778     path.close();
 779     pathB.setFillType(SkPath::kWinding_FillType);
 780     pathB.moveTo(5,6);
 781     pathB.cubicTo(4,5, 1,0, 2,1);
 782     pathB.close();
 783     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 784 }
 785
 786 static void cubicOp43d(skiatest::Reporter* reporter, const char* filename) {
 787     SkPath path, pathB;
 788     path.setFillType(SkPath::kWinding_FillType);
 789     path.moveTo(0,2);
 790     path.cubicTo(1,2, 4,0, 3,1);
 791     path.close();
 792     pathB.setFillType(SkPath::kWinding_FillType);
 793     pathB.moveTo(0,4);
 794     pathB.cubicTo(1,3, 2,0, 2,1);
 795     pathB.close();
 796     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 797 }
 798
 799 static void cubicOp44d(skiatest::Reporter* reporter, const char* filename) {
 800     SkPath path, pathB;
 801     path.setFillType(SkPath::kWinding_FillType);
 802     path.moveTo(0,2);
 803     path.cubicTo(3,6, 4,0, 3,2);
 804     path.close();
 805     pathB.setFillType(SkPath::kWinding_FillType);
 806     pathB.moveTo(0,4);
 807     pathB.cubicTo(2,3, 2,0, 6,3);
 808     pathB.close();
 809     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 810 }
 811
 812 static void cubicOp45d(skiatest::Reporter* reporter, const char* filename) {
 813     SkPath path, pathB;
 814     path.setFillType(SkPath::kWinding_FillType);
 815     path.moveTo(0,2);
 816     path.cubicTo(2,4, 4,0, 3,2);
 817     path.close();
 818     pathB.setFillType(SkPath::kWinding_FillType);
 819     pathB.moveTo(0,4);
 820     pathB.cubicTo(2,3, 2,0, 4,2);
 821     pathB.close();
 822     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 823 }
 824
 825 static void cubicOp46d(skiatest::Reporter* reporter, const char* filename) {
 826     SkPath path, pathB;
 827     path.setFillType(SkPath::kWinding_FillType);
 828     path.moveTo(0,2);
 829     path.cubicTo(3,5, 5,0, 4,2);
 830     path.close();
 831     pathB.setFillType(SkPath::kWinding_FillType);
 832     pathB.moveTo(0,5);
 833     pathB.cubicTo(2,4, 2,0, 5,3);
 834     pathB.close();
 835     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 836 }
 837
 838 static void cubicOp47d(skiatest::Reporter* reporter, const char* filename) {
 839     SkPath path, pathB;
 840     path.setFillType(SkPath::kWinding_FillType);
 841     path.moveTo(0,1);
 842     path.cubicTo(1,6, 6,2, 5,4);
 843     path.close();
 844     pathB.setFillType(SkPath::kWinding_FillType);
 845     pathB.moveTo(2,6);
 846     pathB.cubicTo(4,5, 1,0, 6,1);
 847     pathB.close();
 848     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 849 }
 850
 851 static void cubicOp48d(skiatest::Reporter* reporter, const char* filename) {
 852     SkPath path, pathB;
 853     path.setFillType(SkPath::kWinding_FillType);
 854     path.moveTo(0,2);
 855     path.cubicTo(2,3, 5,1, 3,2);
 856     path.close();
 857     pathB.setFillType(SkPath::kWinding_FillType);
 858     pathB.moveTo(1,5);
 859     pathB.cubicTo(2,3, 2,0, 3,2);
 860     pathB.close();
 861     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 862 }
 863
 864 static void cubicOp49d(skiatest::Reporter* reporter, const char* filename) {
 865     SkPath path, pathB;
 866     path.setFillType(SkPath::kWinding_FillType);
 867     path.moveTo(0,2);
 868     path.cubicTo(1,5, 3,2, 4,1);
 869     path.close();
 870     pathB.setFillType(SkPath::kWinding_FillType);
 871     pathB.moveTo(2,3);
 872     pathB.cubicTo(1,4, 2,0, 5,1);
 873     pathB.close();
 874     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 875 }
 876
 877 static void cubicOp50d(skiatest::Reporter* reporter, const char* filename) {
 878     SkPath path, pathB;
 879     path.setFillType(SkPath::kWinding_FillType);
 880     path.moveTo(0,3);
 881     path.cubicTo(1,6, 5,0, 5,1);
 882     path.close();
 883     pathB.setFillType(SkPath::kWinding_FillType);
 884     pathB.moveTo(0,5);
 885     pathB.cubicTo(1,5, 3,0, 6,1);
 886     pathB.close();
 887     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 888 }
 889
 890 static void cubicOp51d(skiatest::Reporter* reporter, const char* filename) {
 891     SkPath path, pathB;
 892     path.setFillType(SkPath::kWinding_FillType);
 893     path.moveTo(0,3);
 894     path.cubicTo(1,2, 4,1, 6,0);
 895     path.close();
 896     pathB.setFillType(SkPath::kWinding_FillType);
 897     pathB.moveTo(1,4);
 898     pathB.cubicTo(0,6, 3,0, 2,1);
 899     pathB.close();
 900     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 901 }
 902
 903 static void cubicOp52d(skiatest::Reporter* reporter, const char* filename) {
 904     SkPath path, pathB;
 905     path.setFillType(SkPath::kWinding_FillType);
 906     path.moveTo(0,2);
 907     path.cubicTo(1,2, 5,4, 4,3);
 908     path.close();
 909     pathB.setFillType(SkPath::kWinding_FillType);
 910     pathB.moveTo(4,5);
 911     pathB.cubicTo(3,4, 2,0, 2,1);
 912     pathB.close();
 913     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 914 }
 915
 916 static void cubicOp53d(skiatest::Reporter* reporter, const char* filename) {
 917     SkPath path, pathB;
 918     path.setFillType(SkPath::kWinding_FillType);
 919     path.moveTo(0,3);
 920     path.cubicTo(1,2, 5,3, 2,1);
 921     path.close();
 922     pathB.setFillType(SkPath::kWinding_FillType);
 923     pathB.moveTo(3,5);
 924     pathB.cubicTo(1,2, 3,0, 2,1);
 925     pathB.close();
 926     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 927 }
 928
 929 static void cubicOp54d(skiatest::Reporter* reporter, const char* filename) {
 930     SkPath path, pathB;
 931     path.setFillType(SkPath::kWinding_FillType);
 932     path.moveTo(0,4);
 933     path.cubicTo(1,3, 5,4, 4,2);
 934     path.close();
 935     pathB.setFillType(SkPath::kWinding_FillType);
 936     pathB.moveTo(4,5);
 937     pathB.cubicTo(2,4, 4,0, 3,1);
 938     pathB.close();
 939     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 940 }
 941
 942 static void cubicOp55d(skiatest::Reporter* reporter, const char* filename) {
 943     SkPath path, pathB;
 944     path.setFillType(SkPath::kWinding_FillType);
 945     path.moveTo(0,5);
 946     path.cubicTo(1,3, 3,2, 5,0);
 947     path.close();
 948     pathB.setFillType(SkPath::kWinding_FillType);
 949     pathB.moveTo(2,3);
 950     pathB.cubicTo(0,5, 5,0, 3,1);
 951     pathB.close();
 952     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 953 }
 954
 955 static void cubicOp56d(skiatest::Reporter* reporter, const char* filename) {
 956     SkPath path, pathB;
 957     path.setFillType(SkPath::kWinding_FillType);
 958     path.moveTo(0,1);
 959     path.cubicTo(2,6, 5,0, 2,1);
 960     path.close();
 961     pathB.setFillType(SkPath::kWinding_FillType);
 962     pathB.moveTo(0,5);
 963     pathB.cubicTo(1,2, 1,0, 6,2);
 964     pathB.close();
 965     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 966 }
 967
 968 static void cubicOp57d(skiatest::Reporter* reporter, const char* filename) {
 969     SkPath path, pathB;
 970     path.setFillType(SkPath::kWinding_FillType);
 971     path.moveTo(0,5);
 972     path.cubicTo(0,5, 5,4, 6,4);
 973     path.close();
 974     pathB.setFillType(SkPath::kWinding_FillType);
 975     pathB.moveTo(4,5);
 976     pathB.cubicTo(4,6, 5,0, 5,0);
 977     pathB.close();
 978     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 979 }
 980
 981 static void cubicOp58d(skiatest::Reporter* reporter, const char* filename) {
 982     SkPath path, pathB;
 983     path.setFillType(SkPath::kWinding_FillType);
 984     path.moveTo(0,5);
 985     path.cubicTo(3,4, 6,5, 5,3);
 986     path.close();
 987     pathB.setFillType(SkPath::kWinding_FillType);
 988     pathB.moveTo(5,6);
 989     pathB.cubicTo(3,5, 5,0, 4,3);
 990     pathB.close();
 991     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
 992 }
 993
 994 static void cubicOp59d(skiatest::Reporter* reporter, const char* filename) {
 995     SkPath path, pathB;
 996     path.setFillType(SkPath::kWinding_FillType);
 997     path.moveTo(0,1);
 998     path.cubicTo(5,6, 4,0, 4,1);
 999     path.close();
1000     pathB.setFillType(SkPath::kWinding_FillType);
1001     pathB.moveTo(0,4);
1002     pathB.cubicTo(1,4, 1,0, 6,5);
1003     pathB.close();
1004     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1005 }
1006
1007 static void cubicOp60d(skiatest::Reporter* reporter, const char* filename) {
1008     SkPath path, pathB;
1009     path.setFillType(SkPath::kWinding_FillType);
1010     path.moveTo(0,2);
1011     path.cubicTo(4,6, 6,0, 5,2);
1012     path.close();
1013     pathB.setFillType(SkPath::kWinding_FillType);
1014     pathB.moveTo(0,6);
1015     pathB.cubicTo(2,5, 2,0, 6,4);
1016     pathB.close();
1017     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1018 }
1019
1020 static void cubicOp61d(skiatest::Reporter* reporter, const char* filename) {
1021     SkPath path, pathB;
1022     path.setFillType(SkPath::kWinding_FillType);
1023     path.moveTo(1,2);
1024     path.cubicTo(0,5, 3,2, 6,1);
1025     path.close();
1026     pathB.setFillType(SkPath::kWinding_FillType);
1027     pathB.moveTo(2,3);
1028     pathB.cubicTo(1,6, 2,1, 5,0);
1029     pathB.close();
1030     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1031 }
1032
1033 static void cubicOp62d(skiatest::Reporter* reporter, const char* filename) {
1034     SkPath path, pathB;
1035     path.setFillType(SkPath::kWinding_FillType);
1036     path.moveTo(1,3);
1037     path.cubicTo(5,6, 5,3, 5,4);
1038     path.close();
1039     pathB.setFillType(SkPath::kWinding_FillType);
1040     pathB.moveTo(3,5);
1041     pathB.cubicTo(4,5, 3,1, 6,5);
1042     pathB.close();
1043     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1044 }
1045
1046 static void cubicOp63d(skiatest::Reporter* reporter, const char* filename) {
1047     SkPath path, pathB;
1048     path.setFillType(SkPath::kWinding_FillType);
1049     path.moveTo(2,3);
1050     path.cubicTo(0,4, 3,2, 5,3);
1051     path.close();
1052     pathB.setFillType(SkPath::kWinding_FillType);
1053     pathB.moveTo(2,3);
1054     pathB.cubicTo(3,5, 3,2, 4,0);
1055     pathB.close();
1056     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1057 }
1058
1059 static void cubicOp64d(skiatest::Reporter* reporter, const char* filename) {
1060     SkPath path, pathB;
1061     path.moveTo(0,1);
1062     path.cubicTo(0,1, 1,0, 3,0);
1063     path.lineTo(0,1);
1064     path.close();
1065     pathB.moveTo(0,1);
1066     pathB.cubicTo(0,3, 1,0, 1,0);
1067     pathB.lineTo(0,1);
1068     pathB.close();
1069     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1070 }
1071
1072 static void cubicOp65d(skiatest::Reporter* reporter, const char* filename) {
1073     SkPath path, pathB;
1074     path.moveTo(0,1);
1075     path.cubicTo(1,5, 1,0, 1,0);
1076     path.lineTo(0,1);
1077     path.close();
1078     pathB.moveTo(0,1);
1079     pathB.cubicTo(0,1, 1,0, 5,1);
1080     pathB.lineTo(0,1);
1081     pathB.close();
1082     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1083 }
1084
1085 static void rectOp1d(skiatest::Reporter* reporter, const char* filename) {
1086     SkPath path, pathB;
1087     path.moveTo(0,1);
1088     path.cubicTo(0,1, 1,0, 3,0);
1089     path.lineTo(0,1);
1090     path.close();
1091     pathB.moveTo(0,1);
1092     pathB.cubicTo(0,3, 1,0, 1,0);
1093     pathB.lineTo(0,1);
1094     pathB.close();
1095     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1096 }
1097
1098 static void cubicOp66u(skiatest::Reporter* reporter, const char* filename) {
1099     SkPath path, pathB;
1100     path.setFillType(SkPath::kWinding_FillType);
1101     path.moveTo(0,1);
1102     path.cubicTo(2,6, 4,2, 5,3);
1103     path.close();
1104     pathB.setFillType(SkPath::kWinding_FillType);
1105     pathB.moveTo(2,4);
1106     pathB.cubicTo(3,5, 1,0, 6,2);
1107     pathB.close();
1108     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1109 }
1110
1111 static void cubicOp67u(skiatest::Reporter* reporter, const char* filename) {
1112     SkPath path, pathB;
1113     path.moveTo(3,5);
1114     path.cubicTo(1,6, 5,0, 3,1);
1115     path.lineTo(3,5);
1116     path.close();
1117     pathB.moveTo(0,5);
1118     pathB.cubicTo(1,3, 5,3, 6,1);
1119     pathB.lineTo(0,5);
1120     pathB.close();
1121     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1122 }
1123
1124 static void cubicOp68u(skiatest::Reporter* reporter, const char* filename) {
1125     SkPath path, pathB;
1126     path.moveTo(0,5);
1127     path.cubicTo(4,5, 4,1, 5,0);
1128     path.close();
1129     pathB.moveTo(1,4);
1130     pathB.cubicTo(0,5, 5,0, 5,4);
1131     pathB.close();
1132     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1133 }
1134
1135 static void cubicOp69d(skiatest::Reporter* reporter, const char* filename) {
1136     SkPath path, pathB;
1137     path.moveTo(1,3);
1138     path.cubicTo(0,1, 3,1, 2,0);
1139     path.close();
1140     pathB.moveTo(1,3);
1141     pathB.cubicTo(0,2, 3,1, 1,0);
1142     pathB.close();
1143     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1144 }
1145
1146 SkPathOp ops[] = {
1147     kUnion_PathOp,
1148     kXOR_PathOp,
1149     kReverseDifference_PathOp,
1150     kXOR_PathOp,
1151     kReverseDifference_PathOp,
1152 };
1153
1154 static void rRect1(skiatest::Reporter* reporter, const char* filename) {
1155     SkScalar xA = 0.65f;
1156     SkScalar xB = 10.65f;
1157     SkScalar xC = 20.65f;
1158     SkScalar xD = 30.65f;
1159     SkScalar xE = 40.65f;
1160     SkScalar xF = 50.65f;
1161
1162     SkScalar yA = 0.65f;
1163     SkScalar yB = 10.65f;
1164     SkScalar yC = 20.65f;
1165     SkScalar yD = 30.65f;
1166     SkScalar yE = 40.65f;
1167     SkScalar yF = 50.65f;
1168     SkPath paths[5];
1169     SkRect rects[5];
1170     rects[0].set(xB, yB, xE, yE);
1171     paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5));  // red
1172     rects[1].set(xA, yA, xD, yD);
1173     paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5));  // green
1174     rects[2].set(xC, yA, xF, yD);
1175     paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5));  // blue
1176     rects[3].set(xA, yC, xD, yF);
1177     paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5));  // yellow
1178     rects[4].set(xC, yC, xF, yF);
1179     paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5));  // cyan
1180     SkPath path;
1181     path.setFillType(SkPath::kInverseEvenOdd_FillType);
1182     for (int index = 0; index < 5; ++index) {
1183         testPathOp(reporter, path, paths[index], ops[index], filename);
1184         Op(path, paths[index], ops[index], &path);
1185     }
1186 }
1187
1188 static void skp1(skiatest::Reporter* reporter, const char* filename) {
1189     SkPath path;
1190     path.setFillType(SkPath::kEvenOdd_FillType);
1191     path.moveTo(189,7);
1192     path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1193     path.lineTo(243,4);
1194     path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1195     path.lineTo(246,21);
1196     path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1197     path.lineTo(192,24);
1198     path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1199     path.lineTo(189,7);
1200     path.close();
1201     path.moveTo(191,8);
1202     path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1203     path.lineTo(242,6);
1204     path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1205     path.lineTo(244,20);
1206     path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1207     path.lineTo(193,22);
1208     path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1209     path.lineTo(191,8);
1210     path.close();
1211     SkPath pathB;
1212     pathB.setFillType(SkPath::kWinding_FillType);
1213     pathB.moveTo(189,4);
1214     pathB.lineTo(199,14);
1215     pathB.lineTo(236,14);
1216     pathB.lineTo(246,4);
1217     pathB.lineTo(189,4);
1218     pathB.close();
1219     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1220 }
1221
1222 static void skp2(skiatest::Reporter* reporter, const char* filename) {
1223     SkPath path;
1224     path.setFillType(SkPath::kEvenOdd_FillType);
1225     path.moveTo(253.000000f, 11757.0000f);
1226     path.lineTo(253.000000f, 222.000000f);
1227     path.lineTo(823.000000f, 222.000000f);
1228     path.lineTo(823.000000f, 11757.0000f);
1229     path.lineTo(253.000000f, 11757.0000f);
1230     path.close();
1231     SkPath pathB;
1232     pathB.setFillType(SkPath::kWinding_FillType);
1233     pathB.moveTo(258.000000f, 1028.00000f);
1234     pathB.lineTo(258.000000f, 1027.00000f);
1235     pathB.lineTo(823.000000f, 1027.00000f);
1236     pathB.lineTo(823.000000f, 1028.00000f);
1237     pathB.lineTo(258.000000f, 1028.00000f);
1238     pathB.close();
1239     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1240 }
1241
1242 static void skp3(skiatest::Reporter* reporter, const char* filename) {
1243     SkPath path;
1244     path.setFillType(SkPath::kEvenOdd_FillType);
1245     path.moveTo(717.000000f, 507.000000f);
1246     path.lineTo(717.000000f, 425.000000f);
1247     path.lineTo(973.000000f, 425.000000f);
1248     path.lineTo(973.000000f, 507.000000f);
1249     path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1250     path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1251     path.lineTo(720.000000f, 510.000000f);
1252     path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1253     path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1254     path.close();
1255     path.moveTo(719.000000f, 426.000000f);
1256     path.lineTo(971.000000f, 426.000000f);
1257     path.lineTo(971.000000f, 506.000000f);
1258     path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1259     path.lineTo(721.000000f, 508.000000f);
1260     path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1261     path.lineTo(719.000000f, 426.000000f);
1262     path.close();
1263     SkPath pathB;
1264     pathB.setFillType(SkPath::kWinding_FillType);
1265     pathB.moveTo(717.000000f, 510.000000f);
1266     pathB.lineTo(760.000000f, 467.000000f);
1267     pathB.lineTo(930.000000f, 467.000000f);
1268     pathB.lineTo(973.000000f, 510.000000f);
1269     pathB.lineTo(717.000000f, 510.000000f);
1270     pathB.close();
1271     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1272 }
1273
1274 static void skp4(skiatest::Reporter* reporter, const char* filename) {
1275     SkPath path;
1276     path.setFillType(SkPath::kEvenOdd_FillType);
1277     path.moveTo(230.756805f, 591.756775f);
1278     path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1279     path.lineTo(300.000000f, 590.000000f);
1280     path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1281     path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1282     path.lineTo(306.000000f, 617.000000f);
1283     path.lineTo(229.000000f, 617.000000f);
1284     path.lineTo(229.000000f, 596.000000f);
1285     path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1286     path.close();
1287     path.moveTo(231.000000f, 597.000000f);
1288     path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1289     path.lineTo(299.000000f, 592.000000f);
1290     path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1291     path.lineTo(304.000000f, 616.000000f);
1292     path.lineTo(231.000000f, 616.000000f);
1293     path.lineTo(231.000000f, 597.000000f);
1294     path.close();
1295     SkPath pathB;
1296     pathB.setFillType(SkPath::kWinding_FillType);
1297     pathB.moveTo(306.000000f, 590.000000f);
1298     pathB.lineTo(292.000000f, 604.000000f);
1299     pathB.lineTo(305.000000f, 617.000000f);
1300     pathB.lineTo(306.000000f, 617.000000f);
1301     pathB.lineTo(306.000000f, 590.000000f);
1302     pathB.close();
1303     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1304 }
1305
1306 static void skp5(skiatest::Reporter* reporter, const char* filename) {
1307     SkPath path;
1308     path.setFillType(SkPath::kEvenOdd_FillType);
1309     path.moveTo(18.0000000f, 226.000000f);
1310     path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1311     path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1312     path.lineTo(10.0000000f, 253.000000f);
1313     path.lineTo(1247.00000f, 253.000000f);
1314     path.lineTo(1247.00000f, 234.000000f);
1315     path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1316     path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1317     path.lineTo(18.0000000f, 226.000000f);
1318     path.close();
1319     SkPath pathB;
1320     pathB.setFillType(SkPath::kInverseWinding_FillType);
1321     pathB.moveTo(18.0000000f, 226.000000f);
1322     pathB.lineTo(1239.00000f, 226.000000f);
1323     pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1324     pathB.lineTo(1247.00000f, 252.000000f);
1325     pathB.lineTo(10.0000000f, 252.000000f);
1326     pathB.lineTo(10.0000000f, 234.000000f);
1327     pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1328     pathB.close();
1329     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1330 }
1331
1332 static void cubicOp70d(skiatest::Reporter* reporter, const char* filename) {
1333     SkPath path, pathB;
1334     path.setFillType(SkPath::kWinding_FillType);
1335     path.moveTo(0,1);
1336     path.cubicTo(0,5, 4,0, 5,0);
1337     path.close();
1338     pathB.setFillType(SkPath::kWinding_FillType);
1339     pathB.moveTo(0,4);
1340     pathB.cubicTo(0,5, 1,0, 5,0);
1341     pathB.close();
1342     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1343 }
1344
1345 static void cubicOp71d(skiatest::Reporter* reporter, const char* filename) {
1346     SkPath path, pathB;
1347     path.setFillType(SkPath::kWinding_FillType);
1348     path.moveTo(0,1);
1349     path.cubicTo(0,5, 4,1, 6,4);
1350     path.close();
1351     pathB.setFillType(SkPath::kWinding_FillType);
1352     pathB.moveTo(1,4);
1353     pathB.cubicTo(4,6, 1,0, 5,0);
1354     pathB.close();
1355     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1356 }
1357
1358 static void cubicOp72i(skiatest::Reporter* reporter, const char* filename) {
1359     SkPath path, pathB;
1360     path.setFillType(SkPath::kWinding_FillType);
1361     path.moveTo(0,1);
1362     path.cubicTo(0,5, 5,2, 5,4);
1363     path.close();
1364     pathB.setFillType(SkPath::kWinding_FillType);
1365     pathB.moveTo(2,5);
1366     pathB.cubicTo(4,5, 1,0, 5,0);
1367     pathB.close();
1368     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1369 }
1370
1371 static void cubicOp73d(skiatest::Reporter* reporter, const char* filename) {
1372     SkPath path, pathB;
1373     path.setFillType(SkPath::kWinding_FillType);
1374     path.moveTo(0,1);
1375     path.cubicTo(3,4, 4,0, 6,4);
1376     path.lineTo(0,1);
1377     path.close();
1378     pathB.setFillType(SkPath::kWinding_FillType);
1379     pathB.moveTo(0,4);
1380     pathB.cubicTo(4,6, 1,0, 4,3);
1381     pathB.lineTo(0,4);
1382     pathB.close();
1383     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1384 }
1385
1386 static void cubicOp74d(skiatest::Reporter* reporter, const char* filename) {
1387     SkPath path, pathB;
1388     path.setFillType(SkPath::kWinding_FillType);
1389     path.moveTo(0,1);
1390     path.cubicTo(1,5, 5,1, 5,1);
1391     path.lineTo(0,1);
1392     path.close();
1393     pathB.setFillType(SkPath::kWinding_FillType);
1394     pathB.moveTo(1,5);
1395     pathB.cubicTo(1,5, 1,0, 5,1);
1396     pathB.lineTo(1,5);
1397     pathB.close();
1398     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1399 }
1400
1401 static void cubicOp75d(skiatest::Reporter* reporter, const char* filename) {
1402     SkPath path, pathB;
1403     path.setFillType(SkPath::kWinding_FillType);
1404     path.moveTo(0,1);
1405     path.cubicTo(0,4, 5,1, 6,4);
1406     path.lineTo(0,1);
1407     path.close();
1408     pathB.setFillType(SkPath::kWinding_FillType);
1409     pathB.moveTo(1,5);
1410     pathB.cubicTo(4,6, 1,0, 4,0);
1411     pathB.lineTo(1,5);
1412     pathB.close();
1413     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1414 }
1415
1416 static void cubicOp76u(skiatest::Reporter* reporter, const char* filename) {
1417     SkPath path, pathB;
1418     path.setFillType(SkPath::kWinding_FillType);
1419     path.moveTo(0,1);
1420     path.cubicTo(0,2, 2,0, 5,3);
1421     path.close();
1422     pathB.setFillType(SkPath::kWinding_FillType);
1423     pathB.moveTo(0,2);
1424     pathB.cubicTo(3,5, 1,0, 2,0);
1425     pathB.close();
1426     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1427 }
1428
1429 static void cubicOp77i(skiatest::Reporter* reporter, const char* filename) {
1430     SkPath path, pathB;
1431     path.setFillType(SkPath::kEvenOdd_FillType);
1432     path.moveTo(0,1);
1433     path.cubicTo(1,3, 2,0, 3,2);
1434     path.lineTo(0,1);
1435     path.close();
1436     pathB.setFillType(SkPath::kEvenOdd_FillType);
1437     pathB.moveTo(0,2);
1438     pathB.cubicTo(2,3, 1,0, 3,1);
1439     pathB.lineTo(0,2);
1440     pathB.close();
1441     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1442 }
1443
1444 static void cubicOp78u(skiatest::Reporter* reporter, const char* filename) {
1445     SkPath path, pathB;
1446     path.setFillType(SkPath::kEvenOdd_FillType);
1447     path.moveTo(1,6);
1448     path.cubicTo(1,6, 5,0, 6,1);
1449     path.lineTo(1,6);
1450     path.close();
1451     pathB.setFillType(SkPath::kEvenOdd_FillType);
1452     pathB.moveTo(0,5);
1453     pathB.cubicTo(1,6, 6,1, 6,1);
1454     pathB.lineTo(0,5);
1455     pathB.close();
1456     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1457 }
1458
1459 static void cubicOp79u(skiatest::Reporter* reporter, const char* filename) {
1460     SkPath path, pathB;
1461     path.setFillType(SkPath::kWinding_FillType);
1462     path.moveTo(0,1);
1463     path.cubicTo(1,3, 1,0, 6,4);
1464     path.close();
1465     pathB.setFillType(SkPath::kWinding_FillType);
1466     pathB.moveTo(0,1);
1467     pathB.cubicTo(4,6, 1,0, 3,1);
1468     pathB.close();
1469     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1470 }
1471
1472 static void cubicOp80i(skiatest::Reporter* reporter, const char* filename) {
1473     SkPath path, pathB;
1474     path.setFillType(SkPath::kWinding_FillType);
1475     path.moveTo(0,1);
1476     path.cubicTo(2,3, 2,1, 4,3);
1477     path.lineTo(0,1);
1478     path.close();
1479     pathB.setFillType(SkPath::kWinding_FillType);
1480     pathB.moveTo(1,2);
1481     pathB.cubicTo(3,4, 1,0, 3,2);
1482     pathB.lineTo(1,2);
1483     pathB.close();
1484     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1485 }
1486
1487 static void cubicOp81d(skiatest::Reporter* reporter, const char* filename) {
1488     SkPath path, pathB;
1489     path.setFillType(SkPath::kWinding_FillType);
1490     path.moveTo(0,1);
1491     path.cubicTo(4,6, 4,3, 5,4);
1492     path.close();
1493     pathB.setFillType(SkPath::kWinding_FillType);
1494     pathB.moveTo(3,4);
1495     pathB.cubicTo(4,5, 1,0, 6,4);
1496     pathB.close();
1497     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1498 }
1499
1500 static void cubicOp82i(skiatest::Reporter* reporter, const char* filename) {
1501     SkPath path, pathB;
1502     path.setFillType(SkPath::kEvenOdd_FillType);
1503     path.moveTo(0,1);
1504     path.cubicTo(2,3, 5,2, 3,0);
1505     path.lineTo(0,1);
1506     path.close();
1507     pathB.setFillType(SkPath::kWinding_FillType);
1508     pathB.moveTo(2,5);
1509     pathB.cubicTo(0,3, 1,0, 3,2);
1510     pathB.lineTo(2,5);
1511     pathB.close();
1512     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1513 }
1514
1515 static void cubicOp83i(skiatest::Reporter* reporter, const char* filename) {
1516     SkPath path, pathB;
1517     path.setFillType(SkPath::kWinding_FillType);
1518     path.moveTo(0,1);
1519     path.cubicTo(0,3, 2,1, 4,1);
1520     path.lineTo(0,1);
1521     path.close();
1522     pathB.setFillType(SkPath::kWinding_FillType);
1523     pathB.moveTo(1,2);
1524     pathB.cubicTo(1,4, 1,0, 3,0);
1525     pathB.lineTo(1,2);
1526     pathB.close();
1527     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1528 }
1529
1530 static void cubicOp84d(skiatest::Reporter* reporter, const char* filename) {
1531     SkPath path, pathB;
1532     path.setFillType(SkPath::kWinding_FillType);
1533     path.moveTo(0,4);
1534     path.cubicTo(2,3, 6,3, 3,2);
1535     path.close();
1536     pathB.setFillType(SkPath::kWinding_FillType);
1537     pathB.moveTo(3,6);
1538     pathB.cubicTo(2,3, 4,0, 3,2);
1539     pathB.close();
1540     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1541 }
1542
1543 static void skpClip1(skiatest::Reporter* reporter, const char* filename) {
1544     SkPath path;
1545     path.setFillType(SkPath::kEvenOdd_FillType);
1546     path.moveTo(1126.17114f, 877.171204f);
1547     path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1548     path.lineTo(1243.00000f, 876.000000f);
1549     path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1550     path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1551     path.lineTo(1247.00000f, 907.000000f);
1552     path.lineTo(1246.00000f, 907.000000f);
1553     path.lineTo(1246.00000f, 880.000000f);
1554     path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1555     path.lineTo(1129.00000f, 877.000000f);
1556     path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1557     path.lineTo(1126.00000f, 907.000000f);
1558     path.lineTo(1125.00000f, 907.000000f);
1559     path.lineTo(1125.00000f, 880.000000f);
1560     path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1561     path.close();
1562     SkPath pathB;
1563     pathB.setFillType(SkPath::kWinding_FillType);
1564     pathB.moveTo(1247.00000f, 876.000000f);
1565     pathB.lineTo(1231.00000f, 892.000000f);
1566     pathB.lineTo(1246.00000f, 907.000000f);
1567     pathB.lineTo(1247.00000f, 907.000000f);
1568     pathB.lineTo(1247.00000f, 876.000000f);
1569     pathB.close();
1570     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1571 }
1572
1573 static void skpClip2(skiatest::Reporter* reporter, const char* filename) {
1574     SkPath path;
1575     path.setFillType(SkPath::kEvenOdd_FillType);
1576     path.moveTo(134.000000f, 11414.0000f);
1577     path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1578     path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1579     path.lineTo(806.000000f, 11419.0000f);
1580     path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1581     path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1582     path.lineTo(134.000000f, 11414.0000f);
1583     path.close();
1584     SkPath pathB;
1585     pathB.setFillType(SkPath::kInverseWinding_FillType);
1586     pathB.moveTo(132.000000f, 11415.0000f);
1587     pathB.lineTo(806.000000f, 11415.0000f);
1588     pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1589     pathB.lineTo(808.000000f, 11417.0000f);
1590     pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1591     pathB.lineTo(132.000000f, 11419.0000f);
1592     pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1593     pathB.lineTo(130.000000f, 11416.0000f);
1594     pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1595     pathB.close();
1596     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1597 }
1598
1599 static void skp96prezzi1(skiatest::Reporter* reporter, const char* filename) {
1600     SkPath path;
1601     path.setFillType(SkPath::kEvenOdd_FillType);
1602     path.moveTo(157.464005f, 670.463989f);
1603     path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1604     path.lineTo(248.000000f, 669.000000f);
1605     path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1606     path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1607     path.lineTo(253.000000f, 706.000000f);
1608     path.lineTo(251.000000f, 706.000000f);
1609     path.lineTo(251.000000f, 675.000000f);
1610     path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1611     path.lineTo(162.000000f, 671.000000f);
1612     path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1613     path.lineTo(158.000000f, 706.000000f);
1614     path.lineTo(156.000000f, 706.000000f);
1615     path.lineTo(156.000000f, 674.000000f);
1616     path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1617     path.close();
1618     SkPath pathB;
1619     pathB.setFillType(SkPath::kWinding_FillType);
1620     pathB.moveTo(156.000000f, 669.000000f);
1621     pathB.lineTo(178.500000f, 691.500000f);
1622     pathB.lineTo(230.500000f, 691.500000f);
1623     pathB.lineTo(253.000000f, 669.000000f);
1624     pathB.lineTo(156.000000f, 669.000000f);
1625     pathB.close();
1626     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1627 }
1628
1629 static void skpancestry_com1(skiatest::Reporter* reporter, const char* filename) {
1630     SkPath path;
1631     path.setFillType(SkPath::kEvenOdd_FillType);
1632     path.moveTo(161.000000f, 925.000000f);
1633     path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1634     path.lineTo(158.000000f, 926.000000f);
1635     path.lineTo(1108.00000f, 926.000000f);
1636     path.lineTo(1108.00000f, 925.999634f);
1637     path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1638     path.lineTo(161.000000f, 925.000000f);
1639     path.close();
1640     SkPath pathB;
1641     pathB.setFillType(SkPath::kEvenOdd_FillType);
1642     pathB.moveTo(161.000000f, 926.000000f);
1643     pathB.lineTo(1105.00000f, 926.000000f);
1644     pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1645     pathB.lineTo(1109.00000f, 956.000000f);
1646     pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1647     pathB.lineTo(161.000000f, 960.000000f);
1648     pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1649     pathB.lineTo(157.000000f, 930.000000f);
1650     pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1651     pathB.close();
1652     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1653 }
1654
1655 static void skpeldorado_com_ua1(skiatest::Reporter* reporter, const char* filename) {
1656     SkPath path;
1657     path.setFillType(SkPath::kEvenOdd_FillType);
1658     path.moveTo(286.695129f, 291.000000f);
1659     path.lineTo(229.304855f, 561.000000f);
1660     path.lineTo(979.304871f, 561.000000f);
1661     path.lineTo(1036.69507f, 291.000000f);
1662     path.lineTo(286.695129f, 291.000000f);
1663     path.close();
1664     SkPath pathB;
1665     pathB.setFillType(SkPath::kWinding_FillType);
1666     pathB.moveTo(1006.69513f, 291.000000f);
1667     pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1668     pathB.lineTo(985.681519f, 531.000000f);
1669     pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1670     pathB.lineTo(259.304871f, 561.000000f);
1671     pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1672     pathB.lineTo(280.318420f, 321.000000f);
1673     pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1674     pathB.lineTo(1006.69513f, 291.000000f);
1675     pathB.close();
1676     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1677 }
1678
1679 static void skpbyte_com1(skiatest::Reporter* reporter, const char* filename) {
1680     SkPath path;
1681     path.setFillType(SkPath::kEvenOdd_FillType);
1682     path.moveTo(968.000000f, 14.0000000f);
1683     path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1684     path.lineTo(963.000000f, 32.0000000f);
1685     path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1686     path.lineTo(1034.00000f, 37.0000000f);
1687     path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1688     path.lineTo(1039.00000f, 19.0000000f);
1689     path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1690     path.lineTo(968.000000f, 14.0000000f);
1691     path.close();
1692     SkPath pathB;
1693     pathB.setFillType(SkPath::kInverseWinding_FillType);
1694     pathB.moveTo(968.000000f, 14.0000000f);
1695     pathB.lineTo(1034.00000f, 14.0000000f);
1696     pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1697     pathB.lineTo(1039.00000f, 32.0000000f);
1698     pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1699     pathB.lineTo(968.000000f, 36.0000000f);
1700     pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1701     pathB.lineTo(963.000000f, 19.0000000f);
1702     pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1703     pathB.close();
1704     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1705 }
1706
1707 static void skphealth_com76(skiatest::Reporter* reporter, const char* filename) {
1708     SkPath path;
1709     path.setFillType(SkPath::kEvenOdd_FillType);
1710     path.moveTo(708.099182f, 7.09919119f);
1711     path.lineTo(708.099182f, 7.09920025f);
1712     path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1713     path.lineTo(704.000000f, 33.0000000f);
1714     path.lineTo(705.000000f, 33.0000000f);
1715     path.lineTo(705.000000f, 17.0000000f);
1716     path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1717     path.lineTo(708.099182f, 7.09919119f);
1718     path.close();
1719     SkPath pathB;
1720     pathB.setFillType(SkPath::kWinding_FillType);
1721     pathB.moveTo(704.000000f, 3.00000000f);
1722 #if 0
1723     pathB.lineTo(719.500000f, 3.00000000f);
1724     pathB.lineTo(705.000000f, 33.0000000f);
1725     pathB.lineTo(704.000000f, 33.0000000f);
1726     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1727 #else
1728     pathB.lineTo(704.000000f, 33.0000000f);
1729     pathB.lineTo(705.000000f, 33.0000000f);
1730     pathB.lineTo(719.500000f, 3.00000000f);
1731     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1732 #endif
1733 }
1734
1735 static void skpahrefs_com88(skiatest::Reporter* reporter, const char* filename) {
1736     SkPath path;
1737     path.setFillType(SkPath::kEvenOdd_FillType);
1738     path.moveTo(1099.82886f, 7.17117119f);
1739     path.lineTo(1099.12134f, 7.87867832f);
1740     path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1741     path.lineTo(1100.00000f, 28.0000000f);
1742     path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1743     path.lineTo(1088.00000f, 31.0000000f);
1744     path.lineTo(1088.00000f, 32.0000000f);
1745     path.lineTo(1097.00000f, 32.0000000f);
1746     path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1747     path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1748     path.lineTo(1101.00000f, 10.0000000f);
1749     path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1750     path.lineTo(1099.82886f, 7.17117119f);
1751     path.close();
1752     SkPath pathB;
1753     pathB.setFillType(SkPath::kWinding_FillType);
1754     pathB.moveTo(1101.00000f, 6.00000000f);
1755     pathB.lineTo(1088.00000f, 6.00000000f);
1756     pathB.lineTo(1088.00000f, 19.0000000f);
1757     pathB.lineTo(1101.00000f, 32.0000000f);
1758     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1759 }
1760
1761 static void skpahrefs_com29(skiatest::Reporter* reporter, const char* filename) {
1762     SkPath path;
1763     path.setFillType(SkPath::kEvenOdd_FillType);
1764     path.moveTo(1037.17114f, 7.17119980f);
1765     path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1766     path.lineTo(1074.00000f, 6.00000000f);
1767     path.lineTo(1074.00000f, 32.0000000f);
1768     path.lineTo(1040.00000f, 32.0000000f);
1769     path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1770     path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1771     path.lineTo(1036.00000f, 10.0000000f);
1772     path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1773     path.close();
1774     path.moveTo(1037.00000f, 10.0000000f);
1775     path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1776     path.lineTo(1073.00000f, 7.00000000f);
1777     path.lineTo(1073.00000f, 31.0000000f);
1778     path.lineTo(1040.00000f, 31.0000000f);
1779     path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1780     path.lineTo(1037.00000f, 10.0000000f);
1781     path.close();
1782     SkPath pathB;
1783     pathB.setFillType(SkPath::kWinding_FillType);
1784     pathB.moveTo(1036.00000f, 32.0000000f);
1785     pathB.lineTo(1049.00000f, 19.0000000f);
1786     pathB.lineTo(1073.00000f, 31.0000000f);
1787     pathB.lineTo(1074.00000f, 32.0000000f);
1788     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1789 }
1790
1791 static void cubicOp85d(skiatest::Reporter* reporter, const char* filename) {
1792     SkPath path;
1793     path.setFillType(SkPath::kWinding_FillType);
1794     path.moveTo(0,1);
1795     path.cubicTo(1,6, 1,0, 6,2);
1796     path.close();
1797     SkPath pathB;
1798     pathB.setFillType(SkPath::kWinding_FillType);
1799     pathB.moveTo(0,1);
1800     pathB.cubicTo(2,6, 1,0, 6,1);
1801     pathB.close();
1802     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1803 }
1804
1805 // this fails because the pair of nearly coincident cubics intersect at the ends
1806 // but the line connected to one of the cubics at the same point does not intersect
1807 // the other
1808 static void skpkkiste_to98(skiatest::Reporter* reporter, const char* filename) {
1809     SkPath path;
1810     path.setFillType(SkPath::kEvenOdd_FillType);
1811     path.moveTo(96, 122);
1812     path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1813     path.lineTo(94.1715698f, 125.17157f);
1814     path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1815     path.lineTo(257, 124);
1816     path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1817     path.lineTo(261.535522f, 123.46447f);
1818     path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1819     path.lineTo(96, 122);
1820     path.close();
1821     SkPath pathB;
1822     pathB.setFillType(SkPath::kWinding_FillType);
1823     pathB.moveTo(258, 122);
1824     pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1825     pathB.lineTo(263, 284);
1826     pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1827     pathB.lineTo(96, 289);
1828     pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1829     pathB.lineTo(91, 127);
1830     pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1831     pathB.lineTo(258, 122);
1832     pathB.close();
1833     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1834 }
1835
1836 static void issue1417(skiatest::Reporter* reporter, const char* filename) {
1837     SkPath path1;
1838     path1.moveTo(122.58908843994140625f, 82.2836456298828125f);
1839     path1.quadTo(129.8215789794921875f, 80, 138, 80);
1840     path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f);
1841     path1.lineTo(161.1764678955078125f, 100);
1842     path1.lineTo(161.1764678955078125f, 100);
1843     path1.lineTo(115.29412078857421875f, 100);
1844     path1.lineTo(115.29412078857421875f, 100);
1845     path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1846     path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1847     path1.close();
1848     path1.moveTo(98.68194580078125f, 140.343841552734375f);
1849     path1.lineTo(115.29412078857421875f, 100);
1850     path1.lineTo(115.29412078857421875f, 100);
1851     path1.lineTo(97.9337615966796875f, 100);
1852     path1.lineTo(97.9337615966796875f, 100);
1853     path1.quadTo(88, 112.94264984130859375f, 88, 130);
1854     path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f);
1855     path1.lineTo(98.68194580078125f, 140.343841552734375f);
1856     path1.lineTo(98.68194580078125f, 140.343841552734375f);
1857     path1.close();
1858     path1.moveTo(136.969696044921875f, 166.6666717529296875f);
1859     path1.lineTo(98.68194580078125f, 140.343841552734375f);
1860     path1.lineTo(98.68194580078125f, 140.343841552734375f);
1861     path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1862     path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1863     path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f);
1864     path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f);
1865     path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1866     path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1867     path1.close();
1868     path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1869     path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1870     path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1871     path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1872     path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1873     path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f);
1874     path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f);
1875     path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1876     path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1877     path1.close();
1878     path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1879     path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1880     path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1881     path1.quadTo(188, 131.8880615234375f, 188, 130);
1882     path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100);
1883     path1.lineTo(161.1764678955078125f, 100);
1884     path1.lineTo(161.1764678955078125f, 100);
1885     path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1886     path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1887     path1.close();
1888
1889     SkPath path2;
1890     path2.moveTo(174.117645263671875f, 100);
1891     path2.lineTo(161.1764678955078125f, 100);
1892     path2.lineTo(161.1764678955078125f, 100);
1893     path2.lineTo(155.1280364990234375f, 82.86279296875f);
1894     path2.lineTo(155.1280364990234375f, 82.86279296875f);
1895     path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f);
1896     path2.lineTo(143.5294189453125f, 100);
1897     path2.lineTo(143.5294189453125f, 100);
1898     path2.lineTo(161.1764678955078125f, 100);
1899     path2.lineTo(161.1764678955078125f, 100);
1900     path2.lineTo(168.23529052734375f, 120);
1901     path2.lineTo(168.23529052734375f, 120);
1902     path2.lineTo(181.1764678955078125f, 120);
1903     path2.lineTo(181.1764678955078125f, 120);
1904     path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1905     path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1906     path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1907     path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1908     path2.quadTo(188, 131.8880615234375f, 188, 130);
1909     path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120);
1910     path2.lineTo(181.1764678955078125f, 120);
1911     path2.lineTo(181.1764678955078125f, 120);
1912     path2.lineTo(174.117645263671875f, 100);
1913     path2.lineTo(174.117645263671875f, 100);
1914     path2.close();
1915     path2.moveTo(88.91983795166015625f, 120);
1916     path2.lineTo(107.0588226318359375f, 120);
1917     path2.lineTo(107.0588226318359375f, 120);
1918     path2.lineTo(98.68194580078125f, 140.343841552734375f);
1919     path2.lineTo(98.68194580078125f, 140.343841552734375f);
1920     path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1921     path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1922     path2.quadTo(88, 131.544830322265625f, 88, 130);
1923     path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120);
1924     path2.close();
1925     path2.moveTo(96.67621612548828125f, 145.21490478515625f);
1926     path2.lineTo(98.68194580078125f, 140.343841552734375f);
1927     path2.lineTo(98.68194580078125f, 140.343841552734375f);
1928     path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1929     path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1930     path2.lineTo(118.68194580078125f, 160.343841552734375f);
1931     path2.lineTo(118.68194580078125f, 160.343841552734375f);
1932     path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1933     path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1934     path2.close();
1935     path2.moveTo(113.232177734375f, 173.5789947509765625f);
1936     path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f);
1937     path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1938     path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1939     path2.lineTo(118.68194580078125f, 160.343841552734375f);
1940     path2.lineTo(118.68194580078125f, 160.343841552734375f);
1941     path2.lineTo(113.232177734375f, 173.5789947509765625f);
1942     path2.lineTo(113.232177734375f, 173.5789947509765625f);
1943     path2.close();
1944
1945     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
1946 }
1947
1948 static void issue1418(skiatest::Reporter* reporter, const char* filename) {
1949     SkPath path1;
1950     path1.moveTo(0, 0);
1951     path1.lineTo(1, 0);
1952     path1.lineTo(1, 0);
1953     path1.lineTo(1, 1);
1954     path1.lineTo(1, 1);
1955     path1.lineTo(0, 1);
1956     path1.lineTo(0, 1);
1957     path1.lineTo(0, 0);
1958     path1.lineTo(0, 0);
1959     path1.close();
1960
1961     SkPath path2;
1962     path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f);
1963     path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f);
1964     path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f);
1965     path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0);
1966     path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f);
1967     path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f);
1968     path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f);
1969     path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0);
1970     path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f);
1971     testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
1972 }
1973
1974 static void cubicOp85i(skiatest::Reporter* reporter, const char* filename) {
1975     SkPath path, pathB;
1976     path.setFillType(SkPath::kWinding_FillType);
1977     path.moveTo(3, 4);
1978     path.cubicTo(1, 5, 4, 3, 6, 4);
1979     path.close();
1980     pathB.setFillType(SkPath::kWinding_FillType);
1981     pathB.moveTo(3, 4);
1982     pathB.cubicTo(4, 6, 4, 3, 5, 1);
1983     pathB.close();
1984     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1985 }
1986
1987 static void issue1418b(skiatest::Reporter* reporter, const char* filename) {
1988     SkPath path1;
1989     path1.moveTo(0, 0);
1990     path1.lineTo(1, 0);
1991     path1.lineTo(1, 1);
1992     path1.lineTo(0, 1);
1993     path1.lineTo(0, 0);
1994     path1.close();
1995     path1.setFillType(SkPath::kWinding_FillType);
1996     SkPath path2;
1997     path2.moveTo(0.646446645f, -0.353553414f);
1998     path2.quadTo(0.792893291f, -0.50000006f, 1.00000012f, -0.50000006f);
1999     path2.quadTo(1.20710683f, -0.50000006f, 1.35355353f, -0.353553414f);
2000     path2.quadTo(1.50000012f, -0.207106799f, 1.50000012f, 0);
2001     path2.quadTo(1.50000012f, 0.207106799f, 1.35355353f, 0.353553414f);
2002     path2.quadTo(1.20710683f, 0.50000006f, 1.00000012f, 0.50000006f);
2003     path2.quadTo(0.792893291f, 0.50000006f, 0.646446645f, 0.353553414f);
2004     path2.quadTo(0.50000006f, 0.207106799f, 0.50000006f, 0);
2005     path2.quadTo(0.50000006f, -0.207106799f, 0.646446645f, -0.353553414f);
2006     path2.close();
2007     path2.moveTo(1.00000012f, 0.50000006f);
2008     path2.lineTo(1.00000012f, 1.00000012f);
2009     path2.lineTo(0.50000006f, 1.00000012f);
2010     path2.quadTo(0.50000006f, 0.792893291f, 0.646446645f, 0.646446645f);
2011     path2.quadTo(0.792893291f, 0.50000006f, 1.00000012f, 0.50000006f);
2012     path2.close();
2013     path2.setFillType(SkPath::kEvenOdd_FillType);
2014     testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
2015 }
2016
2017 static void rectOp1i(skiatest::Reporter* reporter, const char* filename) {
2018     SkPath path, pathB;
2019     path.setFillType(SkPath::kWinding_FillType);
2020     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2021     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
2022     pathB.setFillType(SkPath::kWinding_FillType);
2023     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2024     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2025     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2026 }
2027
2028 static void rectOp2i(skiatest::Reporter* reporter, const char* filename) {
2029     SkPath path, pathB;
2030     path.setFillType(SkPath::kEvenOdd_FillType);
2031     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2032     path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
2033     pathB.setFillType(SkPath::kWinding_FillType);
2034     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2035     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2036     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2037 }
2038
2039 static void rectOp3x(skiatest::Reporter* reporter, const char* filename) {
2040     SkPath path, pathB;
2041     path.setFillType(SkPath::kEvenOdd_FillType);
2042     path.moveTo(0, 0);
2043     path.lineTo(3, 0);
2044     path.lineTo(3, 3);
2045     path.lineTo(0, 3);
2046     path.close();
2047     path.moveTo(2, 2);
2048     path.lineTo(3, 2);
2049     path.lineTo(3, 3);
2050     path.lineTo(2, 3);
2051     path.close();
2052     pathB.setFillType(SkPath::kWinding_FillType);
2053     pathB.moveTo(1, 1);
2054     pathB.lineTo(3, 1);
2055     pathB.lineTo(3, 3);
2056     pathB.lineTo(1, 3);
2057     pathB.close();
2058     pathB.moveTo(2, 2);
2059     pathB.lineTo(3, 2);
2060     pathB.lineTo(3, 3);
2061     pathB.lineTo(2, 3);
2062     pathB.close();
2063     testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
2064 }
2065
2066 // this fails to generate two interior line segments
2067 // an earlier pathops succeeded, but still failed to generate one interior line segment
2068 // (but was saved by assemble, which works around a single line missing segment)
2069 static void issue1435(skiatest::Reporter* reporter, const char* filename) {
2070     SkPath path1;
2071     path1.moveTo(160, 60);
2072     path1.lineTo(220, 230);
2073     path1.lineTo(60, 120);
2074     path1.lineTo(260, 120);
2075     path1.lineTo(90, 230);
2076     path1.lineTo(160, 60);
2077     path1.close();
2078     path1.setFillType(SkPath::kEvenOdd_FillType);
2079
2080     SkPath path2;
2081     path2.moveTo(142.589081f, 102.283646f);
2082     path2.quadTo(149.821579f, 100, 158, 100);
2083     path2.quadTo(167.156921f, 100, 175.128036f, 102.862793f);
2084     path2.lineTo(181.176468f, 120);
2085     path2.lineTo(135.294128f, 120);
2086     path2.lineTo(142.589081f, 102.283646f);
2087     path2.close();
2088     path2.moveTo(118.681946f, 160.343842f);
2089     path2.lineTo(135.294128f, 120);
2090     path2.lineTo(117.933762f, 120);
2091     path2.quadTo(108, 132.942657f, 108, 150);
2092     path2.quadTo(108, 151.54483f, 108.08149f, 153.05603f);
2093     path2.lineTo(118.681946f, 160.343842f);
2094     path2.close();
2095     path2.moveTo(156.969696f, 186.666672f);
2096     path2.lineTo(118.681946f, 160.343842f);
2097     path2.lineTo(113.458946f, 173.028259f);
2098     path2.quadTo(116.94117f, 179.651855f, 122.644661f, 185.355347f);
2099     path2.quadTo(130.792465f, 193.503143f, 140.817978f, 197.117783f);
2100     path2.lineTo(156.969696f, 186.666672f);
2101     path2.close();
2102     path2.moveTo(195.830978f, 161.521133f);
2103     path2.lineTo(156.969696f, 186.666672f);
2104     path2.lineTo(173.157288f, 197.795639f);
2105     path2.quadTo(184.392426f, 194.318268f, 193.355347f, 185.355347f);
2106     path2.quadTo(197.805817f, 180.904861f, 200.903809f, 175.894165f);
2107     path2.lineTo(195.830978f, 161.521133f);
2108     path2.close();
2109     path2.moveTo(195.830978f, 161.521133f);
2110     path2.lineTo(207.878281f, 153.725815f);
2111     path2.quadTo(208, 151.888062f, 208, 150);
2112     path2.quadTo(208, 132.942657f, 198.066238f, 120);
2113     path2.lineTo(181.176468f, 120);
2114     path2.lineTo(195.830978f, 161.521133f);
2115     path2.close();
2116     path2.setFillType(SkPath::kEvenOdd_FillType);
2117     testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
2118 }
2119
2120 static void skpkkiste_to716(skiatest::Reporter* reporter, const char* filename) {
2121     SkPath path;
2122     path.setFillType(SkPath::kEvenOdd_FillType);
2123     path.moveTo(1173, 284);
2124     path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2125     path.lineTo(1174, 123.999496f);
2126     path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2127     path.lineTo(1173, 284);
2128     path.close();
2129     SkPath pathB;
2130     pathB.setFillType(SkPath::kWinding_FillType);
2131     pathB.moveTo(1340, 122);
2132     pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127);
2133     pathB.lineTo(1345, 284);
2134     pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289);
2135     pathB.lineTo(1178, 289);
2136     pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284);
2137     pathB.lineTo(1173, 127);
2138     pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122);
2139     pathB.lineTo(1340, 122);
2140     pathB.close();
2141     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2142 }
2143
2144 static void loopEdge1(skiatest::Reporter* reporter, const char* filename) {
2145     SkPath path;
2146     path.setFillType(SkPath::kEvenOdd_FillType);
2147     path.moveTo(0,0);
2148     path.lineTo(3,0);
2149     path.lineTo(3,2);
2150     path.lineTo(1,2);
2151     path.lineTo(1,1);
2152     path.lineTo(2,1);
2153     path.lineTo(2,3);
2154     path.lineTo(0,3);
2155     path.close();
2156     SkPath pathB;
2157     pathB.setFillType(SkPath::kEvenOdd_FillType);
2158     pathB.moveTo(1,2);
2159     pathB.lineTo(2,2);
2160     pathB.lineTo(2,4);
2161     pathB.lineTo(1,4);
2162     pathB.close();
2163     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2164 }
2165
2166 static void loopEdge2(skiatest::Reporter* reporter, const char* filename) {
2167     SkPath path;
2168     path.setFillType(SkPath::kEvenOdd_FillType);
2169     path.moveTo(0,0);
2170     path.lineTo(3,0);
2171     path.lineTo(3,2);
2172     path.lineTo(1,2);
2173     path.lineTo(1,1);
2174     path.lineTo(2,1);
2175     path.lineTo(2,3);
2176     path.lineTo(0,3);
2177     path.close();
2178     SkPath pathB;
2179     pathB.setFillType(SkPath::kEvenOdd_FillType);
2180     pathB.moveTo(1 - 1e-6f,2);
2181     pathB.lineTo(2 - 1e-6f,2);
2182     pathB.lineTo(2 - 1e-6f,4);
2183     pathB.lineTo(1 - 1e-6f,4);
2184     pathB.close();
2185     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2186 }
2187
2188 static void cubicOp86i(skiatest::Reporter* reporter, const char* filename) {
2189     SkPath path, pathB;
2190     path.setFillType(SkPath::kWinding_FillType);
2191     path.moveTo(0, 4);
2192     path.cubicTo(3, 4, 6, 2, 5, 2);
2193     path.close();
2194     pathB.setFillType(SkPath::kEvenOdd_FillType);
2195     pathB.moveTo(2, 6);
2196     pathB.cubicTo(2, 5, 4, 0, 4, 3);
2197     pathB.close();
2198     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2199 }
2200
2201 static void cubicOp87u(skiatest::Reporter* reporter, const char* filename) {
2202     SkPath path, pathB;
2203     path.setFillType(SkPath::kWinding_FillType);
2204     path.moveTo(0,1);
2205     path.cubicTo(0,2, 2,0, 6,4);
2206     path.close();
2207     pathB.setFillType(SkPath::kWinding_FillType);
2208     pathB.moveTo(0,2);
2209     pathB.cubicTo(4,6, 1,0, 2,0);
2210     pathB.close();
2211     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2212 }
2213
2214 static void cubicOp88u(skiatest::Reporter* reporter, const char* filename) {
2215     SkPath path, pathB;
2216     path.setFillType(SkPath::kWinding_FillType);
2217     path.moveTo(0,1);
2218     path.cubicTo(2,5, 5,0, 6,4);
2219     path.close();
2220     pathB.setFillType(SkPath::kWinding_FillType);
2221     pathB.moveTo(0,5);
2222     pathB.cubicTo(4,6, 1,0, 5,2);
2223     pathB.close();
2224     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2225 }
2226
2227 static void cubicOp89u(skiatest::Reporter* reporter, const char* filename) {
2228     SkPath path, pathB;
2229     path.setFillType(SkPath::kWinding_FillType);
2230     path.moveTo(0, 3);
2231     path.cubicTo(1, 6, 5, 0, 6, 3);
2232     path.close();
2233     pathB.setFillType(SkPath::kWinding_FillType);
2234     pathB.moveTo(0, 5);
2235     pathB.cubicTo(3, 6, 3, 0, 6, 1);
2236     pathB.close();
2237     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2238 }
2239
2240 static void cubicOp90u(skiatest::Reporter* reporter, const char* filename) {
2241     SkPath path, pathB;
2242     path.setFillType(SkPath::kEvenOdd_FillType);
2243     path.moveTo(0, 5);
2244     path.cubicTo(1, 2, 5, 2, 4, 1);
2245     path.close();
2246     pathB.setFillType(SkPath::kEvenOdd_FillType);
2247     pathB.moveTo(2, 5);
2248     pathB.cubicTo(1, 4, 5, 0, 2, 1);
2249     pathB.close();
2250     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2251 }
2252
2253 static void cubicOp91u(skiatest::Reporter* reporter, const char* filename) {
2254     SkPath path, pathB;
2255     path.setFillType(SkPath::kWinding_FillType);
2256     path.moveTo(1, 6);
2257     path.cubicTo(0, 3, 6, 3, 5, 0);
2258     path.close();
2259     pathB.setFillType(SkPath::kWinding_FillType);
2260     pathB.moveTo(3, 6);
2261     pathB.cubicTo(0, 5, 6, 1, 3, 0);
2262     pathB.close();
2263     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2264 }
2265
2266 static void skpaaalgarve_org53(skiatest::Reporter* reporter, const char* filename) {  //  add t cancel
2267     SkPath path;
2268     path.setFillType(SkPath::kEvenOdd_FillType);
2269    path.moveTo(-1.24344979e-014f, 348);
2270     path.lineTo(258, 348);
2271     path.lineTo(258, 322);
2272     path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2273     path.quadTo(252.142136f, 312, 248, 312);
2274     path.lineTo(1.77635684e-015f, 312);
2275     path.lineTo(-1.24344979e-014f, 348);
2276     path.close();
2277     SkPath pathB;
2278     pathB.setFillType(SkPath::kWinding_FillType);
2279    pathB.moveTo(0, 312);
2280     pathB.lineTo(258, 312);
2281     pathB.lineTo(258, 348);
2282     pathB.lineTo(0, 348);
2283     pathB.close();
2284     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2285 }
2286
2287 static void skpabcspark_ca103(skiatest::Reporter* reporter, const char* filename) {  //  add t cancel
2288     SkPath path;
2289     path.setFillType(SkPath::kEvenOdd_FillType);
2290     path.moveTo(1.99840144e-015f, 494);
2291     path.lineTo(97, 494);
2292     path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2293     path.quadTo(105, 489.313721f, 105, 486);
2294     path.lineTo(105, 425);
2295     path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2296     path.quadTo(100.313705f, 417, 97, 417);
2297     path.lineTo(2.22044605e-016f, 417);
2298     path.lineTo(1.99840144e-015f, 494);
2299     path.close();
2300     SkPath pathB;
2301     pathB.setFillType(SkPath::kWinding_FillType);
2302     pathB.moveTo(0, 417);
2303     pathB.lineTo(105, 417);
2304     pathB.lineTo(105, 494);
2305     pathB.lineTo(0, 494);
2306     pathB.close();
2307     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2308 }
2309
2310 static void skpacesoftech_com47(skiatest::Reporter* reporter, const char* filename) {  // partial coincidence
2311     SkPath path;
2312     path.setFillType(SkPath::kEvenOdd_FillType);
2313     path.moveTo(670.537415f, 285);
2314     path.lineTo(670.387451f, 285);
2315     path.lineTo(596.315186f, 314.850708f);
2316     path.lineTo(626.19696f, 389);
2317     path.lineTo(626.346863f, 389);
2318     path.lineTo(700.419189f, 359.149261f);
2319     path.lineTo(670.537415f, 285);
2320     path.close();
2321     SkPath pathB;
2322     pathB.setFillType(SkPath::kWinding_FillType);
2323     pathB.moveTo(663.318542f, 374.100616f);
2324     pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f);
2325     pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f);
2326     pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f);
2327     pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f);
2328     pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f);
2329     pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f);
2330     pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f);
2331     pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f);
2332     pathB.close();
2333     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2334 }
2335
2336 static void skpact_com43(skiatest::Reporter* reporter, const char* filename) {  // bridge op
2337     SkPath path;
2338     path.setFillType(SkPath::kEvenOdd_FillType);
2339     path.moveTo(1.45716772e-016f, 924.336121f);
2340     path.lineTo(-1.11022302e-016f, 920);
2341     path.lineTo(6, 920);
2342     path.lineTo(6, 926);
2343     path.lineTo(1.66389287f, 926);
2344     path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2345     path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2346     path.close();
2347     path.moveTo(1, 921);
2348     path.lineTo(5, 921);
2349     path.lineTo(5, 925);
2350     path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2351     path.close();
2352     SkPath pathB;
2353     pathB.setFillType(SkPath::kWinding_FillType);
2354     pathB.moveTo(-1, 920);
2355     pathB.lineTo(0, 920);
2356     pathB.lineTo(3, 927);
2357     pathB.lineTo(-1, 927);
2358     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2359 }
2360
2361 static void skpadbox_lt8(skiatest::Reporter* reporter, const char* filename) {  // zero span
2362     SkPath path;
2363     path.setFillType(SkPath::kEvenOdd_FillType);
2364     path.moveTo(320.097229f, 628.573669f);
2365     path.lineTo(610.227173f, 85.7786865f);
2366     path.lineTo(946.652588f, 265.601807f);
2367     path.lineTo(656.522644f, 808.39679f);
2368     path.lineTo(320.097229f, 628.573669f);
2369     path.close();
2370     SkPath pathB;
2371     pathB.setFillType(SkPath::kInverseWinding_FillType);
2372     pathB.moveTo(333.866608f, 623.496155f);
2373     pathB.lineTo(613.368042f, 100.585754f);
2374     pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2375     pathB.lineTo(932.633057f, 269.854553f);
2376     pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2377     pathB.lineTo(653.631897f, 794.414307f);
2378     pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2379     pathB.lineTo(334.366943f, 625.145508f);
2380     pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2381     pathB.close();
2382     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2383 }
2384
2385 static void skpadindex_de4(skiatest::Reporter* reporter, const char* filename) {  // find chase op
2386     SkPath path;
2387     path.setFillType(SkPath::kEvenOdd_FillType);
2388     path.moveTo(0, 926);
2389     path.lineTo(0, 0);
2390     path.lineTo(1280, 0);
2391     path.lineTo(1280, 926);
2392     path.lineTo(0, 926);
2393     path.close();
2394     SkPath pathB;
2395     pathB.setFillType(SkPath::kWinding_FillType);
2396     pathB.moveTo(0, 312);
2397     pathB.lineTo(8.20486257e-015f, 178);
2398     pathB.lineTo(49, 178);
2399     pathB.lineTo(49, 312);
2400     pathB.close();
2401     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2402 }
2403
2404 static void skpadithya_putr4_blogspot_com551(skiatest::Reporter* reporter, const char* filename) { // calc common
2405     SkPath path;
2406     path.setFillType(SkPath::kEvenOdd_FillType);
2407     path.moveTo(205.605804f, 142.334625f);
2408     path.lineTo(254.665359f, 85.6058044f);
2409     path.lineTo(311.394196f, 134.665359f);
2410     path.lineTo(262.334625f, 191.39418f);
2411     path.lineTo(205.605804f, 142.334625f);
2412     path.close();
2413     SkPath pathB;
2414     pathB.setFillType(SkPath::kWinding_FillType);
2415     pathB.moveTo(283.407959f, 110.462646f);
2416     pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f);
2417     pathB.lineTo(286.537354f, 163.407959f);
2418     pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f);
2419     pathB.lineTo(233.592026f, 166.537338f);
2420     pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f);
2421     pathB.lineTo(230.462646f, 113.592026f);
2422     pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f);
2423     pathB.lineTo(283.407959f, 110.462646f);
2424     pathB.close();
2425     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2426 }
2427
2428 static void skpadspert_de11(skiatest::Reporter* reporter, const char* filename) {  // mark and chase winding
2429     SkPath path;
2430     path.setFillType(SkPath::kEvenOdd_FillType);
2431     path.moveTo(-4.4408921e-016f, 682.5f);
2432     path.lineTo(30.5f, 682.5f);
2433     path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2434     path.lineTo(34.5f, 486.5f);
2435     path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2436     path.lineTo(0, 482.5f);
2437     path.lineTo(-4.4408921e-016f, 682.5f);
2438     path.close();
2439     SkPath pathB;
2440     pathB.setFillType(SkPath::kWinding_FillType);
2441     pathB.moveTo(0, 482);
2442     pathB.lineTo(35, 482);
2443     pathB.lineTo(35, 683);
2444     pathB.lineTo(0, 683);
2445     pathB.close();
2446     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2447 }
2448
2449 static void skpaiaigames_com870(skiatest::Reporter* reporter, const char* filename) {  // cubic/cubic intersect
2450     SkPath path;
2451     path.setFillType(SkPath::kEvenOdd_FillType);
2452     path.moveTo(324.071075f, 845.071045f);
2453     path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2454     path.lineTo(325, 842.127197f);
2455     path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2456     path.lineTo(324.071075f, 845.071045f);
2457     path.close();
2458     path.moveTo(323.363953f, 714.636047f);
2459     path.lineTo(324.071075f, 713.928955f);
2460     path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2461     path.lineTo(325, 716.872803f);
2462     path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2463     path.close();
2464     SkPath pathB;
2465     pathB.setFillType(SkPath::kWinding_FillType);
2466     pathB.moveTo(317, 711);
2467     pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
2468     pathB.lineTo(327, 838);
2469     pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
2470     pathB.lineTo(155, 848);
2471     pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
2472     pathB.lineTo(145, 721);
2473     pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
2474     pathB.lineTo(317, 711);
2475     pathB.close();
2476     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2477 }
2478
2479 static void cubicOp92i(skiatest::Reporter* reporter, const char* filename) {
2480     SkPath path, pathB;
2481     path.setFillType(SkPath::kWinding_FillType);
2482     path.moveTo(0, 1);
2483     path.cubicTo(2, 6, 4, 1, 5, 4);
2484     path.close();
2485     pathB.setFillType(SkPath::kWinding_FillType);
2486     pathB.moveTo(1, 4);
2487     pathB.cubicTo(4, 5, 1, 0, 6, 2);
2488     pathB.close();
2489     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2490 }
2491
2492 static void cubicOp93d(skiatest::Reporter* reporter, const char* filename) {
2493     SkPath path, pathB;
2494     path.setFillType(SkPath::kWinding_FillType);
2495     path.moveTo(0, 1);
2496     path.cubicTo(1, 6, 4, 1, 4, 3);
2497     path.close();
2498     pathB.setFillType(SkPath::kWinding_FillType);
2499     pathB.moveTo(1, 4);
2500     pathB.cubicTo(3, 4, 1, 0, 6, 1);
2501     pathB.close();
2502     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2503 }
2504
2505 static void cubicOp94u(skiatest::Reporter* reporter, const char* filename) {
2506     SkPath path, pathB;
2507     path.setFillType(SkPath::kEvenOdd_FillType);
2508     path.moveTo(0, 3);
2509     path.cubicTo(2, 3, 5, 0, 5, 3);
2510     path.close();
2511     pathB.setFillType(SkPath::kEvenOdd_FillType);
2512     pathB.moveTo(0, 5);
2513     pathB.cubicTo(3, 5, 3, 0, 3, 2);
2514     pathB.close();
2515     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2516 }
2517
2518 static void skpadbox_lt15(skiatest::Reporter* reporter, const char* filename) {
2519     SkPath path;
2520     path.setFillType(SkPath::kEvenOdd_FillType);
2521     path.moveTo(333.292084f, 624.570984f);
2522     path.lineTo(614.229797f, 98.9735107f);
2523     path.lineTo(933.457764f, 269.604431f);
2524     path.lineTo(652.52002f, 795.201904f);
2525     path.lineTo(333.292084f, 624.570984f);
2526     path.close();
2527     SkPath pathB;
2528      pathB.setFillType(SkPath::kWinding_FillType);
2529     pathB.moveTo(613.368042f, 100.585754f);
2530     pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2531     pathB.lineTo(932.633057f, 269.854553f);
2532     pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2533     pathB.lineTo(653.631897f, 794.414307f);
2534     pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2535     pathB.lineTo(334.366943f, 625.145508f);
2536     pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2537     pathB.lineTo(613.368042f, 100.585754f);
2538      pathB.close();
2539     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2540 }
2541
2542 static void skpadoption_org196(skiatest::Reporter* reporter, const char* filename) {
2543     SkPath path;
2544     path.setFillType(SkPath::kEvenOdd_FillType);
2545     path.moveTo(802, 367);
2546     path.lineTo(802, 324);
2547     path.lineTo(956, 324);
2548     path.lineTo(956, 371);
2549     path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2550     path.quadTo(953.071045f, 376, 951, 376);
2551     path.lineTo(811, 376);
2552     path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2553     path.close();
2554     SkPath pathB;
2555     pathB.setFillType(SkPath::kInverseWinding_FillType);
2556     pathB.moveTo(803, 326);
2557     pathB.lineTo(955, 326);
2558     pathB.lineTo(955, 370);
2559     pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375);
2560     pathB.lineTo(808, 375);
2561     pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370);
2562     pathB.lineTo(803, 326);
2563     pathB.close();
2564     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2565 }
2566
2567 static void skpadspert_net23(skiatest::Reporter* reporter, const char* filename) {
2568     SkPath path;
2569     path.setFillType(SkPath::kEvenOdd_FillType);
2570     path.moveTo(-2.220446e-018f, 483.5f);
2571     path.lineTo(0, 482.5f);
2572     path.lineTo(30.5f, 482.5f);
2573     path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2574     path.lineTo(34.5f, 678.5f);
2575     path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2576     path.lineTo(-4.4408921e-016f, 682.5f);
2577     path.lineTo(-4.41868766e-016f, 681.5f);
2578     path.lineTo(30.5f, 681.5f);
2579     path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2580     path.lineTo(33.5f, 486.5f);
2581     path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2582     path.lineTo(-2.220446e-018f, 483.5f);
2583     path.close();
2584     SkPath pathB;
2585     pathB.setFillType(SkPath::kWinding_FillType);
2586     pathB.moveTo(0, 482);
2587     pathB.lineTo(35, 482);
2588     pathB.lineTo(35, 683);
2589     pathB.lineTo(0, 683);
2590     pathB.close();
2591     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2592 }
2593
2594 static void skpadventistmission_org572(skiatest::Reporter* reporter, const char* filename) {
2595     SkPath path;
2596     path.setFillType(SkPath::kEvenOdd_FillType);
2597     path.moveTo(1182.00037f, 926);
2598     path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2599     path.lineTo(938, 924);
2600     path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2601     path.lineTo(1182.00037f, 926);
2602     path.close();
2603     SkPath pathB;
2604     pathB.setFillType(SkPath::kWinding_FillType);
2605     pathB.moveTo(934, 924);
2606     pathB.lineTo(1182, 924);
2607     pathB.lineTo(1182, 926);
2608     pathB.lineTo(934, 926);
2609     pathB.close();
2610     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2611 }
2612
2613 static void skpagentxsites_com55(skiatest::Reporter* reporter, const char* filename) {
2614     SkPath path;
2615     path.setFillType(SkPath::kEvenOdd_FillType);
2616     path.moveTo(925, 27);
2617     path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2618     path.lineTo(924, 55);
2619     path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2620     path.lineTo(1103, 56);
2621     path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2622     path.lineTo(1104, 28);
2623     path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2624     path.lineTo(925, 27);
2625     path.close();
2626     SkPath pathB;
2627     pathB.setFillType(SkPath::kWinding_FillType);
2628     pathB.moveTo(1103, 27);
2629     pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29);
2630     pathB.lineTo(1105, 54);
2631     pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56);
2632     pathB.lineTo(926, 56);
2633     pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54);
2634     pathB.lineTo(924, 29);
2635     pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27);
2636     pathB.lineTo(1103, 27);
2637     pathB.close();
2638     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2639 }
2640
2641 static void skpbakosoft_com10(skiatest::Reporter* reporter, const char* filename) {
2642     SkPath path;
2643     path.setFillType(SkPath::kEvenOdd_FillType);
2644     path.moveTo(190, 170);
2645     path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2646     path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2647     path.lineTo(370, 210);
2648     path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2649     path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2650     path.lineTo(190, 170);
2651     path.close();
2652     SkPath pathB;
2653     pathB.setFillType(SkPath::kWinding_FillType);
2654     pathB.moveTo(210, 190);
2655     pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f);
2656     pathB.quadTo(198.284271f, 210, 190, 210);
2657     pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f);
2658     pathB.quadTo(170, 198.284271f, 170, 190);
2659     pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f);
2660     pathB.quadTo(181.715729f, 170, 190, 170);
2661     pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f);
2662     pathB.quadTo(210, 181.715729f, 210, 190);
2663     pathB.close();
2664     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2665 }
2666
2667 static void skpbambootheme_com12(skiatest::Reporter* reporter, const char* filename) {
2668     SkPath path;
2669     path.setFillType(SkPath::kEvenOdd_FillType);
2670     path.moveTo(47.8780937f, 58);
2671     path.lineTo(0, 58);
2672     path.lineTo(-8.65973959e-015f, 96.9914017f);
2673     path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2674     path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2675     path.close();
2676     SkPath pathB;
2677     pathB.setFillType(SkPath::kEvenOdd_FillType);
2678     pathB.moveTo(-1, -3);
2679     pathB.lineTo(-1, -3);
2680     pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47);
2681     pathB.lineTo(49, 47);
2682     pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97);
2683     pathB.lineTo(-1, 97);
2684     pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47);
2685     pathB.lineTo(-51, 47);
2686     pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3);
2687     pathB.close();
2688     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2689 }
2690
2691 static void skpakmmos_ru100(skiatest::Reporter* reporter, const char* filename) {
2692     SkPath path;
2693     path.setFillType(SkPath::kEvenOdd_FillType);
2694     path.moveTo(693.000488f, 926);
2695     path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2696     path.lineTo(578, 925);
2697     path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2698     path.lineTo(693.000488f, 926);
2699     path.close();
2700     SkPath pathB;
2701     pathB.setFillType(SkPath::kWinding_FillType);
2702     pathB.moveTo(575, 925);
2703     pathB.lineTo(693, 925);
2704     pathB.lineTo(693, 926);
2705     pathB.lineTo(575, 926);
2706     pathB.close();
2707     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2708 }
2709
2710 static void skpcarpetplanet_ru22(skiatest::Reporter* reporter, const char* filename) {
2711     SkPath path;
2712     path.setFillType(SkPath::kEvenOdd_FillType);
2713     path.moveTo(195, 785);
2714     path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2715     path.lineTo(67, 913);
2716     path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2717     path.lineTo(322, 926);
2718     path.lineTo(322, 896.048035f);
2719     path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2720     path.close();
2721     SkPath pathB;
2722     pathB.setFillType(SkPath::kWinding_FillType);
2723     pathB.moveTo(195, 785);
2724     pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
2725     pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
2726     pathB.lineTo(194, 1041);
2727     pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
2728     pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
2729     pathB.lineTo(195, 785);
2730     pathB.close();
2731     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2732 }
2733
2734 #define QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION 0
2735 #if QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION
2736 // this fails because cubic/quad misses an intersection (failure is isolated in c/q int test)
2737 static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) {
2738     SkPath path;
2739     path.setFillType(SkPath::kEvenOdd_FillType);
2740     path.moveTo(945, 597);
2741     path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2742     path.quadTo(870, 640.93396f, 870, 672);
2743     path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2744     path.quadTo(913.93396f, 747, 945, 747);
2745     path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2746     path.quadTo(1020, 703.06604f, 1020, 672);
2747     path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2748     path.quadTo(976.06604f, 597, 945, 597);
2749     path.close();
2750     SkPath pathB;
2751     pathB.setFillType(SkPath::kWinding_FillType);
2752     pathB.moveTo(945.080994f, 597.161987f);
2753     pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
2754     pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
2755     pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
2756     pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
2757     pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
2758     pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
2759     pathB.close();
2760     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2761 }
2762
2763 #endif
2764
2765 static void skpbangalorenest_com4(skiatest::Reporter* reporter, const char* filename) {
2766     SkPath path;
2767     path.setFillType(SkPath::kEvenOdd_FillType);
2768     path.moveTo(0, 926);
2769     path.lineTo(0, 0);
2770     path.lineTo(1265, 0);
2771     path.lineTo(1265, 926);
2772     path.lineTo(0, 926);
2773     path.close();
2774     SkPath pathB;
2775     pathB.setFillType(SkPath::kWinding_FillType);
2776     pathB.moveTo(0, 290);
2777     pathB.lineTo(-2.64514972e-014f, 146);
2778     pathB.lineTo(30, 146);
2779     pathB.lineTo(30, 290);
2780     pathB.close();
2781     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2782 }
2783
2784 static void skpbenzoteh_ru152(skiatest::Reporter* reporter, const char* filename) {
2785     SkPath path;
2786     path.setFillType(SkPath::kEvenOdd_FillType);
2787     path.moveTo(883, 23);
2788     path.lineTo(883, 0);
2789     path.lineTo(1122.5f, 0);
2790     path.lineTo(1122.5f, 25.2136822f);
2791     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2792     path.quadTo(1120.07104f, 28, 1118, 28);
2793     path.lineTo(888, 28);
2794     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2795     path.quadTo(883, 25.0710678f, 883, 23);
2796     path.close();
2797     SkPath pathB;
2798     pathB.setFillType(SkPath::kWinding_FillType);
2799     pathB.moveTo(883, 0);
2800     pathB.lineTo(1123, 0);
2801     pathB.lineTo(1123, 23);
2802     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2803     pathB.quadTo(1120.07104f, 28, 1118, 28);
2804     pathB.lineTo(888, 28);
2805     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2806     pathB.quadTo(883, 25.0710678f, 883, 23);
2807     pathB.close();
2808     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2809 }
2810
2811 static void skpbestred_ru37(skiatest::Reporter* reporter, const char* filename) {
2812     SkPath path;
2813     path.setFillType(SkPath::kEvenOdd_FillType);
2814     path.moveTo(883, 23);
2815     path.lineTo(883, 0);
2816     path.lineTo(1122.5f, 0);
2817     path.lineTo(1122.5f, 25.2136822f);
2818     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2819     path.quadTo(1120.07104f, 28, 1118, 28);
2820     path.lineTo(888, 28);
2821     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2822     path.quadTo(883, 25.0710678f, 883, 23);
2823     path.close();
2824     SkPath pathB;
2825     pathB.setFillType(SkPath::kWinding_FillType);
2826     pathB.moveTo(883, 0);
2827     pathB.lineTo(1123, 0);
2828     pathB.lineTo(1123, 23);
2829     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2830     pathB.quadTo(1120.07104f, 28, 1118, 28);
2831     pathB.lineTo(888, 28);
2832     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2833     pathB.quadTo(883, 25.0710678f, 883, 23);
2834     pathB.close();
2835     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2836 }
2837
2838 static void skpbingoentertainment_net189(skiatest::Reporter* reporter, const char* filename) {
2839     SkPath path;
2840     path.setFillType(SkPath::kEvenOdd_FillType);
2841     path.moveTo(896, 745.38678f);
2842     path.lineTo(896, 873.38678f);
2843     path.lineTo(922.567993f, 876.683716f);
2844     path.lineTo(922.567993f, 748.683716f);
2845     path.lineTo(896, 745.38678f);
2846     path.close();
2847     SkPath pathB;
2848     pathB.setFillType(SkPath::kWinding_FillType);
2849     pathB.moveTo(899.200928f, 745.783997f);
2850     pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f);
2851     pathB.lineTo(895.432007f, 858.316284f);
2852     pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f);
2853     pathB.lineTo(918.799133f, 876.216003f);
2854     pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f);
2855     pathB.lineTo(922.567993f, 763.683716f);
2856     pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f);
2857     pathB.lineTo(899.200928f, 745.783997f);
2858     pathB.close();
2859     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2860 }
2861
2862 static void skpcarrefour_ro62(skiatest::Reporter* reporter, const char* filename) {
2863     SkPath path;
2864     path.setFillType(SkPath::kEvenOdd_FillType);
2865     path.moveTo(1104, 453);
2866     path.lineTo(399, 453);
2867     path.lineTo(399, 657);
2868     path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2869     path.lineTo(1095, 666);
2870     path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2871     path.lineTo(1104, 453);
2872     path.close();
2873     SkPath pathB;
2874     pathB.setFillType(SkPath::kInverseWinding_FillType);
2875     pathB.moveTo(400, 453);
2876     pathB.lineTo(1103, 453);
2877     pathB.lineTo(1103, 666);
2878     pathB.lineTo(406, 666);
2879     pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660);
2880     pathB.lineTo(400, 453);
2881     pathB.close();
2882     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2883 }
2884
2885 static void skpcaffelavazzait_com_ua21(skiatest::Reporter* reporter, const char* filename) {
2886     SkPath path;
2887     path.setFillType(SkPath::kEvenOdd_FillType);
2888     path.moveTo(883, 23);
2889     path.lineTo(883, 0);
2890     path.lineTo(1122.5f, 0);
2891     path.lineTo(1122.5f, 25.2136822f);
2892     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2893     path.quadTo(1120.07104f, 28, 1118, 28);
2894     path.lineTo(888, 28);
2895     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2896     path.quadTo(883, 25.0710678f, 883, 23);
2897     path.close();
2898     SkPath pathB;
2899     pathB.setFillType(SkPath::kWinding_FillType);
2900     pathB.moveTo(883, 0);
2901     pathB.lineTo(1123, 0);
2902     pathB.lineTo(1123, 23);
2903     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2904     pathB.quadTo(1120.07104f, 28, 1118, 28);
2905     pathB.lineTo(888, 28);
2906     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2907     pathB.quadTo(883, 25.0710678f, 883, 23);
2908     pathB.close();
2909     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2910 }
2911
2912 static void skpcamcorder_kz21(skiatest::Reporter* reporter, const char* filename) {
2913     SkPath path;
2914     path.setFillType(SkPath::kEvenOdd_FillType);
2915     path.moveTo(883, 23);
2916     path.lineTo(883, 0);
2917     path.lineTo(1122.5f, 0);
2918     path.lineTo(1122.5f, 25.2136822f);
2919     path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2920     path.quadTo(1120.07104f, 28, 1118, 28);
2921     path.lineTo(888, 28);
2922     path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2923     path.quadTo(883, 25.0710678f, 883, 23);
2924     path.close();
2925     SkPath pathB;
2926     pathB.setFillType(SkPath::kWinding_FillType);
2927     pathB.moveTo(883, 0);
2928     pathB.lineTo(1123, 0);
2929     pathB.lineTo(1123, 23);
2930     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2931     pathB.quadTo(1120.07104f, 28, 1118, 28);
2932     pathB.lineTo(888, 28);
2933     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2934     pathB.quadTo(883, 25.0710678f, 883, 23);
2935     pathB.close();
2936     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2937 }
2938
2939 static void skpcavablar_net563(skiatest::Reporter* reporter, const char* filename) {
2940     SkPath path;
2941     path.setFillType(SkPath::kEvenOdd_FillType);
2942     path.moveTo(160.000488f, 918);
2943     path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2944     path.lineTo(94, 917);
2945     path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2946     path.lineTo(160.000488f, 918);
2947     path.close();
2948     SkPath pathB;
2949     pathB.setFillType(SkPath::kWinding_FillType);
2950     pathB.moveTo(91, 917);
2951     pathB.lineTo(160, 917);
2952     pathB.lineTo(160, 918);
2953     pathB.lineTo(91, 918);
2954     pathB.close();
2955     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2956 }
2957
2958 static void skpinsomnia_gr72(skiatest::Reporter* reporter, const char* filename) {
2959     SkPath path;
2960     path.setFillType(SkPath::kEvenOdd_FillType);
2961     path.moveTo(1138, 231);
2962     path.lineTo(1137, 243.625748f);
2963     path.lineTo(1137, 926);
2964     path.lineTo(1139, 926);
2965     path.lineTo(1139, 231);
2966     path.lineTo(1138, 231);
2967     path.close();
2968     SkPath pathB;
2969     pathB.setFillType(SkPath::kWinding_FillType);
2970     pathB.moveTo(1139, 231);
2971     pathB.lineTo(1138, 231);
2972     pathB.lineTo(633, 6101);
2973     pathB.lineTo(1139, 6607);
2974     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2975 }
2976
2977 static void cubicOp95u(skiatest::Reporter* reporter, const char* filename) {
2978     SkPath path, pathB;
2979     path.setFillType(SkPath::kEvenOdd_FillType);
2980     path.moveTo(0, 2);
2981     path.cubicTo(2, 3, 5, 1, 3, 2);
2982     path.close();
2983     pathB.setFillType(SkPath::kEvenOdd_FillType);
2984     pathB.moveTo(1, 5);
2985     pathB.cubicTo(2, 3, 2, 0, 3, 2);
2986     pathB.close();
2987     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2988 }
2989
2990 static void cubicOp96d(skiatest::Reporter* reporter, const char* filename) {
2991     SkPath path, pathB;
2992     path.setFillType(SkPath::kEvenOdd_FillType);
2993     path.moveTo(1, 6);
2994     path.cubicTo(0, 3, 6, 3, 5, 0);
2995     path.close();
2996     pathB.setFillType(SkPath::kEvenOdd_FillType);
2997     pathB.moveTo(3, 6);
2998     pathB.cubicTo(0, 5, 6, 1, 3, 0);
2999     pathB.close();
3000     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3001 }
3002
3003 static void cubicOp97x(skiatest::Reporter* reporter, const char* filename) {
3004     SkPath path, pathB;
3005     path.setFillType(SkPath::kEvenOdd_FillType);
3006     path.moveTo(0, 2);
3007     path.cubicTo(0, 6, 2, 1, 2, 1);
3008     path.close();
3009     pathB.setFillType(SkPath::kEvenOdd_FillType);
3010     pathB.moveTo(1, 2);
3011     pathB.cubicTo(1, 2, 2, 0, 6, 0);
3012     pathB.close();
3013     testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
3014 }
3015
3016 static void cubicOp98x(skiatest::Reporter* reporter, const char* filename) {
3017     SkPath path, pathB;
3018     path.setFillType(SkPath::kEvenOdd_FillType);
3019     path.moveTo(0, 3);
3020     path.cubicTo(3, 6, 4, 1, 6, 3);
3021     path.close();
3022     pathB.setFillType(SkPath::kEvenOdd_FillType);
3023     pathB.moveTo(1, 4);
3024     pathB.cubicTo(3, 6, 3, 0, 6, 3);
3025     pathB.close();
3026     testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
3027 }
3028
3029 static void cubicOp99(skiatest::Reporter* reporter, const char* filename) {
3030     SkPath path, pathB;
3031     path.setFillType(SkPath::kWinding_FillType);
3032     path.moveTo(3,6);
3033     path.cubicTo(0,3, 6,5, 5,4);
3034     path.close();
3035     pathB.setFillType(SkPath::kWinding_FillType);
3036     pathB.moveTo(5,6);
3037     pathB.cubicTo(4,5, 6,3, 3,0);
3038     pathB.close();
3039     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3040 }
3041
3042 static void cubicOp100(skiatest::Reporter* reporter, const char* filename) {
3043     SkPath path, pathB;
3044     path.setFillType(SkPath::kWinding_FillType);
3045     path.moveTo(0,1);
3046     path.cubicTo(0,2, 2,1, 4,2);
3047     path.close();
3048     pathB.setFillType(SkPath::kWinding_FillType);
3049     pathB.moveTo(1,2);
3050     pathB.cubicTo(2,4, 1,0, 2,0);
3051     pathB.close();
3052     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3053 }
3054
3055 static void cubicOp101(skiatest::Reporter* reporter, const char* filename) {
3056     SkPath path, pathB;
3057     path.setFillType(SkPath::kWinding_FillType);
3058     path.moveTo(0, 1);
3059     path.cubicTo(2, 3, 2, 1, 5, 3);
3060     path.close();
3061     pathB.setFillType(SkPath::kWinding_FillType);
3062     pathB.moveTo(1, 2);
3063     pathB.cubicTo(3, 5, 1, 0, 3, 2);
3064     pathB.close();
3065     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3066 }
3067
3068 static void cubicOp102(skiatest::Reporter* reporter, const char* filename) {
3069     SkPath path, pathB;
3070     path.setFillType(SkPath::kWinding_FillType);
3071     path.moveTo(0,1);
3072     path.cubicTo(1,2, 1,0, 3,0);
3073     path.close();
3074     pathB.setFillType(SkPath::kWinding_FillType);
3075     pathB.moveTo(0,1);
3076     pathB.cubicTo(0,3, 1,0, 2,1);
3077     pathB.close();
3078     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3079 }
3080
3081 static void cubicOp103(skiatest::Reporter* reporter, const char* filename) {
3082     SkPath path, pathB;
3083     path.setFillType(SkPath::kWinding_FillType);
3084     path.moveTo(0,1);
3085     path.cubicTo(1,5, 2,0, 2,1);
3086     path.close();
3087     pathB.setFillType(SkPath::kWinding_FillType);
3088     pathB.moveTo(0,2);
3089     pathB.cubicTo(1,2, 1,0, 5,1);
3090     pathB.close();
3091     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3092 }
3093
3094 static void cubicOp104(skiatest::Reporter* reporter, const char* filename) {
3095     SkPath path, pathB;
3096     path.setFillType(SkPath::kWinding_FillType);
3097     path.moveTo(0,1);
3098     path.cubicTo(0,6, 4,0, 6,1);
3099     path.close();
3100     pathB.setFillType(SkPath::kWinding_FillType);
3101     pathB.moveTo(0,4);
3102     pathB.cubicTo(1,6, 1,0, 6,0);
3103     pathB.close();
3104     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3105 }
3106
3107 static void cubicOp105(skiatest::Reporter* reporter, const char* filename) {
3108     SkPath path, pathB;
3109     path.setFillType(SkPath::kWinding_FillType);
3110     path.moveTo(0,1);
3111     path.cubicTo(0,4, 6,5, 2,0);
3112     path.close();
3113     pathB.setFillType(SkPath::kWinding_FillType);
3114     pathB.moveTo(5,6);
3115     pathB.cubicTo(0,2, 1,0, 4,0);
3116     pathB.close();
3117     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3118 }
3119
3120 static void cubicOp106(skiatest::Reporter* reporter, const char* filename) {
3121     SkPath path, pathB;
3122     path.setFillType(SkPath::kWinding_FillType);
3123     path.moveTo(0, 1);
3124     path.cubicTo(4, 6, 2, 1, 2, 0);
3125     path.close();
3126     pathB.setFillType(SkPath::kWinding_FillType);
3127     pathB.moveTo(1, 2);
3128     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3129     pathB.close();
3130     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3131 }
3132
3133 static void cubicOp107(skiatest::Reporter* reporter, const char* filename) {
3134     SkPath path, pathB;
3135     path.setFillType(SkPath::kWinding_FillType);
3136     path.moveTo(0, 1);
3137     path.cubicTo(4, 6, 2, 1, 2, 0);
3138     path.close();
3139     pathB.setFillType(SkPath::kWinding_FillType);
3140     pathB.moveTo(1, 2);
3141     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3142     pathB.close();
3143     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3144 }
3145
3146 static void cubicOp108(skiatest::Reporter* reporter, const char* filename) {
3147     SkPath path, pathB;
3148     path.setFillType(SkPath::kWinding_FillType);
3149     path.moveTo(0, 1);
3150     path.cubicTo(4, 6, 2, 1, 2, 0);
3151     path.close();
3152     pathB.setFillType(SkPath::kWinding_FillType);
3153     pathB.moveTo(1, 2);
3154     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3155     pathB.close();
3156     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3157 }
3158
3159 static void cubicOp109(skiatest::Reporter* reporter, const char* filename) {
3160     SkPath path, pathB;
3161     path.setFillType(SkPath::kWinding_FillType);
3162     path.moveTo(0,1);
3163     path.cubicTo(4,5, 6,3, 5,4);
3164     path.close();
3165     pathB.setFillType(SkPath::kWinding_FillType);
3166     pathB.moveTo(3,6);
3167     pathB.cubicTo(4,5, 1,0, 5,4);
3168     pathB.close();
3169     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3170 }
3171
3172 static void cubicOp110(skiatest::Reporter* reporter, const char* filename) {
3173     SkPath path, pathB;
3174     path.setFillType(SkPath::kEvenOdd_FillType);
3175     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3176     path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3177     pathB.setFillType(SkPath::kEvenOdd_FillType);
3178     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3179     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3180     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3181 }
3182
3183 static void cubicOp111(skiatest::Reporter* reporter, const char* filename) {
3184     SkPath path, pathB;
3185     path.setFillType(SkPath::kWinding_FillType);
3186     path.moveTo(1,4);
3187     path.cubicTo(0,5, 4,1, 3,1);
3188     path.close();
3189     pathB.setFillType(SkPath::kWinding_FillType);
3190     pathB.moveTo(1,4);
3191     pathB.cubicTo(1,3, 4,1, 5,0);
3192     pathB.close();
3193     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3194 }
3195
3196 static void xOp1u(skiatest::Reporter* reporter, const char* filename) {
3197     SkPath path, pathB;
3198     path.setFillType(SkPath::kEvenOdd_FillType);
3199     path.moveTo(1, 4);
3200     path.cubicTo(4, 5, 3, 2, 6, 3);
3201     path.close();
3202     pathB.setFillType(SkPath::kEvenOdd_FillType);
3203     pathB.moveTo(2, 3);
3204     pathB.cubicTo(3, 6, 4, 1, 5, 4);
3205     pathB.close();
3206     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3207 }
3208
3209 static void xOp1i(skiatest::Reporter* reporter, const char* filename) {
3210     SkPath path, pathB;
3211     path.setFillType(SkPath::kEvenOdd_FillType);
3212     path.moveTo(1, 4);
3213     path.cubicTo(1, 5, 6, 0, 5, 1);
3214     path.close();
3215     pathB.setFillType(SkPath::kEvenOdd_FillType);
3216     pathB.moveTo(0, 6);
3217     pathB.cubicTo(1, 5, 4, 1, 5, 1);
3218     pathB.close();
3219     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3220 }
3221
3222 static void xOp2i(skiatest::Reporter* reporter, const char* filename) {
3223     SkPath path, pathB;
3224     path.setFillType(SkPath::kEvenOdd_FillType);
3225     path.moveTo(1, 5);
3226     path.cubicTo(0, 4, 3, 2, 6, 1);
3227     path.close();
3228     pathB.setFillType(SkPath::kEvenOdd_FillType);
3229     pathB.moveTo(2, 3);
3230     pathB.cubicTo(1, 6, 5, 1, 4, 0);
3231     pathB.close();
3232     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3233 }
3234
3235 static void xOp3i(skiatest::Reporter* reporter, const char* filename) {
3236     SkPath path, pathB;
3237     path.setFillType(SkPath::kWinding_FillType);
3238     path.moveTo(1,4);
3239     path.cubicTo(0,5, 4,1, 3,1);
3240     path.close();
3241     pathB.setFillType(SkPath::kWinding_FillType);
3242     pathB.moveTo(1,4);
3243     pathB.cubicTo(1,3, 4,1, 5,0);
3244     pathB.close();
3245     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3246 }
3247
3248 static void findFirst1(skiatest::Reporter* reporter, const char* filename) {
3249     SkPath path, pathB;
3250     path.setFillType(SkPath::kWinding_FillType);
3251     path.moveTo(0,1);
3252     path.cubicTo(1,6, 5,0, 2,1);
3253     path.close();
3254     pathB.setFillType(SkPath::kWinding_FillType);
3255     pathB.moveTo(0,5);
3256     pathB.cubicTo(1,2, 1,0, 6,1);
3257     pathB.close();
3258     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3259 }
3260
3261 // triggers addSimpleAngle with non-zero argument
3262 static void cubicOp112(skiatest::Reporter* reporter, const char* filename) {
3263     SkPath path, pathB;
3264     path.setFillType(SkPath::kWinding_FillType);
3265     path.moveTo(2,4);
3266     path.cubicTo(2,3, 6,4, 1,0);
3267     path.close();
3268     pathB.setFillType(SkPath::kWinding_FillType);
3269     pathB.moveTo(4,6);
3270     pathB.cubicTo(0,1, 4,2, 3,2);
3271     pathB.close();
3272     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3273 }
3274
3275 static void cubicOp113(skiatest::Reporter* reporter, const char* filename) {
3276     SkPath path, pathB;
3277     path.moveTo(2,4);
3278     path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3279     path.close();
3280     pathB.moveTo(3,5);
3281     pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
3282     pathB.close();
3283     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3284 }
3285
3286 #define CUBIC_OP_114 0
3287 #if CUBIC_OP_114
3288 static void cubicOp114(skiatest::Reporter* reporter, const char* filename) {
3289     SkPath path, pathB;
3290     path.setFillType(SkPath::kWinding_FillType);
3291     path.moveTo(0, 1);
3292     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3293     path.close();
3294     pathB.setFillType(SkPath::kWinding_FillType);
3295     pathB.moveTo(1, 3);
3296     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3297     pathB.close();
3298     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3299 }
3300 #endif
3301
3302 static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) {
3303     SkPath path, pathB;
3304     path.setFillType(SkPath::kWinding_FillType);
3305     path.moveTo(0, 1);
3306     path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3307     path.close();
3308     pathB.setFillType(SkPath::kWinding_FillType);
3309     pathB.moveTo(1, 3);
3310     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3311     pathB.close();
3312     SkPath qPath, qPathB;
3313     CubicPathToQuads(path, &qPath);
3314     CubicPathToQuads(pathB, &qPathB);
3315     testPathOp(reporter, qPath, qPathB, kIntersect_PathOp, filename);
3316 }
3317
3318 static void quadOp10i(skiatest::Reporter* reporter, const char* filename) {
3319     SkPath path, pathB;
3320     path.moveTo(0, 0);
3321     path.quadTo(1, 8, 3, 5);
3322     path.lineTo(8, 1);
3323     path.close();
3324     pathB.moveTo(0, 0);
3325     pathB.quadTo(8, 1, 4, 8);
3326     pathB.close();
3327     testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3328 }
3329
3330 static void kari1(skiatest::Reporter* reporter, const char* filename) {
3331     SkPath path1;
3332     path1.moveTo(39.9375, -5.8359375);
3333     path1.lineTo(40.625, -5.7890625);
3334     path1.lineTo(37.7109375, 1.3515625);
3335     path1.lineTo(37.203125, 0.9609375);
3336     path1.close();
3337
3338     SkPath path2;
3339     path2.moveTo(37.52734375f, -1.44140625f);
3340     path2.cubicTo(37.8736991882324f, -1.69921875f, 38.1640625f, -2.140625f, 38.3984375f, -2.765625f);
3341     path2.lineTo(38.640625f, -2.609375f);
3342     path2.cubicTo(38.53125f, -1.89583337306976f, 38.0664443969727f, -0.154893040657043f, 38.0664443969727f, -0.154893040657043f);
3343     path2.cubicTo(38.0664443969727f, -0.154893040657043f, 37.1809883117676f, -1.18359375f, 37.52734375, -1.44140625f);
3344     path2.close();
3345
3346     testPathOp(reporter, path1, path2, kDifference_PathOp, filename);
3347 }
3348
3349 static void issue2504(skiatest::Reporter* reporter, const char* filename) {
3350     SkPath path1;
3351     path1.moveTo(34.2421875, -5.976562976837158203125);
3352     path1.lineTo(35.453121185302734375, 0);
3353     path1.lineTo(31.9375, 0);
3354     path1.close();
3355
3356     SkPath path2;
3357     path2.moveTo(36.71843719482421875, 0.8886508941650390625);
3358     path2.cubicTo(36.71843719482421875, 0.8886508941650390625,
3359                   35.123386383056640625, 0.554015457630157470703125,
3360                   34.511409759521484375, -0.1152553558349609375);
3361     path2.cubicTo(33.899425506591796875, -0.7845261096954345703125,
3362                   34.53484344482421875, -5.6777553558349609375,
3363                   34.53484344482421875, -5.6777553558349609375);
3364     path2.close();
3365     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3366 }
3367
3368 static void issue2540(skiatest::Reporter* reporter, const char* filename) {
3369     SkPath path1;
3370     path1.moveTo(26.5054988861083984375, 85.73960113525390625);
3371     path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875);
3372     path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625);
3373     path1.lineTo(23.1654987335205078125, 89.72879791259765625);
3374     path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875);
3375     path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375);
3376     path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625);
3377     path1.close();
3378
3379     SkPath path2;
3380     path2.moveTo(-25.077999114990234375, 124.9120025634765625);
3381     path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125);
3382     path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625);
3383     path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625);
3384     path2.close();
3385     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3386 }
3387
3388 static void rects1(skiatest::Reporter* reporter, const char* filename) {
3389     SkPath path, pathB;
3390     path.setFillType(SkPath::kEvenOdd_FillType);
3391     path.moveTo(0, 0);
3392     path.lineTo(1, 0);
3393     path.lineTo(1, 1);
3394     path.lineTo(0, 1);
3395     path.close();
3396     path.moveTo(0, 0);
3397     path.lineTo(6, 0);
3398     path.lineTo(6, 6);
3399     path.lineTo(0, 6);
3400     path.close();
3401     pathB.setFillType(SkPath::kEvenOdd_FillType);
3402     pathB.moveTo(0, 0);
3403     pathB.lineTo(1, 0);
3404     pathB.lineTo(1, 1);
3405     pathB.lineTo(0, 1);
3406     pathB.close();
3407     pathB.moveTo(0, 0);
3408     pathB.lineTo(2, 0);
3409     pathB.lineTo(2, 2);
3410     pathB.lineTo(0, 2);
3411     pathB.close();
3412     testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3413 }
3414
3415 static void rects2(skiatest::Reporter* reporter, const char* filename) {
3416     SkPath path, pathB;
3417     path.setFillType(SkPath::kEvenOdd_FillType);
3418     path.moveTo(0, 0);
3419     path.lineTo(4, 0);
3420     path.lineTo(4, 4);
3421     path.lineTo(0, 4);
3422     path.close();
3423     path.moveTo(3, 3);
3424     path.lineTo(4, 3);
3425     path.lineTo(4, 4);
3426     path.lineTo(3, 4);
3427     path.close();
3428     pathB.setFillType(SkPath::kWinding_FillType);
3429     pathB.moveTo(3, 3);
3430     pathB.lineTo(6, 3);
3431     pathB.lineTo(6, 6);
3432     pathB.lineTo(3, 6);
3433     pathB.close();
3434     pathB.moveTo(3, 3);
3435     pathB.lineTo(4, 3);
3436     pathB.lineTo(4, 4);
3437     pathB.lineTo(3, 4);
3438     pathB.close();
3439     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3440 }
3441
3442 static void rects3(skiatest::Reporter* reporter, const char* filename) {
3443     SkPath path, pathB;
3444     path.setFillType(SkPath::kEvenOdd_FillType);
3445     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3446     path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3447     pathB.setFillType(SkPath::kWinding_FillType);
3448     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3449     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3450     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3451 }
3452
3453 static void rects4(skiatest::Reporter* reporter, const char* filename) {
3454     SkPath path, pathB;
3455     path.setFillType(SkPath::kEvenOdd_FillType);
3456     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3457     path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3458     pathB.setFillType(SkPath::kWinding_FillType);
3459     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3460     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
3461     testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3462 }
3463
3464 #define TEST_ISSUE_2753 0
3465 #if TEST_ISSUE_2753
3466 static void issue2753(skiatest::Reporter* reporter, const char* filename) {
3467     SkPath path1;
3468     path1.moveTo(142.701f, 110.568f);
3469     path1.lineTo(142.957f, 100);
3470     path1.lineTo(153.835f, 100);
3471     path1.lineTo(154.592f, 108.188f);
3472     path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f);
3473     path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f);
3474     path1.close();
3475
3476     SkPath path2;
3477     path2.moveTo(39, 124.001f);
3478     path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f);
3479     path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f);
3480     path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f);
3481     path2.close();
3482
3483     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3484 }
3485 #endif
3486
3487 static void issue2808(skiatest::Reporter* reporter, const char* filename) {
3488     SkPath path1, path2;
3489
3490         path1.moveTo(509.20300293f, 385.601989746f);
3491         path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f);
3492         path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f);
3493         path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f);
3494         path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f);
3495         path1.quadTo(363.932983398f, 355.515594482f, 385.207275391f, 334.241271973f);
3496         path1.quadTo(406.4815979f, 312.96697998f, 436.567993164f, 312.96697998f);
3497         path1.quadTo(466.654388428f, 312.96697998f, 487.928710938f, 334.241271973f);
3498         path1.quadTo(509.20300293f, 355.515594482f, 509.20300293f, 385.601989746f);
3499         path1.close();
3500
3501         path2.moveTo(449.033996582f, 290.87298584f);
3502         path2.quadTo(449.033996582f, 301.028259277f, 441.853149414f, 308.209106445f);
3503         path2.quadTo(434.672271729f, 315.389984131f, 424.516998291f, 315.389984131f);
3504         path2.quadTo(414.361724854f, 315.389984131f, 407.180847168f, 308.209106445f);
3505         path2.quadTo(400, 301.028259277f, 400, 290.87298584f);
3506         path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f);
3507         path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f);
3508         path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f);
3509         path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f);
3510         path2.close();
3511
3512     testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3513 }
3514
3515 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
3516 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
3517
3518 static struct TestDesc tests[] = {
3519 #if TEST_ISSUE_2753  // FIXME: pair of cubics miss intersection
3520     TEST(issue2753),
3521 #endif
3522 #if CUBIC_OP_114  // FIXME: curve with inflection is ordered the wrong way
3523     TEST(cubicOp114),
3524 #endif
3525     TEST(issue2808),
3526     TEST(cubicOp114asQuad),
3527     TEST(rects4),
3528     TEST(rects3),
3529     TEST(rects2),
3530     TEST(rects1),
3531     TEST(issue2540),
3532     TEST(issue2504),
3533     TEST(kari1),
3534     TEST(quadOp10i),
3535     TEST(cubicOp113),
3536 #if QUAD_CUBIC_FAILS_TO_FIND_INTERSECTION
3537     // fails because a cubic/quadratic intersection is missed
3538     // the internal quad/quad is far enough away from the real cubic/quad that it is rejected
3539     TEST(skpcarrot_is24),
3540 #endif
3541     TEST(issue1417),
3542     TEST(cubicOp112),
3543     TEST(skpadspert_net23),
3544     TEST(skpadspert_de11),
3545     TEST(findFirst1),
3546     TEST(xOp2i),
3547     TEST(xOp3i),
3548     TEST(xOp1u),
3549     TEST(xOp1i),
3550     TEST(cubicOp111),
3551     TEST(cubicOp110),
3552     TEST(cubicOp109),
3553     TEST(cubicOp108),
3554     TEST(cubicOp107),
3555     TEST(cubicOp106),
3556     TEST(cubicOp105),
3557     TEST(cubicOp104),
3558     TEST(cubicOp103),
3559     TEST(cubicOp102),
3560     TEST(cubicOp101),
3561     TEST(cubicOp100),
3562     TEST(cubicOp99),
3563     TEST(issue1435),
3564     TEST(cubicOp98x),
3565     TEST(cubicOp97x),
3566     TEST(skpcarpetplanet_ru22),  // cubic/cubic intersect detects unwanted coincidence
3567     TEST(cubicOp96d),
3568     TEST(cubicOp95u),
3569     TEST(skpadbox_lt15),
3570     TEST(skpagentxsites_com55),
3571     TEST(skpadventistmission_org572),
3572     TEST(skpadoption_org196),
3573     TEST(skpbambootheme_com12),
3574     TEST(skpbakosoft_com10),
3575     TEST(skpakmmos_ru100),
3576     TEST(skpbangalorenest_com4),
3577     TEST(skpbingoentertainment_net189),
3578     TEST(skpbestred_ru37),
3579     TEST(skpbenzoteh_ru152),
3580     TEST(skpcamcorder_kz21),
3581     TEST(skpcaffelavazzait_com_ua21),
3582     TEST(skpcarrefour_ro62),
3583     TEST(skpcavablar_net563),
3584     TEST(skpinsomnia_gr72),
3585     TEST(skpadbox_lt8),
3586     TEST(skpact_com43),
3587     TEST(skpacesoftech_com47),
3588     TEST(skpabcspark_ca103),
3589     TEST(cubicOp94u),
3590     TEST(cubicOp93d),
3591     TEST(cubicOp92i),
3592     TEST(skpadithya_putr4_blogspot_com551),
3593     TEST(skpadindex_de4),
3594     TEST(skpaiaigames_com870),
3595     TEST(skpaaalgarve_org53),
3596     TEST(skpkkiste_to716),
3597     TEST(cubicOp91u),
3598     TEST(cubicOp90u),
3599     TEST(cubicOp89u),
3600     TEST(cubicOp88u),
3601     TEST(cubicOp87u),
3602     TEST(cubicOp86i),
3603     TEST(loopEdge2),
3604     TEST(loopEdge1),
3605     TEST(rectOp3x),
3606     TEST(rectOp2i),
3607     TEST(rectOp1i),
3608     TEST(issue1418b),
3609     TEST(cubicOp85i),
3610     TEST(issue1418),
3611     TEST(skpkkiste_to98),
3612     TEST(skpahrefs_com29),
3613     TEST(cubicOp85d),
3614     TEST(skpahrefs_com88),
3615     TEST(skphealth_com76),
3616     TEST(skpancestry_com1),
3617     TEST(skpbyte_com1),
3618     TEST(skpeldorado_com_ua1),
3619     TEST(skp96prezzi1),
3620     TEST(skpClip2),
3621     TEST(skpClip1),
3622     TEST(cubicOp84d),
3623     TEST(cubicOp83i),
3624     TEST(cubicOp82i),
3625     TEST(cubicOp81d),
3626     TEST(cubicOp80i),
3627     TEST(cubicOp79u),
3628     TEST(cubicOp78u),
3629     TEST(cubicOp77i),
3630     TEST(cubicOp76u),
3631     TEST(cubicOp75d),
3632     TEST(cubicOp74d),
3633     TEST(cubicOp73d),
3634     TEST(cubicOp72i),
3635     TEST(cubicOp71d),
3636     TEST(skp5),
3637     TEST(skp4),
3638     TEST(skp3),
3639     TEST(skp2),
3640     TEST(skp1),
3641     TEST(rRect1),
3642     TEST(cubicOp70d),
3643     TEST(cubicOp69d),
3644     TEST(cubicOp68u),
3645     TEST(cubicOp67u),
3646     TEST(cubicOp66u),
3647     TEST(rectOp1d),
3648     TEST(cubicOp65d),
3649     TEST(cubicOp64d),
3650     TEST(cubicOp63d),
3651     TEST(cubicOp62d),
3652     TEST(cubicOp61d),
3653     TEST(cubicOp60d),
3654     TEST(cubicOp59d),
3655     TEST(cubicOp58d),
3656     TEST(cubicOp57d),
3657     TEST(cubicOp56d),
3658     TEST(cubicOp55d),
3659     TEST(cubicOp54d),
3660     TEST(cubicOp53d),
3661     TEST(cubicOp52d),
3662     TEST(cubicOp51d),
3663     TEST(cubicOp50d),
3664     TEST(cubicOp49d),
3665     TEST(cubicOp48d),
3666     TEST(cubicOp47d),
3667     TEST(cubicOp46d),
3668     TEST(cubicOp45d),
3669     TEST(cubicOp44d),
3670     TEST(cubicOp43d),
3671     TEST(cubicOp42d),
3672     TEST(cubicOp41i),
3673     TEST(cubicOp40d),
3674     TEST(cubicOp39d),
3675     TEST(cubicOp38d),
3676     TEST(cubicOp37d),
3677     TEST(cubicOp36u),
3678     TEST(cubicOp35d),
3679     TEST(cubicOp34d),
3680     TEST(cubicOp33i),
3681     TEST(cubicOp32d),
3682     TEST(cubicOp31d),
3683     TEST(cubicOp31x),
3684     TEST(cubicOp31u),
3685     TEST(cubicOp30d),
3686     TEST(cubicOp29d),
3687     TEST(cubicOp28u),
3688     TEST(cubicOp27d),
3689     TEST(cubicOp26d),
3690     TEST(cubicOp25i),
3691     TEST(testOp8d),
3692     TEST(testDiff1),
3693     TEST(testIntersect1),
3694     TEST(testUnion1),
3695     TEST(testXor1),
3696     TEST(testDiff2),
3697     TEST(testIntersect2),
3698     TEST(testUnion2),
3699     TEST(testXor2),
3700     TEST(testOp1d),
3701     TEST(testOp2d),
3702     TEST(testOp3d),
3703     TEST(testOp1u),
3704     TEST(testOp4d),
3705     TEST(testOp5d),
3706     TEST(testOp6d),
3707     TEST(testOp7d),
3708     TEST(testOp2u),
3709
3710     TEST(cubicOp24d),
3711     TEST(cubicOp23d),
3712     TEST(cubicOp22d),
3713     TEST(cubicOp21d),
3714     TEST(cubicOp20d),
3715     TEST(cubicOp19i),
3716     TEST(cubicOp18d),
3717     TEST(cubicOp17d),
3718     TEST(cubicOp16d),
3719     TEST(cubicOp15d),
3720     TEST(cubicOp14d),
3721     TEST(cubicOp13d),
3722     TEST(cubicOp12d),
3723     TEST(cubicOp11d),
3724     TEST(cubicOp10d),
3725     TEST(cubicOp1i),
3726     TEST(cubicOp9d),
3727     TEST(quadOp9d),
3728     TEST(lineOp9d),
3729     TEST(cubicOp8d),
3730     TEST(cubicOp7d),
3731     TEST(cubicOp6d),
3732     TEST(cubicOp5d),
3733     TEST(cubicOp3d),
3734     TEST(cubicOp2d),
3735     TEST(cubicOp1d),
3736 };
3737
3738 static const size_t testCount = SK_ARRAY_COUNT(tests);
3739
3740 static struct TestDesc subTests[] = {
3741     TEST(cubicOp58d),
3742     TEST(cubicOp53d),
3743 };
3744
3745 static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
3746
3747 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0;
3748
3749 static bool runSubTests = false;
3750 static bool runSubTestsFirst = false;
3751 static bool runReverse = false;
3752
3753 DEF_TEST(PathOpsOp, reporter) {
3754 #if DEBUG_SHOW_TEST_NAME
3755     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
3756 #endif
3757     if (runSubTests && runSubTestsFirst) {
3758         RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
3759     }
3760     RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
3761     if (runSubTests && !runSubTestsFirst) {
3762         RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
3763     }
3764 }
3765
3766 static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) {
3767     SkPath path;
3768     path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
3769     SkPath pathB;
3770     pathB.addRect(0,0, 300,16);
3771     testPathFailOp(reporter, path, pathB, kUnion_PathOp, filename);
3772 }
3773
3774 // m 100,0 60,170 -160,-110 200,0 -170,11000000000 z
3775 static void fuzz433(skiatest::Reporter* reporter, const char* filename) {
3776     SkPath path1, path2;
3777     path1.moveTo(100,0);
3778     path1.lineTo(60,170);
3779     path1.lineTo(-160,-110);
3780     path1.lineTo(200,0);
3781     path1.lineTo(-170,11000000000.0f);
3782     path1.close();
3783
3784     path2.moveTo(100 + 20,0 + 20);
3785     path2.lineTo(60 + 20,170 + 20);
3786     path2.lineTo(-160 + 20,-110 + 20);
3787     path2.lineTo(200 + 20,0 + 20);
3788     path2.lineTo(-170 + 20,11000000000.0f + 20);
3789     path2.close();
3790
3791     testPathFailOp(reporter, path1, path2, kIntersect_PathOp, filename);
3792 }
3793
3794 static void fuzz433b(skiatest::Reporter* reporter, const char* filename) {
3795     SkPath path1, path2;
3796     path1.setFillType(SkPath::kEvenOdd_FillType);
3797     path1.moveTo(140, 40);
3798     path1.lineTo(200, 210);
3799     path1.lineTo(40, 100);
3800     path1.lineTo(240, 100);
3801     path1.lineTo(70, 1.1e+10f);
3802     path1.lineTo(140, 40);
3803     path1.close();
3804
3805     path1.setFillType(SkPath::kWinding_FillType);
3806     path2.moveTo(190, 60);
3807     path2.lineTo(250, 230);
3808     path2.lineTo(90, 120);
3809     path2.lineTo(290, 120);
3810     path2.lineTo(120, 1.1e+10f);
3811     path2.lineTo(190, 60);
3812     path2.close();
3813
3814     testPathFailOp(reporter, path1, path2, kUnion_PathOp, filename);
3815 }
3816
3817 static struct TestDesc failTests[] = {
3818     TEST(fuzz433b),
3819     TEST(fuzz433),
3820     TEST(bufferOverflow),
3821 };
3822
3823 static const size_t failTestCount = SK_ARRAY_COUNT(failTests);
3824
3825 DEF_TEST(PathOpsFailOp, reporter) {
3826 #if DEBUG_SHOW_TEST_NAME
3827     strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
3828 #endif
3829     RunTestSet(reporter, failTests, failTestCount, 0, 0, false);
3830 }