experimental/Intersection/SimplifyNew_Test.cpp - Issue 867213004: remove prototype pathops code

Side by Side Diff: experimental/Intersection/SimplifyNew_Test.cpp

Issue 867213004: remove prototype pathops code (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: Created 5 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
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

14 static 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

23 static 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

33 static void addInnerCWTriangle(SkPath& path) {

34 path.moveTo(3,0);

35 path.lineTo(4,1);

36 path.lineTo(2,1);

37 path.close();

38 }

39

40 static void addInnerCCWTriangle(SkPath& path) {

41 path.moveTo(3,0);

42 path.lineTo(2,1);

43 path.lineTo(4,1);

44 path.close();

45 }

46

47 static void addOuterCWTriangle(SkPath& path) {

48 path.moveTo(3,0);

49 path.lineTo(6,2);

50 path.lineTo(0,2);

51 path.close();

52 }

53

54 static void addOuterCCWTriangle(SkPath& path) {

55 path.moveTo(3,0);

56 path.lineTo(0,2);

57 path.lineTo(6,2);

58 path.close();

59 }

60

61 static void testLine2() {

62 SkPath path;

63 path.setFillType(SkPath::kEvenOdd_FillType);

64 addInnerCWTriangle(path);

65 addOuterCWTriangle(path);

66 testSimplifyx(path);

67 }

68

69 static void testLine2x() {

70 SkPath path;

71 path.setFillType(SkPath::kEvenOdd_FillType);

72 addInnerCWTriangle(path);

73 addOuterCWTriangle(path);

74 testSimplifyx(path);

75 }

76

77 static void testLine3() {

78 SkPath path;

79 path.setFillType(SkPath::kEvenOdd_FillType);

80 addInnerCCWTriangle(path);

81 addOuterCWTriangle(path);

82 testSimplifyx(path);

83 }

84

85 static void testLine3x() {

86 SkPath path;

87 path.setFillType(SkPath::kEvenOdd_FillType);

88 addInnerCCWTriangle(path);

89 addOuterCWTriangle(path);

90 testSimplifyx(path);

91 }

92

93 static void testLine3a() {

94 SkPath path;

95 addInnerCWTriangle(path);

96 addOuterCCWTriangle(path);

97 testSimplifyx(path);

98 }

99

100 static void testLine3ax() {

101 SkPath path;

102 path.setFillType(SkPath::kEvenOdd_FillType);

103 addInnerCWTriangle(path);

104 addOuterCCWTriangle(path);

105 testSimplifyx(path);

106 }

107

108 static void testLine3b() {

109 SkPath path;

110 addInnerCCWTriangle(path);

111 addOuterCCWTriangle(path);

112 testSimplifyx(path);

113 }

114

115 static void testLine3bx() {

116 SkPath path;

117 path.setFillType(SkPath::kEvenOdd_FillType);

118 addInnerCCWTriangle(path);

119 addOuterCCWTriangle(path);

120 testSimplifyx(path);

121 }

122

123 static void testLine4() {

124 SkPath path;

125 addOuterCCWTriangle(path);

126 addOuterCWTriangle(path);

127 testSimplifyx(path);

128 }

129

130 static void testLine4x() {

131 SkPath path;

132 path.setFillType(SkPath::kEvenOdd_FillType);

133 addOuterCCWTriangle(path);

134 addOuterCWTriangle(path);

135 testSimplifyx(path);

136 }

137

138 static void testLine5() {

139 SkPath path;

140 addOuterCWTriangle(path);

141 addOuterCWTriangle(path);

142 testSimplifyx(path);

143 }

144

145 static void testLine5x() {

146 SkPath path;

147 path.setFillType(SkPath::kEvenOdd_FillType);

148 addOuterCWTriangle(path);

149 addOuterCWTriangle(path);

150 testSimplifyx(path);

151 }

152

153 static 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

166 static 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

180 static 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

193 static 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

207 static 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

216 static 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

226 static 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

238 static 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

251 static 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

264 static 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

278 static 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

291 static 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

305 static 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

318 static 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

332 static 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

345 static 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

359 static void addCWContainer(SkPath& path) {

360 path.moveTo(6,4);

361 path.lineTo(0,4);

362 path.lineTo(3,1);

363 path.close();

364 }

365

366 static void addCCWContainer(SkPath& path) {

367 path.moveTo(0,4);

368 path.lineTo(6,4);

369 path.lineTo(3,1);

370 path.close();

371 }

372

373 static void addCWContents(SkPath& path) {

374 path.moveTo(2,3);

375 path.lineTo(3,2);

376 path.lineTo(4,3);

377 path.close();

378 }

379

380 static void addCCWContents(SkPath& path) {

381 path.moveTo(3,2);

382 path.lineTo(2,3);

383 path.lineTo(4,3);

384 path.close();

385 }

386

387 static void testLine11() {

388 SkPath path;

389 addCWContainer(path);

390 addCWContents(path);

391 testSimplifyx(path);

392 }

393

394 static void testLine11x() {

395 SkPath path;

396 path.setFillType(SkPath::kEvenOdd_FillType);

397 addCWContainer(path);

398 addCWContents(path);

399 testSimplifyx(path);

400 }

401

402 static void testLine12() {

403 SkPath path;

404 addCCWContainer(path);

405 addCWContents(path);

406 testSimplifyx(path);

407 }

408

409 static void testLine12x() {

410 SkPath path;

411 path.setFillType(SkPath::kEvenOdd_FillType);

412 addCCWContainer(path);

413 addCWContents(path);

414 testSimplifyx(path);

415 }

416

417 static void testLine13() {

418 SkPath path;

419 addCWContainer(path);

420 addCCWContents(path);

421 testSimplifyx(path);

422 }

423

424 static void testLine13x() {

425 SkPath path;

426 path.setFillType(SkPath::kEvenOdd_FillType);

427 addCWContainer(path);

428 addCCWContents(path);

429 testSimplifyx(path);

430 }

431

432 static void testLine14() {

433 SkPath path;

434 addCCWContainer(path);

435 addCCWContents(path);

436 testSimplifyx(path);

437 }

438

439 static void testLine14x() {

440 SkPath path;

441 path.setFillType(SkPath::kEvenOdd_FillType);

442 addCCWContainer(path);

443 addCCWContents(path);

444 testSimplifyx(path);

445 }

446

447 static void testLine15() {

448 SkPath path;

449 path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);

450 testSimplifyx(path);

451 }

452

453 static 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

460 static 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

467 static 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

475 static 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

482 static 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

490 static 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

497 static 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

505 static 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

512 static 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

520 static 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

527 static 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

535 static 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

542 static 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

550 static 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

557 static 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

565 static 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

572 static 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

580 static 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

593 static 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

607 static 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

614 static 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

622 static 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

629 static 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

637 static 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

644 static 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

652 static 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

659 static 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

667 static 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

674 static 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

682 static 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

689 static 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

697 static 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

705 static 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

714 static 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

722 static 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

731 static 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

739 static 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

748 static 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

756 static 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

765 static 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

773 static 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

782 static 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

790 static 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

799 static 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

807 static 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

816 static 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

824 static 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

833 static 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

841 static 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

850 static 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

858 static 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

867 static 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

875 static 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

884 static 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

892 static 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

901 static 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

909 static 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

918 static 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

926 static 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

935 static 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

943 static 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

952 static 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

960 static 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

969 static 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

977 static 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

986 static 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

994 static 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

1003 static 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

1011 static 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

1020 static 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

1027 static 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

1035 static 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

1043 static 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

1052 static 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

1060 static 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

1069 static 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

1077 static 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

1086 static 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

1094 static 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

1103 static 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

1111 static 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

1120 static 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

1128 static 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

1137 static 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

1145 static 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

1154 static 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

1162 static 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

1171 static 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

1179 static 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

1188 static 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

1196 static 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

1205 static 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

1213 static 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

1222 static 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

1231 static 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

1241 static 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

1250 static 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

1260 static 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

1268 static 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

1277 static 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

1286 static 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

1296 static 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

1304 static 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

1313 static 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

1322 static 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

1332 static 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

1340 static 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

1349 static 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

1357 static 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

1366 static 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

1374 static 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

1383 static 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

1391 static 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

1400 static 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

1409 static 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

1419 static 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

1428 static 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

1438 static 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

1448 static 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

1459 static 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

1469 static 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

1480 static 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

1488 static 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

1497 static 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

1505 static 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

1514 static 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

1522 static 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

1531 static 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

1539 static 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

1548 static 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

1557 static 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

1567 static 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

1575 static 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

1584 static 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

1593 static 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

1603 static 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

1612 static 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

1622 static 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

1630 static 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

1639 static 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

1648 static 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

1658 static 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

1667 static 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

1677 static 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

1687 static 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

1700 static 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

1714 static 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

1727 static 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

1741 static 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

1754 static 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

1768 static 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

1781 static 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

1795 static 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

1808 static 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

1822 static 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

1835 static 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

1849 static 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

1862 static 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

1876 static 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

1889 static 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

1903 static 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

1918 static 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

1934 static 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

1949 static 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

1965 static 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

1982 static 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

2000 static 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

2017 static 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

2035 static 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

2052 static 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

2070 static 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

2087 static 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

2105 static 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

2122 static 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

2140 static 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

2155 static 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

2171 static 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

2186 static 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

2202 static 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

2217 static 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

2233 static 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

2248 static 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

2264 static 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

2272 static 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

2280 static 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

2289 static 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

2298 static 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

2307 static 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

2320 static 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

2334 static 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

2347 static 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

2361 static 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

2374 static 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

2388 static 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

2401 static 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

2415 static 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

2428 static 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

2441 static 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

2454 static 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

2467 static 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

2480 static 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

2493 static 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

2506 static 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

2520 static 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

2533 static 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

2546 static 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

2559 static 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

2572 static 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

2585 static 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

