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