src/third_party/skia/tests/PathOpsSimplifyTest.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
   9 #define TEST(name) { name, #name }
  10
  11 static void testLine1(skiatest::Reporter* reporter, const char* filename) {
  12     SkPath path;
  13     path.moveTo(2,0);
  14     path.lineTo(1,1);
  15     path.lineTo(0,0);
  16     path.close();
  17     testSimplify(reporter, path, filename);
  18 }
  19
  20 static void testLine1x(skiatest::Reporter* reporter, const char* filename) {
  21     SkPath path;
  22     path.setFillType(SkPath::kEvenOdd_FillType);
  23     path.moveTo(2,0);
  24     path.lineTo(1,1);
  25     path.lineTo(0,0);
  26     path.close();
  27     testSimplify(reporter, path, filename);
  28 }
  29
  30 static void addInnerCWTriangle(SkPath& path) {
  31     path.moveTo(3,0);
  32     path.lineTo(4,1);
  33     path.lineTo(2,1);
  34     path.close();
  35 }
  36
  37 static void addInnerCCWTriangle(SkPath& path) {
  38     path.moveTo(3,0);
  39     path.lineTo(2,1);
  40     path.lineTo(4,1);
  41     path.close();
  42 }
  43
  44 static void addOuterCWTriangle(SkPath& path) {
  45     path.moveTo(3,0);
  46     path.lineTo(6,2);
  47     path.lineTo(0,2);
  48     path.close();
  49 }
  50
  51 static void addOuterCCWTriangle(SkPath& path) {
  52     path.moveTo(3,0);
  53     path.lineTo(0,2);
  54     path.lineTo(6,2);
  55     path.close();
  56 }
  57
  58 static void testLine2(skiatest::Reporter* reporter, const char* filename) {
  59     SkPath path;
  60     addInnerCWTriangle(path);
  61     addOuterCWTriangle(path);
  62     testSimplify(reporter, path, filename);
  63 }
  64
  65 static void testLine2x(skiatest::Reporter* reporter, const char* filename) {
  66     SkPath path;
  67     path.setFillType(SkPath::kEvenOdd_FillType);
  68     addInnerCWTriangle(path);
  69     addOuterCWTriangle(path);
  70     testSimplify(reporter, path, filename);
  71 }
  72
  73 static void testLine3(skiatest::Reporter* reporter, const char* filename) {
  74     SkPath path;
  75     addInnerCCWTriangle(path);
  76     addOuterCWTriangle(path);
  77     testSimplify(reporter, path, filename);
  78 }
  79
  80 static void testLine3x(skiatest::Reporter* reporter, const char* filename) {
  81     SkPath path;
  82     path.setFillType(SkPath::kEvenOdd_FillType);
  83     addInnerCCWTriangle(path);
  84     addOuterCWTriangle(path);
  85     testSimplify(reporter, path, filename);
  86 }
  87
  88 static void testLine3a(skiatest::Reporter* reporter, const char* filename) {
  89     SkPath path;
  90     addInnerCWTriangle(path);
  91     addOuterCCWTriangle(path);
  92     testSimplify(reporter, path, filename);
  93 }
  94
  95 static void testLine3ax(skiatest::Reporter* reporter, const char* filename) {
  96     SkPath path;
  97     path.setFillType(SkPath::kEvenOdd_FillType);
  98     addInnerCWTriangle(path);
  99     addOuterCCWTriangle(path);
 100     testSimplify(reporter, path, filename);
 101 }
 102
 103 static void testLine3b(skiatest::Reporter* reporter, const char* filename) {
 104     SkPath path;
 105     addInnerCCWTriangle(path);
 106     addOuterCCWTriangle(path);
 107     testSimplify(reporter, path, filename);
 108 }
 109
 110 static void testLine3bx(skiatest::Reporter* reporter, const char* filename) {
 111     SkPath path;
 112     path.setFillType(SkPath::kEvenOdd_FillType);
 113     addInnerCCWTriangle(path);
 114     addOuterCCWTriangle(path);
 115     testSimplify(reporter, path, filename);
 116 }
 117
 118 static void testLine4(skiatest::Reporter* reporter, const char* filename) {
 119     SkPath path;
 120     addOuterCCWTriangle(path);
 121     addOuterCWTriangle(path);
 122     testSimplify(reporter, path, filename);
 123 }
 124
 125 static void testLine4x(skiatest::Reporter* reporter, const char* filename) {
 126     SkPath path;
 127     path.setFillType(SkPath::kEvenOdd_FillType);
 128     addOuterCCWTriangle(path);
 129     addOuterCWTriangle(path);
 130     testSimplify(reporter, path, filename);
 131 }
 132
 133 static void testLine5(skiatest::Reporter* reporter, const char* filename) {
 134     SkPath path;
 135     addOuterCWTriangle(path);
 136     addOuterCWTriangle(path);
 137     testSimplify(reporter, path, filename);
 138 }
 139
 140 static void testLine5x(skiatest::Reporter* reporter, const char* filename) {
 141     SkPath path;
 142     path.setFillType(SkPath::kEvenOdd_FillType);
 143     addOuterCWTriangle(path);
 144     addOuterCWTriangle(path);
 145     testSimplify(reporter, path, filename);
 146 }
 147
 148 static void testLine6(skiatest::Reporter* reporter, const char* filename) {
 149     SkPath path;
 150     path.moveTo(0,0);
 151     path.lineTo(4,0);
 152     path.lineTo(2,2);
 153     path.close();
 154     path.moveTo(2,0);
 155     path.lineTo(6,0);
 156     path.lineTo(4,2);
 157     path.close();
 158     testSimplify(reporter, path, filename);
 159 }
 160
 161 static void testLine6x(skiatest::Reporter* reporter, const char* filename) {
 162     SkPath path;
 163     path.setFillType(SkPath::kEvenOdd_FillType);
 164     path.moveTo(0,0);
 165     path.lineTo(4,0);
 166     path.lineTo(2,2);
 167     path.close();
 168     path.moveTo(2,0);
 169     path.lineTo(6,0);
 170     path.lineTo(4,2);
 171     path.close();
 172     testSimplify(reporter, path, filename);
 173 }
 174
 175 static void testLine7(skiatest::Reporter* reporter, const char* filename) {
 176     SkPath path;
 177     path.moveTo(0,0);
 178     path.lineTo(4,0);
 179     path.lineTo(2,2);
 180     path.close();
 181     path.moveTo(6,0);
 182     path.lineTo(2,0);
 183     path.lineTo(4,2);
 184     path.close();
 185     testSimplify(reporter, path, filename);
 186 }
 187
 188 static void testLine7x(skiatest::Reporter* reporter, const char* filename) {
 189     SkPath path;
 190     path.setFillType(SkPath::kEvenOdd_FillType);
 191     path.moveTo(0,0);
 192     path.lineTo(4,0);
 193     path.lineTo(2,2);
 194     path.close();
 195     path.moveTo(6,0);
 196     path.lineTo(2,0);
 197     path.lineTo(4,2);
 198     path.close();
 199     testSimplify(reporter, path, filename);
 200 }
 201
 202 static void testLine7a(skiatest::Reporter* reporter, const char* filename) {
 203     SkPath path;
 204     path.moveTo(0,0);
 205     path.lineTo(4,0);
 206     path.lineTo(2,2);
 207     path.close();
 208     testSimplify(reporter, path, filename);
 209 }
 210
 211 static void testLine7ax(skiatest::Reporter* reporter, const char* filename) {
 212     SkPath path;
 213     path.setFillType(SkPath::kEvenOdd_FillType);
 214     path.moveTo(0,0);
 215     path.lineTo(4,0);
 216     path.lineTo(2,2);
 217     path.close();
 218     testSimplify(reporter, path, filename);
 219 }
 220
 221 static void testLine7b(skiatest::Reporter* reporter, const char* filename) {
 222     SkPath path;
 223     path.moveTo(0,0);
 224     path.lineTo(4,0);
 225     path.close();
 226     path.moveTo(6,0);
 227     path.lineTo(2,0);
 228     path.lineTo(4,2);
 229     path.close();
 230     testSimplify(reporter, path, filename);
 231 }
 232
 233 static void testLine7bx(skiatest::Reporter* reporter, const char* filename) {
 234     SkPath path;
 235     path.setFillType(SkPath::kEvenOdd_FillType);
 236     path.moveTo(0,0);
 237     path.lineTo(4,0);
 238     path.close();
 239     path.moveTo(6,0);
 240     path.lineTo(2,0);
 241     path.lineTo(4,2);
 242     path.close();
 243     testSimplify(reporter, path, filename);
 244 }
 245
 246 static void testLine8(skiatest::Reporter* reporter, const char* filename) {
 247     SkPath path;
 248     path.moveTo(0,4);
 249     path.lineTo(4,4);
 250     path.lineTo(2,2);
 251     path.close();
 252     path.moveTo(2,4);
 253     path.lineTo(6,4);
 254     path.lineTo(4,2);
 255     path.close();
 256     testSimplify(reporter, path, filename);
 257 }
 258
 259 static void testLine8x(skiatest::Reporter* reporter, const char* filename) {
 260     SkPath path;
 261     path.setFillType(SkPath::kEvenOdd_FillType);
 262     path.moveTo(0,4);
 263     path.lineTo(4,4);
 264     path.lineTo(2,2);
 265     path.close();
 266     path.moveTo(2,4);
 267     path.lineTo(6,4);
 268     path.lineTo(4,2);
 269     path.close();
 270     testSimplify(reporter, path, filename);
 271 }
 272
 273 static void testLine9(skiatest::Reporter* reporter, const char* filename) {
 274     SkPath path;
 275     path.moveTo(0,4);
 276     path.lineTo(4,4);
 277     path.lineTo(2,2);
 278     path.close();
 279     path.moveTo(6,4);
 280     path.lineTo(2,4);
 281     path.lineTo(4,2);
 282     path.close();
 283     testSimplify(reporter, path, filename);
 284 }
 285
 286 static void testLine9x(skiatest::Reporter* reporter, const char* filename) {
 287     SkPath path;
 288     path.setFillType(SkPath::kEvenOdd_FillType);
 289     path.moveTo(0,4);
 290     path.lineTo(4,4);
 291     path.lineTo(2,2);
 292     path.close();
 293     path.moveTo(6,4);
 294     path.lineTo(2,4);
 295     path.lineTo(4,2);
 296     path.close();
 297     testSimplify(reporter, path, filename);
 298 }
 299
 300 static void testLine10(skiatest::Reporter* reporter, const char* filename) {
 301     SkPath path;
 302     path.moveTo(0,4);
 303     path.lineTo(4,4);
 304     path.lineTo(2,2);
 305     path.close();
 306     path.moveTo(2,1);
 307     path.lineTo(3,4);
 308     path.lineTo(6,1);
 309     path.close();
 310     testSimplify(reporter, path, filename);
 311 }
 312
 313 static void testLine10x(skiatest::Reporter* reporter, const char* filename) {
 314     SkPath path;
 315     path.setFillType(SkPath::kEvenOdd_FillType);
 316     path.moveTo(0,4);
 317     path.lineTo(4,4);
 318     path.lineTo(2,2);
 319     path.close();
 320     path.moveTo(2,1);
 321     path.lineTo(3,4);
 322     path.lineTo(6,1);
 323     path.close();
 324     testSimplify(reporter, path, filename);
 325 }
 326
 327 static void testLine10a(skiatest::Reporter* reporter, const char* filename) {
 328     SkPath path;
 329     path.moveTo(0,4);
 330     path.lineTo(8,4);
 331     path.lineTo(4,0);
 332     path.close();
 333     path.moveTo(2,2);
 334     path.lineTo(3,3);
 335     path.lineTo(4,2);
 336     path.close();
 337     testSimplify(reporter, path, filename);
 338 }
 339
 340 static void testLine10ax(skiatest::Reporter* reporter, const char* filename) {
 341     SkPath path;
 342     path.setFillType(SkPath::kEvenOdd_FillType);
 343     path.moveTo(0,4);
 344     path.lineTo(8,4);
 345     path.lineTo(4,0);
 346     path.close();
 347     path.moveTo(2,2);
 348     path.lineTo(3,3);
 349     path.lineTo(4,2);
 350     path.close();
 351     testSimplify(reporter, path, filename);
 352 }
 353
 354 static void addCWContainer(SkPath& path) {
 355     path.moveTo(6,4);
 356     path.lineTo(0,4);
 357     path.lineTo(3,1);
 358     path.close();
 359 }
 360
 361 static void addCCWContainer(SkPath& path) {
 362     path.moveTo(0,4);
 363     path.lineTo(6,4);
 364     path.lineTo(3,1);
 365     path.close();
 366 }
 367
 368 static void addCWContents(SkPath& path) {
 369     path.moveTo(2,3);
 370     path.lineTo(3,2);
 371     path.lineTo(4,3);
 372     path.close();
 373 }
 374
 375 static void addCCWContents(SkPath& path) {
 376     path.moveTo(3,2);
 377     path.lineTo(2,3);
 378     path.lineTo(4,3);
 379     path.close();
 380 }
 381
 382 static void testLine11(skiatest::Reporter* reporter, const char* filename) {
 383     SkPath path;
 384     addCWContainer(path);
 385     addCWContents(path);
 386     testSimplify(reporter, path, filename);
 387 }
 388
 389 static void testLine11x(skiatest::Reporter* reporter, const char* filename) {
 390     SkPath path;
 391     path.setFillType(SkPath::kEvenOdd_FillType);
 392     addCWContainer(path);
 393     addCWContents(path);
 394     testSimplify(reporter, path, filename);
 395 }
 396
 397 static void testLine12(skiatest::Reporter* reporter, const char* filename) {
 398     SkPath path;
 399     addCCWContainer(path);
 400     addCWContents(path);
 401     testSimplify(reporter, path, filename);
 402 }
 403
 404 static void testLine12x(skiatest::Reporter* reporter, const char* filename) {
 405     SkPath path;
 406     path.setFillType(SkPath::kEvenOdd_FillType);
 407     addCCWContainer(path);
 408     addCWContents(path);
 409     testSimplify(reporter, path, filename);
 410 }
 411
 412 static void testLine13(skiatest::Reporter* reporter, const char* filename) {
 413     SkPath path;
 414     addCWContainer(path);
 415     addCCWContents(path);
 416     testSimplify(reporter, path, filename);
 417 }
 418
 419 static void testLine13x(skiatest::Reporter* reporter, const char* filename) {
 420     SkPath path;
 421     path.setFillType(SkPath::kEvenOdd_FillType);
 422     addCWContainer(path);
 423     addCCWContents(path);
 424     testSimplify(reporter, path, filename);
 425 }
 426
 427 static void testLine14(skiatest::Reporter* reporter, const char* filename) {
 428     SkPath path;
 429     addCCWContainer(path);
 430     addCCWContents(path);
 431     testSimplify(reporter, path, filename);
 432 }
 433
 434 static void testLine14x(skiatest::Reporter* reporter, const char* filename) {
 435     SkPath path;
 436     path.setFillType(SkPath::kEvenOdd_FillType);
 437     addCCWContainer(path);
 438     addCCWContents(path);
 439     testSimplify(reporter, path, filename);
 440 }
 441
 442 static void testLine15(skiatest::Reporter* reporter, const char* filename) {
 443     SkPath path;
 444     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 445     testSimplify(reporter, path, filename);
 446 }
 447
 448 static void testLine15x(skiatest::Reporter* reporter, const char* filename) {
 449     SkPath path;
 450     path.setFillType(SkPath::kEvenOdd_FillType);
 451     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 452     testSimplify(reporter, path, filename);
 453 }
 454
 455 static void testLine16(skiatest::Reporter* reporter, const char* filename) {
 456     SkPath path;
 457     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 458     path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
 459     testSimplify(reporter, path, filename);
 460 }
 461
 462 static void testLine16x(skiatest::Reporter* reporter, const char* filename) {
 463     SkPath path;
 464     path.setFillType(SkPath::kEvenOdd_FillType);
 465     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 466     path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
 467     testSimplify(reporter, path, filename);
 468 }
 469
 470 static void testLine17(skiatest::Reporter* reporter, const char* filename) {
 471     SkPath path;
 472     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 473     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 474     testSimplify(reporter, path, filename);
 475 }
 476
 477 static void testLine17x(skiatest::Reporter* reporter, const char* filename) {
 478     SkPath path;
 479     path.setFillType(SkPath::kEvenOdd_FillType);
 480     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 481     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 482     testSimplify(reporter, path, filename);
 483 }
 484
 485 static void testLine18(skiatest::Reporter* reporter, const char* filename) {
 486     SkPath path;
 487     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 488     path.addRect(12, 4, 21, 21, SkPath::kCW_Direction);
 489     testSimplify(reporter, path, filename);
 490 }
 491
 492 static void testLine18x(skiatest::Reporter* reporter, const char* filename) {
 493     SkPath path;
 494     path.setFillType(SkPath::kEvenOdd_FillType);
 495     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 496     path.addRect(12, 4, 21, 21, SkPath::kCW_Direction);
 497     testSimplify(reporter, path, filename);
 498 }
 499
 500 static void testLine19(skiatest::Reporter* reporter, const char* filename) {
 501     SkPath path;
 502     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 503     path.addRect(12, 16, 21, 21, SkPath::kCW_Direction);
 504     testSimplify(reporter, path, filename);
 505 }
 506
 507 static void testLine19x(skiatest::Reporter* reporter, const char* filename) {
 508     SkPath path;
 509     path.setFillType(SkPath::kEvenOdd_FillType);
 510     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 511     path.addRect(12, 16, 21, 21, SkPath::kCW_Direction);
 512     testSimplify(reporter, path, filename);
 513 }
 514
 515 static void testLine20(skiatest::Reporter* reporter, const char* filename) {
 516     SkPath path;
 517     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 518     path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
 519     testSimplify(reporter, path, filename);
 520 }
 521
 522 static void testLine20x(skiatest::Reporter* reporter, const char* filename) {
 523     SkPath path;
 524     path.setFillType(SkPath::kEvenOdd_FillType);
 525     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 526     path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
 527     testSimplify(reporter, path, filename);
 528 }
 529
 530 static void testLine21(skiatest::Reporter* reporter, const char* filename) {
 531     SkPath path;
 532     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 533     path.addRect(0, 16, 9, 9, SkPath::kCW_Direction);
 534     testSimplify(reporter, path, filename);
 535 }
 536
 537 static void testLine21x(skiatest::Reporter* reporter, const char* filename) {
 538     SkPath path;
 539     path.setFillType(SkPath::kEvenOdd_FillType);
 540     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 541     path.addRect(0, 16, 9, 9, SkPath::kCW_Direction);
 542     testSimplify(reporter, path, filename);
 543 }
 544
 545 static void testLine22(skiatest::Reporter* reporter, const char* filename) {
 546     SkPath path;
 547     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 548     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 549     testSimplify(reporter, path, filename);
 550 }
 551
 552 static void testLine22x(skiatest::Reporter* reporter, const char* filename) {
 553     SkPath path;
 554     path.setFillType(SkPath::kEvenOdd_FillType);
 555     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 556     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 557     testSimplify(reporter, path, filename);
 558 }
 559
 560 static void testLine23(skiatest::Reporter* reporter, const char* filename) {
 561     SkPath path;
 562     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 563     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 564     testSimplify(reporter, path, filename);
 565 }
 566
 567 static void testLine23x(skiatest::Reporter* reporter, const char* filename) {
 568     SkPath path;
 569     path.setFillType(SkPath::kEvenOdd_FillType);
 570     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
 571     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 572     testSimplify(reporter, path, filename);
 573 }
 574
 575 static void testLine24a(skiatest::Reporter* reporter, const char* filename) {
 576     SkPath path;
 577     path.moveTo(2,0);
 578     path.lineTo(4,4);
 579     path.lineTo(0,4);
 580     path.close();
 581     path.moveTo(2,0);
 582     path.lineTo(1,2);
 583     path.lineTo(2,2);
 584     path.close();
 585     testSimplify(reporter, path, filename);
 586 }
 587
 588 static void testLine24ax(skiatest::Reporter* reporter, const char* filename) {
 589     SkPath path;
 590     path.setFillType(SkPath::kEvenOdd_FillType);
 591     path.moveTo(2,0);
 592     path.lineTo(4,4);
 593     path.lineTo(0,4);
 594     path.close();
 595     path.moveTo(2,0);
 596     path.lineTo(1,2);
 597     path.lineTo(2,2);
 598     path.close();
 599     testSimplify(reporter, path, filename);
 600 }
 601
 602 static void testLine24(skiatest::Reporter* reporter, const char* filename) {
 603     SkPath path;
 604     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 605     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 606     testSimplify(reporter, path, filename);
 607 }
 608
 609 static void testLine24x(skiatest::Reporter* reporter, const char* filename) {
 610     SkPath path;
 611     path.setFillType(SkPath::kEvenOdd_FillType);
 612     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 613     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 614     testSimplify(reporter, path, filename);
 615 }
 616
 617 static void testLine25(skiatest::Reporter* reporter, const char* filename) {
 618     SkPath path;
 619     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 620     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 621     testSimplify(reporter, path, filename);
 622 }
 623
 624 static void testLine25x(skiatest::Reporter* reporter, const char* filename) {
 625     SkPath path;
 626     path.setFillType(SkPath::kEvenOdd_FillType);
 627     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 628     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 629     testSimplify(reporter, path, filename);
 630 }
 631
 632 static void testLine26(skiatest::Reporter* reporter, const char* filename) {
 633     SkPath path;
 634     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 635     path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
 636     testSimplify(reporter, path, filename);
 637 }
 638
 639 static void testLine26x(skiatest::Reporter* reporter, const char* filename) {
 640     SkPath path;
 641     path.setFillType(SkPath::kEvenOdd_FillType);
 642     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 643     path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
 644     testSimplify(reporter, path, filename);
 645 }
 646
 647 static void testLine27(skiatest::Reporter* reporter, const char* filename) {
 648     SkPath path;
 649     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 650     path.addRect(12, 8, 21, 21, SkPath::kCW_Direction);
 651     testSimplify(reporter, path, filename);
 652 }
 653
 654 static void testLine27x(skiatest::Reporter* reporter, const char* filename) {
 655     SkPath path;
 656     path.setFillType(SkPath::kEvenOdd_FillType);
 657     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 658     path.addRect(12, 8, 21, 21, SkPath::kCW_Direction);
 659     testSimplify(reporter, path, filename);
 660 }
 661
 662 static void testLine28(skiatest::Reporter* reporter, const char* filename) {
 663     SkPath path;
 664     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 665     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 666     testSimplify(reporter, path, filename);
 667 }
 668
 669 static void testLine28x(skiatest::Reporter* reporter, const char* filename) {
 670     SkPath path;
 671     path.setFillType(SkPath::kEvenOdd_FillType);
 672     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 673     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 674     testSimplify(reporter, path, filename);
 675 }
 676
 677 static void testLine29(skiatest::Reporter* reporter, const char* filename) {
 678     SkPath path;
 679     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 680     path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
 681     testSimplify(reporter, path, filename);
 682 }
 683
 684 static void testLine29x(skiatest::Reporter* reporter, const char* filename) {
 685     SkPath path;
 686     path.setFillType(SkPath::kEvenOdd_FillType);
 687     path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
 688     path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
 689     testSimplify(reporter, path, filename);
 690 }
 691
 692 static void testLine30(skiatest::Reporter* reporter, const char* filename) {
 693     SkPath path;
 694     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 695     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 696     path.addRect(4, 4, 13, 13, SkPath::kCW_Direction);
 697     testSimplify(reporter, path, filename);
 698 }
 699
 700 static void testLine30x(skiatest::Reporter* reporter, const char* filename) {
 701     SkPath path;
 702     path.setFillType(SkPath::kEvenOdd_FillType);
 703     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 704     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 705     path.addRect(4, 4, 13, 13, SkPath::kCW_Direction);
 706     testSimplify(reporter, path, filename);
 707 }
 708
 709 static void testLine31(skiatest::Reporter* reporter, const char* filename) {
 710     SkPath path;
 711     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 712     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 713     path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
 714     testSimplify(reporter, path, filename);
 715 }
 716
 717 static void testLine31x(skiatest::Reporter* reporter, const char* filename) {
 718     SkPath path;
 719     path.setFillType(SkPath::kEvenOdd_FillType);
 720     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 721     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 722     path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
 723     testSimplify(reporter, path, filename);
 724 }
 725
 726 static void testLine32(skiatest::Reporter* reporter, const char* filename) {
 727     SkPath path;
 728     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 729     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 730     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 731     testSimplify(reporter, path, filename);
 732 }
 733
 734 static void testLine32x(skiatest::Reporter* reporter, const char* filename) {
 735     SkPath path;
 736     path.setFillType(SkPath::kEvenOdd_FillType);
 737     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 738     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 739     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 740     testSimplify(reporter, path, filename);
 741 }
 742
 743 static void testLine33(skiatest::Reporter* reporter, const char* filename) {
 744     SkPath path;
 745     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 746     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 747     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 748     testSimplify(reporter, path, filename);
 749 }
 750
 751 static void testLine33x(skiatest::Reporter* reporter, const char* filename) {
 752     SkPath path;
 753     path.setFillType(SkPath::kEvenOdd_FillType);
 754     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 755     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 756     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 757     testSimplify(reporter, path, filename);
 758 }
 759
 760 static void testLine34(skiatest::Reporter* reporter, const char* filename) {
 761     SkPath path;
 762     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 763     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 764     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 765     testSimplify(reporter, path, filename);
 766 }
 767
 768 static void testLine34x(skiatest::Reporter* reporter, const char* filename) {
 769     SkPath path;
 770     path.setFillType(SkPath::kEvenOdd_FillType);
 771     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 772     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 773     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
 774     testSimplify(reporter, path, filename);
 775 }
 776
 777 static void testLine35(skiatest::Reporter* reporter, const char* filename) {
 778     SkPath path;
 779     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 780     path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
 781     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 782     testSimplify(reporter, path, filename);
 783 }
 784
 785 static void testLine35x(skiatest::Reporter* reporter, const char* filename) {
 786     SkPath path;
 787     path.setFillType(SkPath::kEvenOdd_FillType);
 788     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 789     path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
 790     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 791     testSimplify(reporter, path, filename);
 792 }
 793
 794 static void testLine36(skiatest::Reporter* reporter, const char* filename) {
 795     SkPath path;
 796     path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
 797     path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
 798     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 799     testSimplify(reporter, path, filename);
 800 }
 801
 802 static void testLine36x(skiatest::Reporter* reporter, const char* filename) {
 803     SkPath path;
 804     path.setFillType(SkPath::kEvenOdd_FillType);
 805     path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
 806     path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
 807     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 808     testSimplify(reporter, path, filename);
 809 }
 810
 811 static void testLine37(skiatest::Reporter* reporter, const char* filename) {
 812     SkPath path;
 813     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
 814     path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
 815     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 816     testSimplify(reporter, path, filename);
 817 }
 818
 819 static void testLine37x(skiatest::Reporter* reporter, const char* filename) {
 820     SkPath path;
 821     path.setFillType(SkPath::kEvenOdd_FillType);
 822     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
 823     path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
 824     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
 825     testSimplify(reporter, path, filename);
 826 }
 827
 828 static void testLine38(skiatest::Reporter* reporter, const char* filename) {
 829     SkPath path;
 830     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 831     path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
 832     path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
 833     testSimplify(reporter, path, filename);
 834 }
 835
 836 static void testLine38x(skiatest::Reporter* reporter, const char* filename) {
 837     SkPath path;
 838     path.setFillType(SkPath::kEvenOdd_FillType);
 839     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 840     path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
 841     path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
 842     testSimplify(reporter, path, filename);
 843 }
 844
 845 static void testLine40(skiatest::Reporter* reporter, const char* filename) {
 846     SkPath path;
 847     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 848     path.addRect(12, 18, 24, 24, SkPath::kCW_Direction);
 849     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 850     testSimplify(reporter, path, filename);
 851 }
 852
 853 static void testLine40x(skiatest::Reporter* reporter, const char* filename) {
 854     SkPath path;
 855     path.setFillType(SkPath::kEvenOdd_FillType);
 856     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 857     path.addRect(12, 18, 24, 24, SkPath::kCW_Direction);
 858     path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
 859     testSimplify(reporter, path, filename);
 860 }
 861
 862 static void testLine41(skiatest::Reporter* reporter, const char* filename) {
 863     SkPath path;
 864     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 865     path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
 866     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 867     testSimplify(reporter, path, filename);
 868 }
 869
 870 static void testLine41x(skiatest::Reporter* reporter, const char* filename) {
 871     SkPath path;
 872     path.setFillType(SkPath::kEvenOdd_FillType);
 873     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 874     path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
 875     path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
 876     testSimplify(reporter, path, filename);
 877 }
 878
 879 static void testLine42(skiatest::Reporter* reporter, const char* filename) {
 880     SkPath path;
 881     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 882     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 883     path.addRect(8, 16, 17, 17, SkPath::kCW_Direction);
 884     testSimplify(reporter, path, filename);
 885 }
 886
 887 static void testLine42x(skiatest::Reporter* reporter, const char* filename) {
 888     SkPath path;
 889     path.setFillType(SkPath::kEvenOdd_FillType);
 890     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 891     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 892     path.addRect(8, 16, 17, 17, SkPath::kCW_Direction);
 893     testSimplify(reporter, path, filename);
 894 }
 895
 896 static void testLine43(skiatest::Reporter* reporter, const char* filename) {
 897     SkPath path;
 898     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 899     path.addRect(6, 24, 18, 18, SkPath::kCW_Direction);
 900     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
 901     testSimplify(reporter, path, filename);
 902 }
 903
 904 static void testLine43x(skiatest::Reporter* reporter, const char* filename) {
 905     SkPath path;
 906     path.setFillType(SkPath::kEvenOdd_FillType);
 907     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 908     path.addRect(6, 24, 18, 18, SkPath::kCW_Direction);
 909     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
 910     testSimplify(reporter, path, filename);
 911 }
 912
 913 static void testLine44(skiatest::Reporter* reporter, const char* filename) {
 914     SkPath path;
 915     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
 916     path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
 917     path.addRect(18, 32, 27, 36, SkPath::kCCW_Direction);
 918     testSimplify(reporter, path, filename);
 919 }
 920
 921 static void testLine44x(skiatest::Reporter* reporter, const char* filename) {
 922     SkPath path;
 923     path.setFillType(SkPath::kEvenOdd_FillType);
 924     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
 925     path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
 926     path.addRect(18, 32, 27, 36, SkPath::kCCW_Direction);
 927     testSimplify(reporter, path, filename);
 928 }
 929
 930 static void testLine45(skiatest::Reporter* reporter, const char* filename) {
 931     SkPath path;
 932     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 933     path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
 934     path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
 935     testSimplify(reporter, path, filename);
 936 }
 937
 938 static void testLine45x(skiatest::Reporter* reporter, const char* filename) {
 939     SkPath path;
 940     path.setFillType(SkPath::kEvenOdd_FillType);
 941     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
 942     path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
 943     path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
 944     testSimplify(reporter, path, filename);
 945 }
 946
 947 static void testLine46(skiatest::Reporter* reporter, const char* filename) {
 948     SkPath path;
 949     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
 950     path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
 951     path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
 952     testSimplify(reporter, path, filename);
 953 }
 954
 955 static void testLine46x(skiatest::Reporter* reporter, const char* filename) {
 956     SkPath path;
 957     path.setFillType(SkPath::kEvenOdd_FillType);
 958     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
 959     path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
 960     path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
 961     testSimplify(reporter, path, filename);
 962 }
 963
 964 static void testLine47(skiatest::Reporter* reporter, const char* filename) {
 965     SkPath path;
 966     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 967     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 968     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
 969     testSimplify(reporter, path, filename);
 970 }
 971
 972 static void testLine47x(skiatest::Reporter* reporter, const char* filename) {
 973     SkPath path;
 974     path.setFillType(SkPath::kEvenOdd_FillType);
 975     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 976     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
 977     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
 978     testSimplify(reporter, path, filename);
 979 }
 980
 981 static void testLine48(skiatest::Reporter* reporter, const char* filename) {
 982     SkPath path;
 983     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 984     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 985     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
 986     testSimplify(reporter, path, filename);
 987 }
 988
 989 static void testLine48x(skiatest::Reporter* reporter, const char* filename) {
 990     SkPath path;
 991     path.setFillType(SkPath::kEvenOdd_FillType);
 992     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
 993     path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
 994     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
 995     testSimplify(reporter, path, filename);
 996 }
 997
 998 static void testLine49(skiatest::Reporter* reporter, const char* filename) {
 999     SkPath path;
1000     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1001     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
1002     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
1003     testSimplify(reporter, path, filename);
1004 }
1005
1006 static void testLine49x(skiatest::Reporter* reporter, const char* filename) {
1007     SkPath path;
1008     path.setFillType(SkPath::kEvenOdd_FillType);
1009     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1010     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
1011     path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
1012     testSimplify(reporter, path, filename);
1013 }
1014
1015 static void testLine50(skiatest::Reporter* reporter, const char* filename) {
1016     SkPath path;
1017     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1018     path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1019     testSimplify(reporter, path, filename);
1020 }
1021
1022 static void testLine50x(skiatest::Reporter* reporter, const char* filename) {
1023     SkPath path;
1024     path.setFillType(SkPath::kEvenOdd_FillType);
1025     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1026     path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1027     testSimplify(reporter, path, filename);
1028 }
1029
1030 static void testLine51(skiatest::Reporter* reporter, const char* filename) {
1031     SkPath path;
1032     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1033     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1034     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1035     testSimplify(reporter, path, filename);
1036 }
1037
1038 static void testLine51x(skiatest::Reporter* reporter, const char* filename) {
1039     SkPath path;
1040     path.setFillType(SkPath::kEvenOdd_FillType);
1041     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1042     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1043     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1044     testSimplify(reporter, path, filename);
1045 }
1046
1047 static void testLine52(skiatest::Reporter* reporter, const char* filename) {
1048     SkPath path;
1049     path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1050     path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1051     path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1052     testSimplify(reporter, path, filename);
1053 }
1054
1055 static void testLine52x(skiatest::Reporter* reporter, const char* filename) {
1056     SkPath path;
1057     path.setFillType(SkPath::kEvenOdd_FillType);
1058     path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1059     path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1060     path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1061     testSimplify(reporter, path, filename);
1062 }
1063
1064 static void testLine53(skiatest::Reporter* reporter, const char* filename) {
1065     SkPath path;
1066     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1067     path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1068     path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1069     testSimplify(reporter, path, filename);
1070 }
1071
1072 static void testLine53x(skiatest::Reporter* reporter, const char* filename) {
1073     SkPath path;
1074     path.setFillType(SkPath::kEvenOdd_FillType);
1075     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1076     path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1077     path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1078     testSimplify(reporter, path, filename);
1079 }
1080
1081 static void testLine54(skiatest::Reporter* reporter, const char* filename) {
1082     SkPath path;
1083     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1084     path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
1085     path.addRect(8, 4, 17, 17, SkPath::kCCW_Direction);
1086     testSimplify(reporter, path, filename);
1087 }
1088
1089 static void testLine54x(skiatest::Reporter* reporter, const char* filename) {
1090     SkPath path;
1091     path.setFillType(SkPath::kEvenOdd_FillType);
1092     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1093     path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
1094     path.addRect(8, 4, 17, 17, SkPath::kCCW_Direction);
1095     testSimplify(reporter, path, filename);
1096 }
1097
1098 static void testLine55(skiatest::Reporter* reporter, const char* filename) {
1099     SkPath path;
1100     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1101     path.addRect(6, 6, 18, 18, SkPath::kCW_Direction);
1102     path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1103     testSimplify(reporter, path, filename);
1104 }
1105
1106 static void testLine55x(skiatest::Reporter* reporter, const char* filename) {
1107     SkPath path;
1108     path.setFillType(SkPath::kEvenOdd_FillType);
1109     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1110     path.addRect(6, 6, 18, 18, SkPath::kCW_Direction);
1111     path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1112     testSimplify(reporter, path, filename);
1113 }
1114
1115 static void testLine56(skiatest::Reporter* reporter, const char* filename) {
1116     SkPath path;
1117     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1118     path.addRect(18, 20, 30, 30, SkPath::kCW_Direction);
1119     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1120     testSimplify(reporter, path, filename);
1121 }
1122
1123 static void testLine56x(skiatest::Reporter* reporter, const char* filename) {
1124     SkPath path;
1125     path.setFillType(SkPath::kEvenOdd_FillType);
1126     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1127     path.addRect(18, 20, 30, 30, SkPath::kCW_Direction);
1128     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1129     testSimplify(reporter, path, filename);
1130 }
1131
1132 static void testLine57(skiatest::Reporter* reporter, const char* filename) {
1133     SkPath path;
1134     path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1135     path.addRect(20, 0, 30, 40, SkPath::kCW_Direction);
1136     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1137     testSimplify(reporter, path, filename);
1138 }
1139
1140 static void testLine57x(skiatest::Reporter* reporter, const char* filename) {
1141     SkPath path;
1142     path.setFillType(SkPath::kEvenOdd_FillType);
1143     path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1144     path.addRect(20, 0, 30, 40, SkPath::kCW_Direction);
1145     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1146     testSimplify(reporter, path, filename);
1147 }
1148
1149 static void testLine58(skiatest::Reporter* reporter, const char* filename) {
1150     SkPath path;
1151     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1152     path.addRect(0, 0, 12, 12, SkPath::kCCW_Direction);
1153     path.addRect(0, 12, 9, 9, SkPath::kCCW_Direction);
1154     testSimplify(reporter, path, filename);
1155 }
1156
1157 static void testLine58x(skiatest::Reporter* reporter, const char* filename) {
1158     SkPath path;
1159     path.setFillType(SkPath::kEvenOdd_FillType);
1160     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1161     path.addRect(0, 0, 12, 12, SkPath::kCCW_Direction);
1162     path.addRect(0, 12, 9, 9, SkPath::kCCW_Direction);
1163     testSimplify(reporter, path, filename);
1164 }
1165
1166 static void testLine59(skiatest::Reporter* reporter, const char* filename) {
1167     SkPath path;
1168     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1169     path.addRect(6, 6, 18, 18, SkPath::kCCW_Direction);
1170     path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1171     testSimplify(reporter, path, filename);
1172 }
1173
1174 static void testLine59x(skiatest::Reporter* reporter, const char* filename) {
1175     SkPath path;
1176     path.setFillType(SkPath::kEvenOdd_FillType);
1177     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1178     path.addRect(6, 6, 18, 18, SkPath::kCCW_Direction);
1179     path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1180     testSimplify(reporter, path, filename);
1181 }
1182
1183 static void testLine60(skiatest::Reporter* reporter, const char* filename) {
1184     SkPath path;
1185     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1186     path.addRect(6, 12, 18, 18, SkPath::kCCW_Direction);
1187     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1188     testSimplify(reporter, path, filename);
1189 }
1190
1191 static void testLine60x(skiatest::Reporter* reporter, const char* filename) {
1192     SkPath path;
1193     path.setFillType(SkPath::kEvenOdd_FillType);
1194     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1195     path.addRect(6, 12, 18, 18, SkPath::kCCW_Direction);
1196     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1197     testSimplify(reporter, path, filename);
1198 }
1199
1200 static void testLine61(skiatest::Reporter* reporter, const char* filename) {
1201     SkPath path;
1202     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1203     path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
1204     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1205     testSimplify(reporter, path, filename);
1206 }
1207
1208 static void testLine61x(skiatest::Reporter* reporter, const char* filename) {
1209     SkPath path;
1210     path.setFillType(SkPath::kEvenOdd_FillType);
1211     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1212     path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
1213     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1214     testSimplify(reporter, path, filename);
1215 }
1216
1217 static void testLine62(skiatest::Reporter* reporter, const char* filename) {
1218     SkPath path;
1219     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1220     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1221     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1222     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1223     testSimplify(reporter, path, filename);
1224 }
1225
1226 static void testLine62x(skiatest::Reporter* reporter, const char* filename) {
1227     SkPath path;
1228     path.setFillType(SkPath::kEvenOdd_FillType);
1229     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1230     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1231     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1232     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1233     testSimplify(reporter, path, filename);
1234 }
1235
1236 static void testLine63(skiatest::Reporter* reporter, const char* filename) {
1237     SkPath path;
1238     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1239     path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
1240     path.addRect(0, 6, 12, 12, SkPath::kCCW_Direction);
1241     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1242     testSimplify(reporter, path, filename);
1243 }
1244
1245 static void testLine63x(skiatest::Reporter* reporter, const char* filename) {
1246     SkPath path;
1247     path.setFillType(SkPath::kEvenOdd_FillType);
1248     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1249     path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
1250     path.addRect(0, 6, 12, 12, SkPath::kCCW_Direction);
1251     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1252     testSimplify(reporter, path, filename);
1253 }
1254
1255 static void testLine64(skiatest::Reporter* reporter, const char* filename) {
1256     SkPath path;
1257     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1258     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1259     path.addRect(18, 6, 30, 30, SkPath::kCW_Direction);
1260     testSimplify(reporter, path, filename);
1261 }
1262
1263 static void testLine64x(skiatest::Reporter* reporter, const char* filename) {
1264     SkPath path;
1265     path.setFillType(SkPath::kEvenOdd_FillType);
1266     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1267     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1268     path.addRect(18, 6, 30, 30, SkPath::kCW_Direction);
1269     testSimplify(reporter, path, filename);
1270 }
1271
1272 static void testLine65(skiatest::Reporter* reporter, const char* filename) {
1273     SkPath path;
1274     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1275     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
1276     path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
1277     path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1278     testSimplify(reporter, path, filename);
1279 }
1280
1281 static void testLine65x(skiatest::Reporter* reporter, const char* filename) {
1282     SkPath path;
1283     path.setFillType(SkPath::kEvenOdd_FillType);
1284     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1285     path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
1286     path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
1287     path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1288     testSimplify(reporter, path, filename);
1289 }
1290
1291 static void testLine66(skiatest::Reporter* reporter, const char* filename) {
1292     SkPath path;
1293     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1294     path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1295     path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1296     testSimplify(reporter, path, filename);
1297 }
1298
1299 static void testLine66x(skiatest::Reporter* reporter, const char* filename) {
1300     SkPath path;
1301     path.setFillType(SkPath::kEvenOdd_FillType);
1302     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1303     path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1304     path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1305     testSimplify(reporter, path, filename);
1306 }
1307
1308 static void testLine67(skiatest::Reporter* reporter, const char* filename) {
1309     SkPath path;
1310     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1311     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1312     path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1313     path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1314     testSimplify(reporter, path, filename);
1315 }
1316
1317 static void testLine67x(skiatest::Reporter* reporter, const char* filename) {
1318     SkPath path;
1319     path.setFillType(SkPath::kEvenOdd_FillType);
1320     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1321     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1322     path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1323     path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1324     testSimplify(reporter, path, filename);
1325 }
1326
1327 static void testLine68a(skiatest::Reporter* reporter, const char* filename) {
1328     SkPath path;
1329     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1330     path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1331     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1332     testSimplify(reporter, path, filename);
1333 }
1334
1335 static void testLine68ax(skiatest::Reporter* reporter, const char* filename) {
1336     SkPath path;
1337     path.setFillType(SkPath::kEvenOdd_FillType);
1338     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1339     path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1340     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1341     testSimplify(reporter, path, filename);
1342 }
1343
1344 static void testLine68b(skiatest::Reporter* reporter, const char* filename) {
1345     SkPath path;
1346     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1347     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1348     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1349     testSimplify(reporter, path, filename);
1350 }
1351
1352 static void testLine68bx(skiatest::Reporter* reporter, const char* filename) {
1353     SkPath path;
1354     path.setFillType(SkPath::kEvenOdd_FillType);
1355     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1356     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1357     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1358     testSimplify(reporter, path, filename);
1359 }
1360
1361 static void testLine68c(skiatest::Reporter* reporter, const char* filename) {
1362     SkPath path;
1363     path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1364     path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1365     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1366     testSimplify(reporter, path, filename);
1367 }
1368
1369 static void testLine68cx(skiatest::Reporter* reporter, const char* filename) {
1370     SkPath path;
1371     path.setFillType(SkPath::kEvenOdd_FillType);
1372     path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1373     path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1374     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1375     testSimplify(reporter, path, filename);
1376 }
1377
1378 static void testLine68d(skiatest::Reporter* reporter, const char* filename) {
1379     SkPath path;
1380     path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1381     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1382     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1383     testSimplify(reporter, path, filename);
1384 }
1385
1386 static void testLine68dx(skiatest::Reporter* reporter, const char* filename) {
1387     SkPath path;
1388     path.setFillType(SkPath::kEvenOdd_FillType);
1389     path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1390     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1391     path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1392     testSimplify(reporter, path, filename);
1393 }
1394
1395 static void testLine68e(skiatest::Reporter* reporter, const char* filename) {
1396     SkPath path;
1397     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1398     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1399     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1400     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1401     testSimplify(reporter, path, filename);
1402 }
1403
1404 static void testLine68ex(skiatest::Reporter* reporter, const char* filename) {
1405     SkPath path;
1406     path.setFillType(SkPath::kEvenOdd_FillType);
1407     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1408     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1409     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1410     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1411     testSimplify(reporter, path, filename);
1412 }
1413
1414 static void testLine68f(skiatest::Reporter* reporter, const char* filename) {
1415     SkPath path;
1416     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1417     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1418     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1419     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1420     testSimplify(reporter, path, filename);
1421 }
1422
1423 static void testLine68fx(skiatest::Reporter* reporter, const char* filename) {
1424     SkPath path;
1425     path.setFillType(SkPath::kEvenOdd_FillType);
1426     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1427     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1428     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1429     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1430     testSimplify(reporter, path, filename);
1431 }
1432
1433 static void testLine68g(skiatest::Reporter* reporter, const char* filename) {
1434     SkPath path;
1435     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1436     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1437     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1438     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1439     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1440     testSimplify(reporter, path, filename);
1441 }
1442
1443 static void testLine68gx(skiatest::Reporter* reporter, const char* filename) {
1444     SkPath path;
1445     path.setFillType(SkPath::kEvenOdd_FillType);
1446     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1447     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1448     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1449     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1450     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1451     testSimplify(reporter, path, filename);
1452 }
1453
1454 static void testLine68h(skiatest::Reporter* reporter, const char* filename) {
1455     SkPath path;
1456     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1457     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1458     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1459     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1460     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1461     testSimplify(reporter, path, filename);
1462 }
1463
1464 static void testLine68hx(skiatest::Reporter* reporter, const char* filename) {
1465     SkPath path;
1466     path.setFillType(SkPath::kEvenOdd_FillType);
1467     path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1468     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1469     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1470     path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1471     path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1472     testSimplify(reporter, path, filename);
1473 }
1474
1475 static void testLine69(skiatest::Reporter* reporter, const char* filename) {
1476     SkPath path;
1477     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1478     path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1479     path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1480     testSimplify(reporter, path, filename);
1481 }
1482
1483 static void testLine69x(skiatest::Reporter* reporter, const char* filename) {
1484     SkPath path;
1485     path.setFillType(SkPath::kEvenOdd_FillType);
1486     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1487     path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1488     path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1489     testSimplify(reporter, path, filename);
1490 }
1491
1492 static void testLine70(skiatest::Reporter* reporter, const char* filename) {
1493     SkPath path;
1494     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1495     path.addRect(0, 24, 12, 12, SkPath::kCW_Direction);
1496     path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1497     testSimplify(reporter, path, filename);
1498 }
1499
1500 static void testLine70x(skiatest::Reporter* reporter, const char* filename) {
1501     SkPath path;
1502     path.setFillType(SkPath::kEvenOdd_FillType);
1503     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1504     path.addRect(0, 24, 12, 12, SkPath::kCW_Direction);
1505     path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1506     testSimplify(reporter, path, filename);
1507 }
1508
1509 static void testLine71(skiatest::Reporter* reporter, const char* filename) {
1510     SkPath path;
1511     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1512     path.addRect(12, 0, 24, 24, SkPath::kCW_Direction);
1513     path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1514     testSimplify(reporter, path, filename);
1515 }
1516
1517 static void testLine71x(skiatest::Reporter* reporter, const char* filename) {
1518     SkPath path;
1519     path.setFillType(SkPath::kEvenOdd_FillType);
1520     path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1521     path.addRect(12, 0, 24, 24, SkPath::kCW_Direction);
1522     path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1523     testSimplify(reporter, path, filename);
1524 }
1525
1526 static void testLine72(skiatest::Reporter* reporter, const char* filename) {
1527     SkPath path;
1528     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1529     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1530     path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1531     testSimplify(reporter, path, filename);
1532 }
1533
1534 static void testLine72x(skiatest::Reporter* reporter, const char* filename) {
1535     SkPath path;
1536     path.setFillType(SkPath::kEvenOdd_FillType);
1537     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1538     path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1539     path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1540     testSimplify(reporter, path, filename);
1541 }
1542
1543 static void testLine73(skiatest::Reporter* reporter, const char* filename) {
1544     SkPath path;
1545     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1546     path.addRect(0, 40, 20, 20, SkPath::kCW_Direction);
1547     path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1548     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
1549     testSimplify(reporter, path, filename);
1550 }
1551
1552 static void testLine73x(skiatest::Reporter* reporter, const char* filename) {
1553     SkPath path;
1554     path.setFillType(SkPath::kEvenOdd_FillType);
1555     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1556     path.addRect(0, 40, 20, 20, SkPath::kCW_Direction);
1557     path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1558     path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
1559     testSimplify(reporter, path, filename);
1560 }
1561
1562 static void testLine74(skiatest::Reporter* reporter, const char* filename) {
1563     SkPath path;
1564     path.addRect(20, 30, 40, 40, SkPath::kCW_Direction);
1565     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1566     path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
1567     testSimplify(reporter, path, filename);
1568 }
1569
1570 static void testLine74x(skiatest::Reporter* reporter, const char* filename) {
1571     SkPath path;
1572     path.setFillType(SkPath::kEvenOdd_FillType);
1573     path.addRect(20, 30, 40, 40, SkPath::kCW_Direction);
1574     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1575     path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
1576     testSimplify(reporter, path, filename);
1577 }
1578
1579 static void testLine75(skiatest::Reporter* reporter, const char* filename) {
1580     SkPath path;
1581     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1582     path.addRect(10, 0, 30, 30, SkPath::kCCW_Direction);
1583     path.addRect(18, 0, 30, 30, SkPath::kCCW_Direction);
1584     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1585     testSimplify(reporter, path, filename);
1586 }
1587
1588 static void testLine75x(skiatest::Reporter* reporter, const char* filename) {
1589     SkPath path;
1590     path.setFillType(SkPath::kEvenOdd_FillType);
1591     path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1592     path.addRect(10, 0, 30, 30, SkPath::kCCW_Direction);
1593     path.addRect(18, 0, 30, 30, SkPath::kCCW_Direction);
1594     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1595     testSimplify(reporter, path, filename);
1596 }
1597
1598 static void testLine76(skiatest::Reporter* reporter, const char* filename) {
1599     SkPath path;
1600     path.addRect(36, 0, 66, 60, SkPath::kCW_Direction);
1601     path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
1602     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1603     path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1604     testSimplify(reporter, path, filename);
1605 }
1606
1607 static void testLine76x(skiatest::Reporter* reporter, const char* filename) {
1608     SkPath path;
1609     path.setFillType(SkPath::kEvenOdd_FillType);
1610     path.addRect(36, 0, 66, 60, SkPath::kCW_Direction);
1611     path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
1612     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1613     path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1614     testSimplify(reporter, path, filename);
1615 }
1616
1617 static void testLine77(skiatest::Reporter* reporter, const char* filename) {
1618     SkPath path;
1619     path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1620     path.addRect(24, 6, 36, 36, SkPath::kCCW_Direction);
1621     path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
1622     testSimplify(reporter, path, filename);
1623 }
1624
1625 static void testLine77x(skiatest::Reporter* reporter, const char* filename) {
1626     SkPath path;
1627     path.setFillType(SkPath::kEvenOdd_FillType);
1628     path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1629     path.addRect(24, 6, 36, 36, SkPath::kCCW_Direction);
1630     path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
1631     testSimplify(reporter, path, filename);
1632 }
1633
1634 static void testLine78(skiatest::Reporter* reporter, const char* filename) {
1635     SkPath path;
1636     path.addRect(0, 0, 30, 60, SkPath::kCW_Direction);
1637     path.addRect(10, 20, 30, 30, SkPath::kCCW_Direction);
1638     path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
1639     path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
1640     testSimplify(reporter, path, filename);
1641 }
1642
1643 static void testLine78x(skiatest::Reporter* reporter, const char* filename) {
1644     SkPath path;
1645     path.setFillType(SkPath::kEvenOdd_FillType);
1646     path.addRect(0, 0, 30, 60, SkPath::kCW_Direction);
1647     path.addRect(10, 20, 30, 30, SkPath::kCCW_Direction);
1648     path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
1649     path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
1650     testSimplify(reporter, path, filename);
1651 }
1652
1653 static void testLine79(skiatest::Reporter* reporter, const char* filename) {
1654     SkPath path;
1655     path.addRect(0, 36, 60, 30, SkPath::kCW_Direction);
1656     path.addRect(10, 30, 40, 30, SkPath::kCW_Direction);
1657     path.addRect(0, 20, 12, 30, SkPath::kCCW_Direction);
1658     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1659     testSimplify(reporter, path, filename);
1660 }
1661
1662 static void testLine79x(skiatest::Reporter* reporter, const char* filename) {
1663     SkPath path;
1664     path.setFillType(SkPath::kEvenOdd_FillType);
1665     path.addRect(0, 36, 60, 30, SkPath::kCW_Direction);
1666     path.addRect(10, 30, 40, 30, SkPath::kCW_Direction);
1667     path.addRect(0, 20, 12, 30, SkPath::kCCW_Direction);
1668     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1669     testSimplify(reporter, path, filename);
1670 }
1671
1672 static void testLine81(skiatest::Reporter* reporter, const char* filename) {
1673     SkPath path;
1674     path.addRect(-1, -1, 3, 3, SkPath::kCW_Direction);
1675     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1676     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1677     path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1678     path.addRect(1, 1, 2, 2, SkPath::kCCW_Direction);
1679     testSimplify(reporter, path, filename);
1680 }
1681
1682 static void testDegenerate1(skiatest::Reporter* reporter, const char* filename) {
1683     SkPath path;
1684     path.moveTo(0, 0);
1685     path.lineTo(0, 0);
1686     path.lineTo(2, 0);
1687     path.close();
1688     path.moveTo(0, 0);
1689     path.lineTo(1, 0);
1690     path.lineTo(2, 0);
1691     path.close();
1692     testSimplify(reporter, path, filename);
1693 }
1694
1695 static void testDegenerate1x(skiatest::Reporter* reporter, const char* filename) {
1696     SkPath path;
1697     path.setFillType(SkPath::kEvenOdd_FillType);
1698     path.moveTo(0, 0);
1699     path.lineTo(0, 0);
1700     path.lineTo(2, 0);
1701     path.close();
1702     path.moveTo(0, 0);
1703     path.lineTo(1, 0);
1704     path.lineTo(2, 0);
1705     path.close();
1706     testSimplify(reporter, path, filename);
1707 }
1708
1709 static void testDegenerate2(skiatest::Reporter* reporter, const char* filename) {
1710     SkPath path;
1711     path.moveTo(0, 0);
1712     path.lineTo(0, 0);
1713     path.lineTo(0, 0);
1714     path.close();
1715     path.moveTo(0, 0);
1716     path.lineTo(1, 0);
1717     path.lineTo(0, 1);
1718     path.close();
1719     testSimplify(reporter, path, filename);
1720 }
1721
1722 static void testDegenerate2x(skiatest::Reporter* reporter, const char* filename) {
1723     SkPath path;
1724     path.setFillType(SkPath::kEvenOdd_FillType);
1725     path.moveTo(0, 0);
1726     path.lineTo(0, 0);
1727     path.lineTo(0, 0);
1728     path.close();
1729     path.moveTo(0, 0);
1730     path.lineTo(1, 0);
1731     path.lineTo(0, 1);
1732     path.close();
1733     testSimplify(reporter, path, filename);
1734 }
1735
1736 static void testDegenerate3(skiatest::Reporter* reporter, const char* filename) {
1737     SkPath path;
1738     path.moveTo(0, 0);
1739     path.lineTo(2, 0);
1740     path.lineTo(1, 0);
1741     path.close();
1742     path.moveTo(0, 0);
1743     path.lineTo(0, 0);
1744     path.lineTo(3, 0);
1745     path.close();
1746     testSimplify(reporter, path, filename);
1747 }
1748
1749 static void testDegenerate3x(skiatest::Reporter* reporter, const char* filename) {
1750     SkPath path;
1751     path.setFillType(SkPath::kEvenOdd_FillType);
1752     path.moveTo(0, 0);
1753     path.lineTo(2, 0);
1754     path.lineTo(1, 0);
1755     path.close();
1756     path.moveTo(0, 0);
1757     path.lineTo(0, 0);
1758     path.lineTo(3, 0);
1759     path.close();
1760     testSimplify(reporter, path, filename);
1761 }
1762
1763 static void testDegenerate4(skiatest::Reporter* reporter, const char* filename) {
1764     SkPath path;
1765     path.moveTo(0, 0);
1766     path.lineTo(1, 0);
1767     path.lineTo(1, 3);
1768     path.close();
1769     path.moveTo(1, 0);
1770     path.lineTo(1, 1);
1771     path.lineTo(1, 2);
1772     path.close();
1773     testSimplify(reporter, path, filename);
1774 }
1775
1776 static void testDegenerate4x(skiatest::Reporter* reporter, const char* filename) {
1777     SkPath path;
1778     path.setFillType(SkPath::kEvenOdd_FillType);
1779     path.moveTo(0, 0);
1780     path.lineTo(1, 0);
1781     path.lineTo(1, 3);
1782     path.close();
1783     path.moveTo(1, 0);
1784     path.lineTo(1, 1);
1785     path.lineTo(1, 2);
1786     path.close();
1787     testSimplify(reporter, path, filename);
1788 }
1789
1790 static void testNondegenerate1(skiatest::Reporter* reporter, const char* filename) {
1791     SkPath path;
1792     path.moveTo(0, 0);
1793     path.lineTo(3, 0);
1794     path.lineTo(1, 3);
1795     path.close();
1796     path.moveTo(1, 1);
1797     path.lineTo(2, 1);
1798     path.lineTo(1, 2);
1799     path.close();
1800     testSimplify(reporter, path, filename);
1801 }
1802
1803 static void testNondegenerate1x(skiatest::Reporter* reporter, const char* filename) {
1804     SkPath path;
1805     path.setFillType(SkPath::kEvenOdd_FillType);
1806     path.moveTo(0, 0);
1807     path.lineTo(3, 0);
1808     path.lineTo(1, 3);
1809     path.close();
1810     path.moveTo(1, 1);
1811     path.lineTo(2, 1);
1812     path.lineTo(1, 2);
1813     path.close();
1814     testSimplify(reporter, path, filename);
1815 }
1816
1817 static void testNondegenerate2(skiatest::Reporter* reporter, const char* filename) {
1818     SkPath path;
1819     path.moveTo(1, 0);
1820     path.lineTo(0, 1);
1821     path.lineTo(1, 1);
1822     path.close();
1823     path.moveTo(0, 2);
1824     path.lineTo(0, 3);
1825     path.lineTo(1, 2);
1826     path.close();
1827     testSimplify(reporter, path, filename);
1828 }
1829
1830 static void testNondegenerate2x(skiatest::Reporter* reporter, const char* filename) {
1831     SkPath path;
1832     path.setFillType(SkPath::kEvenOdd_FillType);
1833     path.moveTo(1, 0);
1834     path.lineTo(0, 1);
1835     path.lineTo(1, 1);
1836     path.close();
1837     path.moveTo(0, 2);
1838     path.lineTo(0, 3);
1839     path.lineTo(1, 2);
1840     path.close();
1841     testSimplify(reporter, path, filename);
1842 }
1843
1844 static void testNondegenerate3(skiatest::Reporter* reporter, const char* filename) {
1845     SkPath path;
1846     path.moveTo(0, 0);
1847     path.lineTo(1, 0);
1848     path.lineTo(2, 1);
1849     path.close();
1850     path.moveTo(0, 1);
1851     path.lineTo(1, 1);
1852     path.lineTo(0, 2);
1853     path.close();
1854     testSimplify(reporter, path, filename);
1855 }
1856
1857 static void testNondegenerate3x(skiatest::Reporter* reporter, const char* filename) {
1858     SkPath path;
1859     path.setFillType(SkPath::kEvenOdd_FillType);
1860     path.moveTo(0, 0);
1861     path.lineTo(1, 0);
1862     path.lineTo(2, 1);
1863     path.close();
1864     path.moveTo(0, 1);
1865     path.lineTo(1, 1);
1866     path.lineTo(0, 2);
1867     path.close();
1868     testSimplify(reporter, path, filename);
1869 }
1870
1871 static void testNondegenerate4(skiatest::Reporter* reporter, const char* filename) {
1872     SkPath path;
1873     path.moveTo(1, 0);
1874     path.lineTo(0, 1);
1875     path.lineTo(1, 2);
1876     path.close();
1877     path.moveTo(0, 2);
1878     path.lineTo(0, 3);
1879     path.lineTo(1, 3);
1880     path.close();
1881     testSimplify(reporter, path, filename);
1882 }
1883
1884 static void testNondegenerate4x(skiatest::Reporter* reporter, const char* filename) {
1885     SkPath path;
1886     path.setFillType(SkPath::kEvenOdd_FillType);
1887     path.moveTo(1, 0);
1888     path.lineTo(0, 1);
1889     path.lineTo(1, 2);
1890     path.close();
1891     path.moveTo(0, 2);
1892     path.lineTo(0, 3);
1893     path.lineTo(1, 3);
1894     path.close();
1895     testSimplify(reporter, path, filename);
1896 }
1897
1898 static void testQuadralateral5(skiatest::Reporter* reporter, const char* filename) {
1899     SkPath path;
1900     path.moveTo(0, 0);
1901     path.lineTo(0, 0);
1902     path.lineTo(1, 0);
1903     path.lineTo(1, 1);
1904     path.close();
1905     path.moveTo(0, 0);
1906     path.lineTo(2, 2);
1907     path.lineTo(3, 2);
1908     path.lineTo(3, 3);
1909     path.close();
1910     testSimplify(reporter, path, filename);
1911 }
1912
1913 static void testQuadralateral5x(skiatest::Reporter* reporter, const char* filename) {
1914     SkPath path;
1915     path.setFillType(SkPath::kEvenOdd_FillType);
1916     path.moveTo(0, 0);
1917     path.lineTo(0, 0);
1918     path.lineTo(1, 0);
1919     path.lineTo(1, 1);
1920     path.close();
1921     path.moveTo(0, 0);
1922     path.lineTo(2, 2);
1923     path.lineTo(3, 2);
1924     path.lineTo(3, 3);
1925     path.close();
1926     testSimplify(reporter, path, filename);
1927 }
1928
1929 static void testQuadralateral6(skiatest::Reporter* reporter, const char* filename) {
1930     SkPath path;
1931     path.moveTo(0, 0);
1932     path.lineTo(0, 0);
1933     path.lineTo(1, 0);
1934     path.lineTo(1, 1);
1935     path.close();
1936     path.moveTo(1, 0);
1937     path.lineTo(2, 0);
1938     path.lineTo(0, 2);
1939     path.lineTo(2, 2);
1940     path.close();
1941     testSimplify(reporter, path, filename);
1942 }
1943
1944 static void testQuadralateral6x(skiatest::Reporter* reporter, const char* filename) {
1945     SkPath path;
1946     path.setFillType(SkPath::kEvenOdd_FillType);
1947     path.moveTo(0, 0);
1948     path.lineTo(0, 0);
1949     path.lineTo(1, 0);
1950     path.lineTo(1, 1);
1951     path.close();
1952     path.moveTo(1, 0);
1953     path.lineTo(2, 0);
1954     path.lineTo(0, 2);
1955     path.lineTo(2, 2);
1956     path.close();
1957     testSimplify(reporter, path, filename);
1958 }
1959
1960 static void testFauxQuadralateral6(skiatest::Reporter* reporter, const char* filename) {
1961     SkPath path;
1962     path.moveTo(0, 0);
1963     path.lineTo(1, 0);
1964     path.lineTo(1, 1);
1965     path.close();
1966     path.moveTo(1, 0);
1967     path.lineTo(2, 0);
1968     path.lineTo(1 + 1.0f/3, 2.0f/3);
1969     path.close();
1970     path.moveTo(1 + 1.0f/3, 2.0f/3);
1971     path.lineTo(0, 2);
1972     path.lineTo(2, 2);
1973     path.close();
1974     testSimplify(reporter, path, filename);
1975 }
1976
1977 static void testFauxQuadralateral6x(skiatest::Reporter* reporter, const char* filename) {
1978     SkPath path;
1979     path.setFillType(SkPath::kEvenOdd_FillType);
1980     path.moveTo(0, 0);
1981     path.lineTo(1, 0);
1982     path.lineTo(1, 1);
1983     path.close();
1984     path.moveTo(1, 0);
1985     path.lineTo(2, 0);
1986     path.lineTo(1 + 1.0f/3, 2.0f/3);
1987     path.close();
1988     path.moveTo(1 + 1.0f/3, 2.0f/3);
1989     path.lineTo(0, 2);
1990     path.lineTo(2, 2);
1991     path.close();
1992     testSimplify(reporter, path, filename);
1993 }
1994
1995 static void testFauxQuadralateral6a(skiatest::Reporter* reporter, const char* filename) {
1996     SkPath path;
1997     path.moveTo(0, 0);
1998     path.lineTo(3, 0);
1999     path.lineTo(3, 3);
2000     path.close();
2001     path.moveTo(3, 0);
2002     path.lineTo(6, 0);
2003     path.lineTo(4, 2);
2004     path.close();
2005     path.moveTo(4, 2);
2006     path.lineTo(0, 6);
2007     path.lineTo(6, 6);
2008     path.close();
2009     testSimplify(reporter, path, filename);
2010 }
2011
2012 static void testFauxQuadralateral6ax(skiatest::Reporter* reporter, const char* filename) {
2013     SkPath path;
2014     path.setFillType(SkPath::kEvenOdd_FillType);
2015     path.moveTo(0, 0);
2016     path.lineTo(3, 0);
2017     path.lineTo(3, 3);
2018     path.close();
2019     path.moveTo(3, 0);
2020     path.lineTo(6, 0);
2021     path.lineTo(4, 2);
2022     path.close();
2023     path.moveTo(4, 2);
2024     path.lineTo(0, 6);
2025     path.lineTo(6, 6);
2026     path.close();
2027     testSimplify(reporter, path, filename);
2028 }
2029
2030 static void testFauxQuadralateral6b(skiatest::Reporter* reporter, const char* filename) {
2031     SkPath path;
2032     path.moveTo(0, 0);
2033     path.lineTo(3, 0);
2034     path.lineTo(3, 3);
2035     path.close();
2036     path.moveTo(3, 0);
2037     path.lineTo(6, 0);
2038     path.lineTo(4, 2);
2039     path.close();
2040     path.moveTo(4, 2);
2041     path.lineTo(6, 6);
2042     path.lineTo(0, 6);
2043     path.close();
2044     testSimplify(reporter, path, filename);
2045 }
2046
2047 static void testFauxQuadralateral6bx(skiatest::Reporter* reporter, const char* filename) {
2048     SkPath path;
2049     path.setFillType(SkPath::kEvenOdd_FillType);
2050     path.moveTo(0, 0);
2051     path.lineTo(3, 0);
2052     path.lineTo(3, 3);
2053     path.close();
2054     path.moveTo(3, 0);
2055     path.lineTo(6, 0);
2056     path.lineTo(4, 2);
2057     path.close();
2058     path.moveTo(4, 2);
2059     path.lineTo(6, 6);
2060     path.lineTo(0, 6);
2061     path.close();
2062     testSimplify(reporter, path, filename);
2063 }
2064
2065 static void testFauxQuadralateral6c(skiatest::Reporter* reporter, const char* filename) {
2066     SkPath path;
2067     path.moveTo(0, 0);
2068     path.lineTo(3, 3);
2069     path.lineTo(3, 0);
2070     path.close();
2071     path.moveTo(3, 0);
2072     path.lineTo(6, 0);
2073     path.lineTo(4, 2);
2074     path.close();
2075     path.moveTo(4, 2);
2076     path.lineTo(0, 6);
2077     path.lineTo(6, 6);
2078     path.close();
2079     testSimplify(reporter, path, filename);
2080 }
2081
2082 static void testFauxQuadralateral6cx(skiatest::Reporter* reporter, const char* filename) {
2083     SkPath path;
2084     path.setFillType(SkPath::kEvenOdd_FillType);
2085     path.moveTo(0, 0);
2086     path.lineTo(3, 3);
2087     path.lineTo(3, 0);
2088     path.close();
2089     path.moveTo(3, 0);
2090     path.lineTo(6, 0);
2091     path.lineTo(4, 2);
2092     path.close();
2093     path.moveTo(4, 2);
2094     path.lineTo(0, 6);
2095     path.lineTo(6, 6);
2096     path.close();
2097     testSimplify(reporter, path, filename);
2098 }
2099
2100 static void testFauxQuadralateral6d(skiatest::Reporter* reporter, const char* filename) {
2101     SkPath path;
2102     path.moveTo(0, 0);
2103     path.lineTo(3, 3);
2104     path.lineTo(3, 0);
2105     path.close();
2106     path.moveTo(3, 0);
2107     path.lineTo(6, 0);
2108     path.lineTo(4, 2);
2109     path.close();
2110     path.moveTo(4, 2);
2111     path.lineTo(6, 6);
2112     path.lineTo(0, 6);
2113     path.close();
2114     testSimplify(reporter, path, filename);
2115 }
2116
2117 static void testFauxQuadralateral6dx(skiatest::Reporter* reporter, const char* filename) {
2118     SkPath path;
2119     path.setFillType(SkPath::kEvenOdd_FillType);
2120     path.moveTo(0, 0);
2121     path.lineTo(3, 3);
2122     path.lineTo(3, 0);
2123     path.close();
2124     path.moveTo(3, 0);
2125     path.lineTo(6, 0);
2126     path.lineTo(4, 2);
2127     path.close();
2128     path.moveTo(4, 2);
2129     path.lineTo(6, 6);
2130     path.lineTo(0, 6);
2131     path.close();
2132     testSimplify(reporter, path, filename);
2133 }
2134
2135 static void testQuadralateral6a(skiatest::Reporter* reporter, const char* filename) {
2136     SkPath path;
2137     path.moveTo(0, 0);
2138     path.lineTo(0, 0);
2139     path.lineTo(3, 0);
2140     path.lineTo(3, 3);
2141     path.close();
2142     path.moveTo(3, 0);
2143     path.lineTo(6, 0);
2144     path.lineTo(0, 6);
2145     path.lineTo(6, 6);
2146     path.close();
2147     testSimplify(reporter, path, filename);
2148 }
2149
2150 static void testQuadralateral6ax(skiatest::Reporter* reporter, const char* filename) {
2151     SkPath path;
2152     path.setFillType(SkPath::kEvenOdd_FillType);
2153     path.moveTo(0, 0);
2154     path.lineTo(0, 0);
2155     path.lineTo(3, 0);
2156     path.lineTo(3, 3);
2157     path.close();
2158     path.moveTo(3, 0);
2159     path.lineTo(6, 0);
2160     path.lineTo(0, 6);
2161     path.lineTo(6, 6);
2162     path.close();
2163     testSimplify(reporter, path, filename);
2164 }
2165
2166 static void testQuadralateral7(skiatest::Reporter* reporter, const char* filename) {
2167     SkPath path;
2168     path.moveTo(0, 0);
2169     path.lineTo(0, 0);
2170     path.lineTo(1, 0);
2171     path.lineTo(2, 1);
2172     path.close();
2173     path.moveTo(1, 0);
2174     path.lineTo(1, 1);
2175     path.lineTo(2, 2);
2176     path.lineTo(1, 3);
2177     path.close();
2178     testSimplify(reporter, path, filename);
2179 }
2180
2181 static void testQuadralateral7x(skiatest::Reporter* reporter, const char* filename) {
2182     SkPath path;
2183     path.setFillType(SkPath::kEvenOdd_FillType);
2184     path.moveTo(0, 0);
2185     path.lineTo(0, 0);
2186     path.lineTo(1, 0);
2187     path.lineTo(2, 1);
2188     path.close();
2189     path.moveTo(1, 0);
2190     path.lineTo(1, 1);
2191     path.lineTo(2, 2);
2192     path.lineTo(1, 3);
2193     path.close();
2194     testSimplify(reporter, path, filename);
2195 }
2196
2197 static void testQuadralateral8(skiatest::Reporter* reporter, const char* filename) {
2198     SkPath path;
2199     path.moveTo(0, 0);
2200     path.lineTo(3, 1);
2201     path.lineTo(1, 3);
2202     path.lineTo(3, 3);
2203     path.close();
2204     path.moveTo(2, 1);
2205     path.lineTo(0, 2);
2206     path.lineTo(3, 2);
2207     path.lineTo(2, 3);
2208     path.close();
2209     testSimplify(reporter, path, filename);
2210 }
2211
2212 static void testQuadralateral8x(skiatest::Reporter* reporter, const char* filename) {
2213     SkPath path;
2214     path.setFillType(SkPath::kEvenOdd_FillType);
2215     path.moveTo(0, 0);
2216     path.lineTo(3, 1);
2217     path.lineTo(1, 3);
2218     path.lineTo(3, 3);
2219     path.close();
2220     path.moveTo(2, 1);
2221     path.lineTo(0, 2);
2222     path.lineTo(3, 2);
2223     path.lineTo(2, 3);
2224     path.close();
2225     testSimplify(reporter, path, filename);
2226 }
2227
2228 static void testQuadralateral9(skiatest::Reporter* reporter, const char* filename) {
2229     SkPath path;
2230     path.moveTo(0, 0);
2231     path.lineTo(1, 0);
2232     path.lineTo(1, 2);
2233     path.lineTo(2, 2);
2234     path.close();
2235     path.moveTo(1, 1);
2236     path.lineTo(2, 1);
2237     path.lineTo(1, 3);
2238     path.lineTo(2, 3);
2239     path.close();
2240     testSimplify(reporter, path, filename);
2241 }
2242
2243 static void testQuadralateral9x(skiatest::Reporter* reporter, const char* filename) {
2244     SkPath path;
2245     path.setFillType(SkPath::kEvenOdd_FillType);
2246     path.moveTo(0, 0);
2247     path.lineTo(1, 0);
2248     path.lineTo(1, 2);
2249     path.lineTo(2, 2);
2250     path.close();
2251     path.moveTo(1, 1);
2252     path.lineTo(2, 1);
2253     path.lineTo(1, 3);
2254     path.lineTo(2, 3);
2255     path.close();
2256     testSimplify(reporter, path, filename);
2257 }
2258
2259 static void testLine1a(skiatest::Reporter* reporter, const char* filename) {
2260     SkPath path;
2261     path.setFillType(SkPath::kWinding_FillType);
2262     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
2263     path.addRect(4, 0, 13, 13, SkPath::kCCW_Direction);
2264     testSimplify(reporter, path, filename);
2265 }
2266
2267 static void testLine1ax(skiatest::Reporter* reporter, const char* filename) {
2268     SkPath path;
2269     path.setFillType(SkPath::kEvenOdd_FillType);
2270     path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
2271     path.addRect(4, 0, 13, 13, SkPath::kCCW_Direction);
2272     testSimplify(reporter, path, filename);
2273 }
2274
2275 static void testLine2ax(skiatest::Reporter* reporter, const char* filename) {
2276     SkPath path;
2277     path.setFillType(SkPath::kEvenOdd_FillType);
2278     path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
2279     path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
2280     path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
2281     testSimplify(reporter, path, filename);
2282 }
2283
2284 static void testLine3aax(skiatest::Reporter* reporter, const char* filename) {
2285     SkPath path;
2286     path.setFillType(SkPath::kEvenOdd_FillType);
2287     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
2288     path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
2289     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
2290     testSimplify(reporter, path, filename);
2291 }
2292
2293 static void testLine4ax(skiatest::Reporter* reporter, const char* filename) {
2294     SkPath path;
2295     path.setFillType(SkPath::kEvenOdd_FillType);
2296     path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
2297     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
2298     path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
2299     testSimplify(reporter, path, filename);
2300 }
2301
2302 static void testQuadratic1(skiatest::Reporter* reporter, const char* filename) {
2303     SkPath path;
2304     path.moveTo(0, 0);
2305     path.quadTo(0, 0, 0, 0);
2306     path.lineTo(1, 0);
2307     path.close();
2308     path.moveTo(0, 0);
2309     path.lineTo(0, 0);
2310     path.quadTo(0, 0, 0, 0);
2311     path.close();
2312     testSimplify(reporter, path, filename);
2313 }
2314
2315 static void testQuadratic1x(skiatest::Reporter* reporter, const char* filename) {
2316     SkPath path;
2317     path.setFillType(SkPath::kEvenOdd_FillType);
2318     path.moveTo(0, 0);
2319     path.quadTo(0, 0, 0, 0);
2320     path.lineTo(1, 0);
2321     path.close();
2322     path.moveTo(0, 0);
2323     path.lineTo(0, 0);
2324     path.quadTo(0, 0, 0, 0);
2325     path.close();
2326     testSimplify(reporter, path, filename);
2327 }
2328
2329 static void testQuadratic2(skiatest::Reporter* reporter, const char* filename) {
2330     SkPath path;
2331     path.moveTo(0, 0);
2332     path.quadTo(0, 0, 0, 0);
2333     path.lineTo(3, 0);
2334     path.close();
2335     path.moveTo(0, 0);
2336     path.lineTo(0, 0);
2337     path.quadTo(1, 0, 0, 1);
2338     path.close();
2339     testSimplify(reporter, path, filename);
2340 }
2341
2342 static void testQuadratic2x(skiatest::Reporter* reporter, const char* filename) {
2343     SkPath path;
2344     path.setFillType(SkPath::kEvenOdd_FillType);
2345     path.moveTo(0, 0);
2346     path.quadTo(0, 0, 0, 0);
2347     path.lineTo(3, 0);
2348     path.close();
2349     path.moveTo(0, 0);
2350     path.lineTo(0, 0);
2351     path.quadTo(1, 0, 0, 1);
2352     path.close();
2353     testSimplify(reporter, path, filename);
2354 }
2355
2356 static void testQuadratic3(skiatest::Reporter* reporter, const char* filename) {
2357     SkPath path;
2358     path.moveTo(0, 0);
2359     path.quadTo(0, 0, 1, 0);
2360     path.lineTo(0, 2);
2361     path.close();
2362     path.moveTo(0, 0);
2363     path.lineTo(0, 0);
2364     path.quadTo(1, 0, 0, 1);
2365     path.close();
2366     testSimplify(reporter, path, filename);
2367 }
2368
2369 static void testQuadratic3x(skiatest::Reporter* reporter, const char* filename) {
2370     SkPath path;
2371     path.setFillType(SkPath::kEvenOdd_FillType);
2372     path.moveTo(0, 0);
2373     path.quadTo(0, 0, 1, 0);
2374     path.lineTo(0, 2);
2375     path.close();
2376     path.moveTo(0, 0);
2377     path.lineTo(0, 0);
2378     path.quadTo(1, 0, 0, 1);
2379     path.close();
2380     testSimplify(reporter, path, filename);
2381 }
2382
2383 static void testQuadratic4(skiatest::Reporter* reporter, const char* filename) {
2384     SkPath path;
2385     path.moveTo(0, 0);
2386     path.quadTo(0, 0, 1, 0);
2387     path.lineTo(0, 2);
2388     path.close();
2389     path.moveTo(0, 0);
2390     path.lineTo(0, 0);
2391     path.quadTo(1, 0, 0, 2);
2392     path.close();
2393     testSimplify(reporter, path, filename);
2394 }
2395
2396 static void testQuadratic4x(skiatest::Reporter* reporter, const char* filename) {
2397     SkPath path;
2398     path.setFillType(SkPath::kEvenOdd_FillType);
2399     path.moveTo(0, 0);
2400     path.quadTo(0, 0, 1, 0);
2401     path.lineTo(0, 2);
2402     path.close();
2403     path.moveTo(0, 0);
2404     path.lineTo(0, 0);
2405     path.quadTo(1, 0, 0, 2);
2406     path.close();
2407     testSimplify(reporter, path, filename);
2408 }
2409
2410 static void testQuadratic5(skiatest::Reporter* reporter, const char* filename) {
2411     SkPath path;
2412     path.moveTo(0, 0);
2413     path.quadTo(0, 0, 0, 0);
2414     path.lineTo(0, 1);
2415     path.close();
2416     path.moveTo(0, 0);
2417     path.lineTo(1, 0);
2418     path.quadTo(0, 1, 0, 2);
2419     path.close();
2420     testSimplify(reporter, path, filename);
2421 }
2422
2423 static void testQuadratic6(skiatest::Reporter* reporter, const char* filename) {
2424     SkPath path;
2425     path.moveTo(0, 0);
2426     path.quadTo(0, 0, 1, 0);
2427     path.lineTo(2, 1);
2428     path.close();
2429     path.moveTo(0, 0);
2430     path.lineTo(0, 0);
2431     path.quadTo(2, 0, 0, 1);
2432     path.close();
2433     testSimplify(reporter, path, filename);
2434 }
2435
2436 static void testQuadratic7(skiatest::Reporter* reporter, const char* filename) {
2437     SkPath path;
2438     path.moveTo(0, 0);
2439     path.quadTo(0, 0, 1, 0);
2440     path.lineTo(3, 1);
2441     path.close();
2442     path.moveTo(0, 0);
2443     path.lineTo(0, 0);
2444     path.quadTo(3, 0, 1, 2);
2445     path.close();
2446     testSimplify(reporter, path, filename);
2447 }
2448
2449 static void testQuadratic8(skiatest::Reporter* reporter, const char* filename) {
2450     SkPath path;
2451     path.moveTo(0, 0);
2452     path.quadTo(0, 0, 1, 0);
2453     path.lineTo(0, 2);
2454     path.close();
2455     path.moveTo(0, 0);
2456     path.lineTo(1, 0);
2457     path.quadTo(0, 1, 1, 2);
2458     path.close();
2459     testSimplify(reporter, path, filename);
2460 }
2461
2462 static void testQuadratic9(skiatest::Reporter* reporter, const char* filename) {
2463     SkPath path;
2464     path.moveTo(0, 0);
2465     path.quadTo(0, 0, 1, 0);
2466     path.lineTo(3, 1);
2467     path.close();
2468     path.moveTo(0, 0);
2469     path.lineTo(1, 0);
2470     path.quadTo(1, 2, 3, 2);
2471     path.close();
2472     testSimplify(reporter, path, filename);
2473 }
2474
2475 static void testQuadratic14(skiatest::Reporter* reporter, const char* filename) {
2476     SkPath path;
2477     path.moveTo(0, 0);
2478     path.quadTo(0, 0, 1, 0);
2479     path.lineTo(3, 2);
2480     path.close();
2481     path.moveTo(0, 0);
2482     path.lineTo(1, 0);
2483     path.quadTo(3, 2, 3, 3);
2484     path.close();
2485     testSimplify(reporter, path, filename);
2486 }
2487
2488 static void testQuadratic15(skiatest::Reporter* reporter, const char* filename) {
2489     SkPath path;
2490     path.moveTo(0, 0);
2491     path.quadTo(0, 0, 1, 0);
2492     path.lineTo(1, 3);
2493     path.close();
2494     path.moveTo(1, 0);
2495     path.lineTo(0, 1);
2496     path.quadTo(1, 1, 0, 3);
2497     path.close();
2498     testSimplify(reporter, path, filename);
2499 }
2500
2501 static void testQuadratic17x(skiatest::Reporter* reporter, const char* filename) {
2502     SkPath path;
2503     path.setFillType(SkPath::kEvenOdd_FillType);
2504     path.moveTo(0, 0);
2505     path.quadTo(0, 0, 3, 1);
2506     path.lineTo(0, 2);
2507     path.close();
2508     path.moveTo(0, 0);
2509     path.lineTo(1, 0);
2510     path.quadTo(3, 1, 0, 2);
2511     path.close();
2512     testSimplify(reporter, path, filename);
2513 }
2514
2515 static void testQuadratic18(skiatest::Reporter* reporter, const char* filename) {
2516     SkPath path;
2517     path.moveTo(0, 0);
2518     path.quadTo(1, 0, 0, 1);
2519     path.lineTo(0, 1);
2520     path.close();
2521     path.moveTo(0, 0);
2522     path.lineTo(0, 0);
2523     path.quadTo(1, 0, 1, 1);
2524     path.close();
2525     testSimplify(reporter, path, filename);
2526 }
2527
2528 static void testQuadratic19(skiatest::Reporter* reporter, const char* filename) {
2529     SkPath path;
2530     path.moveTo(0, 0);
2531     path.quadTo(1, 0, 0, 1);
2532     path.lineTo(0, 1);
2533     path.close();
2534     path.moveTo(0, 0);
2535     path.lineTo(0, 0);
2536     path.quadTo(2, 0, 0, 1);
2537     path.close();
2538     testSimplify(reporter, path, filename);
2539 }
2540
2541 static void testQuadratic20(skiatest::Reporter* reporter, const char* filename) {
2542     SkPath path;
2543     path.moveTo(0, 0);
2544     path.quadTo(1, 0, 0, 1);
2545     path.lineTo(0, 1);
2546     path.close();
2547     path.moveTo(0, 0);
2548     path.lineTo(0, 0);
2549     path.quadTo(1, 0, 0, 1);
2550     path.close();
2551     testSimplify(reporter, path, filename);
2552 }
2553
2554 static void testQuadratic21(skiatest::Reporter* reporter, const char* filename) {
2555     SkPath path;
2556     path.moveTo(0, 0);
2557     path.quadTo(1, 0, 0, 1);
2558     path.lineTo(0, 1);
2559     path.close();
2560     path.moveTo(0, 0);
2561     path.lineTo(0, 0);
2562     path.quadTo(1, 0, 0, 2);
2563     path.close();
2564     testSimplify(reporter, path, filename);
2565 }
2566
2567 static void testQuadratic22(skiatest::Reporter* reporter, const char* filename) {
2568     SkPath path;
2569     path.moveTo(0, 0);
2570     path.quadTo(1, 0, 0, 1);
2571     path.lineTo(0, 1);
2572     path.close();
2573     path.moveTo(0, 0);
2574     path.lineTo(0, 0);
2575     path.quadTo(0, 1, 2, 1);
2576     path.close();
2577     testSimplify(reporter, path, filename);
2578 }
2579
2580 static void testQuadratic23(skiatest::Reporter* reporter, const char* filename) {
2581     SkPath path;
2582     path.moveTo(0, 0);
2583     path.quadTo(1, 0, 0, 1);
2584     path.lineTo(0, 1);
2585     path.close();
2586     path.moveTo(0, 0);
2587     path.lineTo(0, 0);
2588     path.quadTo(0, 2, 1, 2);
2589     path.close();
2590     testSimplify(reporter, path, filename);
2591 }
2592
2593 static void testQuadratic24(skiatest::Reporter* reporter, const char* filename) {
2594     SkPath path;
2595     path.moveTo(0, 0);
2596     path.quadTo(1, 0, 0, 1);
2597     path.lineTo(0, 1);
2598     path.close();
2599     path.moveTo(0, 0);
2600     path.lineTo(1, 0);
2601     path.quadTo(2, 0, 0, 1);
2602     path.close();
2603     testSimplify(reporter, path, filename);
2604 }
2605
2606 static void testQuadratic25(skiatest::Reporter* reporter, const char* filename) {
2607     SkPath path;
2608     path.moveTo(0, 0);
2609     path.quadTo(1, 0, 1, 1);
2610     path.lineTo(1, 1);
2611     path.close();
2612     path.moveTo(0, 0);
2613     path.lineTo(0, 0);
2614     path.quadTo(2, 1, 0, 2);
2615     path.close();
2616     testSimplify(reporter, path, filename);
2617 }
2618
2619 static void testQuadratic26(skiatest::Reporter* reporter, const char* filename) {
2620     SkPath path;
2621     path.moveTo(0, 0);
2622     path.quadTo(1, 0, 1, 1);
2623     path.lineTo(0, 2);
2624     path.close();
2625     path.moveTo(0, 0);
2626     path.lineTo(0, 0);
2627     path.quadTo(1, 0, 0, 1);
2628     path.close();
2629     testSimplify(reporter, path, filename);
2630 }
2631
2632 static void testQuadratic27(skiatest::Reporter* reporter, const char* filename) {
2633     SkPath path;
2634     path.moveTo(0, 0);
2635     path.quadTo(1, 0, 1, 1);
2636     path.lineTo(2, 1);
2637     path.close();
2638     path.moveTo(0, 0);
2639     path.lineTo(0, 0);
2640     path.quadTo(2, 1, 0, 2);
2641     path.close();
2642     testSimplify(reporter, path, filename);
2643 }
2644
2645 static void testQuadratic28(skiatest::Reporter* reporter, const char* filename) {
2646     SkPath path;
2647     path.moveTo(0, 0);
2648     path.quadTo(1, 0, 0, 1);
2649     path.lineTo(0, 1);
2650     path.close();
2651     path.moveTo(0, 0);
2652     path.lineTo(0, 2);
2653     path.quadTo(1, 2, 0, 3);
2654     path.close();
2655     testSimplify(reporter, path, filename);
2656 }
2657
2658 static void testQuadratic29(skiatest::Reporter* reporter, const char* filename) {
2659     SkPath path;
2660     path.moveTo(0, 0);
2661     path.quadTo(1, 0, 2, 1);
2662     path.lineTo(0, 2);
2663     path.close();
2664     path.moveTo(0, 0);
2665     path.lineTo(0, 0);
2666     path.quadTo(1, 0, 0, 1);
2667     path.close();
2668     testSimplify(reporter, path, filename);
2669 }
2670
2671 static void testQuadratic30(skiatest::Reporter* reporter, const char* filename) {
2672     SkPath path;
2673     path.moveTo(0, 0);
2674     path.quadTo(1, 0, 1, 2);
2675     path.lineTo(1, 2);
2676     path.close();
2677     path.moveTo(0, 0);
2678     path.lineTo(1, 0);
2679     path.quadTo(0, 1, 1, 2);
2680     path.close();
2681     testSimplify(reporter, path, filename);
2682 }
2683
2684 static void testQuadratic31(skiatest::Reporter* reporter, const char* filename) {
2685     SkPath path;
2686     path.moveTo(0, 0);
2687     path.quadTo(1, 0, 1, 2);
2688     path.lineTo(1, 2);
2689     path.close();
2690     path.moveTo(0, 0);
2691     path.lineTo(1, 0);
2692     path.quadTo(0, 1, 1, 3);
2693     path.close();
2694     testSimplify(reporter, path, filename);
2695 }
2696
2697 static void testQuadratic32(skiatest::Reporter* reporter, const char* filename) {
2698     SkPath path;
2699     path.moveTo(0, 0);
2700     path.quadTo(1, 0, 2, 3);
2701     path.lineTo(2, 3);
2702     path.close();
2703     path.moveTo(0, 0);
2704     path.lineTo(0, 0);
2705     path.quadTo(3, 1, 0, 2);
2706     path.close();
2707     testSimplify(reporter, path, filename);
2708 }
2709
2710 static void testQuadratic33(skiatest::Reporter* reporter, const char* filename) {
2711     SkPath path;
2712     path.moveTo(0, 0);
2713     path.quadTo(2, 0, 0, 1);
2714     path.lineTo(0, 1);
2715     path.close();
2716     path.moveTo(0, 0);
2717     path.lineTo(1, 1);
2718     path.quadTo(2, 1, 2, 2);
2719     path.close();
2720     testSimplify(reporter, path, filename);
2721 }
2722
2723 static void testQuadratic34(skiatest::Reporter* reporter, const char* filename) {
2724     SkPath path;
2725     path.moveTo(0, 0);
2726     path.quadTo(2, 0, 0, 1);
2727     path.lineTo(0, 1);
2728     path.close();
2729     path.moveTo(1, 0);
2730     path.lineTo(1, 1);
2731     path.quadTo(2, 1, 1, 2);
2732     path.close();
2733     testSimplify(reporter, path, filename);
2734 }
2735
2736 static void testQuadratic35(skiatest::Reporter* reporter, const char* filename) {
2737     SkPath path;
2738     path.moveTo(0, 0);
2739     path.quadTo(0, 1, 1, 1);
2740     path.lineTo(1, 3);
2741     path.close();
2742     path.moveTo(2, 0);
2743     path.lineTo(3, 0);
2744     path.quadTo(0, 1, 1, 1);
2745     path.close();
2746     testSimplify(reporter, path, filename);
2747 }
2748
2749 static void testQuadratic36(skiatest::Reporter* reporter, const char* filename) {
2750     SkPath path;
2751     path.moveTo(0, 0);
2752     path.quadTo(2, 1, 2, 3);
2753     path.lineTo(2, 3);
2754     path.close();
2755     path.moveTo(3, 1);
2756     path.lineTo(1, 2);
2757     path.quadTo(3, 2, 1, 3);
2758     path.close();
2759     testSimplify(reporter, path, filename);
2760 }
2761
2762 static void testQuadratic37(skiatest::Reporter* reporter, const char* filename) {
2763     SkPath path;
2764     path.moveTo(0, 0);
2765     path.quadTo(0, 2, 1, 2);
2766     path.lineTo(1, 2);
2767     path.close();
2768     path.moveTo(0, 0);
2769     path.lineTo(3, 1);
2770     path.quadTo(0, 2, 1, 2);
2771     path.close();
2772     testSimplify(reporter, path, filename);
2773 }
2774
2775 static void testQuadratic38(skiatest::Reporter* reporter, const char* filename) {
2776     SkPath path;
2777     path.moveTo(1, 0);
2778     path.quadTo(0, 1, 1, 1);
2779     path.lineTo(1, 1);
2780     path.close();
2781     path.moveTo(1, 0);
2782     path.lineTo(1, 2);
2783     path.quadTo(2, 2, 1, 3);
2784     path.close();
2785     testSimplify(reporter, path, filename);
2786 }
2787
2788 static void testQuadratic51(skiatest::Reporter* reporter, const char* filename) {
2789     SkPath path;
2790     path.moveTo(369.863983f, 145.645813f);
2791     path.quadTo(382.380371f, 121.254936f, 406.236359f, 121.254936f);
2792     path.lineTo(369.863983f, 145.645813f);
2793     path.close();
2794     path.moveTo(369.970581f, 137.94342f);
2795     path.quadTo(383.98465f, 121.254936f, 406.235992f, 121.254936f);
2796     path.lineTo(369.970581f, 137.94342f);
2797     path.close();
2798     testSimplify(reporter, path, filename);
2799 }
2800
2801 static void testQuadratic53(skiatest::Reporter* reporter, const char* filename) {
2802     SkPath path;
2803     path.moveTo(303.12088f, 141.299606f);
2804     path.lineTo(330.463562f, 217.659027f);
2805     path.lineTo(303.12088f, 141.299606f);
2806     path.close();
2807     path.moveTo(371.919067f, 205.854996f);
2808     path.lineTo(326.236786f, 205.854996f);
2809     path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2810     path.lineTo(371.919067f, 205.854996f);
2811     path.close();
2812     testSimplify(reporter, path, filename);
2813 }
2814
2815 static void testQuadratic55(skiatest::Reporter* reporter, const char* filename) {
2816     SkPath path;
2817 path.moveTo(303.12088f, 141.299606f);
2818 path.lineTo(330.463562f, 217.659027f);
2819 path.lineTo(358.606506f, 141.299606f);
2820 path.lineTo(303.12088f, 141.299606f);
2821 path.close();
2822 path.moveTo(326.236786f, 205.854996f);
2823 path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2824 path.lineTo(326.236786f, 205.854996f);
2825 path.close();
2826     testSimplify(reporter, path, filename);
2827 }
2828
2829 static void testQuadratic56(skiatest::Reporter* reporter, const char* filename) {
2830     SkPath path;
2831 path.moveTo(366.608826f, 151.196014f);
2832 path.quadTo(378.803101f, 136.674606f, 398.164948f, 136.674606f);
2833 path.lineTo(354.009216f, 208.816208f);
2834 path.lineTo(393.291473f, 102.232819f);
2835 path.lineTo(359.978058f, 136.581512f);
2836 path.quadTo(378.315979f, 136.581512f, 388.322723f, 149.613556f);
2837 path.lineTo(364.390686f, 157.898193f);
2838 path.quadTo(375.281769f, 136.674606f, 396.039917f, 136.674606f);
2839 path.lineTo(350, 120);
2840 path.lineTo(366.608826f, 151.196014f);
2841 path.close();
2842     testSimplify(reporter, path, filename);
2843 }
2844
2845 static void testLine80(skiatest::Reporter* reporter, const char* filename) {
2846     SkPath path;
2847 path.moveTo(4, 0);
2848 path.lineTo(3, 7);
2849 path.lineTo(7, 5);
2850 path.lineTo(2, 2);
2851 path.close();
2852 path.moveTo(0, 6);
2853 path.lineTo(6, 12);
2854 path.lineTo(8, 3);
2855 path.close();
2856     testSimplify(reporter, path, filename);
2857 }
2858
2859 static void testQuadratic58(skiatest::Reporter* reporter, const char* filename) {
2860     SkPath path;
2861     path.moveTo(283.714233f, 240);
2862     path.lineTo(283.714233f, 141.299606f);
2863     path.lineTo(303.12088f, 141.299606f);
2864     path.lineTo(330.463562f, 217.659027f);
2865     path.lineTo(358.606506f, 141.299606f);
2866     path.lineTo(362.874634f, 159.705902f);
2867     path.lineTo(335.665344f, 233.397751f);
2868     path.lineTo(322.12738f, 233.397751f);
2869     path.lineTo(295.718353f, 159.505829f);
2870     path.lineTo(295.718353f, 240);
2871     path.lineTo(283.714233f, 240);
2872     path.close();
2873     path.moveTo(322.935669f, 231.030273f);
2874     path.quadTo(312.832214f, 220.393295f, 312.832214f, 203.454178f);
2875     path.quadTo(312.832214f, 186.981888f, 321.73526f, 176.444946f);
2876     path.quadTo(330.638306f, 165.90802f, 344.509705f, 165.90802f);
2877     path.quadTo(357.647522f, 165.90802f, 364.81665f, 175.244537f);
2878     path.lineTo(371.919067f, 205.854996f);
2879     path.lineTo(326.236786f, 205.854996f);
2880     path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2881     path.lineTo(322.935669f, 231.030273f);
2882     path.close();
2883     path.moveTo(326.837006f, 195.984955f);
2884     path.lineTo(358.78125f, 195.984955f);
2885     path.quadTo(358.78125f, 175.778046f, 343.709442f, 175.778046f);
2886     path.quadTo(328.570923f, 175.778046f, 326.837006f, 195.984955f);
2887     path.close();
2888     testSimplify(reporter, path, filename);
2889 }
2890
2891 static void testQuadratic59x(skiatest::Reporter* reporter, const char* filename) {
2892     SkPath path;
2893     path.setFillType(SkPath::kEvenOdd_FillType);
2894     path.moveTo(0, 0);
2895     path.quadTo(0, 0, 0, 0);
2896     path.lineTo(2, 2);
2897     path.close();
2898     path.moveTo(0, 0);
2899     path.lineTo(2, 0);
2900     path.quadTo(3, 1, 1, 2);
2901     path.close();
2902     testSimplify(reporter, path, filename);
2903 }
2904
2905 static void testQuadratic59(skiatest::Reporter* reporter, const char* filename) {
2906     SkPath path;
2907     path.setFillType(SkPath::kWinding_FillType);
2908     path.moveTo(0, 0);
2909     path.quadTo(0, 0, 0, 0);
2910     path.lineTo(2, 2);
2911     path.close();
2912     path.moveTo(0, 0);
2913     path.lineTo(2, 0);
2914     path.quadTo(3, 1, 1, 2);
2915     path.close();
2916     testSimplify(reporter, path, filename);
2917 }
2918
2919 static void testQuadratic63(skiatest::Reporter* reporter, const char* filename) {
2920     SkPath path;
2921     path.moveTo(0, 0);
2922     path.quadTo(0, 0, 0, 0);
2923     path.lineTo(3, 2);
2924     path.close();
2925     path.moveTo(1, 0);
2926     path.lineTo(2, 1);
2927     path.quadTo(2, 1, 2, 2);
2928     path.close();
2929     testSimplify(reporter, path, filename);
2930 }
2931
2932 static void testQuadratic64(skiatest::Reporter* reporter, const char* filename) {
2933     SkPath path;
2934     path.moveTo(0, 0);
2935     path.quadTo(0, 0, 0, 0);
2936     path.lineTo(2, 3);
2937     path.close();
2938     path.moveTo(1, 2);
2939     path.lineTo(2, 2);
2940     path.quadTo(0, 3, 3, 3);
2941     path.close();
2942     testSimplify(reporter, path, filename);
2943 }
2944
2945 static void testQuadratic65(skiatest::Reporter* reporter, const char* filename) {
2946     SkPath path;
2947     path.moveTo(0, 0);
2948     path.quadTo(0, 0, 0, 0);
2949     path.lineTo(3, 2);
2950     path.close();
2951     path.moveTo(2, 1);
2952     path.lineTo(2, 2);
2953     path.quadTo(0, 3, 1, 3);
2954     path.close();
2955     testSimplify(reporter, path, filename);
2956 }
2957
2958 static void testQuadratic67x(skiatest::Reporter* reporter, const char* filename) {
2959     SkPath path;
2960     path.setFillType(SkPath::kEvenOdd_FillType);
2961     path.moveTo(0, 0);
2962     path.quadTo(0, 0, 2, 1);
2963     path.lineTo(2, 2);
2964     path.close();
2965     path.moveTo(0, 0);
2966     path.lineTo(2, 0);
2967     path.quadTo(1, 1, 3, 2);
2968     path.close();
2969     testSimplify(reporter, path, filename);
2970 }
2971
2972 static void testQuadratic68(skiatest::Reporter* reporter, const char* filename) {
2973     SkPath path;
2974     path.moveTo(0, 0);
2975     path.quadTo(1, 0, 0, 1);
2976     path.lineTo(1, 2);
2977     path.close();
2978     path.moveTo(0, 0);
2979     path.lineTo(0, 0);
2980     path.quadTo(0, 1, 2, 1);
2981     path.close();
2982     testSimplify(reporter, path, filename);
2983 }
2984
2985 static void testQuadratic69(skiatest::Reporter* reporter, const char* filename) {
2986     SkPath path;
2987     path.moveTo(0, 0);
2988     path.quadTo(0, 0, 0, 1);
2989     path.lineTo(3, 2);
2990     path.close();
2991     path.moveTo(2, 0);
2992     path.lineTo(1, 1);
2993     path.quadTo(3, 2, 2, 3);
2994     path.close();
2995     testSimplify(reporter, path, filename);
2996 }
2997
2998 static void testQuadratic70x(skiatest::Reporter* reporter, const char* filename) {
2999     SkPath path;
3000     path.setFillType(SkPath::kEvenOdd_FillType);
3001     path.moveTo(0, 0);
3002     path.quadTo(1, 0, 0, 1);
3003     path.lineTo(1, 2);
3004     path.close();
3005     path.moveTo(0, 0);
3006     path.lineTo(0, 0);
3007     path.quadTo(0, 1, 2, 1);
3008     path.close();
3009     testSimplify(reporter, path, filename);
3010 }
3011
3012 static void testQuadratic71(skiatest::Reporter* reporter, const char* filename) {
3013     SkPath path;
3014     path.moveTo(0, 0);
3015     path.quadTo(1, 0, 1, 1);
3016     path.lineTo(3, 2);
3017     path.close();
3018     path.moveTo(0, 0);
3019     path.lineTo(0, 0);
3020     path.quadTo(1, 1, 3, 1);
3021     path.close();
3022     testSimplify(reporter, path, filename);
3023 }
3024
3025 static void testQuadratic72(skiatest::Reporter* reporter, const char* filename) {
3026     SkPath path;
3027     path.moveTo(0, 0);
3028     path.quadTo(1, 0, 1, 2);
3029     path.lineTo(1, 2);
3030     path.close();
3031     path.moveTo(0, 0);
3032     path.lineTo(1, 0);
3033     path.quadTo(0, 1, 3, 2);
3034     path.close();
3035     testSimplify(reporter, path, filename);
3036 }
3037
3038 static void testQuadratic73(skiatest::Reporter* reporter, const char* filename) {
3039     SkPath path;
3040     path.moveTo(0, 0);
3041     path.quadTo(1, 0, 0, 3);
3042     path.lineTo(0, 3);
3043     path.close();
3044     path.moveTo(0, 0);
3045     path.lineTo(1, 0);
3046     path.quadTo(0, 1, 1, 1);
3047     path.close();
3048     testSimplify(reporter, path, filename);
3049 }
3050
3051 static void testQuadratic74(skiatest::Reporter* reporter, const char* filename) {
3052     SkPath path;
3053     path.moveTo(0, 0);
3054     path.quadTo(1, 0, 1, 3);
3055     path.lineTo(1, 3);
3056     path.close();
3057     path.moveTo(0, 0);
3058     path.lineTo(0, 1);
3059     path.quadTo(3, 2, 2, 3);
3060     path.close();
3061     testSimplify(reporter, path, filename);
3062 }
3063
3064 static void testQuadratic75(skiatest::Reporter* reporter, const char* filename) {
3065     SkPath path;
3066     path.moveTo(0, 0);
3067     path.quadTo(1, 0, 1, 3);
3068     path.lineTo(2, 3);
3069     path.close();
3070     path.moveTo(0, 0);
3071     path.lineTo(0, 1);
3072     path.quadTo(3, 2, 2, 3);
3073     path.close();
3074     testSimplify(reporter, path, filename);
3075 }
3076
3077 static void testQuadratic76(skiatest::Reporter* reporter, const char* filename) {
3078     SkPath path;
3079     path.moveTo(0, 0);
3080     path.quadTo(0, 0, 0, 0);
3081     path.lineTo(2, 3);
3082     path.close();
3083     path.moveTo(1, 0);
3084     path.lineTo(1, 2);
3085     path.quadTo(1, 2, 2, 2);
3086     path.close();
3087     testSimplify(reporter, path, filename);
3088 }
3089
3090 static void testQuadratic77(skiatest::Reporter* reporter, const char* filename) {
3091     SkPath path;
3092     path.moveTo(0, 0);
3093     path.quadTo(1, 0, 1, 1);
3094     path.lineTo(3, 1);
3095     path.close();
3096     path.moveTo(0, 0);
3097     path.lineTo(1, 0);
3098     path.quadTo(0, 1, 3, 2);
3099     path.close();
3100     testSimplify(reporter, path, filename);
3101 }
3102
3103 static void testQuadratic78(skiatest::Reporter* reporter, const char* filename) {
3104     SkPath path;
3105     path.moveTo(0, 0);
3106     path.quadTo(1, 0, 1, 2);
3107     path.lineTo(3, 2);
3108     path.close();
3109     path.moveTo(0, 0);
3110     path.lineTo(0, 0);
3111     path.quadTo(2, 1, 0, 2);
3112     path.close();
3113     testSimplify(reporter, path, filename);
3114 }
3115
3116 static void testQuadratic79(skiatest::Reporter* reporter, const char* filename) {
3117     SkPath path;
3118     path.moveTo(0, 0);
3119     path.quadTo(1, 0, 1, 2);
3120     path.lineTo(3, 2);
3121     path.close();
3122     path.moveTo(0, 0);
3123     path.lineTo(1, 0);
3124     path.quadTo(0, 1, 3, 2);
3125     path.close();
3126     testSimplify(reporter, path, filename);
3127 }
3128
3129 static void testEight1(skiatest::Reporter* reporter, const char* filename) {
3130     SkPath path;
3131     path.moveTo(0, 0);
3132     path.lineTo(2, 2);
3133     path.lineTo(0, 2);
3134     path.lineTo(2, 0);
3135     path.close();
3136     testSimplify(reporter, path, filename);
3137 }
3138
3139 static void testEight2(skiatest::Reporter* reporter, const char* filename) {
3140     SkPath path;
3141     path.moveTo(0, 0);
3142     path.lineTo(2, 0);
3143     path.lineTo(0, 2);
3144     path.lineTo(2, 2);
3145     path.close();
3146     testSimplify(reporter, path, filename);
3147 }
3148
3149 static void testEight3(skiatest::Reporter* reporter, const char* filename) {
3150     SkPath path;
3151     path.moveTo(0, 0);
3152     path.lineTo(0, 2);
3153     path.lineTo(2, 0);
3154     path.lineTo(2, 2);
3155     path.close();
3156     testSimplify(reporter, path, filename);
3157 }
3158
3159 static void testEight4(skiatest::Reporter* reporter, const char* filename) {
3160     SkPath path;
3161     path.moveTo(0, 0);
3162     path.lineTo(2, 2);
3163     path.lineTo(2, 0);
3164     path.lineTo(0, 2);
3165     path.close();
3166     testSimplify(reporter, path, filename);
3167 }
3168
3169 static void testEight5(skiatest::Reporter* reporter, const char* filename) {
3170     SkPath path;
3171     path.moveTo(1, 0);
3172     path.lineTo(1, 2);
3173     path.lineTo(0, 2);
3174     path.lineTo(2, 0);
3175     path.close();
3176     testSimplify(reporter, path, filename);
3177 }
3178
3179 static void testEight6(skiatest::Reporter* reporter, const char* filename) {
3180     SkPath path;
3181     path.moveTo(1, 0);
3182     path.lineTo(2, 0);
3183     path.lineTo(0, 2);
3184     path.lineTo(1, 2);
3185     path.close();
3186     testSimplify(reporter, path, filename);
3187 }
3188
3189 static void testEight7(skiatest::Reporter* reporter, const char* filename) {
3190     SkPath path;
3191     path.moveTo(0, 0);
3192     path.lineTo(0, 1);
3193     path.lineTo(2, 1);
3194     path.lineTo(2, 2);
3195     path.close();
3196     testSimplify(reporter, path, filename);
3197 }
3198
3199 static void testEight8(skiatest::Reporter* reporter, const char* filename) {
3200     SkPath path;
3201     path.moveTo(0, 0);
3202     path.lineTo(2, 2);
3203     path.lineTo(2, 1);
3204     path.lineTo(0, 1);
3205     path.close();
3206     testSimplify(reporter, path, filename);
3207 }
3208
3209 static void testEight9(skiatest::Reporter* reporter, const char* filename) {
3210     SkPath path;
3211     path.moveTo(1, 0);
3212     path.lineTo(1, 2);
3213     path.lineTo(2, 1);
3214     path.lineTo(0, 1);
3215     path.close();
3216     testSimplify(reporter, path, filename);
3217 }
3218
3219 static void testEight10(skiatest::Reporter* reporter, const char* filename) {
3220     SkPath path;
3221     path.moveTo(1, 0);
3222     path.lineTo(0, 1);
3223     path.lineTo(2, 1);
3224     path.lineTo(1, 2);
3225     path.close();
3226     testSimplify(reporter, path, filename);
3227 }
3228
3229 static void testQuadratic80(skiatest::Reporter* reporter, const char* filename) {
3230     SkPath path;
3231     path.moveTo(0, 0);
3232     path.quadTo(1, 0, 2, 3);
3233     path.lineTo(2, 3);
3234     path.close();
3235     path.moveTo(1, 0);
3236     path.lineTo(3, 0);
3237     path.quadTo(0, 1, 1, 1);
3238     path.close();
3239     testSimplify(reporter, path, filename);
3240 }
3241
3242 static void testQuadratic81(skiatest::Reporter* reporter, const char* filename) {
3243     SkPath path;
3244     path.moveTo(0, 0);
3245     path.quadTo(2, 0, 1, 1);
3246     path.lineTo(1, 1);
3247     path.close();
3248     path.moveTo(0, 0);
3249     path.lineTo(0, 0);
3250     path.quadTo(2, 1, 0, 2);
3251     path.close();
3252     testSimplify(reporter, path, filename);
3253 }
3254
3255 static void testQuadratic82(skiatest::Reporter* reporter, const char* filename) {
3256     SkPath path;
3257     path.moveTo(0, 0);
3258     path.quadTo(2, 0, 1, 1);
3259     path.lineTo(0, 3);
3260     path.close();
3261     path.moveTo(0, 0);
3262     path.lineTo(0, 0);
3263     path.quadTo(2, 1, 0, 2);
3264     path.close();
3265     testSimplify(reporter, path, filename);
3266 }
3267
3268 static void testQuadratic83(skiatest::Reporter* reporter, const char* filename) {
3269     SkPath path;
3270     path.moveTo(0, 0);
3271     path.quadTo(0, 0, 2, 0);
3272     path.lineTo(2, 2);
3273     path.close();
3274     path.moveTo(0, 1);
3275     path.lineTo(0, 2);
3276     path.quadTo(2, 2, 1, 3);
3277     path.close();
3278     testSimplify(reporter, path, filename);
3279 }
3280
3281 static void testQuadratic84(skiatest::Reporter* reporter, const char* filename) {
3282     SkPath path;
3283     path.moveTo(0, 0);
3284     path.quadTo(2, 0, 1, 1);
3285     path.lineTo(2, 1);
3286     path.close();
3287     path.moveTo(1, 0);
3288     path.lineTo(2, 0);
3289     path.quadTo(0, 1, 2, 2);
3290     path.close();
3291     testSimplify(reporter, path, filename);
3292 }
3293
3294 static void testQuadratic85(skiatest::Reporter* reporter, const char* filename) {
3295     SkPath path;
3296     path.moveTo(0, 0);
3297     path.quadTo(3, 0, 1, 1);
3298     path.lineTo(1, 1);
3299     path.close();
3300     path.moveTo(1, 0);
3301     path.lineTo(3, 0);
3302     path.quadTo(0, 1, 1, 2);
3303     path.close();
3304     testSimplify(reporter, path, filename);
3305 }
3306
3307 static void testQuadratic86(skiatest::Reporter* reporter, const char* filename) {
3308     SkPath path;
3309     path.moveTo(0, 0);
3310     path.quadTo(0, 1, 1, 1);
3311     path.lineTo(2, 3);
3312     path.close();
3313     path.moveTo(0, 0);
3314     path.lineTo(0, 0);
3315     path.quadTo(1, 1, 1, 3);
3316     path.close();
3317     testSimplify(reporter, path, filename);
3318 }
3319
3320 static void testQuadratic87(skiatest::Reporter* reporter, const char* filename) {
3321     SkPath path;
3322     path.moveTo(0, 0);
3323     path.quadTo(2, 1, 0, 2);
3324     path.lineTo(2, 3);
3325     path.close();
3326     path.moveTo(0, 0);
3327     path.lineTo(1, 1);
3328     path.quadTo(0, 2, 3, 2);
3329     path.close();
3330     testSimplify(reporter, path, filename);
3331 }
3332
3333 static void testQuadratic88(skiatest::Reporter* reporter, const char* filename) {
3334     SkPath path;
3335     path.moveTo(0, 0);
3336     path.quadTo(2, 1, 0, 2);
3337     path.lineTo(2, 2);
3338     path.close();
3339     path.moveTo(1, 0);
3340     path.lineTo(1, 1);
3341     path.quadTo(0, 2, 2, 2);
3342     path.close();
3343     testSimplify(reporter, path, filename);
3344 }
3345
3346 static void testQuadratic89x(skiatest::Reporter* reporter, const char* filename) {
3347     SkPath path;
3348     path.setFillType(SkPath::kEvenOdd_FillType);
3349     path.moveTo(0, 0);
3350     path.quadTo(3, 1, 2, 2);
3351     path.lineTo(0, 3);
3352     path.close();
3353     path.moveTo(0, 0);
3354     path.lineTo(2, 1);
3355     path.quadTo(3, 1, 3, 3);
3356     path.close();
3357     testSimplify(reporter, path, filename);
3358 }
3359
3360 static void testQuadratic90x(skiatest::Reporter* reporter, const char* filename) {
3361     SkPath path;
3362     path.setFillType(SkPath::kEvenOdd_FillType);
3363     path.moveTo(0, 0);
3364     path.quadTo(3, 0, 2, 2);
3365     path.lineTo(1, 3);
3366     path.close();
3367     path.moveTo(0, 0);
3368     path.lineTo(0, 1);
3369     path.quadTo(3, 2, 2, 3);
3370     path.close();
3371     testSimplify(reporter, path, filename);
3372 }
3373
3374 static void testQuadratic91(skiatest::Reporter* reporter, const char* filename) {
3375     SkPath path;
3376     path.moveTo(0, 0);
3377     path.quadTo(3, 2, 2, 3);
3378     path.lineTo(2, 3);
3379     path.close();
3380     path.moveTo(0, 0);
3381     path.lineTo(1, 1);
3382     path.quadTo(2, 1, 2, 3);
3383     path.close();
3384     testSimplify(reporter, path, filename);
3385 }
3386
3387 static void testQuadratic92x(skiatest::Reporter* reporter, const char* filename) {
3388     SkPath path;
3389     path.setFillType(SkPath::kEvenOdd_FillType);
3390     path.moveTo(1, 0);
3391     path.quadTo(3, 0, 2, 2);
3392     path.lineTo(2, 2);
3393     path.close();
3394     path.moveTo(2, 0);
3395     path.lineTo(0, 1);
3396     path.quadTo(3, 2, 2, 3);
3397     path.close();
3398     testSimplify(reporter, path, filename);
3399 }
3400
3401 static void testLine82(skiatest::Reporter* reporter, const char* filename) {
3402     SkPath path;
3403     path.addRect(20, 0, 40, 40, SkPath::kCCW_Direction);
3404     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3405     path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
3406     testSimplify(reporter, path, filename);
3407 }
3408
3409 static void testLine82a(skiatest::Reporter* reporter, const char* filename) {
3410     SkPath path;
3411     path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3412     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3413     path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3414     testSimplify(reporter, path, filename);
3415 }
3416
3417 static void testLine82b(skiatest::Reporter* reporter, const char* filename) {
3418     SkPath path;
3419     path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3420     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3421     path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3422     testSimplify(reporter, path, filename);
3423 }
3424
3425 static void testLine82c(skiatest::Reporter* reporter, const char* filename) {
3426     SkPath path;
3427     path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3428     path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3429     path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3430     testSimplify(reporter, path, filename);
3431 }
3432
3433 static void testLine82d(skiatest::Reporter* reporter, const char* filename) {
3434     SkPath path;
3435     path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3436     path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3437     path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3438     testSimplify(reporter, path, filename);
3439 }
3440
3441 static void testLine82e(skiatest::Reporter* reporter, const char* filename) {
3442     SkPath path;
3443     path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3444     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3445     path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3446     testSimplify(reporter, path, filename);
3447 }
3448
3449 static void testLine82f(skiatest::Reporter* reporter, const char* filename) {
3450     SkPath path;
3451     path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3452     path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3453     path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3454     testSimplify(reporter, path, filename);
3455 }
3456
3457 static void testLine82g(skiatest::Reporter* reporter, const char* filename) {
3458     SkPath path;
3459     path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3460     path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3461     path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3462     testSimplify(reporter, path, filename);
3463 }
3464
3465 static void testLine82h(skiatest::Reporter* reporter, const char* filename) {
3466     SkPath path;
3467     path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3468     path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3469     path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3470     testSimplify(reporter, path, filename);
3471 }
3472
3473 static void testLine83(skiatest::Reporter* reporter, const char* filename) {
3474     SkPath path;
3475 path.addRect(10, 30, 30, 40, SkPath::kCCW_Direction);
3476 path.addRect(0, 12, 12, 18, SkPath::kCCW_Direction);
3477 path.addRect(4, 13, 13, 16, SkPath::kCCW_Direction);
3478     testSimplify(reporter, path, filename);
3479 }
3480
3481 static void testLine84(skiatest::Reporter* reporter, const char* filename) {
3482     SkPath path;
3483     path.addRect(0, 12, 60, 30, SkPath::kCCW_Direction);
3484     path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
3485     path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
3486     path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
3487     testSimplify(reporter, path, filename);
3488 }
3489
3490 static void testLine84x(skiatest::Reporter* reporter, const char* filename) {
3491     SkPath path;
3492     path.setFillType(SkPath::kEvenOdd_FillType);
3493     path.addRect(0, 12, 60, 30, SkPath::kCCW_Direction);
3494     path.addRect(10, 20, 40, 30, SkPath::kCCW_Direction);
3495     path.addRect(0, 12, 12, 12, SkPath::kCCW_Direction);
3496     path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
3497     testSimplify(reporter, path, filename);
3498 }
3499
3500 static void testLine85(skiatest::Reporter* reporter, const char* filename) {
3501     SkPath path;
3502     path.addRect(36, 0, 66, 60, SkPath::kCCW_Direction);
3503     path.addRect(20, 0, 40, 40, SkPath::kCCW_Direction);
3504     path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
3505     path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
3506     testSimplify(reporter, path, filename);
3507 }
3508
3509 static void testQuadralateral1(skiatest::Reporter* reporter, const char* filename) {
3510     SkPath path;
3511     path.moveTo(0, 0);
3512     path.lineTo(0, 0);
3513     path.lineTo(0, 0);
3514     path.lineTo(3, 2);
3515     path.close();
3516     path.moveTo(0, 0);
3517     path.lineTo(2, 1);
3518     path.lineTo(2, 2);
3519     path.lineTo(2, 3);
3520     path.close();
3521     testSimplify(reporter, path, filename);
3522 }
3523
3524 static void testCubic1(skiatest::Reporter* reporter, const char* filename) {
3525     SkPath path;
3526     path.moveTo(0, 0);
3527     path.cubicTo(0, 1, 1, 1, 1, 0);
3528     path.close();
3529     path.moveTo(1, 0);
3530     path.cubicTo(0, 0, 0, 1, 1, 1);
3531     path.close();
3532     testSimplify(reporter, path, filename);
3533 }
3534
3535 static void testQuadratic93(skiatest::Reporter* reporter, const char* filename) {
3536     SkPath path;
3537     path.moveTo(3, 0);
3538     path.quadTo(0, 1, 3, 2);
3539     path.lineTo(0, 3);
3540     path.close();
3541     path.moveTo(1, 0);
3542     path.lineTo(2, 0);
3543     path.quadTo(1, 1, 2, 2);
3544     path.close();
3545     testSimplify(reporter, path, filename);
3546 }
3547
3548 static void testCubic2(skiatest::Reporter* reporter, const char* filename) {
3549     SkPath path;
3550     path.moveTo(0,2);
3551     path.cubicTo(0,3, 2,1, 4,0);
3552     path.close();
3553     path.moveTo(1,2);
3554     path.cubicTo(0,4, 2,0, 3,0);
3555     path.close();
3556     testSimplify(reporter, path, filename);
3557 }
3558
3559 static void testQuad1(skiatest::Reporter* reporter, const char* filename) {
3560     SkPath path;
3561     path.moveTo(0,0);
3562     path.quadTo(0,0, 0,1);
3563     path.lineTo(1,1);
3564     path.close();
3565     path.moveTo(0,0);
3566     path.quadTo(1,1, 0,2);
3567     path.close();
3568     testSimplify(reporter, path, filename);
3569 }
3570
3571 static void testQuadralateral2(skiatest::Reporter* reporter, const char* filename) {
3572     SkPath path;
3573     path.moveTo(0, 0);
3574     path.lineTo(2, 2);
3575     path.lineTo(0, 3);
3576     path.lineTo(3, 3);
3577     path.close();
3578     path.moveTo(2, 0);
3579     path.lineTo(3, 0);
3580     path.lineTo(0, 1);
3581     path.lineTo(1, 2);
3582     path.close();
3583     testSimplify(reporter, path, filename);
3584 }
3585
3586 static void testQuadratic94(skiatest::Reporter* reporter, const char* filename) {
3587     SkPath path;
3588     path.moveTo(0, 0);
3589     path.lineTo(8, 8);
3590     path.quadTo(8, 4, 4, 4);
3591     path.quadTo(4, 0, 0, 0);
3592     path.close();
3593     testSimplify(reporter, path, filename);
3594 }
3595
3596 static void testQuadratic95(skiatest::Reporter* reporter, const char* filename) {
3597     SkPath path;
3598     path.moveTo(8, 8);
3599     path.lineTo(0, 0);
3600     path.quadTo(4, 0, 4, 4);
3601     path.quadTo(8, 4, 8, 8);
3602     path.close();
3603     testSimplify(reporter, path, filename);
3604 }
3605
3606 static void testQuadratic96(skiatest::Reporter* reporter, const char* filename) {
3607     SkPath path;
3608     path.moveTo(8, 0);
3609     path.lineTo(0, 8);
3610     path.quadTo(0, 4, 4, 4);
3611     path.quadTo(4, 0, 8, 0);
3612     path.close();
3613     testSimplify(reporter, path, filename);
3614 }
3615
3616 static void testQuadratic97(skiatest::Reporter* reporter, const char* filename) {
3617     SkPath path;
3618     path.moveTo(0, 8);
3619     path.lineTo(8, 0);
3620     path.quadTo(4, 0, 4, 4);
3621     path.quadTo(0, 4, 0, 8);
3622     path.close();
3623     testSimplify(reporter, path, filename);
3624 }
3625
3626 static void testTriangles1(skiatest::Reporter* reporter, const char* filename) {
3627     SkPath path;
3628     path.moveTo(0, 0);
3629     path.lineTo(1, 0);
3630     path.lineTo(3, 3);
3631     path.close();
3632     path.moveTo(0, 0);
3633     path.lineTo(1, 2);
3634     path.lineTo(1, 1);
3635     path.close();
3636     testSimplify(reporter, path, filename);
3637 }
3638
3639 static void testTriangles2(skiatest::Reporter* reporter, const char* filename) {
3640     SkPath path;
3641     path.moveTo(0, 0);
3642     path.lineTo(1, 0);
3643     path.lineTo(3, 3);
3644     path.close();
3645     path.moveTo(1, 1);
3646     path.lineTo(2, 3);
3647     path.lineTo(1, 2);
3648     path.close();
3649     testSimplify(reporter, path, filename);
3650 }
3651
3652 // A test this for this case:
3653 // contourA has two segments that are coincident
3654 // contourB has two segments that are coincident in the same place
3655 // each ends up with +2/0 pairs for winding count
3656 // since logic in OpSegment::addTCoincident doesn't transfer count (only increments/decrements)
3657 // can this be resolved to +4/0 ?
3658 static void testAddTCoincident1(skiatest::Reporter* reporter, const char* filename) {
3659     SkPath path;
3660     path.moveTo(2, 0);
3661     path.lineTo(2, 2);
3662     path.lineTo(1, 1);
3663     path.lineTo(2, 0);
3664     path.lineTo(2, 2);
3665     path.lineTo(1, 1);
3666     path.close();
3667     path.moveTo(2, 0);
3668     path.lineTo(2, 2);
3669     path.lineTo(3, 1);
3670     path.lineTo(2, 0);
3671     path.lineTo(2, 2);
3672     path.lineTo(3, 1);
3673     path.close();
3674     testSimplify(reporter, path, filename);
3675 }
3676
3677 // test with implicit close
3678 static void testAddTCoincident2(skiatest::Reporter* reporter, const char* filename) {
3679     SkPath path;
3680     path.moveTo(2, 0);
3681     path.lineTo(2, 2);
3682     path.lineTo(1, 1);
3683     path.lineTo(2, 0);
3684     path.lineTo(2, 2);
3685     path.lineTo(1, 1);
3686     path.moveTo(2, 0);
3687     path.lineTo(2, 2);
3688     path.lineTo(3, 1);
3689     path.lineTo(2, 0);
3690     path.lineTo(2, 2);
3691     path.lineTo(3, 1);
3692     testSimplify(reporter, path, filename);
3693 }
3694
3695 static void testQuad2(skiatest::Reporter* reporter, const char* filename) {
3696     SkPath path;
3697     path.moveTo(1, 0);
3698     path.quadTo(0, 1, 3, 2);
3699     path.lineTo(2, 3);
3700     path.close();
3701     path.moveTo(0, 0);
3702     path.lineTo(1, 0);
3703     path.quadTo(0, 1, 1, 1);
3704     path.close();
3705 }
3706
3707 static void testQuad3(skiatest::Reporter* reporter, const char* filename) {
3708     SkPath path;
3709     path.moveTo(1, 0);
3710     path.quadTo(0, 1, 3, 2);
3711     path.lineTo(3, 3);
3712     path.close();
3713     path.moveTo(0, 0);
3714     path.lineTo(1, 0);
3715     path.quadTo(0, 1, 1, 1);
3716     path.close();
3717     testSimplify(reporter, path, filename);
3718 }
3719
3720 static void testQuad4(skiatest::Reporter* reporter, const char* filename) {
3721     SkPath path;
3722     path.moveTo(2, 0);
3723     path.quadTo(0, 1, 1, 1);
3724     path.lineTo(3, 3);
3725     path.close();
3726     path.moveTo(0, 0);
3727     path.lineTo(2, 0);
3728     path.quadTo(0, 1, 2, 2);
3729     path.close();
3730     testSimplify(reporter, path, filename);
3731 }
3732
3733 static void testQuad5(skiatest::Reporter* reporter, const char* filename) {
3734     SkPath path;
3735     path.moveTo(2, 0);
3736     path.quadTo(0, 1, 2, 2);
3737     path.lineTo(1, 3);
3738     path.close();
3739     path.moveTo(0, 0);
3740     path.lineTo(2, 0);
3741     path.quadTo(0, 1, 1, 1);
3742     path.close();
3743     testSimplify(reporter, path, filename);
3744 }
3745
3746 static void testQuad6(skiatest::Reporter* reporter, const char* filename) {
3747     SkPath path;
3748     path.moveTo(2, 0);
3749     path.quadTo(0, 1, 2, 2);
3750     path.lineTo(1, 3);
3751     path.close();
3752     path.moveTo(1, 0);
3753     path.lineTo(2, 0);
3754     path.quadTo(0, 1, 1, 1);
3755     path.close();
3756     testSimplify(reporter, path, filename);
3757 }
3758
3759 static void testQuad7(skiatest::Reporter* reporter, const char* filename) {
3760     SkPath path;
3761     path.moveTo(3, 0);
3762     path.quadTo(0, 1, 1, 1);
3763     path.lineTo(1, 3);
3764     path.close();
3765     path.moveTo(1, 0);
3766     path.lineTo(3, 0);
3767     path.quadTo(0, 1, 1, 2);
3768     path.close();
3769     testSimplify(reporter, path, filename);
3770 }
3771
3772 static void testQuadLineIntersect1(skiatest::Reporter* reporter, const char* filename) {
3773     SkPath path;
3774     path.moveTo(0, 0);
3775     path.quadTo(3, 1, 0, 3);
3776     path.lineTo(2, 3);
3777     path.close();
3778     path.moveTo(2, 0);
3779     path.lineTo(0, 1);
3780     path.quadTo(3, 1, 0, 2);
3781     path.close();
3782     testSimplify(reporter, path, filename);
3783 }
3784
3785 static void testQuadLineIntersect2(skiatest::Reporter* reporter, const char* filename) {
3786     SkPath path;
3787     path.moveTo(0, 0);
3788     path.quadTo(3, 1, 0, 3);
3789     path.lineTo(0, 3);
3790     path.close();
3791     path.moveTo(2, 0);
3792     path.lineTo(0, 1);
3793     path.quadTo(3, 1, 0, 2);
3794     path.close();
3795     testSimplify(reporter, path, filename);
3796 }
3797
3798 static void testQuadLineIntersect3(skiatest::Reporter* reporter, const char* filename) {
3799     SkPath path;
3800     path.moveTo(0, 0);
3801     path.quadTo(3, 1, 0, 3);
3802     path.lineTo(1, 3);
3803     path.close();
3804     path.moveTo(2, 0);
3805     path.lineTo(0, 1);
3806     path.quadTo(3, 1, 0, 2);
3807     path.close();
3808     testSimplify(reporter, path, filename);
3809 }
3810
3811 static void skphealth_com76(skiatest::Reporter* reporter, const char* filename) {
3812     SkPath path;
3813     path.setFillType(SkPath::kWinding_FillType);
3814     path.moveTo(708.099182f, 7.09919119f);
3815     path.lineTo(708.099182f, 7.09920025f);
3816     path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
3817     path.lineTo(704.000000f, 33.0000000f);
3818     path.lineTo(705.000000f, 33.0000000f);
3819     path.lineTo(705.000000f, 17.0000000f);
3820     path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
3821     path.lineTo(708.099182f, 7.09919119f);
3822     path.close();
3823     path.moveTo(704.000000f, 3.00000000f);
3824     path.lineTo(704.000000f, 33.0000000f);
3825     path.lineTo(705.000000f, 33.0000000f);
3826     path.lineTo(719.500000f, 3.00000000f);
3827     testSimplify(reporter, path, filename);
3828 }
3829
3830 static void tooCloseTest(skiatest::Reporter* reporter, const char* filename) {
3831     SkPath path;
3832     path.moveTo(0, 0);
3833     path.lineTo(1, 1);
3834     path.lineTo(1,-1);
3835     path.close();
3836     path.moveTo(0, 0);
3837     path.lineTo(1,-2);
3838     path.lineTo(1, 2);
3839     path.lineTo(2, 0);
3840     path.close();
3841     testSimplify(reporter, path, filename);
3842 }
3843
3844 static void testRect1(skiatest::Reporter* reporter, const char* filename) {
3845     SkPath path;
3846     path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction);
3847     path.addRect(30, 20, 50, 50, SkPath::kCCW_Direction);
3848     path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3849     path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
3850     testSimplify(reporter, path, filename);
3851 }
3852
3853 static void testRect2(skiatest::Reporter* reporter, const char* filename) {
3854     SkPath path;
3855     path.setFillType(SkPath::kWinding_FillType);
3856     path.moveTo(0, 0);
3857     path.lineTo(60, 0);
3858     path.lineTo(60, 60);
3859     path.lineTo(0, 60);
3860     path.close();
3861     path.moveTo(30, 20);
3862     path.lineTo(30, 50);
3863     path.lineTo(50, 50);
3864     path.lineTo(50, 20);
3865     path.close();
3866     path.moveTo(24, 20);
3867     path.lineTo(24, 30);
3868     path.lineTo(36, 30);
3869     path.lineTo(36, 20);
3870     path.close();
3871     path.moveTo(32, 24);
3872     path.lineTo(32, 41);
3873     path.lineTo(36, 41);
3874     path.lineTo(36, 24);
3875     path.close();
3876     testSimplify(reporter, path, filename);
3877 }
3878
3879 static void testTriangles3x(skiatest::Reporter* reporter, const char* filename) {
3880     SkPath path;
3881     path.setFillType(SkPath::kEvenOdd_FillType);
3882     path.moveTo(1, 0);
3883     path.quadTo(0, 1, 3, 2);
3884     path.lineTo(1, 3);
3885     path.close();
3886     path.moveTo(0, 0);
3887     path.lineTo(1, 1);
3888     path.quadTo(2, 1, 0, 2);
3889     path.close();
3890     testSimplify(reporter, path, filename);
3891 }
3892
3893 static void testQuad8(skiatest::Reporter* reporter, const char* filename) {
3894     SkPath path;
3895     path.moveTo(3, 0);
3896     path.quadTo(0, 1, 3, 2);
3897     path.lineTo(0, 3);
3898     path.close();
3899     path.moveTo(1, 0);
3900     path.lineTo(3, 0);
3901     path.quadTo(1, 1, 2, 2);
3902     path.close();
3903     testSimplify(reporter, path, filename);
3904 }
3905
3906 static void testTriangles4x(skiatest::Reporter* reporter, const char* filename) {
3907     SkPath path;
3908     path.setFillType(SkPath::kEvenOdd_FillType);
3909     path.moveTo(0, 0);
3910     path.quadTo(2, 0, 0, 3);
3911     path.lineTo(2, 3);
3912     path.close();
3913     path.moveTo(0, 0);
3914     path.lineTo(0, 1);
3915     path.quadTo(3, 2, 2, 3);
3916     path.close();
3917     testSimplify(reporter, path, filename);
3918 }
3919
3920 static void testQuad9(skiatest::Reporter* reporter, const char* filename) {
3921     SkPath path;
3922     path.setFillType(SkPath::kEvenOdd_FillType);
3923     path.moveTo(1, 0);
3924     path.quadTo(0, 1, 3, 2);
3925     path.lineTo(1, 3);
3926     path.close();
3927     path.moveTo(1, 0);
3928     path.lineTo(1, 1);
3929     path.quadTo(2, 1, 1, 3);
3930     path.close();
3931     testSimplify(reporter, path, filename);
3932 }
3933
3934 static void testQuad10(skiatest::Reporter* reporter, const char* filename) {
3935     SkPath path;
3936     path.moveTo(1, 0);
3937     path.quadTo(0, 1, 3, 2);
3938     path.lineTo(3, 3);
3939     path.close();
3940     path.moveTo(1, 0);
3941     path.lineTo(2, 0);
3942     path.quadTo(2, 3, 3, 3);
3943     path.close();
3944     testSimplify(reporter, path, filename);
3945 }
3946
3947 static void testQuad11(skiatest::Reporter* reporter, const char* filename) {
3948     SkPath path;
3949     path.moveTo(2, 0);
3950     path.quadTo(0, 1, 1, 2);
3951     path.lineTo(1, 2);
3952     path.close();
3953     path.moveTo(0, 0);
3954     path.lineTo(1, 1);
3955     path.quadTo(1, 3, 3, 3);
3956     path.close();
3957     testSimplify(reporter, path, filename);
3958 }
3959
3960 static void testQuad12(skiatest::Reporter* reporter, const char* filename) {
3961     SkPath path;
3962     path.moveTo(0, 0);
3963     path.quadTo(0, 0, 0, 0);
3964     path.lineTo(0, 1);
3965     path.close();
3966     path.moveTo(0, 0);
3967     path.lineTo(0, 0);
3968     path.quadTo(1, 0, 0, 1);
3969     path.close();
3970     testSimplify(reporter, path, filename);
3971 }
3972
3973 static void testQuadralateral3(skiatest::Reporter* reporter, const char* filename) {
3974     SkPath path;
3975     path.setFillType(SkPath::kEvenOdd_FillType);
3976     path.moveTo(0, 0);
3977     path.lineTo(0, 0);
3978     path.lineTo(0, 0);
3979     path.lineTo(1, 0);
3980     path.close();
3981     path.moveTo(0, 0);
3982     path.lineTo(0, 0);
3983     path.lineTo(1, 0);
3984     path.lineTo(0, 1);
3985     path.close();
3986     testSimplify(reporter, path, filename);
3987 }
3988
3989
3990 static void testDegenerate5(skiatest::Reporter* reporter, const char* filename) {
3991     SkPath path;
3992     path.moveTo(0, 0);
3993     path.lineTo(0, 0);
3994     path.lineTo(1, 0);
3995     path.close();
3996     path.moveTo(0, 0);
3997     path.lineTo(1, 0);
3998     path.lineTo(0, 1);
3999     path.close();
4000     testSimplify(reporter, path, filename);
4001 }
4002
4003 static void testQuadralateral4(skiatest::Reporter* reporter, const char* filename) {
4004     SkPath path;
4005     path.moveTo(0, 0);
4006     path.lineTo(0, 0);
4007     path.lineTo(0, 0);
4008     path.lineTo(3, 1);
4009     path.close();
4010     path.moveTo(0, 0);
4011     path.lineTo(0, 0);
4012     path.lineTo(0, 1);
4013     path.lineTo(3, 1);
4014     path.close();
4015     testSimplify(reporter, path, filename);
4016 }
4017
4018 static void testDegenerates1(skiatest::Reporter* reporter, const char* filename) {
4019     SkPath path;
4020     path.moveTo(0, 0);
4021     path.quadTo(0, 0, 1, 1);
4022     path.lineTo(2, 3);
4023     path.close();
4024     path.moveTo(0, 0);
4025     path.lineTo(0, 0);
4026     path.quadTo(3, 2, 2, 3);
4027     path.close();
4028     testSimplify(reporter, path, filename);
4029 }
4030
4031 static void testQuad13(skiatest::Reporter* reporter, const char* filename) {
4032     SkPath path;
4033     path.moveTo(0, 0);
4034     path.quadTo(0, 0, 1, 1);
4035     path.lineTo(2, 3);
4036     path.close();
4037     path.moveTo(0, 0);
4038     path.lineTo(0, 0);
4039     path.quadTo(3, 2, 2, 3);
4040     path.close();
4041     testSimplify(reporter, path, filename);
4042 }
4043
4044 static void testQuad14(skiatest::Reporter* reporter, const char* filename) {
4045     SkPath path;
4046     path.setFillType(SkPath::kWinding_FillType);
4047     path.moveTo(0, 0);
4048     path.quadTo(0, 0, 1, 1);
4049     path.lineTo(1, 2);
4050     path.close();
4051     path.moveTo(0, 0);
4052     path.lineTo(0, 0);
4053     path.quadTo(3, 1, 1, 3);
4054     path.close();
4055     testSimplify(reporter, path, filename);
4056 }
4057
4058 static void testQuad15(skiatest::Reporter* reporter, const char* filename) {
4059     SkPath path;
4060     path.moveTo(0, 0);
4061     path.quadTo(0, 0, 1, 1);
4062     path.lineTo(1, 3);
4063     path.close();
4064     path.moveTo(0, 0);
4065     path.lineTo(0, 0);
4066     path.quadTo(2, 0, 1, 3);
4067     path.close();
4068     testSimplify(reporter, path, filename);
4069 }
4070
4071 static void testQuads16(skiatest::Reporter* reporter, const char* filename) {
4072     SkPath path;
4073     path.moveTo(0, 0);
4074     path.quadTo(0, 0, 1, 1);
4075     path.lineTo(3, 2);
4076     path.close();
4077     path.moveTo(0, 0);
4078     path.lineTo(0, 0);
4079     path.quadTo(0, 1, 3, 2);
4080     path.close();
4081     testSimplify(reporter, path, filename);
4082 }
4083
4084 static void testQuads17(skiatest::Reporter* reporter, const char* filename) {
4085     SkPath path;
4086     path.moveTo(0, 0);
4087     path.quadTo(0, 0, 1, 1);
4088     path.lineTo(3, 2);
4089     path.close();
4090     path.moveTo(0, 0);
4091     path.lineTo(0, 0);
4092     path.quadTo(0, 2, 3, 2);
4093     path.close();
4094     testSimplify(reporter, path, filename);
4095 }
4096
4097 static void testQuads18(skiatest::Reporter* reporter, const char* filename) {
4098     SkPath path;
4099     path.moveTo(0, 0);
4100     path.quadTo(0, 0, 1, 1);
4101     path.lineTo(3, 2);
4102     path.close();
4103     path.moveTo(0, 0);
4104     path.lineTo(0, 0);
4105     path.quadTo(1, 2, 3, 2);
4106     path.close();
4107     testSimplify(reporter, path, filename);
4108 }
4109
4110 static void testQuads19(skiatest::Reporter* reporter, const char* filename) {
4111     SkPath path;
4112     path.moveTo(0, 0);
4113     path.quadTo(0, 0, 2, 1);
4114     path.lineTo(1, 2);
4115     path.close();
4116     path.moveTo(0, 0);
4117     path.lineTo(0, 0);
4118     path.quadTo(2, 1, 1, 2);
4119     path.close();
4120     testSimplify(reporter, path, filename);
4121 }
4122
4123 static void testQuads20(skiatest::Reporter* reporter, const char* filename) {
4124     SkPath path;
4125     path.moveTo(0, 0);
4126     path.quadTo(0, 0, 2, 1);
4127     path.lineTo(1, 3);
4128     path.close();
4129     path.moveTo(0, 0);
4130     path.lineTo(0, 0);
4131     path.quadTo(2, 1, 1, 3);
4132     path.close();
4133     testSimplify(reporter, path, filename);
4134 }
4135
4136 static void testQuads21(skiatest::Reporter* reporter, const char* filename) {
4137     SkPath path;
4138     path.moveTo(0, 0);
4139     path.quadTo(0, 0, 1, 1);
4140     path.lineTo(2, 1);
4141     path.close();
4142     path.moveTo(0, 0);
4143     path.lineTo(0, 0);
4144     path.quadTo(3, 0, 2, 3);
4145     path.close();
4146     testSimplify(reporter, path, filename);
4147 }
4148
4149 static void testQuads22(skiatest::Reporter* reporter, const char* filename) {
4150     SkPath path;
4151     path.moveTo(0, 0);
4152     path.quadTo(0, 0, 2, 0);
4153     path.lineTo(1, 1);
4154     path.close();
4155     path.moveTo(0, 0);
4156     path.lineTo(0, 0);
4157     path.quadTo(0, 1, 3, 2);
4158     path.close();
4159     testSimplify(reporter, path, filename);
4160 }
4161
4162 static void testQuads23(skiatest::Reporter* reporter, const char* filename) {
4163     SkPath path;
4164     path.moveTo(0, 0);
4165     path.quadTo(0, 0, 1, 0);
4166     path.lineTo(1, 1);
4167     path.close();
4168     path.moveTo(0, 0);
4169     path.lineTo(0, 0);
4170     path.quadTo(0, 1, 3, 2);
4171     path.close();
4172     testSimplify(reporter, path, filename);
4173 }
4174
4175 static void testQuads24(skiatest::Reporter* reporter, const char* filename) {
4176     SkPath path;
4177     path.moveTo(0, 0);
4178     path.quadTo(0, 0, 0, 1);
4179     path.lineTo(1, 2);
4180     path.close();
4181     path.moveTo(0, 1);
4182     path.lineTo(0, 1);
4183     path.quadTo(0, 2, 3, 3);
4184     path.close();
4185     testSimplify(reporter, path, filename);
4186 }
4187
4188 static void testQuads25(skiatest::Reporter* reporter, const char* filename) {
4189     SkPath path;
4190     path.moveTo(0, 0);
4191     path.quadTo(0, 0, 0, 1);
4192     path.lineTo(2, 1);
4193     path.close();
4194     path.moveTo(0, 0);
4195     path.lineTo(0, 0);
4196     path.quadTo(3, 0, 2, 3);
4197     path.close();
4198     testSimplify(reporter, path, filename);
4199 }
4200
4201 static void testQuads26(skiatest::Reporter* reporter, const char* filename) {
4202     SkPath path;
4203     path.moveTo(0, 0);
4204     path.quadTo(0, 0, 3, 0);
4205     path.lineTo(1, 1);
4206     path.close();
4207     path.moveTo(0, 0);
4208     path.lineTo(0, 0);
4209     path.quadTo(0, 1, 3, 2);
4210     path.close();
4211     testSimplify(reporter, path, filename);
4212 }
4213
4214 static void testQuads27(skiatest::Reporter* reporter, const char* filename) {
4215     SkPath path;
4216     path.moveTo(0, 0);
4217     path.quadTo(0, 0, 2, 0);
4218     path.lineTo(2, 1);
4219     path.close();
4220     path.moveTo(2, 0);
4221     path.lineTo(2, 0);
4222     path.quadTo(3, 0, 1, 3);
4223     path.close();
4224     testSimplify(reporter, path, filename);
4225 }
4226
4227 static void testQuads28(skiatest::Reporter* reporter, const char* filename) {
4228     SkPath path;
4229     path.moveTo(0, 0);
4230     path.quadTo(0, 0, 0, 1);
4231     path.lineTo(2, 2);
4232     path.close();
4233     path.moveTo(0, 0);
4234     path.lineTo(0, 0);
4235     path.quadTo(3, 0, 2, 3);
4236     path.close();
4237     testSimplify(reporter, path, filename);
4238 }
4239
4240 static void testQuads29(skiatest::Reporter* reporter, const char* filename) {
4241     SkPath path;
4242     path.moveTo(0, 0);
4243     path.quadTo(0, 0, 3, 0);
4244     path.lineTo(2, 1);
4245     path.close();
4246     path.moveTo(3, 0);
4247     path.lineTo(3, 0);
4248     path.quadTo(3, 1, 0, 2);
4249     path.close();
4250     testSimplify(reporter, path, filename);
4251 }
4252
4253 static void testQuads30(skiatest::Reporter* reporter, const char* filename) {
4254     SkPath path;
4255     path.moveTo(0, 0);
4256
4257     path.quadTo(0, 0, 2, 0);
4258     path.lineTo(2, 2);
4259     path.close();
4260     path.moveTo(2, 0);
4261     path.lineTo(2, 0);
4262     path.quadTo(3, 2, 1, 3);
4263     path.close();
4264     testSimplify(reporter, path, filename);
4265 }
4266
4267 static void testQuads31(skiatest::Reporter* reporter, const char* filename) {
4268     SkPath path;
4269     path.moveTo(0, 0);
4270     path.quadTo(0, 0, 2, 1);
4271     path.lineTo(1, 3);
4272     path.close();
4273     path.moveTo(3, 0);
4274     path.lineTo(0, 1);
4275
4276     path.quadTo(2, 1, 1, 3);
4277     path.close();
4278     testSimplify(reporter, path, filename);
4279 }
4280
4281 static void testQuads32(skiatest::Reporter* reporter, const char* filename) {
4282     SkPath path;
4283     path.moveTo(0, 0);
4284     path.quadTo(0, 0, 1, 1);
4285     path.lineTo(1, 2);
4286     path.close();
4287     path.moveTo(1, 1);
4288     path.lineTo(1, 1);
4289     path.quadTo(3, 1, 0, 3);
4290     path.close();
4291     testSimplify(reporter, path, filename);
4292 }
4293
4294 static void testQuads33(skiatest::Reporter* reporter, const char* filename) {
4295     SkPath path;
4296     path.moveTo(0, 0);
4297     path.quadTo(0, 0, 1, 1);
4298     path.lineTo(2, 1);
4299     path.close();
4300     path.moveTo(0, 0);
4301     path.lineTo(0, 0);
4302     path.quadTo(3, 0, 2, 3);
4303     path.close();
4304     testSimplify(reporter, path, filename);
4305 }
4306
4307 static void testQuads34(skiatest::Reporter* reporter, const char* filename) {
4308     SkPath path;
4309     path.moveTo(0, 0);
4310     path.quadTo(0, 0, 1, 0);
4311     path.lineTo(2, 1);
4312     path.close();
4313     path.moveTo(1, 0);
4314     path.lineTo(1, 0);
4315     path.quadTo(2, 0, 3, 3);
4316     path.close();
4317     testSimplify(reporter, path, filename);
4318 }
4319
4320 static void testQuads35(skiatest::Reporter* reporter, const char* filename) {
4321     SkPath path;
4322     path.moveTo(0, 0);
4323     path.quadTo(0, 0, 1, 0);
4324     path.lineTo(1, 2);
4325     path.close();
4326     path.moveTo(1, 0);
4327     path.lineTo(1, 0);
4328     path.quadTo(3, 1, 0, 3);
4329     path.close();
4330     testSimplify(reporter, path, filename);
4331 }
4332
4333 static void testQuads36(skiatest::Reporter* reporter, const char* filename) {
4334     SkPath path;
4335     path.moveTo(1, 0);
4336     path.quadTo(2, 0, 1, 2);
4337     path.lineTo(2, 2);
4338     path.close();
4339     path.moveTo(1, 0);
4340     path.lineTo(1, 0);
4341     path.quadTo(3, 0, 2, 3);
4342     path.close();
4343     testSimplify(reporter, path, filename);
4344 }
4345
4346 static void testQuads37(skiatest::Reporter* reporter, const char* filename) {
4347     SkPath path;
4348     path.setFillType(SkPath::kEvenOdd_FillType);
4349     path.moveTo(1, 0);
4350     path.quadTo(2, 0, 1, 2);
4351     path.lineTo(2, 2);
4352     path.close();
4353     path.moveTo(1, 0);
4354     path.lineTo(1, 0);
4355     path.quadTo(3, 0, 2, 3);
4356     path.close();
4357     testSimplify(reporter, path, filename);
4358 }
4359
4360 static void testQuads38(skiatest::Reporter* reporter, const char* filename) {
4361     SkPath path;
4362     path.moveTo(1, 0);
4363     path.quadTo(3, 0, 0, 2);
4364     path.lineTo(3, 2);
4365     path.close();
4366     path.moveTo(1, 0);
4367     path.lineTo(1, 0);
4368     path.quadTo(2, 1, 3, 1);
4369     path.close();
4370     testSimplify(reporter, path, filename);
4371 }
4372
4373 static void testQuads39(skiatest::Reporter* reporter, const char* filename) {
4374     SkPath path;
4375     path.moveTo(1, 0);
4376     path.quadTo(3, 0, 0, 3);
4377     path.lineTo(0, 3);
4378     path.close();
4379     path.moveTo(1, 1);
4380     path.lineTo(0, 2);
4381     path.quadTo(1, 2, 0, 3);
4382     path.close();
4383     testSimplify(reporter, path, filename);
4384 }
4385 static void testQuads40(skiatest::Reporter* reporter, const char* filename) {
4386     SkPath path;
4387     path.moveTo(1, 0);
4388     path.quadTo(3, 0, 3, 3);
4389     path.lineTo(3, 3);
4390     path.close();
4391     path.moveTo(2, 1);
4392     path.lineTo(2, 2);
4393     path.quadTo(3, 2, 3, 3);
4394     path.close();
4395     testSimplify(reporter, path, filename);
4396 }
4397
4398 static void testQuads41(skiatest::Reporter* reporter, const char* filename) {
4399     SkPath path;
4400     path.moveTo(0, 0);
4401     path.quadTo(0, 0, 1, 0);
4402     path.lineTo(2, 1);
4403     path.close();
4404     path.moveTo(0, 0);
4405     path.lineTo(0, 0);
4406     path.quadTo(0, 1, 1, 2);
4407     path.close();
4408     testSimplify(reporter, path, filename);
4409 }
4410
4411
4412 static void testQuads54(skiatest::Reporter* reporter, const char* filename) {
4413     SkPath path;
4414     path.moveTo(1, 0);
4415     path.quadTo(2, 0, 1, 1);
4416     path.lineTo(3, 1);
4417     path.close();
4418     path.moveTo(2, 0);
4419     path.lineTo(1, 1);
4420     path.quadTo(1, 1, 2, 3);
4421     path.close();
4422     testSimplify(reporter, path, filename);
4423 }
4424 static void testQuads53(skiatest::Reporter* reporter, const char* filename) {
4425     SkPath path;
4426     path.moveTo(1, 0);
4427     path.quadTo(2, 0, 1, 1);
4428     path.lineTo(3, 1);
4429     path.close();
4430     path.moveTo(2, 0);
4431     path.lineTo(1, 1);
4432     path.quadTo(2, 3, 2, 3);
4433     path.close();
4434     testSimplify(reporter, path, filename);
4435 }
4436 static void testQuads52(skiatest::Reporter* reporter, const char* filename) {
4437     SkPath path;
4438     path.moveTo(1, 0);
4439     path.quadTo(2, 0, 1, 1);
4440     path.lineTo(3, 1);
4441     path.close();
4442     path.moveTo(2, 0);
4443     path.lineTo(1, 1);
4444     path.quadTo(2, 3, 3, 3);
4445     path.close();
4446     testSimplify(reporter, path, filename);
4447 }
4448 static void testQuads51(skiatest::Reporter* reporter, const char* filename) {
4449     SkPath path;
4450     path.moveTo(2, 0);
4451     path.quadTo(3, 0, 2, 1);
4452     path.lineTo(3, 2);
4453     path.close();
4454     path.moveTo(3, 0);
4455     path.lineTo(3, 1);
4456     path.quadTo(3, 1, 1, 2);
4457     path.close();
4458     testSimplify(reporter, path, filename);
4459 }
4460 static void testQuads50(skiatest::Reporter* reporter, const char* filename) {
4461     SkPath path;
4462     path.moveTo(2, 0);
4463     path.quadTo(3, 0, 2, 1);
4464     path.lineTo(3, 2);
4465     path.close();
4466     path.moveTo(3, 0);
4467     path.lineTo(3, 1);
4468     path.quadTo(1, 2, 1, 2);
4469     path.close();
4470     testSimplify(reporter, path, filename);
4471 }
4472 static void testQuads49(skiatest::Reporter* reporter, const char* filename) {
4473     SkPath path;
4474     path.moveTo(2, 0);
4475     path.quadTo(3, 0, 2, 1);
4476     path.lineTo(3, 2);
4477     path.close();
4478     path.moveTo(3, 0);
4479     path.lineTo(2, 2);
4480     path.quadTo(2, 2, 0, 3);
4481     path.close();
4482     testSimplify(reporter, path, filename);
4483 }
4484 static void testQuads48(skiatest::Reporter* reporter, const char* filename) {
4485     SkPath path;
4486     path.moveTo(2, 0);
4487     path.quadTo(3, 0, 2, 1);
4488     path.lineTo(3, 2);
4489     path.close();
4490     path.moveTo(3, 0);
4491     path.lineTo(2, 2);
4492     path.quadTo(3, 2, 0, 3);
4493     path.close();
4494     testSimplify(reporter, path, filename);
4495 }
4496 static void testQuads47(skiatest::Reporter* reporter, const char* filename) {
4497     SkPath path;
4498     path.moveTo(2, 0);
4499     path.quadTo(3, 0, 2, 1);
4500     path.lineTo(3, 2);
4501     path.close();
4502     path.moveTo(3, 0);
4503     path.lineTo(2, 2);
4504     path.quadTo(0, 3, 0, 3);
4505     path.close();
4506     testSimplify(reporter, path, filename);
4507 }
4508
4509 // this fails because there is a short unorderable segment and the unordered state isn't handled
4510 // correctly later on.
4511 static void testQuads46x(skiatest::Reporter* reporter, const char* filename) {
4512     SkPath path;
4513     path.setFillType(SkPath::kEvenOdd_FillType);
4514     path.moveTo(2, 0);
4515     path.quadTo(0, 1, 3, 2);
4516     path.lineTo(1, 3);
4517     path.close();
4518     path.moveTo(0, 0);
4519     path.lineTo(1, 1);
4520     path.quadTo(3, 2, 1, 3);
4521     path.close();
4522     testSimplify(reporter, path, filename);
4523 }
4524
4525 static void testQuads45(skiatest::Reporter* reporter, const char* filename) {
4526     SkPath path;
4527     path.moveTo(2, 0);
4528     path.quadTo(3, 2, 3, 3);
4529     path.lineTo(3, 3);
4530     path.close();
4531     path.moveTo(0, 0);
4532     path.lineTo(0, 2);
4533     path.quadTo(3, 2, 3, 3);
4534     path.close();
4535     testSimplify(reporter, path, filename);
4536 }
4537
4538 static void testQuads44(skiatest::Reporter* reporter, const char* filename) {
4539     SkPath path;
4540     path.moveTo(2, 0);
4541     path.quadTo(3, 2, 3, 3);
4542     path.lineTo(3, 3);
4543     path.close();
4544     path.moveTo(1, 0);
4545     path.lineTo(0, 2);
4546     path.quadTo(3, 2, 3, 3);
4547     path.close();
4548     testSimplify(reporter, path, filename);
4549 }
4550
4551 static void testQuads43(skiatest::Reporter* reporter, const char* filename) {
4552     SkPath path;
4553     path.moveTo(2, 0);
4554     path.quadTo(2, 3, 3, 3);
4555     path.lineTo(3, 3);
4556     path.close();
4557     path.moveTo(0, 2);
4558     path.lineTo(0, 2);
4559     path.quadTo(2, 3, 3, 3);
4560     path.close();
4561     testSimplify(reporter, path, filename);
4562 }
4563
4564 static void testQuads42(skiatest::Reporter* reporter, const char* filename) {
4565     SkPath path;
4566     path.moveTo(2, 0);
4567     path.quadTo(3, 2, 3, 3);
4568     path.lineTo(3, 3);
4569     path.close();
4570     path.moveTo(2, 0);
4571     path.lineTo(0, 2);
4572     path.quadTo(3, 2, 3, 3);
4573     path.close();
4574     testSimplify(reporter, path, filename);
4575 }
4576
4577 static void testQuads56(skiatest::Reporter* reporter, const char* filename) {
4578     SkPath path;
4579     path.moveTo(2, 0);
4580     path.quadTo(3, 1, 0, 2);
4581     path.lineTo(3, 2);
4582     path.close();
4583     path.moveTo(3, 0);
4584     path.lineTo(2, 1);
4585     path.quadTo(2, 1, 3, 3);
4586     path.close();
4587     testSimplify(reporter, path, filename);
4588 }
4589
4590 static void testQuads57(skiatest::Reporter* reporter, const char* filename) {
4591     SkPath path;
4592     path.moveTo(1, 0);
4593     path.quadTo(3, 0, 3, 1);
4594     path.lineTo(2, 2);
4595     path.close();
4596     path.moveTo(2, 0);
4597     path.lineTo(3, 1);
4598     path.quadTo(2, 2, 3, 2);
4599     path.close();
4600     testSimplify(reporter, path, filename);
4601 }
4602
4603 static void testQuads58(skiatest::Reporter* reporter, const char* filename) {
4604     SkPath path;
4605     path.moveTo(1, 0);
4606     path.quadTo(3, 0, 3, 1);
4607     path.lineTo(1, 3);
4608     path.close();
4609     path.moveTo(2, 0);
4610     path.lineTo(3, 1);
4611     path.quadTo(2, 2, 3, 2);
4612     path.close();
4613     testSimplify(reporter, path, filename);
4614 }
4615
4616 static void testQuads59(skiatest::Reporter* reporter, const char* filename) {
4617     SkPath path;
4618     path.moveTo(3, 0);
4619     path.quadTo(3, 1, 3, 1);
4620     path.lineTo(2, 2);
4621     path.close();
4622     path.moveTo(2, 0);
4623     path.lineTo(3, 1);
4624     path.quadTo(2, 2, 3, 2);
4625     path.close();
4626     testSimplify(reporter, path, filename);
4627 }
4628
4629 static void testQuads60(skiatest::Reporter* reporter, const char* filename) {
4630     SkPath path;
4631     path.moveTo(2, 1);
4632     path.quadTo(0, 2, 3, 2);
4633     path.lineTo(2, 3);
4634     path.close();
4635     path.moveTo(0, 0);
4636     path.lineTo(2, 0);
4637     path.quadTo(1, 1, 2, 2);
4638     path.close();
4639     testSimplify(reporter, path, filename);
4640 }
4641
4642 static void testQuads61(skiatest::Reporter* reporter, const char* filename) {
4643     SkPath path;
4644     path.setFillType(SkPath::kEvenOdd_FillType);
4645     path.moveTo(0, 0);
4646     path.quadTo(0, 0, 2, 0);
4647     path.lineTo(1, 1);
4648     path.close();
4649     path.moveTo(0, 0);
4650     path.lineTo(0, 0);
4651     path.quadTo(1, 0, 2, 2);
4652     path.close();
4653     testSimplify(reporter, path, filename);
4654 }
4655
4656 static void testQuadralateral10(skiatest::Reporter* reporter, const char* filename) {
4657     SkPath path;
4658     path.setFillType(SkPath::kWinding_FillType);
4659     path.moveTo(0, 0);
4660     path.lineTo(0, 0);
4661     path.lineTo(0, 0);
4662     path.lineTo(2, 2);
4663     path.close();
4664     path.moveTo(1, 0);
4665     path.lineTo(1, 1);
4666     path.lineTo(2, 2);
4667     path.lineTo(1, 3);
4668     path.close();
4669     testSimplify(reporter, path, filename);
4670 }
4671
4672 static void testRect3(skiatest::Reporter* reporter, const char* filename) {
4673     SkPath path;
4674     path.setFillType(SkPath::kEvenOdd_FillType);
4675     path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction);
4676     path.addRect(10, 30, 40, 30, SkPath::kCCW_Direction);
4677     path.addRect(24, 6, 36, 36, SkPath::kCCW_Direction);
4678     path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
4679     testSimplify(reporter, path, filename);
4680 }
4681
4682 static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
4683
4684 static TestDesc tests[] = {
4685     TEST(testRect3),
4686     TEST(testQuadralateral10),
4687     TEST(testQuads61),
4688     TEST(testQuads60),
4689     TEST(testQuads59),
4690     TEST(testQuads58),
4691     TEST(testQuads57),
4692     TEST(testQuads56),
4693     TEST(testQuads54),
4694     TEST(testQuads53),
4695     TEST(testQuads52),
4696     TEST(testQuads51),
4697     TEST(testQuads50),
4698     TEST(testQuads49),
4699     TEST(testQuads48),
4700     TEST(testQuads47),
4701     TEST(testQuads46x),
4702     TEST(testQuads45),
4703     TEST(testQuads44),
4704     TEST(testQuads43),
4705     TEST(testQuads42),
4706     TEST(testQuads41),
4707     TEST(testQuads36),
4708     TEST(testQuads37),
4709     TEST(testQuads38),
4710     TEST(testQuads39),
4711     TEST(testQuads40),
4712     TEST(testQuads16),
4713     TEST(testQuads17),
4714     TEST(testQuads18),
4715     TEST(testQuads19),
4716     TEST(testQuads20),
4717     TEST(testQuads21),
4718     TEST(testQuads22),
4719     TEST(testQuads23),
4720     TEST(testQuads24),
4721     TEST(testQuads25),
4722     TEST(testQuads26),
4723     TEST(testQuads27),
4724     TEST(testQuads28),
4725     TEST(testQuads29),
4726     TEST(testQuads30),
4727     TEST(testQuads31),
4728     TEST(testQuads32),
4729     TEST(testQuads33),
4730     TEST(testQuads34),
4731     TEST(testQuads35),
4732     TEST(testDegenerates1),
4733     TEST(testQuad13),
4734     TEST(testQuad14),
4735     TEST(testQuad15),
4736     TEST(testQuadratic56),
4737     TEST(testQuadralateral4),
4738     TEST(testQuadralateral3),
4739     TEST(testDegenerate5),
4740     TEST(testQuad12),
4741     TEST(testQuadratic51),  // has unorderable angles
4742     TEST(testQuad8),
4743     TEST(testQuad11),
4744     TEST(testQuad10),
4745     TEST(testQuad9),
4746     TEST(testTriangles4x),
4747     TEST(testTriangles3x),
4748     TEST(testRect2),
4749     TEST(testRect1),
4750     TEST(tooCloseTest),
4751     TEST(skphealth_com76),
4752     TEST(testQuadLineIntersect1),
4753     TEST(testQuadLineIntersect2),
4754     TEST(testQuadLineIntersect3),
4755     TEST(testQuad7),
4756     TEST(testQuad6),
4757     TEST(testQuad5),
4758     TEST(testQuad4),
4759     TEST(testQuad3),
4760     TEST(testQuad2),
4761     TEST(testAddTCoincident2),
4762     TEST(testAddTCoincident1),
4763     TEST(testTriangles2),
4764     TEST(testTriangles1),
4765     TEST(testQuadratic97),
4766     TEST(testQuadratic96),
4767     TEST(testQuadratic95),
4768     TEST(testQuadratic94),
4769     TEST(testQuadralateral2),
4770     TEST(testQuad1),
4771     TEST(testCubic2),
4772     TEST(testCubic1),
4773     TEST(testQuadralateral1),
4774     TEST(testLine85),
4775     TEST(testLine84),
4776     TEST(testLine84x),
4777     TEST(testLine83),
4778     TEST(testLine82h),
4779     TEST(testLine82g),
4780     TEST(testLine82f),
4781     TEST(testLine82e),
4782     TEST(testLine82d),
4783     TEST(testLine82c),
4784     TEST(testLine82b),
4785     TEST(testLine82a),
4786     TEST(testLine82),
4787     TEST(testQuadratic93),
4788     TEST(testQuadratic92x),
4789     TEST(testQuadratic91),
4790     TEST(testQuadratic90x),
4791     TEST(testQuadratic89x),
4792     TEST(testQuadratic88),
4793     TEST(testQuadratic87),
4794     TEST(testQuadratic86),
4795     TEST(testQuadratic85),
4796     TEST(testQuadratic84),
4797     TEST(testQuadratic83),
4798     TEST(testQuadratic82),
4799     TEST(testQuadratic81),
4800     TEST(testQuadratic80),
4801     TEST(testEight1),
4802     TEST(testEight2),
4803     TEST(testEight3),
4804     TEST(testEight4),
4805     TEST(testEight5),
4806     TEST(testEight6),
4807     TEST(testEight7),
4808     TEST(testEight8),
4809     TEST(testEight9),
4810     TEST(testEight10),
4811     TEST(testQuadratic79),
4812     TEST(testQuadratic78),
4813     TEST(testQuadratic77),
4814     TEST(testQuadratic76),
4815     TEST(testQuadratic75),
4816     TEST(testQuadratic74),
4817     TEST(testQuadratic73),
4818     TEST(testQuadratic72),
4819     TEST(testQuadratic71),
4820     TEST(testQuadratic70x),
4821     TEST(testQuadratic69),
4822     TEST(testQuadratic68),
4823     TEST(testQuadratic67x),
4824     TEST(testQuadratic65),
4825     TEST(testQuadratic64),
4826     TEST(testQuadratic63),
4827     TEST(testLine1a),
4828     TEST(testLine1ax),
4829     TEST(testQuadratic59),
4830     TEST(testQuadratic59x),
4831     TEST(testQuadratic58),
4832     TEST(testQuadratic55),
4833     TEST(testQuadratic53),
4834     TEST(testQuadratic38),
4835     TEST(testQuadratic37),
4836     TEST(testQuadratic36),
4837     TEST(testQuadratic35),
4838     TEST(testQuadratic34),
4839     TEST(testQuadratic33),
4840     TEST(testQuadratic32),
4841     TEST(testQuadratic31),
4842     TEST(testQuadratic30),
4843     TEST(testQuadratic29),
4844     TEST(testQuadratic28),
4845     TEST(testQuadratic27),
4846     TEST(testQuadratic26),
4847     TEST(testQuadratic25),
4848     TEST(testQuadratic24),
4849     TEST(testQuadratic23),
4850     TEST(testQuadratic22),
4851     TEST(testQuadratic21),
4852     TEST(testQuadratic20),
4853     TEST(testQuadratic19),
4854     TEST(testQuadratic18),
4855     TEST(testQuadratic17x),
4856     TEST(testQuadratic15),
4857     TEST(testQuadratic14),
4858     TEST(testQuadratic9),
4859     TEST(testQuadratic8),
4860     TEST(testQuadratic7),
4861     TEST(testQuadratic6),
4862     TEST(testQuadratic5),
4863     TEST(testQuadratic4x),
4864     TEST(testQuadratic3x),
4865     TEST(testQuadratic2x),
4866     TEST(testQuadratic1x),
4867     TEST(testQuadratic4),
4868     TEST(testQuadratic3),
4869     TEST(testQuadratic2),
4870     TEST(testQuadratic1),
4871     TEST(testLine4ax),
4872     TEST(testLine3aax),
4873     TEST(testLine2ax),
4874     TEST(testLine1ax),
4875     TEST(testQuadralateral9x),
4876     TEST(testQuadralateral8x),
4877     TEST(testQuadralateral7x),
4878     TEST(testQuadralateral6x),
4879     TEST(testQuadralateral6ax),
4880     TEST(testQuadralateral9),
4881     TEST(testQuadralateral8),
4882     TEST(testQuadralateral7),
4883     TEST(testQuadralateral6),
4884     TEST(testQuadralateral6a),
4885     TEST(testFauxQuadralateral6dx),
4886     TEST(testFauxQuadralateral6cx),
4887     TEST(testFauxQuadralateral6bx),
4888     TEST(testFauxQuadralateral6ax),
4889     TEST(testFauxQuadralateral6x),
4890     TEST(testFauxQuadralateral6d),
4891     TEST(testFauxQuadralateral6c),
4892     TEST(testFauxQuadralateral6b),
4893     TEST(testFauxQuadralateral6a),
4894     TEST(testFauxQuadralateral6),
4895     TEST(testQuadralateral5x),
4896     TEST(testQuadralateral5),
4897     TEST(testNondegenerate4x),
4898     TEST(testNondegenerate3x),
4899     TEST(testNondegenerate2x),
4900     TEST(testNondegenerate1x),
4901     TEST(testNondegenerate4),
4902     TEST(testNondegenerate3),
4903     TEST(testNondegenerate2),
4904     TEST(testNondegenerate1),
4905     TEST(testDegenerate4x),
4906     TEST(testDegenerate3x),
4907     TEST(testDegenerate2x),
4908     TEST(testDegenerate1x),
4909     TEST(testDegenerate4),
4910     TEST(testDegenerate3),
4911     TEST(testDegenerate2),
4912     TEST(testDegenerate1),
4913     TEST(testLine79x),
4914     TEST(testLine78x),
4915     TEST(testLine77x),
4916     TEST(testLine76x),
4917     TEST(testLine75x),
4918     TEST(testLine74x),
4919     TEST(testLine73x),
4920     TEST(testLine72x),
4921     TEST(testLine71x),
4922     TEST(testLine70x),
4923     TEST(testLine69x),
4924     TEST(testLine68hx),
4925     TEST(testLine68gx),
4926     TEST(testLine68fx),
4927     TEST(testLine68ex),
4928     TEST(testLine68dx),
4929     TEST(testLine68cx),
4930     TEST(testLine68bx),
4931     TEST(testLine68ax),
4932     TEST(testLine67x),
4933     TEST(testLine66x),
4934     TEST(testLine65x),
4935     TEST(testLine64x),
4936     TEST(testLine63x),
4937     TEST(testLine62x),
4938     TEST(testLine61x),
4939     TEST(testLine60x),
4940     TEST(testLine59x),
4941     TEST(testLine58x),
4942     TEST(testLine57x),
4943     TEST(testLine56x),
4944     TEST(testLine55x),
4945     TEST(testLine54x),
4946     TEST(testLine53x),
4947     TEST(testLine52x),
4948     TEST(testLine51x),
4949     TEST(testLine50x),
4950     TEST(testLine49x),
4951     TEST(testLine48x),
4952     TEST(testLine47x),
4953     TEST(testLine46x),
4954     TEST(testLine45x),
4955     TEST(testLine44x),
4956     TEST(testLine43x),
4957     TEST(testLine42x),
4958     TEST(testLine41x),
4959     TEST(testLine40x),
4960     TEST(testLine38x),
4961     TEST(testLine37x),
4962     TEST(testLine36x),
4963     TEST(testLine35x),
4964     TEST(testLine34x),
4965     TEST(testLine33x),
4966     TEST(testLine32x),
4967     TEST(testLine31x),
4968     TEST(testLine30x),
4969     TEST(testLine29x),
4970     TEST(testLine28x),
4971     TEST(testLine27x),
4972     TEST(testLine26x),
4973     TEST(testLine25x),
4974     TEST(testLine24ax),
4975     TEST(testLine24x),
4976     TEST(testLine23x),
4977     TEST(testLine22x),
4978     TEST(testLine21x),
4979     TEST(testLine20x),
4980     TEST(testLine19x),
4981     TEST(testLine18x),
4982     TEST(testLine17x),
4983     TEST(testLine16x),
4984     TEST(testLine15x),
4985     TEST(testLine14x),
4986     TEST(testLine13x),
4987     TEST(testLine12x),
4988     TEST(testLine11x),
4989     TEST(testLine10ax),
4990     TEST(testLine10x),
4991     TEST(testLine9x),
4992     TEST(testLine8x),
4993     TEST(testLine7bx),
4994     TEST(testLine7ax),
4995     TEST(testLine7x),
4996     TEST(testLine6x),
4997     TEST(testLine5x),
4998     TEST(testLine4x),
4999     TEST(testLine3bx),
5000     TEST(testLine3ax),
5001     TEST(testLine3x),
5002     TEST(testLine2x),
5003     TEST(testLine1x),
5004     TEST(testLine81),
5005     TEST(testLine80),
5006     TEST(testLine79),
5007     TEST(testLine78),
5008     TEST(testLine77),
5009     TEST(testLine76),
5010     TEST(testLine75),
5011     TEST(testLine74),
5012     TEST(testLine73),
5013     TEST(testLine72),
5014     TEST(testLine71),
5015     TEST(testLine70),
5016     TEST(testLine69),
5017     TEST(testLine68h),
5018     TEST(testLine68g),
5019     TEST(testLine68f),
5020     TEST(testLine68e),
5021     TEST(testLine68d),
5022     TEST(testLine68c),
5023     TEST(testLine68b),
5024     TEST(testLine68a),
5025     TEST(testLine67),
5026     TEST(testLine66),
5027     TEST(testLine65),
5028     TEST(testLine64),
5029     TEST(testLine63),
5030     TEST(testLine62),
5031     TEST(testLine61),
5032     TEST(testLine60),
5033     TEST(testLine59),
5034     TEST(testLine58),
5035     TEST(testLine57),
5036     TEST(testLine56),
5037     TEST(testLine55),
5038     TEST(testLine54),
5039     TEST(testLine53),
5040     TEST(testLine52),
5041     TEST(testLine51),
5042     TEST(testLine50),
5043     TEST(testLine49),
5044     TEST(testLine48),
5045     TEST(testLine47),
5046     TEST(testLine46),
5047     TEST(testLine45),
5048     TEST(testLine44),
5049     TEST(testLine43),
5050     TEST(testLine42),
5051     TEST(testLine41),
5052     TEST(testLine40),
5053     TEST(testLine38),
5054     TEST(testLine37),
5055     TEST(testLine36),
5056     TEST(testLine35),
5057     TEST(testLine34),
5058     TEST(testLine33),
5059     TEST(testLine32),
5060     TEST(testLine31),
5061     TEST(testLine30),
5062     TEST(testLine29),
5063     TEST(testLine28),
5064     TEST(testLine27),
5065     TEST(testLine26),
5066     TEST(testLine25),
5067     TEST(testLine24a),
5068     TEST(testLine24),
5069     TEST(testLine23),
5070     TEST(testLine22),
5071     TEST(testLine21),
5072     TEST(testLine20),
5073     TEST(testLine19),
5074     TEST(testLine18),
5075     TEST(testLine17),
5076     TEST(testLine16),
5077     TEST(testLine15),
5078     TEST(testLine14),
5079     TEST(testLine13),
5080     TEST(testLine12),
5081     TEST(testLine11),
5082     TEST(testLine10a),
5083     TEST(testLine10),
5084     TEST(testLine9),
5085     TEST(testLine8),
5086     TEST(testLine7b),
5087     TEST(testLine7a),
5088     TEST(testLine7),
5089     TEST(testLine6),
5090     TEST(testLine5),
5091     TEST(testLine4),
5092     TEST(testLine3b),
5093     TEST(testLine3a),
5094     TEST(testLine3),
5095     TEST(testLine2),
5096     TEST(testLine1),
5097 };
5098
5099 static const size_t testCount = SK_ARRAY_COUNT(tests);
5100
5101 static TestDesc subTests[] = {
5102     TEST(testLine3),
5103     TEST(testLine2),
5104     TEST(testLine1),
5105 };
5106
5107 static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
5108
5109 static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0;
5110
5111 static bool runSubTests = false;
5112 static bool runSubTestsFirst = false;
5113 static bool runReverse = false;
5114 static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
5115
5116 DEF_TEST(PathOpsSimplify, reporter) {
5117     if (runSubTests && runSubTestsFirst) {
5118         RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
5119     }
5120     RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
5121     if (runSubTests && !runSubTestsFirst) {
5122         RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
5123     }
5124 }