2598 static 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

2611 static 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

2624 static 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

2637 static 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

2650 static 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

2663 static 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

2676 static 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

2689 static 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

2702 static 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

2715 static 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

2728 static 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

2741 static 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

2754 static 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

2767 static 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

2780 static 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

2793 static 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

2806 static 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 }

2819 static void testQuadratic55() {

2820 SkPath path;

2821 path.moveTo(303.12088f, 141.299606f);

2822 path.lineTo(330.463562f, 217.659027f);

2823 path.lineTo(358.606506f, 141.299606f);

2824 path.lineTo(303.12088f, 141.299606f);

2825 path.close();

2826 path.moveTo(326.236786f, 205.854996f);

2827 path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);

2828 path.lineTo(326.236786f, 205.854996f);

2829 path.close();

2830 testSimplifyx(path);

2831 }

2832

2833 static void testQuadratic56() {

2834 SkPath path;

2835 path.moveTo(366.608826f, 151.196014f);

2836 path.quadTo(378.803101f, 136.674606f, 398.164948f, 136.674606f);

2837 path.lineTo(354.009216f, 208.816208f);

2838 path.lineTo(393.291473f, 102.232819f);

2839 path.lineTo(359.978058f, 136.581512f);

2840 path.quadTo(378.315979f, 136.581512f, 388.322723f, 149.613556f);

2841 path.lineTo(364.390686f, 157.898193f);

2842 path.quadTo(375.281769f, 136.674606f, 396.039917f, 136.674606f);

2843 path.lineTo(350, 120);

2844 path.lineTo(366.608826f, 151.196014f);

2845 path.close();

2846 testSimplifyx(path);

2847 }

2848

2849 static void testLine80() {

2850 SkPath path;

2851 path.moveTo(4, 0);

2852 path.lineTo(3, 7);

2853 path.lineTo(7, 5);

2854 path.lineTo(2, 2);

2855 path.close();

2856 path.moveTo(0, 6);

2857 path.lineTo(6, 12);

2858 path.lineTo(8, 3);

2859 path.close();

2860 testSimplifyx(path);

2861 }

2862

2863 static void testQuadratic58() {

2864 SkPath path;

2865 path.moveTo(283.714233f, 240);

2866 path.lineTo(283.714233f, 141.299606f);

2867 path.lineTo(303.12088f, 141.299606f);

2868 path.lineTo(330.463562f, 217.659027f);

2869 path.lineTo(358.606506f, 141.299606f);

2870 path.lineTo(362.874634f, 159.705902f);

2871 path.lineTo(335.665344f, 233.397751f);

2872 path.lineTo(322.12738f, 233.397751f);

2873 path.lineTo(295.718353f, 159.505829f);

2874 path.lineTo(295.718353f, 240);

2875 path.lineTo(283.714233f, 240);

2876 path.close();

2877 path.moveTo(322.935669f, 231.030273f);

2878 path.quadTo(312.832214f, 220.393295f, 312.832214f, 203.454178f);

2879 path.quadTo(312.832214f, 186.981888f, 321.73526f, 176.444946f);

2880 path.quadTo(330.638306f, 165.90802f, 344.509705f, 165.90802f);

2881 path.quadTo(357.647522f, 165.90802f, 364.81665f, 175.244537f);

2882 path.lineTo(371.919067f, 205.854996f);

2883 path.lineTo(326.236786f, 205.854996f);

2884 path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);

2885 path.lineTo(322.935669f, 231.030273f);

2886 path.close();

2887 path.moveTo(326.837006f, 195.984955f);

2888 path.lineTo(358.78125f, 195.984955f);

2889 path.quadTo(358.78125f, 175.778046f, 343.709442f, 175.778046f);

2890 path.quadTo(328.570923f, 175.778046f, 326.837006f, 195.984955f);

2891 path.close();

2892 testSimplifyx(path);

2893 }

2894

2895 static 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

2909 static 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

2923 static 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

2936 static 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

2949 static 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

2962 static 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

2976 static 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

2989 static 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

3002 static 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

3016 static 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

3029 static 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

3042 static 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

3055 static 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

3068 static 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

3081 static 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

3094 static 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

3107 static 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

3120 static 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

3133 static 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

3143 static 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

3153 static 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

3163 static 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

3173 static 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

3183 static 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

3193 static 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

3203 static 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

3213 static 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

3223 static 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

3233 static 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

3246 static 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

3259 static 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

3272 static 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

3285 static 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

3298 static 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

3311 static 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

3324 static 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

3337 static 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

3350 static 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

3364 static 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

3378 static 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

3391 static 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

3405 static 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

3413 static 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

3421 static 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

3429 static 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

3437 static 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

3445 static 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

3453 static 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

3461 static 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

3469 static 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

3477 static void testLine83() {

3478 SkPath path;

3479 path.addRect(10, 30, 30, 40, SkPath::kCCW_Direction);

3480 path.addRect(0, 12, 12, 18, SkPath::kCCW_Direction);

3481 path.addRect(4, 13, 13, 16, SkPath::kCCW_Direction);

3482 testSimplifyx(path);

3483 }

3484

3485 static 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

3494 static 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

3504 static 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

3513 static 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

3528 static 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 static void testQuadratic93() {

3540 SkPath path;

3541 path.moveTo(3, 0);

3542 path.quadTo(0, 1, 3, 2);

3543 path.lineTo(0, 3);

3544 path.close();

3545 path.moveTo(1, 0);

3546 path.lineTo(2, 0);

3547 path.quadTo(1, 1, 2, 2);

3548 path.close();

3549 testSimplifyx(path);

3550 }

3551

3552 static void cubicOp1d() {

3553 SkPath path, pathB;

3554 path.setFillType(SkPath::kWinding_FillType);

3555 path.moveTo(0,1);

3556 path.cubicTo(0,2, 1,0, 1,0);

3557 path.close();

3558 pathB.setFillType(SkPath::kWinding_FillType);

3559 pathB.moveTo(0,1);

3560 pathB.cubicTo(0,1, 1,0, 2,0);

3561 pathB.close();

3562 testShapeOp(path, pathB, kDifference_Op);

3563 }

3564

3565 static void cubicOp2d() {

3566 SkPath path, pathB;

3567 path.setFillType(SkPath::kWinding_FillType);

3568 path.moveTo(0,2);

3569 path.cubicTo(0,1, 1,0, 1,0);

3570 path.close();

3571 pathB.setFillType(SkPath::kWinding_FillType);

3572 pathB.moveTo(0,1);

3573 pathB.cubicTo(0,1, 2,0, 1,0);

3574 pathB.close();

3575 testShapeOp(path, pathB, kDifference_Op);

3576 }

3577

3578 static void cubicOp3d() {

3579 SkPath path, pathB;

3580 path.setFillType(SkPath::kWinding_FillType);

3581 path.moveTo(0,1);

3582 path.cubicTo(2,3, 1,0, 1,0);

3583 path.close();

3584 pathB.setFillType(SkPath::kWinding_FillType);

3585 pathB.moveTo(0,1);

3586 pathB.cubicTo(0,1, 1,0, 3,2);

3587 pathB.close();

3588 testShapeOp(path, pathB, kDifference_Op);

3589 }

3590

3591 static void cubicOp5d() {

3592 SkPath path, pathB;

3593 path.setFillType(SkPath::kWinding_FillType);

3594 path.moveTo(0,1);

3595 path.cubicTo(0,2, 1,0, 2,0);

3596 path.close();

3597 pathB.setFillType(SkPath::kWinding_FillType);

3598 pathB.moveTo(0,1);

3599 pathB.cubicTo(0,2, 1,0, 2,0);

3600 pathB.close();

3601 testShapeOp(path, pathB, kDifference_Op);

3602 }

3603

3604 static void cubicOp6d() {

3605 SkPath path, pathB;

3606 path.setFillType(SkPath::kWinding_FillType);

3607 path.moveTo(0,1);

3608 path.cubicTo(0,6, 1,0, 3,0);

3609 path.close();

3610 pathB.setFillType(SkPath::kWinding_FillType);

3611 pathB.moveTo(0,1);

3612 pathB.cubicTo(0,3, 1,0, 6,0);

3613 pathB.close();

3614 testShapeOp(path, pathB, kDifference_Op);

3615 }

3616

3617 static void cubicOp7d() {

3618 SkPath path, pathB;

3619 path.setFillType(SkPath::kWinding_FillType);

3620 path.moveTo(0,1);

3621 path.cubicTo(3,4, 1,0, 3,0);

3622 path.close();

3623 pathB.setFillType(SkPath::kWinding_FillType);

3624 pathB.moveTo(0,1);

3625 pathB.cubicTo(0,3, 1,0, 4,3);

3626 pathB.close();

3627 testShapeOp(path, pathB, kDifference_Op);

3628 }

3629

3630 static void cubicOp8d() {

3631 SkPath path, pathB;

3632 path.setFillType(SkPath::kWinding_FillType);

3633 path.moveTo(0,1);

3634 path.cubicTo(0,5, 1,0, 4,0);

3635 path.close();

3636 pathB.setFillType(SkPath::kWinding_FillType);

3637 pathB.moveTo(0,1);

3638 pathB.cubicTo(0,4, 1,0, 5,0);

3639 pathB.close();

3640 testShapeOp(path, pathB, kDifference_Op);

3641 }

3642

3643 static void cubicOp9d() {

3644 SkPath path, pathB;

3645 path.setFillType(SkPath::kWinding_FillType);

3646 path.moveTo(0,1);

3647 path.cubicTo(1,6, 1,0, 2,1);

3648 path.close();

3649 pathB.setFillType(SkPath::kWinding_FillType);

3650 pathB.moveTo(0,1);

3651 pathB.cubicTo(1,2, 1,0, 6,1);

3652 pathB.close();

3653 testShapeOp(path, pathB, kDifference_Op);

3654 }

3655

3656 static void quadOp9d() {

3657 SkPath path, pathB;

3658 path.setFillType(SkPath::kWinding_FillType);

3659 path.moveTo(0,1);

3660 path.quadTo(1,6, 1.5f,1);

3661 path.quadTo(1.5f,0.5f, 2,1);

3662 path.close();

3663 pathB.setFillType(SkPath::kWinding_FillType);

3664 pathB.moveTo(0,1);

3665 pathB.quadTo(1,2, 1.4f,1);

3666 pathB.quadTo(3,0.4f, 6,1);

3667 pathB.close();

3668 testShapeOp(path, pathB, kDifference_Op);

3669 }

3670

3671 static void lineOp9d() {

3672 SkPath path, pathB;

3673 path.setFillType(SkPath::kWinding_FillType);

3674 path.moveTo(0,1);

3675 path.lineTo(1,6);

3676 path.lineTo(1.5f,1);

3677 path.lineTo(1.8f,0.8f);

3678 path.lineTo(2,1);

3679 path.close();

3680 pathB.setFillType(SkPath::kWinding_FillType);

3681 pathB.moveTo(0,1);

3682 pathB.lineTo(1,2);

3683 pathB.lineTo(1.4f,1);

3684 pathB.lineTo(3,0.4f);

3685 pathB.lineTo(6,1);

3686 pathB.close();

3687 testShapeOp(path, pathB, kDifference_Op);

3688 }

3689

3690 static void cubicOp1i() {

3691 SkPath path, pathB;

3692 path.setFillType(SkPath::kWinding_FillType);

3693 path.moveTo(0,1);

3694 path.cubicTo(1,2, 1,0, 2,1);

3695 path.close();

3696 pathB.setFillType(SkPath::kWinding_FillType);

3697 pathB.moveTo(0,1);

3698 pathB.cubicTo(1,2, 1,0, 2,1);

3699 pathB.close();

3700 testShapeOp(path, pathB, kIntersect_Op);

3701 }

3702

3703 static void cubicOp10d() {

3704 SkPath path, pathB;

3705 path.setFillType(SkPath::kWinding_FillType);

3706 path.moveTo(0,1);

3707 path.cubicTo(1,3, 1,0, 4,1);

3708 path.close();

3709 pathB.setFillType(SkPath::kWinding_FillType);

3710 pathB.moveTo(0,1);

3711 pathB.cubicTo(1,4, 1,0, 3,1);

3712 pathB.close();

3713 testShapeOp(path, pathB, kDifference_Op);

3714 }

3715

3716 static void cubicOp11d() {

3717 SkPath path, pathB;

3718 path.setFillType(SkPath::kWinding_FillType);

3719 path.moveTo(0,1);

3720 path.cubicTo(3,4, 1,0, 5,1);

3721 path.close();

3722 pathB.setFillType(SkPath::kWinding_FillType);

3723 pathB.moveTo(0,1);

3724 pathB.cubicTo(1,5, 1,0, 4,3);

3725 pathB.close();

3726 testShapeOp(path, pathB, kDifference_Op);

3727 }

3728

3729 static void cubicOp12d() {

3730 SkPath path, pathB;

3731 path.setFillType(SkPath::kWinding_FillType);

3732 path.moveTo(0,1);

3733 path.cubicTo(1,6, 1,0, 1,0);

3734 path.close();

3735 pathB.setFillType(SkPath::kWinding_FillType);

3736 pathB.moveTo(0,1);

3737 pathB.cubicTo(0,1, 1,0, 6,1);

3738 pathB.close();

3739 testShapeOp(path, pathB, kDifference_Op);

3740 }

3741

3742 static void cubicOp13d() {

3743 SkPath path, pathB;

3744 path.setFillType(SkPath::kWinding_FillType);

3745 path.moveTo(0,1);

3746 path.cubicTo(4,5, 1,0, 5,3);

3747 path.close();

3748 pathB.setFillType(SkPath::kWinding_FillType);

3749 pathB.moveTo(0,1);

3750 pathB.cubicTo(3,5, 1,0, 5,4);

3751 pathB.close();

3752 testShapeOp(path, pathB, kDifference_Op);

3753 }

3754

3755 static void cubicOp14d() {

3756 SkPath path, pathB;

3757 path.setFillType(SkPath::kWinding_FillType);

3758 path.moveTo(0,1);

3759 path.cubicTo(0,2, 2,0, 2,1);

3760 path.close();

3761 pathB.setFillType(SkPath::kWinding_FillType);

3762 pathB.moveTo(0,2);

3763 pathB.cubicTo(1,2, 1,0, 2,0);

3764 pathB.close();

3765 testShapeOp(path, pathB, kDifference_Op);

3766 }

3767

3768 static void cubicOp15d() {

3769 SkPath path, pathB;

3770 path.setFillType(SkPath::kWinding_FillType);

3771 path.moveTo(0,1);

3772 path.cubicTo(3,6, 2,0, 2,1);

3773 path.close();

3774 pathB.setFillType(SkPath::kWinding_FillType);

3775 pathB.moveTo(0,2);

3776 pathB.cubicTo(1,2, 1,0, 6,3);

3777 pathB.close();

3778 testShapeOp(path, pathB, kDifference_Op);

3779 }

3780

3781 static void cubicOp16d() {

3782 SkPath path, pathB;

3783 path.setFillType(SkPath::kWinding_FillType);

3784 path.moveTo(0,2);

3785 path.cubicTo(0,1, 3,0, 1,0);

3786 path.close();

3787 pathB.setFillType(SkPath::kWinding_FillType);

3788 pathB.moveTo(0,3);

3789 pathB.cubicTo(0,1, 2,0, 1,0);

3790 pathB.close();

3791 testShapeOp(path, pathB, kDifference_Op);

3792 }

3793

3794 static void cubicOp17d() {

3795 SkPath path, pathB;

3796 path.setFillType(SkPath::kWinding_FillType);

3797 path.moveTo(0,2);

3798 path.cubicTo(0,2, 4,0, 2,1);

3799 path.close();

3800 pathB.setFillType(SkPath::kWinding_FillType);

3801 pathB.moveTo(0,4);

3802 pathB.cubicTo(1,2, 2,0, 2,0);

3803 pathB.close();

3804 testShapeOp(path, pathB, kDifference_Op);

3805 }

3806

3807 static void cubicOp18d() {

3808 SkPath path, pathB;

3809 path.setFillType(SkPath::kWinding_FillType);

3810 path.moveTo(0,1);

3811 path.cubicTo(3,5, 2,0, 2,1);

3812 path.close();

3813 pathB.setFillType(SkPath::kWinding_FillType);

3814 pathB.moveTo(0,2);

3815 pathB.cubicTo(1,2, 1,0, 5,3);

3816 pathB.close();

3817 testShapeOp(path, pathB, kDifference_Op);

3818 }

3819

3820 static void cubicOp19i() {

3821 SkPath path, pathB;

3822 path.setFillType(SkPath::kWinding_FillType);

3823 path.moveTo(0,2);

3824 path.cubicTo(0,1, 2,1, 6,2);

3825 path.close();

3826 pathB.setFillType(SkPath::kWinding_FillType);

3827 pathB.moveTo(1,2);

3828 pathB.cubicTo(2,6, 2,0, 1,0);

3829 pathB.close();

3830 testShapeOp(path, pathB, kIntersect_Op);

3831 }

3832

3833 static void cubicOp20d() {

3834 SkPath path, pathB;

3835 path.setFillType(SkPath::kWinding_FillType);

3836 path.moveTo(0,1);

3837 path.cubicTo(0,1, 6,0, 2,1);

3838 path.close();

3839 pathB.setFillType(SkPath::kWinding_FillType);

3840 pathB.moveTo(0,6);

3841 pathB.cubicTo(1,2, 1,0, 1,0);

3842 pathB.close();

3843 testShapeOp(path, pathB, kDifference_Op);

3844 }

3845

3846 static void cubicOp21d() {

3847 SkPath path, pathB;

3848 path.setFillType(SkPath::kWinding_FillType);

3849 path.moveTo(0,1);

3850 path.cubicTo(0,1, 2,1, 6,5);

3851 path.close();

3852 pathB.setFillType(SkPath::kWinding_FillType);

3853 pathB.moveTo(1,2);

3854 pathB.cubicTo(5,6, 1,0, 1,0);

3855 pathB.close();

3856 testShapeOp(path, pathB, kDifference_Op);

3857 }

3858

3859 static void cubicOp22d() {

3860 SkPath path, pathB;

3861 path.setFillType(SkPath::kWinding_FillType);

3862 path.moveTo(0,1);

3863 path.cubicTo(2,3, 3,0, 2,1);

3864 path.close();

3865 pathB.setFillType(SkPath::kWinding_FillType);

3866 pathB.moveTo(0,3);

3867 pathB.cubicTo(1,2, 1,0, 3,2);

3868 pathB.close();

3869 testShapeOp(path, pathB, kDifference_Op);

3870 }

3871

3872 static void cubicOp23d() {

3873 SkPath path, pathB;

3874 path.setFillType(SkPath::kWinding_FillType);

3875 path.moveTo(0,1);

3876 path.cubicTo(1,2, 4,0, 2,1);

3877 path.close();

3878 pathB.setFillType(SkPath::kWinding_FillType);

3879 pathB.moveTo(0,4);

3880 pathB.cubicTo(1,2, 1,0, 2,1);

3881 pathB.close();

3882 testShapeOp(path, pathB, kDifference_Op);

3883 }

3884

3885 static void cubicOp24d() {

3886 SkPath path, pathB;

3887 path.setFillType(SkPath::kWinding_FillType);

3888 path.moveTo(0,1);

3889 path.cubicTo(1,2, 2,0, 3,2);

3890 path.close();

3891 pathB.setFillType(SkPath::kWinding_FillType);

3892 pathB.moveTo(0,2);

3893 pathB.cubicTo(2,3, 1,0, 2,1);

3894 pathB.close();

3895 testShapeOp(path, pathB, kDifference_Op);

3896 }

3897

3898 static void testIntersect1() {

3899 SkPath one, two;

3900 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3901 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);

3902 testShapeOp(one, two, kIntersect_Op);

3903 }

3904

3905 static void testUnion1() {

3906 SkPath one, two;

3907 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3908 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);

3909 testShapeOp(one, two, kUnion_Op);

3910 }

3911

3912 static void testDiff1() {

3913 SkPath one, two;

3914 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3915 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);

3916 testShapeOp(one, two, kDifference_Op);

3917 }

3918

3919 static void testXor1() {

3920 SkPath one, two;

3921 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3922 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);

3923 testShapeOp(one, two, kXor_Op);

3924 }

3925

3926 static void testIntersect2() {

3927 SkPath one, two;

3928 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3929 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);

3930 testShapeOp(one, two, kIntersect_Op);

3931 }

3932

3933 static void testUnion2() {

3934 SkPath one, two;

3935 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3936 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);

3937 testShapeOp(one, two, kUnion_Op);

3938 }

3939

3940 static void testDiff2() {

3941 SkPath one, two;

3942 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3943 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);

3944 testShapeOp(one, two, kDifference_Op);

3945 }

3946

3947 static void testXor2() {

3948 SkPath one, two;

3949 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);

3950 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);

3951 testShapeOp(one, two, kXor_Op);

3952 }

3953

3954 static void testOp1d() {

3955 SkPath path, pathB;

3956 path.setFillType(SkPath::kWinding_FillType);

3957 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3958 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

3959 pathB.setFillType(SkPath::kWinding_FillType);

3960 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3961 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3962 testShapeOp(path, pathB, kDifference_Op);

3963 }

3964

3965 static void testOp2d() {

3966 SkPath path, pathB;

3967 path.setFillType(SkPath::kWinding_FillType);

3968 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3969 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

3970 pathB.setFillType(SkPath::kEvenOdd_FillType);

3971 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3972 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3973 testShapeOp(path, pathB, kDifference_Op);

3974 }

3975

3976 static void testOp3d() {

3977 SkPath path, pathB;

3978 path.setFillType(SkPath::kWinding_FillType);

3979 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3980 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);

3981 pathB.setFillType(SkPath::kWinding_FillType);

3982 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3983 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3984 testShapeOp(path, pathB, kDifference_Op);

3985 }

3986

3987 static void testOp1u() {

3988 SkPath path, pathB;

3989 path.setFillType(SkPath::kWinding_FillType);

3990 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3991 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);

3992 pathB.setFillType(SkPath::kWinding_FillType);

3993 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3994 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

3995 testShapeOp(path, pathB, kUnion_Op);

3996 }

3997

3998 static void testOp4d() {

3999 SkPath path, pathB;

4000 path.setFillType(SkPath::kWinding_FillType);

4001 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4002 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);

4003 pathB.setFillType(SkPath::kWinding_FillType);

4004 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4005 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4006 testShapeOp(path, pathB, kDifference_Op);

4007 }

4008

4009 static void testOp5d() {

4010 SkPath path, pathB;

4011 path.setFillType(SkPath::kEvenOdd_FillType);

4012 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

4013 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);

4014 pathB.setFillType(SkPath::kEvenOdd_FillType);

4015 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4016 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4017 testShapeOp(path, pathB, kDifference_Op);

4018 }

4019

4020 static void testOp6d() {

4021 SkPath path, pathB;

4022 path.setFillType(SkPath::kEvenOdd_FillType);

4023 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4024 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);

4025 pathB.setFillType(SkPath::kWinding_FillType);

4026 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4027 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4028 testShapeOp(path, pathB, kDifference_Op);

4029 }

4030

4031 static void testOp7d() {

4032 SkPath path, pathB;

4033 path.setFillType(SkPath::kEvenOdd_FillType);

4034 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

4035 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4036 pathB.setFillType(SkPath::kEvenOdd_FillType);

4037 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4038 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4039 testShapeOp(path, pathB, kDifference_Op);

4040 }

4041

4042 static void testOp2u() {

4043 SkPath path, pathB;

4044 path.setFillType(SkPath::kEvenOdd_FillType);

4045 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

4046 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);

4047 pathB.setFillType(SkPath::kWinding_FillType);

4048 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);

4049 pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);

4050 testShapeOp(path, pathB, kUnion_Op);

4051 }

4052

4053 static void testOp8d() {

4054 SkPath path, pathB;

4055 path.addRect(0, 0, 640, 480);

4056 pathB.moveTo(577330, 1971.72f);

4057 pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);

4058 pathB.close();

4059 testShapeOp(path, pathB, kDifference_Op);

4060 }

4061 static void cubicOp25i() {

4062 SkPath path, pathB;

4063 path.setFillType(SkPath::kWinding_FillType);

4064 path.moveTo(0,1);

4065 path.cubicTo(2,4, 5,0, 3,2);

4066 path.close();

4067 pathB.setFillType(SkPath::kWinding_FillType);

4068 pathB.moveTo(0,5);

4069 pathB.cubicTo(2,3, 1,0, 4,2);

4070 pathB.close();

4071 testShapeOp(path, pathB, kIntersect_Op);

4072 }

4073

4074 static void cubicOp26d() {

4075 SkPath path, pathB;

4076 path.setFillType(SkPath::kWinding_FillType);

4077 path.moveTo(0,1);

4078 path.cubicTo(3,4, 4,0, 3,2);

4079 path.close();

4080 pathB.setFillType(SkPath::kWinding_FillType);

4081 pathB.moveTo(0,4);

4082 pathB.cubicTo(2,3, 1,0, 4,3);

4083 pathB.close();

4084 testShapeOp(path, pathB, kDifference_Op);

4085 }

4086

4087 static void cubicOp27d() {

4088 SkPath path, pathB;

4089 path.setFillType(SkPath::kWinding_FillType);

4090 path.moveTo(0,1);

4091 path.cubicTo(3,6, 1,0, 5,2);

4092 path.close();

4093 pathB.setFillType(SkPath::kWinding_FillType);

4094 pathB.moveTo(0,1);

4095 pathB.cubicTo(2,5, 1,0, 6,3);

4096 pathB.close();

4097 testShapeOp(path, pathB, kDifference_Op);

4098 }

4099

4100 static void cubicOp28u() {

4101 SkPath path, pathB;

4102 path.setFillType(SkPath::kWinding_FillType);

4103 path.moveTo(0,1);

4104 path.cubicTo(1,4, 6,0, 3,2);

4105 path.close();

4106 pathB.setFillType(SkPath::kWinding_FillType);

4107 pathB.moveTo(0,6);

4108 pathB.cubicTo(2,3, 1,0, 4,1);

4109 pathB.close();

4110 testShapeOp(path, pathB, kUnion_Op);

4111 }

4112

4113 static void cubicOp29d() {

4114 SkPath path, pathB;

4115 path.setFillType(SkPath::kWinding_FillType);

4116 path.moveTo(0,1);

4117 path.cubicTo(2,5, 6,0, 4,2);

4118 path.close();

4119 pathB.setFillType(SkPath::kWinding_FillType);

4120 pathB.moveTo(0,6);

4121 pathB.cubicTo(2,4, 1,0, 5,2);

4122 pathB.close();

4123 testShapeOp(path, pathB, kDifference_Op);

4124 }

4125

4126 static void cubicOp30d() {

4127 SkPath path, pathB;

4128 path.setFillType(SkPath::kWinding_FillType);

4129 path.moveTo(0,1);

4130 path.cubicTo(2,5, 6,0, 5,3);

4131 path.close();

4132 pathB.setFillType(SkPath::kWinding_FillType);

4133 pathB.moveTo(0,6);

4134 pathB.cubicTo(3,5, 1,0, 5,2);

4135 pathB.close();

4136 testShapeOp(path, pathB, kDifference_Op);

4137 }

4138

4139 static void cubicOp31d() {

4140 SkPath path, pathB;

4141 path.setFillType(SkPath::kWinding_FillType);

4142 path.moveTo(0,2);

4143 path.cubicTo(0,3, 2,1, 4,0);

4144 path.close();

4145 pathB.setFillType(SkPath::kWinding_FillType);

4146 pathB.moveTo(1,2);

4147 pathB.cubicTo(0,4, 2,0, 3,0);

4148 pathB.close();

4149 testShapeOp(path, pathB, kDifference_Op);

4150 }

4151

4152 static void cubicOp31u() {

4153 SkPath path, pathB;

4154 path.setFillType(SkPath::kWinding_FillType);

4155 path.moveTo(0,2);

4156 path.cubicTo(0,3, 2,1, 4,0);

4157 path.close();

4158 pathB.setFillType(SkPath::kWinding_FillType);

4159 pathB.moveTo(1,2);

4160 pathB.cubicTo(0,4, 2,0, 3,0);

4161 pathB.close();

4162 testShapeOp(path, pathB, kUnion_Op);

4163 }

4164

4165 static void cubicOp31x() {

4166 SkPath path, pathB;

4167 path.setFillType(SkPath::kWinding_FillType);

4168 path.moveTo(0,2);

4169 path.cubicTo(0,3, 2,1, 4,0);

4170 path.close();

4171 pathB.setFillType(SkPath::kWinding_FillType);

4172 pathB.moveTo(1,2);

4173 pathB.cubicTo(0,4, 2,0, 3,0);

4174 pathB.close();

4175 testShapeOp(path, pathB, kXor_Op);

4176 }

4177

4178 static void testCubic2() {

4179 SkPath path;

4180 path.moveTo(0,2);

4181 path.cubicTo(0,3, 2,1, 4,0);

4182 path.close();

4183 path.moveTo(1,2);

4184 path.cubicTo(0,4, 2,0, 3,0);

4185 path.close();

4186 testSimplifyx(path);

4187 }

4188

4189 static void cubicOp32d() {

4190 SkPath path, pathB;

4191 path.setFillType(SkPath::kWinding_FillType);

4192 path.moveTo(0,1);

4193 path.cubicTo(1,2, 6,0, 3,1);

4194 path.close();

4195 pathB.setFillType(SkPath::kWinding_FillType);

4196 pathB.moveTo(0,6);

4197 pathB.cubicTo(1,3, 1,0, 2,1);

4198 pathB.close();

4199 testShapeOp(path, pathB, kDifference_Op);

4200 }

4201

4202 static void cubicOp33i() {

4203 SkPath path, pathB;

4204 path.setFillType(SkPath::kWinding_FillType);

4205 path.moveTo(0,1);

4206 path.cubicTo(1,2, 6,0, 3,1);

4207 path.close();

4208 pathB.setFillType(SkPath::kWinding_FillType);

4209 pathB.moveTo(0,6);

4210 pathB.cubicTo(1,3, 1,0, 2,1);

4211 pathB.close();

4212 testShapeOp(path, pathB, kIntersect_Op);

4213 }

4214

4215 static void cubicOp34d() {

4216 SkPath path, pathB;

4217 path.setFillType(SkPath::kWinding_FillType);

4218 path.moveTo(0,1);

4219 path.cubicTo(3,5, 2,1, 3,1);

4220 path.close();

4221 pathB.setFillType(SkPath::kWinding_FillType);

4222 pathB.moveTo(1,2);

4223 pathB.cubicTo(1,3, 1,0, 5,3);

4224 pathB.close();

4225 testShapeOp(path, pathB, kDifference_Op);

4226 }

4227

4228 static void cubicOp35d() {

4229 SkPath path, pathB;

4230 path.setFillType(SkPath::kWinding_FillType);

4231 path.moveTo(0,1);

4232 path.cubicTo(1,5, 2,1, 4,0);

4233 path.close();

4234 pathB.setFillType(SkPath::kWinding_FillType);

4235 pathB.moveTo(1,2);

4236 pathB.cubicTo(0,4, 1,0, 5,1);

4237 pathB.close();

4238 testShapeOp(path, pathB, kDifference_Op);

4239 }

4240

4241 static void cubicOp36u() {

4242 SkPath path, pathB;

4243 path.setFillType(SkPath::kWinding_FillType);

4244 path.moveTo(0,1);

4245 path.cubicTo(1,6, 2,0, 5,1);

4246 path.close();

4247 pathB.setFillType(SkPath::kWinding_FillType);

4248 pathB.moveTo(0,2);

4249 pathB.cubicTo(1,5, 1,0, 6,1);

4250 pathB.close();

4251 testShapeOp(path, pathB, kUnion_Op);

4252 }

4253

4254 static void cubicOp37d() {

4255 SkPath path, pathB;

4256 path.setFillType(SkPath::kWinding_FillType);

4257 path.moveTo(0,1);

4258 path.cubicTo(2,6, 6,1, 4,3);

4259 path.close();

4260 pathB.setFillType(SkPath::kWinding_FillType);

4261 pathB.moveTo(1,6);

4262 pathB.cubicTo(3,4, 1,0, 6,2);

4263 pathB.close();

4264 testShapeOp(path, pathB, kDifference_Op);

4265 }

4266

4267 #if 1

4268 // this fails to detect a cubic/cubic intersection

4269 // the slight overlap is missed when the cubics are approximated by quadratics

4270 // and the subsequent line/cubic intersection also (correctly) misses the inters ection

4271 // if the line/cubic was a matching line/approx.quadratic then the missing inter section

4272 // could have been detected

4273 static void cubicOp38d() {

4274 SkPath path, pathB;

4275 path.setFillType(SkPath::kWinding_FillType);

4276 path.moveTo(0,1);

4277 path.cubicTo(0,6, 3,2, 4,1);

4278 path.close();

4279 pathB.setFillType(SkPath::kWinding_FillType);

4280 pathB.moveTo(2,3);

4281 pathB.cubicTo(1,4, 1,0, 6,0);

4282 pathB.close();

4283 testShapeOp(path, pathB, kDifference_Op);

4284 }

4285 #endif

4286

4287 static void cubicOp39d() {

4288 SkPath path, pathB;

4289 path.setFillType(SkPath::kWinding_FillType);

4290 path.moveTo(0,1);

4291 path.cubicTo(2,3, 5,1, 4,3);

4292 path.close();

4293 pathB.setFillType(SkPath::kWinding_FillType);

4294 pathB.moveTo(1,5);

4295 pathB.cubicTo(3,4, 1,0, 3,2);

4296 pathB.close();

4297 testShapeOp(path, pathB, kDifference_Op);

4298 }

4299

4300 static void cubicOp40d() {

4301 SkPath path, pathB;

4302 path.setFillType(SkPath::kWinding_FillType);

4303 path.moveTo(0,1);

4304 path.cubicTo(1,5, 3,2, 4,2);

4305 path.close();

4306 pathB.setFillType(SkPath::kWinding_FillType);

4307 pathB.moveTo(2,3);

4308 pathB.cubicTo(2,4, 1,0, 5,1);

4309 pathB.close();

4310 testShapeOp(path, pathB, kDifference_Op);

4311 }

4312

4313 static void cubicOp41i() {

4314 SkPath path, pathB;

4315 path.setFillType(SkPath::kWinding_FillType);

4316 path.moveTo(0,1);

4317 path.cubicTo(2,6, 4,3, 6,4);

4318 path.close();

4319 pathB.setFillType(SkPath::kWinding_FillType);

4320 pathB.moveTo(3,4);

4321 pathB.cubicTo(4,6, 1,0, 6,2);

4322 pathB.close();

4323 testShapeOp(path, pathB, kIntersect_Op);

4324 }

4325

4326 static void cubicOp42d() {

4327 SkPath path, pathB;

4328 path.setFillType(SkPath::kWinding_FillType);

4329 path.moveTo(0,1);

4330 path.cubicTo(1,2, 6,5, 5,4);

4331 path.close();

4332 pathB.setFillType(SkPath::kWinding_FillType);

4333 pathB.moveTo(5,6);

4334 pathB.cubicTo(4,5, 1,0, 2,1);

4335 pathB.close();

4336 testShapeOp(path, pathB, kDifference_Op);

4337 }

4338

4339 static void cubicOp43d() {

4340 SkPath path, pathB;

4341 path.setFillType(SkPath::kWinding_FillType);

4342 path.moveTo(0,2);

4343 path.cubicTo(1,2, 4,0, 3,1);

4344 path.close();

4345 pathB.setFillType(SkPath::kWinding_FillType);

4346 pathB.moveTo(0,4);

4347 pathB.cubicTo(1,3, 2,0, 2,1);

4348 pathB.close();

4349 testShapeOp(path, pathB, kDifference_Op);

4350 }

4351

4352 static void cubicOp44d() {

4353 SkPath path, pathB;

4354 path.setFillType(SkPath::kWinding_FillType);

4355 path.moveTo(0,2);

4356 path.cubicTo(3,6, 4,0, 3,2);

4357 path.close();

4358 pathB.setFillType(SkPath::kWinding_FillType);

4359 pathB.moveTo(0,4);

4360 pathB.cubicTo(2,3, 2,0, 6,3);

4361 pathB.close();

4362 testShapeOp(path, pathB, kDifference_Op);

4363 }

4364

4365 static void cubicOp45d() {

4366 SkPath path, pathB;

4367 path.setFillType(SkPath::kWinding_FillType);

4368 path.moveTo(0,2);

4369 path.cubicTo(2,4, 4,0, 3,2);

4370 path.close();

4371 pathB.setFillType(SkPath::kWinding_FillType);

4372 pathB.moveTo(0,4);

4373 pathB.cubicTo(2,3, 2,0, 4,2);

4374 pathB.close();

4375 testShapeOp(path, pathB, kDifference_Op);

4376 }

4377

4378 static void cubicOp46d() {

4379 SkPath path, pathB;

4380 path.setFillType(SkPath::kWinding_FillType);

4381 path.moveTo(0,2);

4382 path.cubicTo(3,5, 5,0, 4,2);

4383 path.close();

4384 pathB.setFillType(SkPath::kWinding_FillType);

4385 pathB.moveTo(0,5);

4386 pathB.cubicTo(2,4, 2,0, 5,3);

4387 pathB.close();

4388 testShapeOp(path, pathB, kDifference_Op);

4389 }

4390

4391 static void cubicOp47d() {

4392 SkPath path, pathB;

4393 path.setFillType(SkPath::kWinding_FillType);

4394 path.moveTo(0,1);

4395 path.cubicTo(1,6, 6,2, 5,4);

4396 path.close();

4397 pathB.setFillType(SkPath::kWinding_FillType);

4398 pathB.moveTo(2,6);

4399 pathB.cubicTo(4,5, 1,0, 6,1);

4400 pathB.close();

4401 testShapeOp(path, pathB, kDifference_Op);

4402 }

4403

4404 static void cubicOp48d() {

4405 SkPath path, pathB;

4406 path.setFillType(SkPath::kWinding_FillType);

4407 path.moveTo(0,2);

4408 path.cubicTo(2,3, 5,1, 3,2);

4409 path.close();

4410 pathB.setFillType(SkPath::kWinding_FillType);

4411 pathB.moveTo(1,5);

4412 pathB.cubicTo(2,3, 2,0, 3,2);

4413 pathB.close();

4414 testShapeOp(path, pathB, kDifference_Op);

4415 }

4416

4417 static void cubicOp49d() {

4418 SkPath path, pathB;

4419 path.setFillType(SkPath::kWinding_FillType);

4420 path.moveTo(0,2);

4421 path.cubicTo(1,5, 3,2, 4,1);

4422 path.close();

4423 pathB.setFillType(SkPath::kWinding_FillType);

4424 pathB.moveTo(2,3);

4425 pathB.cubicTo(1,4, 2,0, 5,1);

4426 pathB.close();

4427 testShapeOp(path, pathB, kDifference_Op);

4428 }

4429

4430 static void cubicOp50d() {

4431 SkPath path, pathB;

4432 path.setFillType(SkPath::kWinding_FillType);

4433 path.moveTo(0,3);

4434 path.cubicTo(1,6, 5,0, 5,1);

4435 path.close();

4436 pathB.setFillType(SkPath::kWinding_FillType);

4437 pathB.moveTo(0,5);

4438 pathB.cubicTo(1,5, 3,0, 6,1);

4439 pathB.close();

4440 testShapeOp(path, pathB, kDifference_Op);

4441 }

4442

4443 static void cubicOp51d() {

4444 SkPath path, pathB;

4445 path.setFillType(SkPath::kWinding_FillType);

4446 path.moveTo(0,3);

4447 path.cubicTo(1,2, 4,1, 6,0);

4448 path.close();

4449 pathB.setFillType(SkPath::kWinding_FillType);

4450 pathB.moveTo(1,4);

4451 pathB.cubicTo(0,6, 3,0, 2,1);

4452 pathB.close();

4453 testShapeOp(path, pathB, kDifference_Op);

4454 }

4455

4456 static void cubicOp52d() {

4457 SkPath path, pathB;

4458 path.setFillType(SkPath::kWinding_FillType);

4459 path.moveTo(0,2);

4460 path.cubicTo(1,2, 5,4, 4,3);

4461 path.close();

4462 pathB.setFillType(SkPath::kWinding_FillType);

4463 pathB.moveTo(4,5);

4464 pathB.cubicTo(3,4, 2,0, 2,1);

4465 pathB.close();

4466 testShapeOp(path, pathB, kDifference_Op);

4467 }

4468

4469 static void cubicOp53d() {

4470 SkPath path, pathB;

4471 path.setFillType(SkPath::kWinding_FillType);

4472 path.moveTo(0,3);

4473 path.cubicTo(1,2, 5,3, 2,1);

4474 path.close();

4475 pathB.setFillType(SkPath::kWinding_FillType);

4476 pathB.moveTo(3,5);

4477 pathB.cubicTo(1,2, 3,0, 2,1);

4478 pathB.close();

4479 testShapeOp(path, pathB, kDifference_Op);

4480 }

4481

4482 static void cubicOp54d() {

4483 SkPath path, pathB;

4484 path.setFillType(SkPath::kWinding_FillType);

4485 path.moveTo(0,4);

4486 path.cubicTo(1,3, 5,4, 4,2);

4487 path.close();

4488 pathB.setFillType(SkPath::kWinding_FillType);

4489 pathB.moveTo(4,5);

4490 pathB.cubicTo(2,4, 4,0, 3,1);

4491 pathB.close();

4492 testShapeOp(path, pathB, kDifference_Op);

4493 }

4494

4495 static void cubicOp55d() {

4496 SkPath path, pathB;

4497 path.setFillType(SkPath::kWinding_FillType);

4498 path.moveTo(0,5);

4499 path.cubicTo(1,3, 3,2, 5,0);

4500 path.close();

4501 pathB.setFillType(SkPath::kWinding_FillType);

4502 pathB.moveTo(2,3);

4503 pathB.cubicTo(0,5, 5,0, 3,1);

4504 pathB.close();

4505 testShapeOp(path, pathB, kDifference_Op);

4506 }

4507

4508 static void cubicOp56d() {

4509 SkPath path, pathB;

4510 path.setFillType(SkPath::kWinding_FillType);

4511 path.moveTo(0,1);

4512 path.cubicTo(2,6, 5,0, 2,1);

4513 path.close();

4514 pathB.setFillType(SkPath::kWinding_FillType);

4515 pathB.moveTo(0,5);

4516 pathB.cubicTo(1,2, 1,0, 6,2);

4517 pathB.close();

4518 testShapeOp(path, pathB, kDifference_Op);

4519 }

4520

4521 static void cubicOp57d() {

4522 SkPath path, pathB;

4523 path.setFillType(SkPath::kWinding_FillType);

4524 path.moveTo(0,5);

4525 path.cubicTo(0,5, 5,4, 6,4);

4526 path.close();

4527 pathB.setFillType(SkPath::kWinding_FillType);

4528 pathB.moveTo(4,5);

4529 pathB.cubicTo(4,6, 5,0, 5,0);

4530 pathB.close();

4531 testShapeOp(path, pathB, kDifference_Op);

4532 }

4533

4534 static void cubicOp58d() {

4535 SkPath path, pathB;

4536 path.setFillType(SkPath::kWinding_FillType);

4537 path.moveTo(0,5);

4538 path.cubicTo(3,4, 6,5, 5,3);

4539 path.close();

4540 pathB.setFillType(SkPath::kWinding_FillType);

4541 pathB.moveTo(5,6);

4542 pathB.cubicTo(3,5, 5,0, 4,3);

4543 pathB.close();

4544 testShapeOp(path, pathB, kDifference_Op);

4545 }

4546

4547 static void cubicOp59d() {

4548 SkPath path, pathB;

4549 path.setFillType(SkPath::kWinding_FillType);

4550 path.moveTo(0,1);

4551 path.cubicTo(5,6, 4,0, 4,1);

4552 path.close();

4553 pathB.setFillType(SkPath::kWinding_FillType);

4554 pathB.moveTo(0,4);

4555 pathB.cubicTo(1,4, 1,0, 6,5);

4556 pathB.close();

4557 testShapeOp(path, pathB, kDifference_Op);

4558 }

4559

4560 static void cubicOp60d() {

4561 SkPath path, pathB;

4562 path.setFillType(SkPath::kWinding_FillType);

4563 path.moveTo(0,2);

4564 path.cubicTo(4,6, 6,0, 5,2);

4565 path.close();

4566 pathB.setFillType(SkPath::kWinding_FillType);

4567 pathB.moveTo(0,6);

4568 pathB.cubicTo(2,5, 2,0, 6,4);

4569 pathB.close();

4570 testShapeOp(path, pathB, kDifference_Op);

4571 }

4572

4573 static void cubicOp61d() {

4574 SkPath path, pathB;

4575 path.setFillType(SkPath::kWinding_FillType);

4576 path.moveTo(1,2);

4577 path.cubicTo(0,5, 3,2, 6,1);

4578 path.close();

4579 pathB.setFillType(SkPath::kWinding_FillType);

4580 pathB.moveTo(2,3);

4581 pathB.cubicTo(1,6, 2,1, 5,0);

4582 pathB.close();

4583 testShapeOp(path, pathB, kDifference_Op);

4584 }

4585

4586 static void cubicOp62d() {

4587 SkPath path, pathB;

4588 path.setFillType(SkPath::kWinding_FillType);

4589 path.moveTo(1,3);

4590 path.cubicTo(5,6, 5,3, 5,4);

4591 path.close();

4592 pathB.setFillType(SkPath::kWinding_FillType);

4593 pathB.moveTo(3,5);

4594 pathB.cubicTo(4,5, 3,1, 6,5);

4595 pathB.close();

4596 testShapeOp(path, pathB, kDifference_Op);

4597 }

4598

4599 static void cubicOp63d() {

4600 SkPath path, pathB;

4601 path.setFillType(SkPath::kWinding_FillType);

4602 path.moveTo(2,3);

4603 path.cubicTo(0,4, 3,2, 5,3);

4604 path.close();

4605 pathB.setFillType(SkPath::kWinding_FillType);

4606 pathB.moveTo(2,3);

4607 pathB.cubicTo(3,5, 3,2, 4,0);

4608 pathB.close();

4609 testShapeOp(path, pathB, kDifference_Op);

4610 }

4611

4612 static void testQuad1() {

4613 SkPath path;

4614 path.moveTo(0,0);

4615 path.quadTo(0,0, 0,1);

4616 path.lineTo(1,1);

4617 path.close();

4618 path.moveTo(0,0);

4619 path.quadTo(1,1, 0,2);

4620 path.close();

4621 testSimplifyx(path);

4622 }

4623

4624 static void testQuad1z() {

4625 SkPath path;

4626 path.moveTo(0,0);

4627 path.quadTo(0,0, 0,1);

4628 path.lineTo(1,1);

4629 path.close();

4630 path.moveTo(0,0);

4631 path.lineTo(0.5f,1);

4632 path.lineTo(0,2);

4633 path.close();

4634 testSimplifyx(path);

4635 }

4636

4637 static void testQuad1c() {

4638 SkPath path;

4639 path.moveTo(0,0);

4640 path.quadTo(0,0, 0,1);

4641 path.lineTo(1,1);

4642 path.close();

4643 path.moveTo(0,0);

4644 path.cubicTo(0.5f,0.5f, 0.5f,1.5f, 0,2);

4645 path.close();

4646 testSimplifyx(path);

4647 }

4648

4649 static void testRectOp1d() {

4650 SkPath path, pathB;

4651 path.moveTo(0,1);

4652 path.cubicTo(0,1, 1,0, 3,0);

4653 path.lineTo(0,1);

4654 path.close();

4655 pathB.moveTo(0,1);

4656 pathB.cubicTo(0,3, 1,0, 1,0);

4657 pathB.lineTo(0,1);

4658 pathB.close();

4659 testShapeOp(path, pathB, kDifference_Op);

4660 }

4661

4662 static void testCubicOp64d() {

4663 SkPath path, pathB;

4664 path.setFillType(SkPath::kWinding_FillType);

4665 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);

4666 path.addRect(2, 2, 3, 3, SkPath::kCW_Direction);

4667 pathB.setFillType(SkPath::kEvenOdd_FillType);

4668 pathB.addRect(0, 0, 4, 4, SkPath::kCW_Direction);

4669 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);

4670 testShapeOp(path, pathB, kDifference_Op);

4671 }

4672

4673 static void (*firstTest)() = testRectOp1d;

4674

4675 static struct {

4676 void (*fun)();

4677 const char* str;

4678 } tests[] = {

4679 TEST(testRectOp1d),

4680 TEST(testCubicOp64d),

4681 TEST(testQuad1c),

4682 TEST(testQuad1z),

4683 TEST(testQuad1),

4684 TEST(testQuadratic93), // FIXME: gets stuck in a loop because top is unso rtable

4685 TEST(cubicOp63d),

4686 TEST(cubicOp62d),

4687 TEST(cubicOp61d),

4688 TEST(cubicOp60d),

4689 TEST(cubicOp59d),

4690 TEST(cubicOp58d),

4691 TEST(cubicOp57d),

4692 TEST(cubicOp56d),

4693 TEST(cubicOp55d),

4694 TEST(cubicOp54d),

4695 TEST(cubicOp53d),

4696 TEST(cubicOp52d),

4697 TEST(cubicOp51d),

4698 TEST(cubicOp50d),

4699 TEST(cubicOp49d),

4700 TEST(cubicOp48d),

4701 TEST(cubicOp47d),

4702 TEST(cubicOp46d),

4703 TEST(cubicOp45d),

4704 TEST(cubicOp44d),

4705 TEST(cubicOp43d),

4706 TEST(cubicOp42d),

4707 TEST(cubicOp41i),

4708 TEST(cubicOp40d),

4709 TEST(cubicOp39d),

4710 TEST(cubicOp38d),

4711 TEST(cubicOp37d),

4712 TEST(cubicOp36u),

4713 TEST(cubicOp35d),

4714 TEST(cubicOp34d),

4715 TEST(cubicOp33i),

4716 TEST(cubicOp32d),

4717 TEST(cubicOp31d),

4718 TEST(testCubic2),

4719 TEST(cubicOp31x),

4720 TEST(cubicOp31u),

4721 TEST(cubicOp30d),

4722 TEST(cubicOp29d),

4723 TEST(cubicOp28u),

4724 TEST(cubicOp27d),

4725 TEST(cubicOp26d),

4726 TEST(cubicOp25i),

4727 TEST(testOp8d),

4728 TEST(testDiff1),

4729 TEST(testIntersect1),

4730 TEST(testUnion1),

4731 TEST(testXor1),

4732 TEST(testDiff2),

4733 TEST(testIntersect2),

4734 TEST(testUnion2),

4735 TEST(testXor2),

4736 TEST(testOp1d),

4737 TEST(testOp2d),

4738 TEST(testOp3d),

4739 TEST(testOp1u),

4740 TEST(testOp4d),

4741 TEST(testOp5d),

4742 TEST(testOp6d),

4743 TEST(testOp7d),

4744 TEST(testOp2u),

4745

4746 TEST(cubicOp24d),

4747 TEST(cubicOp23d),

4748 TEST(cubicOp22d),

4749 TEST(cubicOp21d),

4750 TEST(cubicOp20d),

4751 TEST(cubicOp19i),

4752 TEST(cubicOp18d),

4753 TEST(cubicOp17d),

4754 TEST(cubicOp16d),

4755 TEST(cubicOp15d),

4756 TEST(cubicOp14d),

4757 TEST(cubicOp13d),

4758 TEST(cubicOp12d),

4759 TEST(cubicOp11d),

4760 TEST(cubicOp10d),

4761 TEST(cubicOp1i),

4762 TEST(cubicOp9d),

4763 TEST(quadOp9d),

4764 TEST(lineOp9d),

4765 TEST(cubicOp8d),

4766 TEST(cubicOp7d),

4767 TEST(cubicOp6d),

4768 TEST(cubicOp5d),

4769 TEST(cubicOp3d),

4770 TEST(cubicOp2d),

4771 TEST(cubicOp1d),

4772 TEST(testCubic1),

4773 TEST(testQuadralateral1),

4774 TEST(testLine85),

4775 TEST(testLine84),

4776 TEST(testLine84x),

4777 TEST(testLine83),

4778 TEST(testLine82h),

4779 TEST(testLine82g),

4780 TEST(testLine82f),

4781 TEST(testLine82e),

4782 TEST(testLine82d),

4783 TEST(testLine82c),

4784 TEST(testLine82b),

4785 TEST(testLine82a),

4786 TEST(testLine82),

4787 TEST(testQuadratic92x),

4788 TEST(testQuadratic91),

4789 TEST(testQuadratic90x),

4790 TEST(testQuadratic89x),

4791 TEST(testQuadratic88),

4792 TEST(testQuadratic87),

4793 TEST(testQuadratic86),

4794 TEST(testQuadratic85),

4795 TEST(testQuadratic84),

4796 TEST(testQuadratic83),

4797 TEST(testQuadratic82),

4798 TEST(testQuadratic81),

4799 TEST(testQuadratic80),

4800 TEST(testEight1),

4801 TEST(testEight2),

4802 TEST(testEight3),

4803 TEST(testEight4),

4804 TEST(testEight5),

4805 TEST(testEight6),

4806 TEST(testEight7),

4807 TEST(testEight8),

4808 TEST(testEight9),

4809 TEST(testEight10),

4810 TEST(testQuadratic79),

4811 TEST(testQuadratic78),

4812 TEST(testQuadratic77),

4813 TEST(testQuadratic76),

4814 TEST(testQuadratic75),

4815 TEST(testQuadratic74),

4816 TEST(testQuadratic73),

4817 TEST(testQuadratic72),

4818 TEST(testQuadratic71),

4819 TEST(testQuadratic70x),

4820 TEST(testQuadratic69),

4821 TEST(testQuadratic68),

4822 TEST(testQuadratic67x),

4823 TEST(testQuadratic65),

4824 TEST(testQuadratic64),

4825 TEST(testQuadratic63),

4826 TEST(testLine1a),

4827 TEST(testLine1ax),

4828 TEST(testQuadratic59),

4829 TEST(testQuadratic59x),

4830 TEST(testQuadratic58),

4831 TEST(testQuadratic56),

4832 TEST(testQuadratic55),

4833 TEST(testQuadratic53),

4834 TEST(testQuadratic51),

4835 TEST(testQuadratic38),

4836 TEST(testQuadratic37),

4837 TEST(testQuadratic36),

4838 TEST(testQuadratic35),

4839 TEST(testQuadratic34),

4840 TEST(testQuadratic33),

4841 TEST(testQuadratic32),

4842 TEST(testQuadratic31),

4843 TEST(testQuadratic30),

4844 TEST(testQuadratic29),

4845 TEST(testQuadratic28),

4846 TEST(testQuadratic27),

4847 TEST(testQuadratic26),

4848 TEST(testQuadratic25),

4849 TEST(testQuadratic24),

4850 TEST(testQuadratic23),

4851 TEST(testQuadratic22),

4852 TEST(testQuadratic21),

4853 TEST(testQuadratic20),

4854 TEST(testQuadratic19),

4855 TEST(testQuadratic18),

4856 TEST(testQuadratic17x),

4857 TEST(testQuadratic15),

4858 TEST(testQuadratic14),

4859 TEST(testQuadratic9),

4860 TEST(testQuadratic8),

4861 TEST(testQuadratic7),

4862 TEST(testQuadratic6),

4863 TEST(testQuadratic5),

4864 TEST(testQuadratic4x),

4865 TEST(testQuadratic3x),

4866 TEST(testQuadratic2x),

4867 TEST(testQuadratic1x),

4868 TEST(testQuadratic4),

4869 TEST(testQuadratic3),

4870 TEST(testQuadratic2),

4871 TEST(testQuadratic1),

4872 TEST(testLine4ax),

4873 TEST(testLine3aax),

4874 TEST(testLine2ax),

4875 TEST(testLine1ax),

4876 TEST(testQuadralateral9x),

4877 TEST(testQuadralateral8x),

4878 TEST(testQuadralateral7x),

4879 TEST(testQuadralateral6x),

4880 TEST(testQuadralateral6ax),

4881 TEST(testQuadralateral9),

4882 TEST(testQuadralateral8),

4883 TEST(testQuadralateral7),

4884 TEST(testQuadralateral6),

4885 TEST(testQuadralateral6a),

4886 TEST(testFauxQuadralateral6dx),

4887 TEST(testFauxQuadralateral6cx),

4888 TEST(testFauxQuadralateral6bx),

4889 TEST(testFauxQuadralateral6ax),

4890 TEST(testFauxQuadralateral6x),

4891 TEST(testFauxQuadralateral6d),

4892 TEST(testFauxQuadralateral6c),

4893 TEST(testFauxQuadralateral6b),

4894 TEST(testFauxQuadralateral6a),

4895 TEST(testFauxQuadralateral6),

4896 TEST(testQuadralateral5x),

4897 TEST(testQuadralateral5),

4898 TEST(testNondegenerate4x),

4899 TEST(testNondegenerate3x),

4900 TEST(testNondegenerate2x),

4901 TEST(testNondegenerate1x),

4902 TEST(testNondegenerate4),

4903 TEST(testNondegenerate3),

4904 TEST(testNondegenerate2),

4905 TEST(testNondegenerate1),

4906 TEST(testDegenerate4x),

4907 TEST(testDegenerate3x),

4908 TEST(testDegenerate2x),

4909 TEST(testDegenerate1x),

4910 TEST(testDegenerate4),

4911 TEST(testDegenerate3),

4912 TEST(testDegenerate2),

4913 TEST(testDegenerate1),

4914 TEST(testLine79x),

4915 TEST(testLine78x),

4916 TEST(testLine77x),

4917 TEST(testLine76x),

4918 TEST(testLine75x),

4919 TEST(testLine74x),

4920 TEST(testLine73x),

4921 TEST(testLine72x),

4922 TEST(testLine71x),

4923 TEST(testLine70x),

4924 TEST(testLine69x),

4925 TEST(testLine68hx),

4926 TEST(testLine68gx),

4927 TEST(testLine68fx),

4928 TEST(testLine68ex),

4929 TEST(testLine68dx),

4930 TEST(testLine68cx),

4931 TEST(testLine68bx),

4932 TEST(testLine68ax),

4933 TEST(testLine67x),

4934 TEST(testLine66x),

4935 TEST(testLine65x),

4936 TEST(testLine64x),

4937 TEST(testLine63x),

4938 TEST(testLine62x),

4939 TEST(testLine61x),

4940 TEST(testLine60x),

4941 TEST(testLine59x),

4942 TEST(testLine58x),

4943 TEST(testLine57x),

4944 TEST(testLine56x),

4945 TEST(testLine55x),

4946 TEST(testLine54x),

4947 TEST(testLine53x),

4948 TEST(testLine52x),

4949 TEST(testLine51x),

4950 TEST(testLine50x),

4951 TEST(testLine49x),

4952 TEST(testLine48x),

4953 TEST(testLine47x),

4954 TEST(testLine46x),

4955 TEST(testLine45x),

4956 TEST(testLine44x),

4957 TEST(testLine43x),

4958 TEST(testLine42x),

4959 TEST(testLine41x),

4960 TEST(testLine40x),

4961 TEST(testLine38x),

4962 TEST(testLine37x),

4963 TEST(testLine36x),

4964 TEST(testLine35x),

4965 TEST(testLine34x),

4966 TEST(testLine33x),

4967 TEST(testLine32x),

4968 TEST(testLine31x),

4969 TEST(testLine30x),

4970 TEST(testLine29x),

4971 TEST(testLine28x),

4972 TEST(testLine27x),

4973 TEST(testLine26x),

4974 TEST(testLine25x),

4975 TEST(testLine24ax),

4976 TEST(testLine24x),

4977 TEST(testLine23x),

4978 TEST(testLine22x),

4979 TEST(testLine21x),

4980 TEST(testLine20x),

4981 TEST(testLine19x),

4982 TEST(testLine18x),

4983 TEST(testLine17x),

4984 TEST(testLine16x),

4985 TEST(testLine15x),

4986 TEST(testLine14x),

4987 TEST(testLine13x),

4988 TEST(testLine12x),

4989 TEST(testLine11x),

4990 TEST(testLine10ax),

4991 TEST(testLine10x),

4992 TEST(testLine9x),

4993 TEST(testLine8x),

4994 TEST(testLine7bx),

4995 TEST(testLine7ax),

4996 TEST(testLine7x),

4997 TEST(testLine6x),

4998 TEST(testLine5x),

4999 TEST(testLine4x),

5000 TEST(testLine3bx),

5001 TEST(testLine3ax),

5002 TEST(testLine3x),

5003 TEST(testLine2x),

5004 TEST(testLine1x),

5005 TEST(testLine81),

5006 TEST(testLine80),

5007 TEST(testLine79),

5008 TEST(testLine78),

5009 TEST(testLine77),

5010 TEST(testLine76),

5011 TEST(testLine75),

5012 TEST(testLine74),

5013 TEST(testLine73),

5014 TEST(testLine72),

5015 TEST(testLine71),

5016 TEST(testLine70),

5017 TEST(testLine69),

5018 TEST(testLine68h),

5019 TEST(testLine68g),

5020 TEST(testLine68f),

5021 TEST(testLine68e),

5022 TEST(testLine68d),

5023 TEST(testLine68c),

5024 TEST(testLine68b),

5025 TEST(testLine68a),

5026 TEST(testLine67),

5027 TEST(testLine66),

5028 TEST(testLine65),

5029 TEST(testLine64),

5030 TEST(testLine63),

5031 TEST(testLine62),

5032 TEST(testLine61),

5033 TEST(testLine60),

5034 TEST(testLine59),

5035 TEST(testLine58),

5036 TEST(testLine57),

5037 TEST(testLine56),

5038 TEST(testLine55),

5039 TEST(testLine54),

5040 TEST(testLine53),

5041 TEST(testLine52),

5042 TEST(testLine51),

5043 TEST(testLine50),

5044 TEST(testLine49),

5045 TEST(testLine48),

5046 TEST(testLine47),

5047 TEST(testLine46),

5048 TEST(testLine45),

5049 TEST(testLine44),

5050 TEST(testLine43),

5051 TEST(testLine42),

5052 TEST(testLine41),

5053 TEST(testLine40),

5054 TEST(testLine38),

5055 TEST(testLine37),

5056 TEST(testLine36),

5057 TEST(testLine35),

5058 TEST(testLine34),

5059 TEST(testLine33),

5060 TEST(testLine32),

5061 TEST(testLine31),

5062 TEST(testLine30),

5063 TEST(testLine29),

5064 TEST(testLine28),

5065 TEST(testLine27),

5066 TEST(testLine26),

5067 TEST(testLine25),

5068 TEST(testLine24a),

5069 TEST(testLine24),

5070 TEST(testLine23),

5071 TEST(testLine22),

5072 TEST(testLine21),

5073 TEST(testLine20),

5074 TEST(testLine19),

5075 TEST(testLine18),

5076 TEST(testLine17),

5077 TEST(testLine16),

5078 TEST(testLine15),

5079 TEST(testLine14),

5080 TEST(testLine13),

5081 TEST(testLine12),

5082 TEST(testLine11),

5083 TEST(testLine10a),

5084 TEST(testLine10),

5085 TEST(testLine9),

5086 TEST(testLine8),

5087 TEST(testLine7b),

5088 TEST(testLine7a),

5089 TEST(testLine7),

5090 TEST(testLine6),

5091 TEST(testLine5),

5092 TEST(testLine4),

5093 TEST(testLine3b),

5094 TEST(testLine3a),

5095 TEST(testLine3),

5096 TEST(testLine2),

5097 TEST(testLine1),

5098 };

5099

5100 static const size_t testCount = sizeof(tests) / sizeof(tests[0]);

5101

5102

5103 static struct {

5104 void (*fun)();

5105 const char* str;

5106 } subTests[] = {

5107 TEST(cubicOp43d),

5108 TEST(quadOp9d),

5109 TEST(cubicOp9d),

5110 TEST(cubicOp1i),

5111 TEST(cubicOp10d),

5112 TEST(cubicOp11d),

5113 TEST(cubicOp15d),

5114 TEST(cubicOp18d),

5115 TEST(cubicOp22d),

5116 TEST(cubicOp23d),

5117 TEST(cubicOp24d),

5118 TEST(cubicOp28u),

5119 TEST(cubicOp33i),

5120 TEST(cubicOp36u),

5121 TEST(cubicOp40d),

5122 };

5123

5124 static const size_t subTestCount = sizeof(subTests) / sizeof(subTests[0]);

5125

5126 static void (*firstSubTest)() = 0;

5127

5128 static bool skipAll = false;

5129 static bool runSubTestsFirst = false;

5130 static bool runReverse = false;

5131 static void (*stopTest)() = 0;

5132

5133 void SimplifyNew_Test() {

5134 if (skipAll) {

5135 return;

5136 }

5137 #ifdef SK_DEBUG

5138 gDebugMaxWindSum = 4;

5139 gDebugMaxWindValue = 4;

5140 #endif

5141 size_t index;

5142 if (runSubTestsFirst && firstSubTest) {

5143 index = subTestCount - 1;

5144 while (index > 0 && subTests[index].fun != firstSubTest) {

5145 --index;

5146 }

5147 SkDebugf(" %s [%s]\n", __FUNCTION__, subTests[index].str);

5148 (*subTests[index].fun)();

5149 }

5150 if (runSubTestsFirst) {

5151 index = subTestCount - 1;

5152 do {

5153 SkDebugf(" %s [%s]\n", __FUNCTION__, subTests[index].str);

5154 (*subTests[index].fun)();

5155 } while (index--);

5156 }

5157 index = testCount - 1;

5158 if (firstTest) {

5159 while (index > 0 && tests[index].fun != firstTest) {

5160 --index;

5161 }

5162 #if FORCE_RELEASE == 0

5163 SkDebugf("<div id=\"%s\">\n", tests[index].str);

5164 #endif

5165 SkDebugf(" %s [%s]\n", __FUNCTION__, tests[index].str);

5166 (*tests[index].fun)();

5167 }

5168 index = runReverse ? testCount - 1 : 0;

5169 size_t last = runReverse ? 0 : testCount - 1;

5170 bool firstTestComplete = false;

5171 do {

5172 SkDebugf(" %s [%s]\n", __FUNCTION__, tests[index].str);

5173 (*tests[index].fun)();

5174 firstTestComplete = true;

5175 if (tests[index].fun == stopTest) {

5176 SkDebugf("lastTest\n");

5177 }

5178 if (index == last) {

5179 break;

5180 }

5181 index += runReverse ? -1 : 1;

5182 } while (true);

5183 if (!runSubTestsFirst) {

5184 index = subTestCount - 1;

5185 do {

5186 SkDebugf(" %s [%s]\n", __FUNCTION__, subTests[index].str);

5187 (*subTests[index].fun)();

5188 } while (index--);

5189 }

5190 #ifdef SK_DEBUG

5191 gDebugMaxWindSum = SK_MaxS32;

5192 gDebugMaxWindValue = SK_MaxS32;

5193 #endif

5194 }

OLD	NEW

« no previous file with comments | « experimental/Intersection/SimplifyFindTop_Test.cpp ('k') | experimental/Intersection/SimplifyRect4x4_Test.cpp » ('j') | no next file with comments »