1/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "EdgeWalker_Test.h"
9#include "Intersection_Tests.h"
10#include "ShapeOps.h"
11
12#define TEST(name) { name, #name }
13
14static void testLine1() {
15    SkPath path;
16    path.moveTo(2,0);
17    path.lineTo(1,1);
18    path.lineTo(0,0);
19    path.close();
20    testSimplifyx(path);
21}
22
23static void testLine1x() {
24    SkPath path;
25    path.setFillType(SkPath::kEvenOdd_FillType);
26    path.moveTo(2,0);
27    path.lineTo(1,1);
28    path.lineTo(0,0);
29    path.close();
30    testSimplifyx(path);
31}
32
33static void addInnerCWTriangle(SkPath& path) {
34    path.moveTo(3,0);
35    path.lineTo(4,1);
36    path.lineTo(2,1);
37    path.close();
38}
39
40static void addInnerCCWTriangle(SkPath& path) {
41    path.moveTo(3,0);
42    path.lineTo(2,1);
43    path.lineTo(4,1);
44    path.close();
45}
46
47static void addOuterCWTriangle(SkPath& path) {
48    path.moveTo(3,0);
49    path.lineTo(6,2);
50    path.lineTo(0,2);
51    path.close();
52}
53
54static void addOuterCCWTriangle(SkPath& path) {
55    path.moveTo(3,0);
56    path.lineTo(0,2);
57    path.lineTo(6,2);
58    path.close();
59}
60
61static void testLine2() {
62    SkPath path;
63    path.setFillType(SkPath::kEvenOdd_FillType);
64    addInnerCWTriangle(path);
65    addOuterCWTriangle(path);
66    testSimplifyx(path);
67}
68
69static void testLine2x() {
70    SkPath path;
71    path.setFillType(SkPath::kEvenOdd_FillType);
72    addInnerCWTriangle(path);
73    addOuterCWTriangle(path);
74    testSimplifyx(path);
75}
76
77static void testLine3() {
78    SkPath path;
79    path.setFillType(SkPath::kEvenOdd_FillType);
80    addInnerCCWTriangle(path);
81    addOuterCWTriangle(path);
82    testSimplifyx(path);
83}
84
85static void testLine3x() {
86    SkPath path;
87    path.setFillType(SkPath::kEvenOdd_FillType);
88    addInnerCCWTriangle(path);
89    addOuterCWTriangle(path);
90    testSimplifyx(path);
91}
92
93static void testLine3a() {
94    SkPath path;
95    addInnerCWTriangle(path);
96    addOuterCCWTriangle(path);
97    testSimplifyx(path);
98}
99
100static void testLine3ax() {
101    SkPath path;
102    path.setFillType(SkPath::kEvenOdd_FillType);
103    addInnerCWTriangle(path);
104    addOuterCCWTriangle(path);
105    testSimplifyx(path);
106}
107
108static void testLine3b() {
109    SkPath path;
110    addInnerCCWTriangle(path);
111    addOuterCCWTriangle(path);
112    testSimplifyx(path);
113}
114
115static void testLine3bx() {
116    SkPath path;
117    path.setFillType(SkPath::kEvenOdd_FillType);
118    addInnerCCWTriangle(path);
119    addOuterCCWTriangle(path);
120    testSimplifyx(path);
121}
122
123static void testLine4() {
124    SkPath path;
125    addOuterCCWTriangle(path);
126    addOuterCWTriangle(path);
127    testSimplifyx(path);
128}
129
130static void testLine4x() {
131    SkPath path;
132    path.setFillType(SkPath::kEvenOdd_FillType);
133    addOuterCCWTriangle(path);
134    addOuterCWTriangle(path);
135    testSimplifyx(path);
136}
137
138static void testLine5() {
139    SkPath path;
140    addOuterCWTriangle(path);
141    addOuterCWTriangle(path);
142    testSimplifyx(path);
143}
144
145static void testLine5x() {
146    SkPath path;
147    path.setFillType(SkPath::kEvenOdd_FillType);
148    addOuterCWTriangle(path);
149    addOuterCWTriangle(path);
150    testSimplifyx(path);
151}
152
153static void testLine6() {
154    SkPath path;
155    path.moveTo(0,0);
156    path.lineTo(4,0);
157    path.lineTo(2,2);
158    path.close();
159    path.moveTo(2,0);
160    path.lineTo(6,0);
161    path.lineTo(4,2);
162    path.close();
163    testSimplifyx(path);
164}
165
166static void testLine6x() {
167    SkPath path;
168    path.setFillType(SkPath::kEvenOdd_FillType);
169    path.moveTo(0,0);
170    path.lineTo(4,0);
171    path.lineTo(2,2);
172    path.close();
173    path.moveTo(2,0);
174    path.lineTo(6,0);
175    path.lineTo(4,2);
176    path.close();
177    testSimplifyx(path);
178}
179
180static void testLine7() {
181    SkPath path;
182    path.moveTo(0,0);
183    path.lineTo(4,0);
184    path.lineTo(2,2);
185    path.close();
186    path.moveTo(6,0);
187    path.lineTo(2,0);
188    path.lineTo(4,2);
189    path.close();
190    testSimplifyx(path);
191}
192
193static void testLine7x() {
194    SkPath path;
195    path.setFillType(SkPath::kEvenOdd_FillType);
196    path.moveTo(0,0);
197    path.lineTo(4,0);
198    path.lineTo(2,2);
199    path.close();
200    path.moveTo(6,0);
201    path.lineTo(2,0);
202    path.lineTo(4,2);
203    path.close();
204    testSimplifyx(path);
205}
206
207static void testLine7a() {
208    SkPath path;
209    path.moveTo(0,0);
210    path.lineTo(4,0);
211    path.lineTo(2,2);
212    path.close();
213    testSimplifyx(path);
214}
215
216static void testLine7ax() {
217    SkPath path;
218    path.setFillType(SkPath::kEvenOdd_FillType);
219    path.moveTo(0,0);
220    path.lineTo(4,0);
221    path.lineTo(2,2);
222    path.close();
223    testSimplifyx(path);
224}
225
226static void testLine7b() {
227    SkPath path;
228    path.moveTo(0,0);
229    path.lineTo(4,0);
230    path.close();
231    path.moveTo(6,0);
232    path.lineTo(2,0);
233    path.lineTo(4,2);
234    path.close();
235    testSimplifyx(path);
236}
237
238static void testLine7bx() {
239    SkPath path;
240    path.setFillType(SkPath::kEvenOdd_FillType);
241    path.moveTo(0,0);
242    path.lineTo(4,0);
243    path.close();
244    path.moveTo(6,0);
245    path.lineTo(2,0);
246    path.lineTo(4,2);
247    path.close();
248    testSimplifyx(path);
249}
250
251static void testLine8() {
252    SkPath path;
253    path.moveTo(0,4);
254    path.lineTo(4,4);
255    path.lineTo(2,2);
256    path.close();
257    path.moveTo(2,4);
258    path.lineTo(6,4);
259    path.lineTo(4,2);
260    path.close();
261    testSimplifyx(path);
262}
263
264static void testLine8x() {
265    SkPath path;
266    path.setFillType(SkPath::kEvenOdd_FillType);
267    path.moveTo(0,4);
268    path.lineTo(4,4);
269    path.lineTo(2,2);
270    path.close();
271    path.moveTo(2,4);
272    path.lineTo(6,4);
273    path.lineTo(4,2);
274    path.close();
275    testSimplifyx(path);
276}
277
278static void testLine9() {
279    SkPath path;
280    path.moveTo(0,4);
281    path.lineTo(4,4);
282    path.lineTo(2,2);
283    path.close();
284    path.moveTo(6,4);
285    path.lineTo(2,4);
286    path.lineTo(4,2);
287    path.close();
288    testSimplifyx(path);
289}
290
291static void testLine9x() {
292    SkPath path;
293    path.setFillType(SkPath::kEvenOdd_FillType);
294    path.moveTo(0,4);
295    path.lineTo(4,4);
296    path.lineTo(2,2);
297    path.close();
298    path.moveTo(6,4);
299    path.lineTo(2,4);
300    path.lineTo(4,2);
301    path.close();
302    testSimplifyx(path);
303}
304
305static void testLine10() {
306    SkPath path;
307    path.moveTo(0,4);
308    path.lineTo(4,4);
309    path.lineTo(2,2);
310    path.close();
311    path.moveTo(2,1);
312    path.lineTo(3,4);
313    path.lineTo(6,1);
314    path.close();
315    testSimplifyx(path);
316}
317
318static void testLine10x() {
319    SkPath path;
320    path.setFillType(SkPath::kEvenOdd_FillType);
321    path.moveTo(0,4);
322    path.lineTo(4,4);
323    path.lineTo(2,2);
324    path.close();
325    path.moveTo(2,1);
326    path.lineTo(3,4);
327    path.lineTo(6,1);
328    path.close();
329    testSimplifyx(path);
330}
331
332static void testLine10a() {
333    SkPath path;
334    path.moveTo(0,4);
335    path.lineTo(8,4);
336    path.lineTo(4,0);
337    path.close();
338    path.moveTo(2,2);
339    path.lineTo(3,3);
340    path.lineTo(4,2);
341    path.close();
342    testSimplifyx(path);
343}
344
345static void testLine10ax() {
346    SkPath path;
347    path.setFillType(SkPath::kEvenOdd_FillType);
348    path.moveTo(0,4);
349    path.lineTo(8,4);
350    path.lineTo(4,0);
351    path.close();
352    path.moveTo(2,2);
353    path.lineTo(3,3);
354    path.lineTo(4,2);
355    path.close();
356    testSimplifyx(path);
357}
358
359static void addCWContainer(SkPath& path) {
360    path.moveTo(6,4);
361    path.lineTo(0,4);
362    path.lineTo(3,1);
363    path.close();
364}
365
366static void addCCWContainer(SkPath& path) {
367    path.moveTo(0,4);
368    path.lineTo(6,4);
369    path.lineTo(3,1);
370    path.close();
371}
372
373static void addCWContents(SkPath& path) {
374    path.moveTo(2,3);
375    path.lineTo(3,2);
376    path.lineTo(4,3);
377    path.close();
378}
379
380static void addCCWContents(SkPath& path) {
381    path.moveTo(3,2);
382    path.lineTo(2,3);
383    path.lineTo(4,3);
384    path.close();
385}
386
387static void testLine11() {
388    SkPath path;
389    addCWContainer(path);
390    addCWContents(path);
391    testSimplifyx(path);
392}
393
394static void testLine11x() {
395    SkPath path;
396    path.setFillType(SkPath::kEvenOdd_FillType);
397    addCWContainer(path);
398    addCWContents(path);
399    testSimplifyx(path);
400}
401
402static void testLine12() {
403    SkPath path;
404    addCCWContainer(path);
405    addCWContents(path);
406    testSimplifyx(path);
407}
408
409static void testLine12x() {
410    SkPath path;
411    path.setFillType(SkPath::kEvenOdd_FillType);
412    addCCWContainer(path);
413    addCWContents(path);
414    testSimplifyx(path);
415}
416
417static void testLine13() {
418    SkPath path;
419    addCWContainer(path);
420    addCCWContents(path);
421    testSimplifyx(path);
422}
423
424static void testLine13x() {
425    SkPath path;
426    path.setFillType(SkPath::kEvenOdd_FillType);
427    addCWContainer(path);
428    addCCWContents(path);
429    testSimplifyx(path);
430}
431
432static void testLine14() {
433    SkPath path;
434    addCCWContainer(path);
435    addCCWContents(path);
436    testSimplifyx(path);
437}
438
439static void testLine14x() {
440    SkPath path;
441    path.setFillType(SkPath::kEvenOdd_FillType);
442    addCCWContainer(path);
443    addCCWContents(path);
444    testSimplifyx(path);
445}
446
447static void testLine15() {
448    SkPath path;
449    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
450    testSimplifyx(path);
451}
452
453static void testLine15x() {
454    SkPath path;
455    path.setFillType(SkPath::kEvenOdd_FillType);
456    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
457    testSimplifyx(path);
458}
459
460static void testLine16() {
461    SkPath path;
462    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
463    path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
464    testSimplifyx(path);
465}
466
467static void testLine16x() {
468    SkPath path;
469    path.setFillType(SkPath::kEvenOdd_FillType);
470    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
471    path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
472    testSimplifyx(path);
473}
474
475static void testLine17() {
476    SkPath path;
477    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
478    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
479    testSimplifyx(path);
480}
481
482static void testLine17x() {
483    SkPath path;
484    path.setFillType(SkPath::kEvenOdd_FillType);
485    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
486    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
487    testSimplifyx(path);
488}
489
490static void testLine18() {
491    SkPath path;
492    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
493    path.addRect(12, 4, 21, 21, SkPath::kCW_Direction);
494    testSimplifyx(path);
495}
496
497static void testLine18x() {
498    SkPath path;
499    path.setFillType(SkPath::kEvenOdd_FillType);
500    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
501    path.addRect(12, 4, 21, 21, SkPath::kCW_Direction);
502    testSimplifyx(path);
503}
504
505static void testLine19() {
506    SkPath path;
507    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
508    path.addRect(12, 16, 21, 21, SkPath::kCW_Direction);
509    testSimplifyx(path);
510}
511
512static void testLine19x() {
513    SkPath path;
514    path.setFillType(SkPath::kEvenOdd_FillType);
515    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
516    path.addRect(12, 16, 21, 21, SkPath::kCW_Direction);
517    testSimplifyx(path);
518}
519
520static void testLine20() {
521    SkPath path;
522    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
523    path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
524    testSimplifyx(path);
525}
526
527static void testLine20x() {
528    SkPath path;
529    path.setFillType(SkPath::kEvenOdd_FillType);
530    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
531    path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
532    testSimplifyx(path);
533}
534
535static void testLine21() {
536    SkPath path;
537    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
538    path.addRect(0, 16, 9, 9, SkPath::kCW_Direction);
539    testSimplifyx(path);
540}
541
542static void testLine21x() {
543    SkPath path;
544    path.setFillType(SkPath::kEvenOdd_FillType);
545    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
546    path.addRect(0, 16, 9, 9, SkPath::kCW_Direction);
547    testSimplifyx(path);
548}
549
550static void testLine22() {
551    SkPath path;
552    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
553    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
554    testSimplifyx(path);
555}
556
557static void testLine22x() {
558    SkPath path;
559    path.setFillType(SkPath::kEvenOdd_FillType);
560    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
561    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
562    testSimplifyx(path);
563}
564
565static void testLine23() {
566    SkPath path;
567    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
568    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
569    testSimplifyx(path);
570}
571
572static void testLine23x() {
573    SkPath path;
574    path.setFillType(SkPath::kEvenOdd_FillType);
575    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
576    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
577    testSimplifyx(path);
578}
579
580static void testLine24a() {
581    SkPath path;
582    path.moveTo(2,0);
583    path.lineTo(4,4);
584    path.lineTo(0,4);
585    path.close();
586    path.moveTo(2,0);
587    path.lineTo(1,2);
588    path.lineTo(2,2);
589    path.close();
590    testSimplifyx(path);
591}
592
593static void testLine24ax() {
594    SkPath path;
595    path.setFillType(SkPath::kEvenOdd_FillType);
596    path.moveTo(2,0);
597    path.lineTo(4,4);
598    path.lineTo(0,4);
599    path.close();
600    path.moveTo(2,0);
601    path.lineTo(1,2);
602    path.lineTo(2,2);
603    path.close();
604    testSimplifyx(path);
605}
606
607static void testLine24() {
608    SkPath path;
609    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
610    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
611    testSimplifyx(path);
612}
613
614static void testLine24x() {
615    SkPath path;
616    path.setFillType(SkPath::kEvenOdd_FillType);
617    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
618    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
619    testSimplifyx(path);
620}
621
622static void testLine25() {
623    SkPath path;
624    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
625    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
626    testSimplifyx(path);
627}
628
629static void testLine25x() {
630    SkPath path;
631    path.setFillType(SkPath::kEvenOdd_FillType);
632    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
633    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
634    testSimplifyx(path);
635}
636
637static void testLine26() {
638    SkPath path;
639    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
640    path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
641    testSimplifyx(path);
642}
643
644static void testLine26x() {
645    SkPath path;
646    path.setFillType(SkPath::kEvenOdd_FillType);
647    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
648    path.addRect(0, 12, 9, 9, SkPath::kCW_Direction);
649    testSimplifyx(path);
650}
651
652static void testLine27() {
653    SkPath path;
654    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
655    path.addRect(12, 8, 21, 21, SkPath::kCW_Direction);
656    testSimplifyx(path);
657}
658
659static void testLine27x() {
660    SkPath path;
661    path.setFillType(SkPath::kEvenOdd_FillType);
662    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
663    path.addRect(12, 8, 21, 21, SkPath::kCW_Direction);
664    testSimplifyx(path);
665}
666
667static void testLine28() {
668    SkPath path;
669    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
670    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
671    testSimplifyx(path);
672}
673
674static void testLine28x() {
675    SkPath path;
676    path.setFillType(SkPath::kEvenOdd_FillType);
677    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
678    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
679    testSimplifyx(path);
680}
681
682static void testLine29() {
683    SkPath path;
684    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
685    path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
686    testSimplifyx(path);
687}
688
689static void testLine29x() {
690    SkPath path;
691    path.setFillType(SkPath::kEvenOdd_FillType);
692    path.addRect(0, 18, 12, 12, SkPath::kCW_Direction);
693    path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
694    testSimplifyx(path);
695}
696
697static void testLine30() {
698    SkPath path;
699    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
700    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
701    path.addRect(4, 4, 13, 13, SkPath::kCW_Direction);
702    testSimplifyx(path);
703}
704
705static void testLine30x() {
706    SkPath path;
707    path.setFillType(SkPath::kEvenOdd_FillType);
708    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
709    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
710    path.addRect(4, 4, 13, 13, SkPath::kCW_Direction);
711    testSimplifyx(path);
712}
713
714static void testLine31() {
715    SkPath path;
716    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
717    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
718    path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
719    testSimplifyx(path);
720}
721
722static void testLine31x() {
723    SkPath path;
724    path.setFillType(SkPath::kEvenOdd_FillType);
725    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
726    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
727    path.addRect(0, 4, 9, 9, SkPath::kCW_Direction);
728    testSimplifyx(path);
729}
730
731static void testLine32() {
732    SkPath path;
733    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
734    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
735    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
736    testSimplifyx(path);
737}
738
739static void testLine32x() {
740    SkPath path;
741    path.setFillType(SkPath::kEvenOdd_FillType);
742    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
743    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
744    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
745    testSimplifyx(path);
746}
747
748static void testLine33() {
749    SkPath path;
750    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
751    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
752    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
753    testSimplifyx(path);
754}
755
756static void testLine33x() {
757    SkPath path;
758    path.setFillType(SkPath::kEvenOdd_FillType);
759    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
760    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
761    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
762    testSimplifyx(path);
763}
764
765static void testLine34() {
766    SkPath path;
767    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
768    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
769    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
770    testSimplifyx(path);
771}
772
773static void testLine34x() {
774    SkPath path;
775    path.setFillType(SkPath::kEvenOdd_FillType);
776    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
777    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
778    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
779    testSimplifyx(path);
780}
781
782static void testLine35() {
783    SkPath path;
784    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
785    path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
786    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
787    testSimplifyx(path);
788}
789
790static void testLine35x() {
791    SkPath path;
792    path.setFillType(SkPath::kEvenOdd_FillType);
793    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
794    path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
795    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
796    testSimplifyx(path);
797}
798
799static void testLine36() {
800    SkPath path;
801    path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
802    path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
803    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
804    testSimplifyx(path);
805}
806
807static void testLine36x() {
808    SkPath path;
809    path.setFillType(SkPath::kEvenOdd_FillType);
810    path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
811    path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
812    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
813    testSimplifyx(path);
814}
815
816static void testLine37() {
817    SkPath path;
818    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
819    path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
820    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
821    testSimplifyx(path);
822}
823
824static void testLine37x() {
825    SkPath path;
826    path.setFillType(SkPath::kEvenOdd_FillType);
827    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
828    path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
829    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
830    testSimplifyx(path);
831}
832
833static void testLine38() {
834    SkPath path;
835    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
836    path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
837    path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
838    testSimplifyx(path);
839}
840
841static void testLine38x() {
842    SkPath path;
843    path.setFillType(SkPath::kEvenOdd_FillType);
844    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
845    path.addRect(6, 12, 18, 18, SkPath::kCW_Direction);
846    path.addRect(12, 12, 21, 21, SkPath::kCW_Direction);
847    testSimplifyx(path);
848}
849
850static void testLine40() {
851    SkPath path;
852    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
853    path.addRect(12, 18, 24, 24, SkPath::kCW_Direction);
854    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
855    testSimplifyx(path);
856}
857
858static void testLine40x() {
859    SkPath path;
860    path.setFillType(SkPath::kEvenOdd_FillType);
861    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
862    path.addRect(12, 18, 24, 24, SkPath::kCW_Direction);
863    path.addRect(4, 16, 13, 13, SkPath::kCW_Direction);
864    testSimplifyx(path);
865}
866
867static void testLine41() {
868    SkPath path;
869    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
870    path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
871    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
872    testSimplifyx(path);
873}
874
875static void testLine41x() {
876    SkPath path;
877    path.setFillType(SkPath::kEvenOdd_FillType);
878    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
879    path.addRect(18, 24, 30, 30, SkPath::kCW_Direction);
880    path.addRect(12, 0, 21, 21, SkPath::kCW_Direction);
881    testSimplifyx(path);
882}
883
884static void testLine42() {
885    SkPath path;
886    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
887    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
888    path.addRect(8, 16, 17, 17, SkPath::kCW_Direction);
889    testSimplifyx(path);
890}
891
892static void testLine42x() {
893    SkPath path;
894    path.setFillType(SkPath::kEvenOdd_FillType);
895    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
896    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
897    path.addRect(8, 16, 17, 17, SkPath::kCW_Direction);
898    testSimplifyx(path);
899}
900
901static void testLine43() {
902    SkPath path;
903    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
904    path.addRect(6, 24, 18, 18, SkPath::kCW_Direction);
905    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
906    testSimplifyx(path);
907}
908
909static void testLine43x() {
910    SkPath path;
911    path.setFillType(SkPath::kEvenOdd_FillType);
912    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
913    path.addRect(6, 24, 18, 18, SkPath::kCW_Direction);
914    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
915    testSimplifyx(path);
916}
917
918static void testLine44() {
919    SkPath path;
920    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
921    path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
922    path.addRect(18, 32, 27, 36, SkPath::kCCW_Direction);
923    testSimplifyx(path);
924}
925
926static void testLine44x() {
927    SkPath path;
928    path.setFillType(SkPath::kEvenOdd_FillType);
929    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
930    path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
931    path.addRect(18, 32, 27, 36, SkPath::kCCW_Direction);
932    testSimplifyx(path);
933}
934
935static void testLine45() {
936    SkPath path;
937    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
938    path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
939    path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
940    testSimplifyx(path);
941}
942
943static void testLine45x() {
944    SkPath path;
945    path.setFillType(SkPath::kEvenOdd_FillType);
946    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
947    path.addRect(18, 0, 30, 30, SkPath::kCW_Direction);
948    path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
949    testSimplifyx(path);
950}
951
952static void testLine46() {
953    SkPath path;
954    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
955    path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
956    path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
957    testSimplifyx(path);
958}
959
960static void testLine46x() {
961    SkPath path;
962    path.setFillType(SkPath::kEvenOdd_FillType);
963    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
964    path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
965    path.addRect(24, 32, 33, 36, SkPath::kCW_Direction);
966    testSimplifyx(path);
967}
968
969static void testLine47() {
970    SkPath path;
971    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
972    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
973    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
974    testSimplifyx(path);
975}
976
977static void testLine47x() {
978    SkPath path;
979    path.setFillType(SkPath::kEvenOdd_FillType);
980    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
981    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
982    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
983    testSimplifyx(path);
984}
985
986static void testLine48() {
987    SkPath path;
988    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
989    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
990    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
991    testSimplifyx(path);
992}
993
994static void testLine48x() {
995    SkPath path;
996    path.setFillType(SkPath::kEvenOdd_FillType);
997    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
998    path.addRect(0, 6, 12, 12, SkPath::kCW_Direction);
999    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
1000    testSimplifyx(path);
1001}
1002
1003static void testLine49() {
1004    SkPath path;
1005    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1006    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
1007    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
1008    testSimplifyx(path);
1009}
1010
1011static void testLine49x() {
1012    SkPath path;
1013    path.setFillType(SkPath::kEvenOdd_FillType);
1014    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1015    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
1016    path.addRect(0, 0, 9, 9, SkPath::kCW_Direction);
1017    testSimplifyx(path);
1018}
1019
1020static void testLine50() {
1021    SkPath path;
1022    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1023    path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1024    testSimplifyx(path);
1025}
1026
1027static void testLine50x() {
1028    SkPath path;
1029    path.setFillType(SkPath::kEvenOdd_FillType);
1030    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1031    path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1032    testSimplifyx(path);
1033}
1034
1035static void testLine51() {
1036    SkPath path;
1037    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1038    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1039    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1040    testSimplifyx(path);
1041}
1042
1043static void testLine51x() {
1044    SkPath path;
1045    path.setFillType(SkPath::kEvenOdd_FillType);
1046    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1047    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1048    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1049    testSimplifyx(path);
1050}
1051
1052static void testLine52() {
1053    SkPath path;
1054    path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1055    path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1056    path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1057    testSimplifyx(path);
1058}
1059
1060static void testLine52x() {
1061    SkPath path;
1062    path.setFillType(SkPath::kEvenOdd_FillType);
1063    path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1064    path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1065    path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1066    testSimplifyx(path);
1067}
1068
1069static void testLine53() {
1070    SkPath path;
1071    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1072    path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1073    path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1074    testSimplifyx(path);
1075}
1076
1077static void testLine53x() {
1078    SkPath path;
1079    path.setFillType(SkPath::kEvenOdd_FillType);
1080    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
1081    path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1082    path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1083    testSimplifyx(path);
1084}
1085
1086static void testLine54() {
1087    SkPath path;
1088    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1089    path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
1090    path.addRect(8, 4, 17, 17, SkPath::kCCW_Direction);
1091    testSimplifyx(path);
1092}
1093
1094static void testLine54x() {
1095    SkPath path;
1096    path.setFillType(SkPath::kEvenOdd_FillType);
1097    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1098    path.addRect(6, 0, 18, 18, SkPath::kCW_Direction);
1099    path.addRect(8, 4, 17, 17, SkPath::kCCW_Direction);
1100    testSimplifyx(path);
1101}
1102
1103static void testLine55() {
1104    SkPath path;
1105    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1106    path.addRect(6, 6, 18, 18, SkPath::kCW_Direction);
1107    path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1108    testSimplifyx(path);
1109}
1110
1111static void testLine55x() {
1112    SkPath path;
1113    path.setFillType(SkPath::kEvenOdd_FillType);
1114    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1115    path.addRect(6, 6, 18, 18, SkPath::kCW_Direction);
1116    path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1117    testSimplifyx(path);
1118}
1119
1120static void testLine56() {
1121    SkPath path;
1122    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1123    path.addRect(18, 20, 30, 30, SkPath::kCW_Direction);
1124    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1125    testSimplifyx(path);
1126}
1127
1128static void testLine56x() {
1129    SkPath path;
1130    path.setFillType(SkPath::kEvenOdd_FillType);
1131    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1132    path.addRect(18, 20, 30, 30, SkPath::kCW_Direction);
1133    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1134    testSimplifyx(path);
1135}
1136
1137static void testLine57() {
1138    SkPath path;
1139    path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1140    path.addRect(20, 0, 30, 40, SkPath::kCW_Direction);
1141    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1142    testSimplifyx(path);
1143}
1144
1145static void testLine57x() {
1146    SkPath path;
1147    path.setFillType(SkPath::kEvenOdd_FillType);
1148    path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1149    path.addRect(20, 0, 30, 40, SkPath::kCW_Direction);
1150    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1151    testSimplifyx(path);
1152}
1153
1154static void testLine58() {
1155    SkPath path;
1156    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1157    path.addRect(0, 0, 12, 12, SkPath::kCCW_Direction);
1158    path.addRect(0, 12, 9, 9, SkPath::kCCW_Direction);
1159    testSimplifyx(path);
1160}
1161
1162static void testLine58x() {
1163    SkPath path;
1164    path.setFillType(SkPath::kEvenOdd_FillType);
1165    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1166    path.addRect(0, 0, 12, 12, SkPath::kCCW_Direction);
1167    path.addRect(0, 12, 9, 9, SkPath::kCCW_Direction);
1168    testSimplifyx(path);
1169}
1170
1171static void testLine59() {
1172    SkPath path;
1173    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1174    path.addRect(6, 6, 18, 18, SkPath::kCCW_Direction);
1175    path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1176    testSimplifyx(path);
1177}
1178
1179static void testLine59x() {
1180    SkPath path;
1181    path.setFillType(SkPath::kEvenOdd_FillType);
1182    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1183    path.addRect(6, 6, 18, 18, SkPath::kCCW_Direction);
1184    path.addRect(4, 4, 13, 13, SkPath::kCCW_Direction);
1185    testSimplifyx(path);
1186}
1187
1188static void testLine60() {
1189    SkPath path;
1190    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1191    path.addRect(6, 12, 18, 18, SkPath::kCCW_Direction);
1192    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1193    testSimplifyx(path);
1194}
1195
1196static void testLine60x() {
1197    SkPath path;
1198    path.setFillType(SkPath::kEvenOdd_FillType);
1199    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1200    path.addRect(6, 12, 18, 18, SkPath::kCCW_Direction);
1201    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1202    testSimplifyx(path);
1203}
1204
1205static void testLine61() {
1206    SkPath path;
1207    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1208    path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
1209    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1210    testSimplifyx(path);
1211}
1212
1213static void testLine61x() {
1214    SkPath path;
1215    path.setFillType(SkPath::kEvenOdd_FillType);
1216    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1217    path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
1218    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1219    testSimplifyx(path);
1220}
1221
1222static void testLine62() {
1223    SkPath path;
1224    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1225    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1226    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1227    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1228    testSimplifyx(path);
1229}
1230
1231static void testLine62x() {
1232    SkPath path;
1233    path.setFillType(SkPath::kEvenOdd_FillType);
1234    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1235    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1236    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
1237    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
1238    testSimplifyx(path);
1239}
1240
1241static void testLine63() {
1242    SkPath path;
1243    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1244    path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
1245    path.addRect(0, 6, 12, 12, SkPath::kCCW_Direction);
1246    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1247    testSimplifyx(path);
1248}
1249
1250static void testLine63x() {
1251    SkPath path;
1252    path.setFillType(SkPath::kEvenOdd_FillType);
1253    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1254    path.addRect(0, 10, 20, 20, SkPath::kCW_Direction);
1255    path.addRect(0, 6, 12, 12, SkPath::kCCW_Direction);
1256    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1257    testSimplifyx(path);
1258}
1259
1260static void testLine64() {
1261    SkPath path;
1262    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1263    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1264    path.addRect(18, 6, 30, 30, SkPath::kCW_Direction);
1265    testSimplifyx(path);
1266}
1267
1268static void testLine64x() {
1269    SkPath path;
1270    path.setFillType(SkPath::kEvenOdd_FillType);
1271    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1272    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1273    path.addRect(18, 6, 30, 30, SkPath::kCW_Direction);
1274    testSimplifyx(path);
1275}
1276
1277static void testLine65() {
1278    SkPath path;
1279    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1280    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
1281    path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
1282    path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1283    testSimplifyx(path);
1284}
1285
1286static void testLine65x() {
1287    SkPath path;
1288    path.setFillType(SkPath::kEvenOdd_FillType);
1289    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1290    path.addRect(10, 0, 30, 30, SkPath::kCW_Direction);
1291    path.addRect(24, 0, 36, 36, SkPath::kCW_Direction);
1292    path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1293    testSimplifyx(path);
1294}
1295
1296static void testLine66() {
1297    SkPath path;
1298    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1299    path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1300    path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1301    testSimplifyx(path);
1302}
1303
1304static void testLine66x() {
1305    SkPath path;
1306    path.setFillType(SkPath::kEvenOdd_FillType);
1307    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1308    path.addRect(0, 30, 20, 20, SkPath::kCW_Direction);
1309    path.addRect(12, 20, 24, 30, SkPath::kCW_Direction);
1310    testSimplifyx(path);
1311}
1312
1313static void testLine67() {
1314    SkPath path;
1315    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1316    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1317    path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1318    path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1319    testSimplifyx(path);
1320}
1321
1322static void testLine67x() {
1323    SkPath path;
1324    path.setFillType(SkPath::kEvenOdd_FillType);
1325    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1326    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1327    path.addRect(24, 20, 36, 30, SkPath::kCW_Direction);
1328    path.addRect(32, 0, 36, 41, SkPath::kCW_Direction);
1329    testSimplifyx(path);
1330}
1331
1332static void testLine68a() {
1333    SkPath path;
1334    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1335    path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1336    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1337    testSimplifyx(path);
1338}
1339
1340static void testLine68ax() {
1341    SkPath path;
1342    path.setFillType(SkPath::kEvenOdd_FillType);
1343    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1344    path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1345    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1346    testSimplifyx(path);
1347}
1348
1349static void testLine68b() {
1350    SkPath path;
1351    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1352    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1353    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1354    testSimplifyx(path);
1355}
1356
1357static void testLine68bx() {
1358    SkPath path;
1359    path.setFillType(SkPath::kEvenOdd_FillType);
1360    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1361    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1362    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1363    testSimplifyx(path);
1364}
1365
1366static void testLine68c() {
1367    SkPath path;
1368    path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1369    path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1370    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1371    testSimplifyx(path);
1372}
1373
1374static void testLine68cx() {
1375    SkPath path;
1376    path.setFillType(SkPath::kEvenOdd_FillType);
1377    path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1378    path.addRect(2, 2, 6, 6, SkPath::kCW_Direction);
1379    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1380    testSimplifyx(path);
1381}
1382
1383static void testLine68d() {
1384    SkPath path;
1385    path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1386    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1387    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1388    testSimplifyx(path);
1389}
1390
1391static void testLine68dx() {
1392    SkPath path;
1393    path.setFillType(SkPath::kEvenOdd_FillType);
1394    path.addRect(0, 0, 8, 8, SkPath::kCCW_Direction);
1395    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1396    path.addRect(1, 2, 4, 2, SkPath::kCW_Direction);
1397    testSimplifyx(path);
1398}
1399
1400static void testLine68e() {
1401    SkPath path;
1402    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1403    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1404    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1405    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1406    testSimplifyx(path);
1407}
1408
1409static void testLine68ex() {
1410    SkPath path;
1411    path.setFillType(SkPath::kEvenOdd_FillType);
1412    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1413    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1414    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1415    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1416    testSimplifyx(path);
1417}
1418
1419static void testLine68f() {
1420    SkPath path;
1421    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1422    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1423    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1424    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1425    testSimplifyx(path);
1426}
1427
1428static void testLine68fx() {
1429    SkPath path;
1430    path.setFillType(SkPath::kEvenOdd_FillType);
1431    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1432    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1433    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1434    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1435    testSimplifyx(path);
1436}
1437
1438static void testLine68g() {
1439    SkPath path;
1440    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1441    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1442    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1443    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1444    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1445    testSimplifyx(path);
1446}
1447
1448static void testLine68gx() {
1449    SkPath path;
1450    path.setFillType(SkPath::kEvenOdd_FillType);
1451    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1452    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1453    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1454    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1455    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1456    testSimplifyx(path);
1457}
1458
1459static void testLine68h() {
1460    SkPath path;
1461    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1462    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1463    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1464    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1465    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1466    testSimplifyx(path);
1467}
1468
1469static void testLine68hx() {
1470    SkPath path;
1471    path.setFillType(SkPath::kEvenOdd_FillType);
1472    path.addRect(0, 0, 8, 8, SkPath::kCW_Direction);
1473    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1474    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1475    path.addRect(2, 2, 6, 6, SkPath::kCCW_Direction);
1476    path.addRect(1, 2, 2, 2, SkPath::kCW_Direction);
1477    testSimplifyx(path);
1478}
1479
1480static void testLine69() {
1481    SkPath path;
1482    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1483    path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1484    path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1485    testSimplifyx(path);
1486}
1487
1488static void testLine69x() {
1489    SkPath path;
1490    path.setFillType(SkPath::kEvenOdd_FillType);
1491    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
1492    path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1493    path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1494    testSimplifyx(path);
1495}
1496
1497static void testLine70() {
1498    SkPath path;
1499    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1500    path.addRect(0, 24, 12, 12, SkPath::kCW_Direction);
1501    path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1502    testSimplifyx(path);
1503}
1504
1505static void testLine70x() {
1506    SkPath path;
1507    path.setFillType(SkPath::kEvenOdd_FillType);
1508    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1509    path.addRect(0, 24, 12, 12, SkPath::kCW_Direction);
1510    path.addRect(12, 32, 21, 36, SkPath::kCCW_Direction);
1511    testSimplifyx(path);
1512}
1513
1514static void testLine71() {
1515    SkPath path;
1516    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1517    path.addRect(12, 0, 24, 24, SkPath::kCW_Direction);
1518    path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1519    testSimplifyx(path);
1520}
1521
1522static void testLine71x() {
1523    SkPath path;
1524    path.setFillType(SkPath::kEvenOdd_FillType);
1525    path.addRect(0, 0, 20, 20, SkPath::kCW_Direction);
1526    path.addRect(12, 0, 24, 24, SkPath::kCW_Direction);
1527    path.addRect(12, 32, 21, 36, SkPath::kCW_Direction);
1528    testSimplifyx(path);
1529}
1530
1531static void testLine72() {
1532    SkPath path;
1533    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1534    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1535    path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1536    testSimplifyx(path);
1537}
1538
1539static void testLine72x() {
1540    SkPath path;
1541    path.setFillType(SkPath::kEvenOdd_FillType);
1542    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1543    path.addRect(10, 40, 30, 30, SkPath::kCW_Direction);
1544    path.addRect(6, 20, 18, 30, SkPath::kCW_Direction);
1545    testSimplifyx(path);
1546}
1547
1548static void testLine73() {
1549    SkPath path;
1550    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1551    path.addRect(0, 40, 20, 20, SkPath::kCW_Direction);
1552    path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1553    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
1554    testSimplifyx(path);
1555}
1556
1557static void testLine73x() {
1558    SkPath path;
1559    path.setFillType(SkPath::kEvenOdd_FillType);
1560    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1561    path.addRect(0, 40, 20, 20, SkPath::kCW_Direction);
1562    path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
1563    path.addRect(0, 0, 9, 9, SkPath::kCCW_Direction);
1564    testSimplifyx(path);
1565}
1566
1567static void testLine74() {
1568    SkPath path;
1569    path.addRect(20, 30, 40, 40, SkPath::kCW_Direction);
1570    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1571    path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
1572    testSimplifyx(path);
1573}
1574
1575static void testLine74x() {
1576    SkPath path;
1577    path.setFillType(SkPath::kEvenOdd_FillType);
1578    path.addRect(20, 30, 40, 40, SkPath::kCW_Direction);
1579    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1580    path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
1581    testSimplifyx(path);
1582}
1583
1584static void testLine75() {
1585    SkPath path;
1586    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1587    path.addRect(10, 0, 30, 30, SkPath::kCCW_Direction);
1588    path.addRect(18, 0, 30, 30, SkPath::kCCW_Direction);
1589    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1590    testSimplifyx(path);
1591}
1592
1593static void testLine75x() {
1594    SkPath path;
1595    path.setFillType(SkPath::kEvenOdd_FillType);
1596    path.addRect(0, 0, 60, 60, SkPath::kCW_Direction);
1597    path.addRect(10, 0, 30, 30, SkPath::kCCW_Direction);
1598    path.addRect(18, 0, 30, 30, SkPath::kCCW_Direction);
1599    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
1600    testSimplifyx(path);
1601}
1602
1603static void testLine76() {
1604    SkPath path;
1605    path.addRect(36, 0, 66, 60, SkPath::kCW_Direction);
1606    path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
1607    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1608    path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1609    testSimplifyx(path);
1610}
1611
1612static void testLine76x() {
1613    SkPath path;
1614    path.setFillType(SkPath::kEvenOdd_FillType);
1615    path.addRect(36, 0, 66, 60, SkPath::kCW_Direction);
1616    path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
1617    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
1618    path.addRect(32, 6, 36, 41, SkPath::kCCW_Direction);
1619    testSimplifyx(path);
1620}
1621
1622static void testLine77() {
1623    SkPath path;
1624    path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1625    path.addRect(24, 6, 36, 36, SkPath::kCCW_Direction);
1626    path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
1627    testSimplifyx(path);
1628}
1629
1630static void testLine77x() {
1631    SkPath path;
1632    path.setFillType(SkPath::kEvenOdd_FillType);
1633    path.addRect(20, 0, 40, 40, SkPath::kCW_Direction);
1634    path.addRect(24, 6, 36, 36, SkPath::kCCW_Direction);
1635    path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
1636    testSimplifyx(path);
1637}
1638
1639static void testLine78() {
1640    SkPath path;
1641    path.addRect(0, 0, 30, 60, SkPath::kCW_Direction);
1642    path.addRect(10, 20, 30, 30, SkPath::kCCW_Direction);
1643    path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
1644    path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
1645    testSimplifyx(path);
1646}
1647
1648static void testLine78x() {
1649    SkPath path;
1650    path.setFillType(SkPath::kEvenOdd_FillType);
1651    path.addRect(0, 0, 30, 60, SkPath::kCW_Direction);
1652    path.addRect(10, 20, 30, 30, SkPath::kCCW_Direction);
1653    path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
1654    path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
1655    testSimplifyx(path);
1656}
1657
1658static void testLine79() {
1659    SkPath path;
1660    path.addRect(0, 36, 60, 30, SkPath::kCW_Direction);
1661    path.addRect(10, 30, 40, 30, SkPath::kCW_Direction);
1662    path.addRect(0, 20, 12, 30, SkPath::kCCW_Direction);
1663    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1664    testSimplifyx(path);
1665}
1666
1667static void testLine79x() {
1668    SkPath path;
1669    path.setFillType(SkPath::kEvenOdd_FillType);
1670    path.addRect(0, 36, 60, 30, SkPath::kCW_Direction);
1671    path.addRect(10, 30, 40, 30, SkPath::kCW_Direction);
1672    path.addRect(0, 20, 12, 30, SkPath::kCCW_Direction);
1673    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
1674    testSimplifyx(path);
1675}
1676
1677static void testLine81() {
1678    SkPath path;
1679    path.addRect(-1, -1, 3, 3, SkPath::kCW_Direction);
1680    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1681    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1682    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
1683    path.addRect(1, 1, 2, 2, SkPath::kCCW_Direction);
1684    testSimplifyx(path);
1685}
1686
1687static void testDegenerate1() {
1688    SkPath path;
1689    path.moveTo(0, 0);
1690    path.lineTo(0, 0);
1691    path.lineTo(2, 0);
1692    path.close();
1693    path.moveTo(0, 0);
1694    path.lineTo(1, 0);
1695    path.lineTo(2, 0);
1696    path.close();
1697    testSimplifyx(path);
1698}
1699
1700static void testDegenerate1x() {
1701    SkPath path;
1702    path.setFillType(SkPath::kEvenOdd_FillType);
1703    path.moveTo(0, 0);
1704    path.lineTo(0, 0);
1705    path.lineTo(2, 0);
1706    path.close();
1707    path.moveTo(0, 0);
1708    path.lineTo(1, 0);
1709    path.lineTo(2, 0);
1710    path.close();
1711    testSimplifyx(path);
1712}
1713
1714static void testDegenerate2() {
1715    SkPath path;
1716    path.moveTo(0, 0);
1717    path.lineTo(0, 0);
1718    path.lineTo(0, 0);
1719    path.close();
1720    path.moveTo(0, 0);
1721    path.lineTo(1, 0);
1722    path.lineTo(0, 1);
1723    path.close();
1724    testSimplifyx(path);
1725}
1726
1727static void testDegenerate2x() {
1728    SkPath path;
1729    path.setFillType(SkPath::kEvenOdd_FillType);
1730    path.moveTo(0, 0);
1731    path.lineTo(0, 0);
1732    path.lineTo(0, 0);
1733    path.close();
1734    path.moveTo(0, 0);
1735    path.lineTo(1, 0);
1736    path.lineTo(0, 1);
1737    path.close();
1738    testSimplifyx(path);
1739}
1740
1741static void testDegenerate3() {
1742    SkPath path;
1743    path.moveTo(0, 0);
1744    path.lineTo(2, 0);
1745    path.lineTo(1, 0);
1746    path.close();
1747    path.moveTo(0, 0);
1748    path.lineTo(0, 0);
1749    path.lineTo(3, 0);
1750    path.close();
1751    testSimplifyx(path);
1752}
1753
1754static void testDegenerate3x() {
1755    SkPath path;
1756    path.setFillType(SkPath::kEvenOdd_FillType);
1757    path.moveTo(0, 0);
1758    path.lineTo(2, 0);
1759    path.lineTo(1, 0);
1760    path.close();
1761    path.moveTo(0, 0);
1762    path.lineTo(0, 0);
1763    path.lineTo(3, 0);
1764    path.close();
1765    testSimplifyx(path);
1766}
1767
1768static void testDegenerate4() {
1769    SkPath path;
1770    path.moveTo(0, 0);
1771    path.lineTo(1, 0);
1772    path.lineTo(1, 3);
1773    path.close();
1774    path.moveTo(1, 0);
1775    path.lineTo(1, 1);
1776    path.lineTo(1, 2);
1777    path.close();
1778    testSimplifyx(path);
1779}
1780
1781static void testDegenerate4x() {
1782    SkPath path;
1783    path.setFillType(SkPath::kEvenOdd_FillType);
1784    path.moveTo(0, 0);
1785    path.lineTo(1, 0);
1786    path.lineTo(1, 3);
1787    path.close();
1788    path.moveTo(1, 0);
1789    path.lineTo(1, 1);
1790    path.lineTo(1, 2);
1791    path.close();
1792    testSimplifyx(path);
1793}
1794
1795static void testNondegenerate1() {
1796    SkPath path;
1797    path.moveTo(0, 0);
1798    path.lineTo(3, 0);
1799    path.lineTo(1, 3);
1800    path.close();
1801    path.moveTo(1, 1);
1802    path.lineTo(2, 1);
1803    path.lineTo(1, 2);
1804    path.close();
1805    testSimplifyx(path);
1806}
1807
1808static void testNondegenerate1x() {
1809    SkPath path;
1810    path.setFillType(SkPath::kEvenOdd_FillType);
1811    path.moveTo(0, 0);
1812    path.lineTo(3, 0);
1813    path.lineTo(1, 3);
1814    path.close();
1815    path.moveTo(1, 1);
1816    path.lineTo(2, 1);
1817    path.lineTo(1, 2);
1818    path.close();
1819    testSimplifyx(path);
1820}
1821
1822static void testNondegenerate2() {
1823    SkPath path;
1824    path.moveTo(1, 0);
1825    path.lineTo(0, 1);
1826    path.lineTo(1, 1);
1827    path.close();
1828    path.moveTo(0, 2);
1829    path.lineTo(0, 3);
1830    path.lineTo(1, 2);
1831    path.close();
1832    testSimplifyx(path);
1833}
1834
1835static void testNondegenerate2x() {
1836    SkPath path;
1837    path.setFillType(SkPath::kEvenOdd_FillType);
1838    path.moveTo(1, 0);
1839    path.lineTo(0, 1);
1840    path.lineTo(1, 1);
1841    path.close();
1842    path.moveTo(0, 2);
1843    path.lineTo(0, 3);
1844    path.lineTo(1, 2);
1845    path.close();
1846    testSimplifyx(path);
1847}
1848
1849static void testNondegenerate3() {
1850    SkPath path;
1851    path.moveTo(0, 0);
1852    path.lineTo(1, 0);
1853    path.lineTo(2, 1);
1854    path.close();
1855    path.moveTo(0, 1);
1856    path.lineTo(1, 1);
1857    path.lineTo(0, 2);
1858    path.close();
1859    testSimplifyx(path);
1860}
1861
1862static void testNondegenerate3x() {
1863    SkPath path;
1864    path.setFillType(SkPath::kEvenOdd_FillType);
1865    path.moveTo(0, 0);
1866    path.lineTo(1, 0);
1867    path.lineTo(2, 1);
1868    path.close();
1869    path.moveTo(0, 1);
1870    path.lineTo(1, 1);
1871    path.lineTo(0, 2);
1872    path.close();
1873    testSimplifyx(path);
1874}
1875
1876static void testNondegenerate4() {
1877    SkPath path;
1878    path.moveTo(1, 0);
1879    path.lineTo(0, 1);
1880    path.lineTo(1, 2);
1881    path.close();
1882    path.moveTo(0, 2);
1883    path.lineTo(0, 3);
1884    path.lineTo(1, 3);
1885    path.close();
1886    testSimplifyx(path);
1887}
1888
1889static void testNondegenerate4x() {
1890    SkPath path;
1891    path.setFillType(SkPath::kEvenOdd_FillType);
1892    path.moveTo(1, 0);
1893    path.lineTo(0, 1);
1894    path.lineTo(1, 2);
1895    path.close();
1896    path.moveTo(0, 2);
1897    path.lineTo(0, 3);
1898    path.lineTo(1, 3);
1899    path.close();
1900    testSimplifyx(path);
1901}
1902
1903static void testQuadralateral5() {
1904    SkPath path;
1905    path.moveTo(0, 0);
1906    path.lineTo(0, 0);
1907    path.lineTo(1, 0);
1908    path.lineTo(1, 1);
1909    path.close();
1910    path.moveTo(0, 0);
1911    path.lineTo(2, 2);
1912    path.lineTo(3, 2);
1913    path.lineTo(3, 3);
1914    path.close();
1915    testSimplifyx(path);
1916}
1917
1918static void testQuadralateral5x() {
1919    SkPath path;
1920    path.setFillType(SkPath::kEvenOdd_FillType);
1921    path.moveTo(0, 0);
1922    path.lineTo(0, 0);
1923    path.lineTo(1, 0);
1924    path.lineTo(1, 1);
1925    path.close();
1926    path.moveTo(0, 0);
1927    path.lineTo(2, 2);
1928    path.lineTo(3, 2);
1929    path.lineTo(3, 3);
1930    path.close();
1931    testSimplifyx(path);
1932}
1933
1934static void testQuadralateral6() {
1935    SkPath path;
1936    path.moveTo(0, 0);
1937    path.lineTo(0, 0);
1938    path.lineTo(1, 0);
1939    path.lineTo(1, 1);
1940    path.close();
1941    path.moveTo(1, 0);
1942    path.lineTo(2, 0);
1943    path.lineTo(0, 2);
1944    path.lineTo(2, 2);
1945    path.close();
1946    testSimplifyx(path);
1947}
1948
1949static void testQuadralateral6x() {
1950    SkPath path;
1951    path.setFillType(SkPath::kEvenOdd_FillType);
1952    path.moveTo(0, 0);
1953    path.lineTo(0, 0);
1954    path.lineTo(1, 0);
1955    path.lineTo(1, 1);
1956    path.close();
1957    path.moveTo(1, 0);
1958    path.lineTo(2, 0);
1959    path.lineTo(0, 2);
1960    path.lineTo(2, 2);
1961    path.close();
1962    testSimplifyx(path);
1963}
1964
1965static void testFauxQuadralateral6() {
1966    SkPath path;
1967    path.moveTo(0, 0);
1968    path.lineTo(1, 0);
1969    path.lineTo(1, 1);
1970    path.close();
1971    path.moveTo(1, 0);
1972    path.lineTo(2, 0);
1973    path.lineTo(1 + 1.0f/3, 2.0f/3);
1974    path.close();
1975    path.moveTo(1 + 1.0f/3, 2.0f/3);
1976    path.lineTo(0, 2);
1977    path.lineTo(2, 2);
1978    path.close();
1979    testSimplifyx(path);
1980}
1981
1982static void testFauxQuadralateral6x() {
1983    SkPath path;
1984    path.setFillType(SkPath::kEvenOdd_FillType);
1985    path.moveTo(0, 0);
1986    path.lineTo(1, 0);
1987    path.lineTo(1, 1);
1988    path.close();
1989    path.moveTo(1, 0);
1990    path.lineTo(2, 0);
1991    path.lineTo(1 + 1.0f/3, 2.0f/3);
1992    path.close();
1993    path.moveTo(1 + 1.0f/3, 2.0f/3);
1994    path.lineTo(0, 2);
1995    path.lineTo(2, 2);
1996    path.close();
1997    testSimplifyx(path);
1998}
1999
2000static void testFauxQuadralateral6a() {
2001    SkPath path;
2002    path.moveTo(0, 0);
2003    path.lineTo(3, 0);
2004    path.lineTo(3, 3);
2005    path.close();
2006    path.moveTo(3, 0);
2007    path.lineTo(6, 0);
2008    path.lineTo(4, 2);
2009    path.close();
2010    path.moveTo(4, 2);
2011    path.lineTo(0, 6);
2012    path.lineTo(6, 6);
2013    path.close();
2014    testSimplifyx(path);
2015}
2016
2017static void testFauxQuadralateral6ax() {
2018    SkPath path;
2019    path.setFillType(SkPath::kEvenOdd_FillType);
2020    path.moveTo(0, 0);
2021    path.lineTo(3, 0);
2022    path.lineTo(3, 3);
2023    path.close();
2024    path.moveTo(3, 0);
2025    path.lineTo(6, 0);
2026    path.lineTo(4, 2);
2027    path.close();
2028    path.moveTo(4, 2);
2029    path.lineTo(0, 6);
2030    path.lineTo(6, 6);
2031    path.close();
2032    testSimplifyx(path);
2033}
2034
2035static void testFauxQuadralateral6b() {
2036    SkPath path;
2037    path.moveTo(0, 0);
2038    path.lineTo(3, 0);
2039    path.lineTo(3, 3);
2040    path.close();
2041    path.moveTo(3, 0);
2042    path.lineTo(6, 0);
2043    path.lineTo(4, 2);
2044    path.close();
2045    path.moveTo(4, 2);
2046    path.lineTo(6, 6);
2047    path.lineTo(0, 6);
2048    path.close();
2049    testSimplifyx(path);
2050}
2051
2052static void testFauxQuadralateral6bx() {
2053    SkPath path;
2054    path.setFillType(SkPath::kEvenOdd_FillType);
2055    path.moveTo(0, 0);
2056    path.lineTo(3, 0);
2057    path.lineTo(3, 3);
2058    path.close();
2059    path.moveTo(3, 0);
2060    path.lineTo(6, 0);
2061    path.lineTo(4, 2);
2062    path.close();
2063    path.moveTo(4, 2);
2064    path.lineTo(6, 6);
2065    path.lineTo(0, 6);
2066    path.close();
2067    testSimplifyx(path);
2068}
2069
2070static void testFauxQuadralateral6c() {
2071    SkPath path;
2072    path.moveTo(0, 0);
2073    path.lineTo(3, 3);
2074    path.lineTo(3, 0);
2075    path.close();
2076    path.moveTo(3, 0);
2077    path.lineTo(6, 0);
2078    path.lineTo(4, 2);
2079    path.close();
2080    path.moveTo(4, 2);
2081    path.lineTo(0, 6);
2082    path.lineTo(6, 6);
2083    path.close();
2084    testSimplifyx(path);
2085}
2086
2087static void testFauxQuadralateral6cx() {
2088    SkPath path;
2089    path.setFillType(SkPath::kEvenOdd_FillType);
2090    path.moveTo(0, 0);
2091    path.lineTo(3, 3);
2092    path.lineTo(3, 0);
2093    path.close();
2094    path.moveTo(3, 0);
2095    path.lineTo(6, 0);
2096    path.lineTo(4, 2);
2097    path.close();
2098    path.moveTo(4, 2);
2099    path.lineTo(0, 6);
2100    path.lineTo(6, 6);
2101    path.close();
2102    testSimplifyx(path);
2103}
2104
2105static void testFauxQuadralateral6d() {
2106    SkPath path;
2107    path.moveTo(0, 0);
2108    path.lineTo(3, 3);
2109    path.lineTo(3, 0);
2110    path.close();
2111    path.moveTo(3, 0);
2112    path.lineTo(6, 0);
2113    path.lineTo(4, 2);
2114    path.close();
2115    path.moveTo(4, 2);
2116    path.lineTo(6, 6);
2117    path.lineTo(0, 6);
2118    path.close();
2119    testSimplifyx(path);
2120}
2121
2122static void testFauxQuadralateral6dx() {
2123    SkPath path;
2124    path.setFillType(SkPath::kEvenOdd_FillType);
2125    path.moveTo(0, 0);
2126    path.lineTo(3, 3);
2127    path.lineTo(3, 0);
2128    path.close();
2129    path.moveTo(3, 0);
2130    path.lineTo(6, 0);
2131    path.lineTo(4, 2);
2132    path.close();
2133    path.moveTo(4, 2);
2134    path.lineTo(6, 6);
2135    path.lineTo(0, 6);
2136    path.close();
2137    testSimplifyx(path);
2138}
2139
2140static void testQuadralateral6a() {
2141    SkPath path;
2142    path.moveTo(0, 0);
2143    path.lineTo(0, 0);
2144    path.lineTo(3, 0);
2145    path.lineTo(3, 3);
2146    path.close();
2147    path.moveTo(3, 0);
2148    path.lineTo(6, 0);
2149    path.lineTo(0, 6);
2150    path.lineTo(6, 6);
2151    path.close();
2152    testSimplifyx(path);
2153}
2154
2155static void testQuadralateral6ax() {
2156    SkPath path;
2157    path.setFillType(SkPath::kEvenOdd_FillType);
2158    path.moveTo(0, 0);
2159    path.lineTo(0, 0);
2160    path.lineTo(3, 0);
2161    path.lineTo(3, 3);
2162    path.close();
2163    path.moveTo(3, 0);
2164    path.lineTo(6, 0);
2165    path.lineTo(0, 6);
2166    path.lineTo(6, 6);
2167    path.close();
2168    testSimplifyx(path);
2169}
2170
2171static void testQuadralateral7() {
2172    SkPath path;
2173    path.moveTo(0, 0);
2174    path.lineTo(0, 0);
2175    path.lineTo(1, 0);
2176    path.lineTo(2, 1);
2177    path.close();
2178    path.moveTo(1, 0);
2179    path.lineTo(1, 1);
2180    path.lineTo(2, 2);
2181    path.lineTo(1, 3);
2182    path.close();
2183    testSimplifyx(path);
2184}
2185
2186static void testQuadralateral7x() {
2187    SkPath path;
2188    path.setFillType(SkPath::kEvenOdd_FillType);
2189    path.moveTo(0, 0);
2190    path.lineTo(0, 0);
2191    path.lineTo(1, 0);
2192    path.lineTo(2, 1);
2193    path.close();
2194    path.moveTo(1, 0);
2195    path.lineTo(1, 1);
2196    path.lineTo(2, 2);
2197    path.lineTo(1, 3);
2198    path.close();
2199    testSimplifyx(path);
2200}
2201
2202static void testQuadralateral8() {
2203    SkPath path;
2204    path.moveTo(0, 0);
2205    path.lineTo(3, 1);
2206    path.lineTo(1, 3);
2207    path.lineTo(3, 3);
2208    path.close();
2209    path.moveTo(2, 1);
2210    path.lineTo(0, 2);
2211    path.lineTo(3, 2);
2212    path.lineTo(2, 3);
2213    path.close();
2214    testSimplifyx(path);
2215}
2216
2217static void testQuadralateral8x() {
2218    SkPath path;
2219    path.setFillType(SkPath::kEvenOdd_FillType);
2220    path.moveTo(0, 0);
2221    path.lineTo(3, 1);
2222    path.lineTo(1, 3);
2223    path.lineTo(3, 3);
2224    path.close();
2225    path.moveTo(2, 1);
2226    path.lineTo(0, 2);
2227    path.lineTo(3, 2);
2228    path.lineTo(2, 3);
2229    path.close();
2230    testSimplifyx(path);
2231}
2232
2233static void testQuadralateral9() {
2234    SkPath path;
2235    path.moveTo(0, 0);
2236    path.lineTo(1, 0);
2237    path.lineTo(1, 2);
2238    path.lineTo(2, 2);
2239    path.close();
2240    path.moveTo(1, 1);
2241    path.lineTo(2, 1);
2242    path.lineTo(1, 3);
2243    path.lineTo(2, 3);
2244    path.close();
2245    testSimplifyx(path);
2246}
2247
2248static void testQuadralateral9x() {
2249    SkPath path;
2250    path.setFillType(SkPath::kEvenOdd_FillType);
2251    path.moveTo(0, 0);
2252    path.lineTo(1, 0);
2253    path.lineTo(1, 2);
2254    path.lineTo(2, 2);
2255    path.close();
2256    path.moveTo(1, 1);
2257    path.lineTo(2, 1);
2258    path.lineTo(1, 3);
2259    path.lineTo(2, 3);
2260    path.close();
2261    testSimplifyx(path);
2262}
2263
2264static void testLine1a() {
2265    SkPath path;
2266    path.setFillType(SkPath::kWinding_FillType);
2267    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
2268    path.addRect(4, 0, 13, 13, SkPath::kCCW_Direction);
2269    testSimplifyx(path);
2270}
2271
2272static void testLine1ax() {
2273    SkPath path;
2274    path.setFillType(SkPath::kEvenOdd_FillType);
2275    path.addRect(0, 0, 12, 12, SkPath::kCW_Direction);
2276    path.addRect(4, 0, 13, 13, SkPath::kCCW_Direction);
2277    testSimplifyx(path);
2278}
2279
2280static void testLine2ax() {
2281    SkPath path;
2282    path.setFillType(SkPath::kEvenOdd_FillType);
2283    path.addRect(0, 20, 20, 20, SkPath::kCW_Direction);
2284    path.addRect(0, 20, 12, 30, SkPath::kCW_Direction);
2285    path.addRect(12, 0, 21, 21, SkPath::kCCW_Direction);
2286    testSimplifyx(path);
2287}
2288
2289static void testLine3aax() {
2290    SkPath path;
2291    path.setFillType(SkPath::kEvenOdd_FillType);
2292    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
2293    path.addRect(18, 20, 30, 30, SkPath::kCCW_Direction);
2294    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
2295    testSimplifyx(path);
2296}
2297
2298static void testLine4ax() {
2299    SkPath path;
2300    path.setFillType(SkPath::kEvenOdd_FillType);
2301    path.addRect(10, 30, 30, 30, SkPath::kCW_Direction);
2302    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
2303    path.addRect(0, 32, 9, 36, SkPath::kCCW_Direction);
2304    testSimplifyx(path);
2305}
2306
2307static void testQuadratic1() {
2308    SkPath path;
2309    path.moveTo(0, 0);
2310    path.quadTo(0, 0, 0, 0);
2311    path.lineTo(1, 0);
2312    path.close();
2313    path.moveTo(0, 0);
2314    path.lineTo(0, 0);
2315    path.quadTo(0, 0, 0, 0);
2316    path.close();
2317    testSimplifyx(path);
2318}
2319
2320static void testQuadratic1x() {
2321    SkPath path;
2322    path.setFillType(SkPath::kEvenOdd_FillType);
2323    path.moveTo(0, 0);
2324    path.quadTo(0, 0, 0, 0);
2325    path.lineTo(1, 0);
2326    path.close();
2327    path.moveTo(0, 0);
2328    path.lineTo(0, 0);
2329    path.quadTo(0, 0, 0, 0);
2330    path.close();
2331    testSimplifyx(path);
2332}
2333
2334static void testQuadratic2() {
2335    SkPath path;
2336    path.moveTo(0, 0);
2337    path.quadTo(0, 0, 0, 0);
2338    path.lineTo(3, 0);
2339    path.close();
2340    path.moveTo(0, 0);
2341    path.lineTo(0, 0);
2342    path.quadTo(1, 0, 0, 1);
2343    path.close();
2344    testSimplifyx(path);
2345}
2346
2347static void testQuadratic2x() {
2348    SkPath path;
2349    path.setFillType(SkPath::kEvenOdd_FillType);
2350    path.moveTo(0, 0);
2351    path.quadTo(0, 0, 0, 0);
2352    path.lineTo(3, 0);
2353    path.close();
2354    path.moveTo(0, 0);
2355    path.lineTo(0, 0);
2356    path.quadTo(1, 0, 0, 1);
2357    path.close();
2358    testSimplifyx(path);
2359}
2360
2361static void testQuadratic3() {
2362    SkPath path;
2363    path.moveTo(0, 0);
2364    path.quadTo(0, 0, 1, 0);
2365    path.lineTo(0, 2);
2366    path.close();
2367    path.moveTo(0, 0);
2368    path.lineTo(0, 0);
2369    path.quadTo(1, 0, 0, 1);
2370    path.close();
2371    testSimplifyx(path);
2372}
2373
2374static void testQuadratic3x() {
2375    SkPath path;
2376    path.setFillType(SkPath::kEvenOdd_FillType);
2377    path.moveTo(0, 0);
2378    path.quadTo(0, 0, 1, 0);
2379    path.lineTo(0, 2);
2380    path.close();
2381    path.moveTo(0, 0);
2382    path.lineTo(0, 0);
2383    path.quadTo(1, 0, 0, 1);
2384    path.close();
2385    testSimplifyx(path);
2386}
2387
2388static void testQuadratic4() {
2389    SkPath path;
2390    path.moveTo(0, 0);
2391    path.quadTo(0, 0, 1, 0);
2392    path.lineTo(0, 2);
2393    path.close();
2394    path.moveTo(0, 0);
2395    path.lineTo(0, 0);
2396    path.quadTo(1, 0, 0, 2);
2397    path.close();
2398    testSimplifyx(path);
2399}
2400
2401static void testQuadratic4x() {
2402    SkPath path;
2403    path.setFillType(SkPath::kEvenOdd_FillType);
2404    path.moveTo(0, 0);
2405    path.quadTo(0, 0, 1, 0);
2406    path.lineTo(0, 2);
2407    path.close();
2408    path.moveTo(0, 0);
2409    path.lineTo(0, 0);
2410    path.quadTo(1, 0, 0, 2);
2411    path.close();
2412    testSimplifyx(path);
2413}
2414
2415static void testQuadratic5() {
2416    SkPath path;
2417    path.moveTo(0, 0);
2418    path.quadTo(0, 0, 0, 0);
2419    path.lineTo(0, 1);
2420    path.close();
2421    path.moveTo(0, 0);
2422    path.lineTo(1, 0);
2423    path.quadTo(0, 1, 0, 2);
2424    path.close();
2425    testSimplifyx(path);
2426}
2427
2428static void testQuadratic6() {
2429    SkPath path;
2430    path.moveTo(0, 0);
2431    path.quadTo(0, 0, 1, 0);
2432    path.lineTo(2, 1);
2433    path.close();
2434    path.moveTo(0, 0);
2435    path.lineTo(0, 0);
2436    path.quadTo(2, 0, 0, 1);
2437    path.close();
2438    testSimplifyx(path);
2439}
2440
2441static void testQuadratic7() {
2442    SkPath path;
2443    path.moveTo(0, 0);
2444    path.quadTo(0, 0, 1, 0);
2445    path.lineTo(3, 1);
2446    path.close();
2447    path.moveTo(0, 0);
2448    path.lineTo(0, 0);
2449    path.quadTo(3, 0, 1, 2);
2450    path.close();
2451    testSimplifyx(path);
2452}
2453
2454static void testQuadratic8() {
2455    SkPath path;
2456    path.moveTo(0, 0);
2457    path.quadTo(0, 0, 1, 0);
2458    path.lineTo(0, 2);
2459    path.close();
2460    path.moveTo(0, 0);
2461    path.lineTo(1, 0);
2462    path.quadTo(0, 1, 1, 2);
2463    path.close();
2464    testSimplifyx(path);
2465}
2466
2467static void testQuadratic9() {
2468    SkPath path;
2469    path.moveTo(0, 0);
2470    path.quadTo(0, 0, 1, 0);
2471    path.lineTo(3, 1);
2472    path.close();
2473    path.moveTo(0, 0);
2474    path.lineTo(1, 0);
2475    path.quadTo(1, 2, 3, 2);
2476    path.close();
2477    testSimplifyx(path);
2478}
2479
2480static void testQuadratic14() {
2481    SkPath path;
2482    path.moveTo(0, 0);
2483    path.quadTo(0, 0, 1, 0);
2484    path.lineTo(3, 2);
2485    path.close();
2486    path.moveTo(0, 0);
2487    path.lineTo(1, 0);
2488    path.quadTo(3, 2, 3, 3);
2489    path.close();
2490    testSimplifyx(path);
2491}
2492
2493static void testQuadratic15() {
2494    SkPath path;
2495    path.moveTo(0, 0);
2496    path.quadTo(0, 0, 1, 0);
2497    path.lineTo(1, 3);
2498    path.close();
2499    path.moveTo(1, 0);
2500    path.lineTo(0, 1);
2501    path.quadTo(1, 1, 0, 3);
2502    path.close();
2503    testSimplifyx(path);
2504}
2505
2506static void testQuadratic17x() {
2507    SkPath path;
2508    path.setFillType(SkPath::kEvenOdd_FillType);
2509    path.moveTo(0, 0);
2510    path.quadTo(0, 0, 3, 1);
2511    path.lineTo(0, 2);
2512    path.close();
2513    path.moveTo(0, 0);
2514    path.lineTo(1, 0);
2515    path.quadTo(3, 1, 0, 2);
2516    path.close();
2517    testSimplifyx(path);
2518}
2519
2520static void testQuadratic18() {
2521    SkPath path;
2522    path.moveTo(0, 0);
2523    path.quadTo(1, 0, 0, 1);
2524    path.lineTo(0, 1);
2525    path.close();
2526    path.moveTo(0, 0);
2527    path.lineTo(0, 0);
2528    path.quadTo(1, 0, 1, 1);
2529    path.close();
2530    testSimplifyx(path);
2531}
2532
2533static void testQuadratic19() {
2534    SkPath path;
2535    path.moveTo(0, 0);
2536    path.quadTo(1, 0, 0, 1);
2537    path.lineTo(0, 1);
2538    path.close();
2539    path.moveTo(0, 0);
2540    path.lineTo(0, 0);
2541    path.quadTo(2, 0, 0, 1);
2542    path.close();
2543    testSimplifyx(path);
2544}
2545
2546static void testQuadratic20() {
2547    SkPath path;
2548    path.moveTo(0, 0);
2549    path.quadTo(1, 0, 0, 1);
2550    path.lineTo(0, 1);
2551    path.close();
2552    path.moveTo(0, 0);
2553    path.lineTo(0, 0);
2554    path.quadTo(1, 0, 0, 1);
2555    path.close();
2556    testSimplifyx(path);
2557}
2558
2559static void testQuadratic21() {
2560    SkPath path;
2561    path.moveTo(0, 0);
2562    path.quadTo(1, 0, 0, 1);
2563    path.lineTo(0, 1);
2564    path.close();
2565    path.moveTo(0, 0);
2566    path.lineTo(0, 0);
2567    path.quadTo(1, 0, 0, 2);
2568    path.close();
2569    testSimplifyx(path);
2570}
2571
2572static void testQuadratic22() {
2573    SkPath path;
2574    path.moveTo(0, 0);
2575    path.quadTo(1, 0, 0, 1);
2576    path.lineTo(0, 1);
2577    path.close();
2578    path.moveTo(0, 0);
2579    path.lineTo(0, 0);
2580    path.quadTo(0, 1, 2, 1);
2581    path.close();
2582    testSimplifyx(path);
2583}
2584
2585static void testQuadratic23() {
2586    SkPath path;
2587    path.moveTo(0, 0);
2588    path.quadTo(1, 0, 0, 1);
2589    path.lineTo(0, 1);
2590    path.close();
2591    path.moveTo(0, 0);
2592    path.lineTo(0, 0);
2593    path.quadTo(0, 2, 1, 2);
2594    path.close();
2595    testSimplifyx(path);
2596}
2597
2598static void testQuadratic24() {
2599    SkPath path;
2600    path.moveTo(0, 0);
2601    path.quadTo(1, 0, 0, 1);
2602    path.lineTo(0, 1);
2603    path.close();
2604    path.moveTo(0, 0);
2605    path.lineTo(1, 0);
2606    path.quadTo(2, 0, 0, 1);
2607    path.close();
2608    testSimplifyx(path);
2609}
2610
2611static void testQuadratic25() {
2612    SkPath path;
2613    path.moveTo(0, 0);
2614    path.quadTo(1, 0, 1, 1);
2615    path.lineTo(1, 1);
2616    path.close();
2617    path.moveTo(0, 0);
2618    path.lineTo(0, 0);
2619    path.quadTo(2, 1, 0, 2);
2620    path.close();
2621    testSimplifyx(path);
2622}
2623
2624static void testQuadratic26() {
2625    SkPath path;
2626    path.moveTo(0, 0);
2627    path.quadTo(1, 0, 1, 1);
2628    path.lineTo(0, 2);
2629    path.close();
2630    path.moveTo(0, 0);
2631    path.lineTo(0, 0);
2632    path.quadTo(1, 0, 0, 1);
2633    path.close();
2634    testSimplifyx(path);
2635}
2636
2637static void testQuadratic27() {
2638    SkPath path;
2639    path.moveTo(0, 0);
2640    path.quadTo(1, 0, 1, 1);
2641    path.lineTo(2, 1);
2642    path.close();
2643    path.moveTo(0, 0);
2644    path.lineTo(0, 0);
2645    path.quadTo(2, 1, 0, 2);
2646    path.close();
2647    testSimplifyx(path);
2648}
2649
2650static void testQuadratic28() {
2651    SkPath path;
2652    path.moveTo(0, 0);
2653    path.quadTo(1, 0, 0, 1);
2654    path.lineTo(0, 1);
2655    path.close();
2656    path.moveTo(0, 0);
2657    path.lineTo(0, 2);
2658    path.quadTo(1, 2, 0, 3);
2659    path.close();
2660    testSimplifyx(path);
2661}
2662
2663static void testQuadratic29() {
2664    SkPath path;
2665    path.moveTo(0, 0);
2666    path.quadTo(1, 0, 2, 1);
2667    path.lineTo(0, 2);
2668    path.close();
2669    path.moveTo(0, 0);
2670    path.lineTo(0, 0);
2671    path.quadTo(1, 0, 0, 1);
2672    path.close();
2673    testSimplifyx(path);
2674}
2675
2676static void testQuadratic30() {
2677    SkPath path;
2678    path.moveTo(0, 0);
2679    path.quadTo(1, 0, 1, 2);
2680    path.lineTo(1, 2);
2681    path.close();
2682    path.moveTo(0, 0);
2683    path.lineTo(1, 0);
2684    path.quadTo(0, 1, 1, 2);
2685    path.close();
2686    testSimplifyx(path);
2687}
2688
2689static void testQuadratic31() {
2690    SkPath path;
2691    path.moveTo(0, 0);
2692    path.quadTo(1, 0, 1, 2);
2693    path.lineTo(1, 2);
2694    path.close();
2695    path.moveTo(0, 0);
2696    path.lineTo(1, 0);
2697    path.quadTo(0, 1, 1, 3);
2698    path.close();
2699    testSimplifyx(path);
2700}
2701
2702static void testQuadratic32() {
2703    SkPath path;
2704    path.moveTo(0, 0);
2705    path.quadTo(1, 0, 2, 3);
2706    path.lineTo(2, 3);
2707    path.close();
2708    path.moveTo(0, 0);
2709    path.lineTo(0, 0);
2710    path.quadTo(3, 1, 0, 2);
2711    path.close();
2712    testSimplifyx(path);
2713}
2714
2715static void testQuadratic33() {
2716    SkPath path;
2717    path.moveTo(0, 0);
2718    path.quadTo(2, 0, 0, 1);
2719    path.lineTo(0, 1);
2720    path.close();
2721    path.moveTo(0, 0);
2722    path.lineTo(1, 1);
2723    path.quadTo(2, 1, 2, 2);
2724    path.close();
2725    testSimplifyx(path);
2726}
2727
2728static void testQuadratic34() {
2729    SkPath path;
2730    path.moveTo(0, 0);
2731    path.quadTo(2, 0, 0, 1);
2732    path.lineTo(0, 1);
2733    path.close();
2734    path.moveTo(1, 0);
2735    path.lineTo(1, 1);
2736    path.quadTo(2, 1, 1, 2);
2737    path.close();
2738    testSimplifyx(path);
2739}
2740
2741static void testQuadratic35() {
2742    SkPath path;
2743    path.moveTo(0, 0);
2744    path.quadTo(0, 1, 1, 1);
2745    path.lineTo(1, 3);
2746    path.close();
2747    path.moveTo(2, 0);
2748    path.lineTo(3, 0);
2749    path.quadTo(0, 1, 1, 1);
2750    path.close();
2751    testSimplifyx(path);
2752}
2753
2754static void testQuadratic36() {
2755    SkPath path;
2756    path.moveTo(0, 0);
2757    path.quadTo(2, 1, 2, 3);
2758    path.lineTo(2, 3);
2759    path.close();
2760    path.moveTo(3, 1);
2761    path.lineTo(1, 2);
2762    path.quadTo(3, 2, 1, 3);
2763    path.close();
2764    testSimplifyx(path);
2765}
2766
2767static void testQuadratic37() {
2768    SkPath path;
2769    path.moveTo(0, 0);
2770    path.quadTo(0, 2, 1, 2);
2771    path.lineTo(1, 2);
2772    path.close();
2773    path.moveTo(0, 0);
2774    path.lineTo(3, 1);
2775    path.quadTo(0, 2, 1, 2);
2776    path.close();
2777    testSimplifyx(path);
2778}
2779
2780static void testQuadratic38() {
2781    SkPath path;
2782    path.moveTo(1, 0);
2783    path.quadTo(0, 1, 1, 1);
2784    path.lineTo(1, 1);
2785    path.close();
2786    path.moveTo(1, 0);
2787    path.lineTo(1, 2);
2788    path.quadTo(2, 2, 1, 3);
2789    path.close();
2790    testSimplifyx(path);
2791}
2792
2793static void testQuadratic51() {
2794    SkPath path;
2795    path.moveTo(369.863983f, 145.645813f);
2796    path.quadTo(382.380371f, 121.254936f, 406.236359f, 121.254936f);
2797    path.lineTo(369.863983f, 145.645813f);
2798    path.close();
2799    path.moveTo(369.970581f, 137.94342f);
2800    path.quadTo(383.98465f, 121.254936f, 406.235992f, 121.254936f);
2801    path.lineTo(369.970581f, 137.94342f);
2802    path.close();
2803    testSimplifyx(path);
2804}
2805
2806static void testQuadratic53() {
2807    SkPath path;
2808    path.moveTo(303.12088f, 141.299606f);
2809    path.lineTo(330.463562f, 217.659027f);
2810    path.lineTo(303.12088f, 141.299606f);
2811    path.close();
2812    path.moveTo(371.919067f, 205.854996f);
2813    path.lineTo(326.236786f, 205.854996f);
2814    path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2815    path.lineTo(371.919067f, 205.854996f);
2816    path.close();
2817    testSimplifyx(path);
2818}
2819static void testQuadratic55() {
2820    SkPath path;
2821path.moveTo(303.12088f, 141.299606f);
2822path.lineTo(330.463562f, 217.659027f);
2823path.lineTo(358.606506f, 141.299606f);
2824path.lineTo(303.12088f, 141.299606f);
2825path.close();
2826path.moveTo(326.236786f, 205.854996f);
2827path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2828path.lineTo(326.236786f, 205.854996f);
2829path.close();
2830    testSimplifyx(path);
2831}
2832
2833static void testQuadratic56() {
2834    SkPath path;
2835path.moveTo(366.608826f, 151.196014f);
2836path.quadTo(378.803101f, 136.674606f, 398.164948f, 136.674606f);
2837path.lineTo(354.009216f, 208.816208f);
2838path.lineTo(393.291473f, 102.232819f);
2839path.lineTo(359.978058f, 136.581512f);
2840path.quadTo(378.315979f, 136.581512f, 388.322723f, 149.613556f);
2841path.lineTo(364.390686f, 157.898193f);
2842path.quadTo(375.281769f, 136.674606f, 396.039917f, 136.674606f);
2843path.lineTo(350, 120);
2844path.lineTo(366.608826f, 151.196014f);
2845path.close();
2846    testSimplifyx(path);
2847}
2848
2849static void testLine80() {
2850    SkPath path;
2851path.moveTo(4, 0);
2852path.lineTo(3, 7);
2853path.lineTo(7, 5);
2854path.lineTo(2, 2);
2855path.close();
2856path.moveTo(0, 6);
2857path.lineTo(6, 12);
2858path.lineTo(8, 3);
2859path.close();
2860    testSimplifyx(path);
2861}
2862
2863static void testQuadratic58() {
2864    SkPath path;
2865path.moveTo(283.714233f, 240);
2866path.lineTo(283.714233f, 141.299606f);
2867path.lineTo(303.12088f, 141.299606f);
2868path.lineTo(330.463562f, 217.659027f);
2869path.lineTo(358.606506f, 141.299606f);
2870path.lineTo(362.874634f, 159.705902f);
2871path.lineTo(335.665344f, 233.397751f);
2872path.lineTo(322.12738f, 233.397751f);
2873path.lineTo(295.718353f, 159.505829f);
2874path.lineTo(295.718353f, 240);
2875path.lineTo(283.714233f, 240);
2876path.close();
2877path.moveTo(322.935669f, 231.030273f);
2878path.quadTo(312.832214f, 220.393295f, 312.832214f, 203.454178f);
2879path.quadTo(312.832214f, 186.981888f, 321.73526f, 176.444946f);
2880path.quadTo(330.638306f, 165.90802f, 344.509705f, 165.90802f);
2881path.quadTo(357.647522f, 165.90802f, 364.81665f, 175.244537f);
2882path.lineTo(371.919067f, 205.854996f);
2883path.lineTo(326.236786f, 205.854996f);
2884path.quadTo(329.104431f, 231.663818f, 351.512085f, 231.663818f);
2885path.lineTo(322.935669f, 231.030273f);
2886path.close();
2887path.moveTo(326.837006f, 195.984955f);
2888path.lineTo(358.78125f, 195.984955f);
2889path.quadTo(358.78125f, 175.778046f, 343.709442f, 175.778046f);
2890path.quadTo(328.570923f, 175.778046f, 326.837006f, 195.984955f);
2891path.close();
2892    testSimplifyx(path);
2893}
2894
2895static void testQuadratic59x() {
2896    SkPath path;
2897    path.setFillType(SkPath::kEvenOdd_FillType);
2898    path.moveTo(0, 0);
2899    path.quadTo(0, 0, 0, 0);
2900    path.lineTo(2, 2);
2901    path.close();
2902    path.moveTo(0, 0);
2903    path.lineTo(2, 0);
2904    path.quadTo(3, 1, 1, 2);
2905    path.close();
2906    testSimplifyx(path);
2907}
2908
2909static void testQuadratic59() {
2910    SkPath path;
2911    path.setFillType(SkPath::kWinding_FillType);
2912    path.moveTo(0, 0);
2913    path.quadTo(0, 0, 0, 0);
2914    path.lineTo(2, 2);
2915    path.close();
2916    path.moveTo(0, 0);
2917    path.lineTo(2, 0);
2918    path.quadTo(3, 1, 1, 2);
2919    path.close();
2920    testSimplifyx(path);
2921}
2922
2923static void testQuadratic63() {
2924    SkPath path;
2925    path.moveTo(0, 0);
2926    path.quadTo(0, 0, 0, 0);
2927    path.lineTo(3, 2);
2928    path.close();
2929    path.moveTo(1, 0);
2930    path.lineTo(2, 1);
2931    path.quadTo(2, 1, 2, 2);
2932    path.close();
2933    testSimplifyx(path);
2934}
2935
2936static void testQuadratic64() {
2937    SkPath path;
2938    path.moveTo(0, 0);
2939    path.quadTo(0, 0, 0, 0);
2940    path.lineTo(2, 3);
2941    path.close();
2942    path.moveTo(1, 2);
2943    path.lineTo(2, 2);
2944    path.quadTo(0, 3, 3, 3);
2945    path.close();
2946    testSimplifyx(path);
2947}
2948
2949static void testQuadratic65() {
2950    SkPath path;
2951    path.moveTo(0, 0);
2952    path.quadTo(0, 0, 0, 0);
2953    path.lineTo(3, 2);
2954    path.close();
2955    path.moveTo(2, 1);
2956    path.lineTo(2, 2);
2957    path.quadTo(0, 3, 1, 3);
2958    path.close();
2959    testSimplifyx(path);
2960}
2961
2962static void testQuadratic67x() {
2963    SkPath path;
2964    path.setFillType(SkPath::kEvenOdd_FillType);
2965    path.moveTo(0, 0);
2966    path.quadTo(0, 0, 2, 1);
2967    path.lineTo(2, 2);
2968    path.close();
2969    path.moveTo(0, 0);
2970    path.lineTo(2, 0);
2971    path.quadTo(1, 1, 3, 2);
2972    path.close();
2973    testSimplifyx(path);
2974}
2975
2976static void testQuadratic68() {
2977    SkPath path;
2978    path.moveTo(0, 0);
2979    path.quadTo(1, 0, 0, 1);
2980    path.lineTo(1, 2);
2981    path.close();
2982    path.moveTo(0, 0);
2983    path.lineTo(0, 0);
2984    path.quadTo(0, 1, 2, 1);
2985    path.close();
2986    testSimplifyx(path);
2987}
2988
2989static void testQuadratic69() {
2990    SkPath path;
2991    path.moveTo(0, 0);
2992    path.quadTo(0, 0, 0, 1);
2993    path.lineTo(3, 2);
2994    path.close();
2995    path.moveTo(2, 0);
2996    path.lineTo(1, 1);
2997    path.quadTo(3, 2, 2, 3);
2998    path.close();
2999    testSimplifyx(path);
3000}
3001
3002static void testQuadratic70x() {
3003    SkPath path;
3004    path.setFillType(SkPath::kEvenOdd_FillType);
3005    path.moveTo(0, 0);
3006    path.quadTo(1, 0, 0, 1);
3007    path.lineTo(1, 2);
3008    path.close();
3009    path.moveTo(0, 0);
3010    path.lineTo(0, 0);
3011    path.quadTo(0, 1, 2, 1);
3012    path.close();
3013    testSimplifyx(path);
3014}
3015
3016static void testQuadratic71() {
3017    SkPath path;
3018    path.moveTo(0, 0);
3019    path.quadTo(1, 0, 1, 1);
3020    path.lineTo(3, 2);
3021    path.close();
3022    path.moveTo(0, 0);
3023    path.lineTo(0, 0);
3024    path.quadTo(1, 1, 3, 1);
3025    path.close();
3026    testSimplifyx(path);
3027}
3028
3029static void testQuadratic72() {
3030    SkPath path;
3031    path.moveTo(0, 0);
3032    path.quadTo(1, 0, 1, 2);
3033    path.lineTo(1, 2);
3034    path.close();
3035    path.moveTo(0, 0);
3036    path.lineTo(1, 0);
3037    path.quadTo(0, 1, 3, 2);
3038    path.close();
3039    testSimplifyx(path);
3040}
3041
3042static void testQuadratic73() {
3043    SkPath path;
3044    path.moveTo(0, 0);
3045    path.quadTo(1, 0, 0, 3);
3046    path.lineTo(0, 3);
3047    path.close();
3048    path.moveTo(0, 0);
3049    path.lineTo(1, 0);
3050    path.quadTo(0, 1, 1, 1);
3051    path.close();
3052    testSimplifyx(path);
3053}
3054
3055static void testQuadratic74() {
3056    SkPath path;
3057    path.moveTo(0, 0);
3058    path.quadTo(1, 0, 1, 3);
3059    path.lineTo(1, 3);
3060    path.close();
3061    path.moveTo(0, 0);
3062    path.lineTo(0, 1);
3063    path.quadTo(3, 2, 2, 3);
3064    path.close();
3065    testSimplifyx(path);
3066}
3067
3068static void testQuadratic75() {
3069    SkPath path;
3070    path.moveTo(0, 0);
3071    path.quadTo(1, 0, 1, 3);
3072    path.lineTo(2, 3);
3073    path.close();
3074    path.moveTo(0, 0);
3075    path.lineTo(0, 1);
3076    path.quadTo(3, 2, 2, 3);
3077    path.close();
3078    testSimplifyx(path);
3079}
3080
3081static void testQuadratic76() {
3082    SkPath path;
3083    path.moveTo(0, 0);
3084    path.quadTo(0, 0, 0, 0);
3085    path.lineTo(2, 3);
3086    path.close();
3087    path.moveTo(1, 0);
3088    path.lineTo(1, 2);
3089    path.quadTo(1, 2, 2, 2);
3090    path.close();
3091    testSimplifyx(path);
3092}
3093
3094static void testQuadratic77() {
3095    SkPath path;
3096    path.moveTo(0, 0);
3097    path.quadTo(1, 0, 1, 1);
3098    path.lineTo(3, 1);
3099    path.close();
3100    path.moveTo(0, 0);
3101    path.lineTo(1, 0);
3102    path.quadTo(0, 1, 3, 2);
3103    path.close();
3104    testSimplifyx(path);
3105}
3106
3107static void testQuadratic78() {
3108    SkPath path;
3109    path.moveTo(0, 0);
3110    path.quadTo(1, 0, 1, 2);
3111    path.lineTo(3, 2);
3112    path.close();
3113    path.moveTo(0, 0);
3114    path.lineTo(0, 0);
3115    path.quadTo(2, 1, 0, 2);
3116    path.close();
3117    testSimplifyx(path);
3118}
3119
3120static void testQuadratic79() {
3121    SkPath path;
3122    path.moveTo(0, 0);
3123    path.quadTo(1, 0, 1, 2);
3124    path.lineTo(3, 2);
3125    path.close();
3126    path.moveTo(0, 0);
3127    path.lineTo(1, 0);
3128    path.quadTo(0, 1, 3, 2);
3129    path.close();
3130    testSimplifyx(path);
3131}
3132
3133static void testEight1() {
3134    SkPath path;
3135    path.moveTo(0, 0);
3136    path.lineTo(2, 2);
3137    path.lineTo(0, 2);
3138    path.lineTo(2, 0);
3139    path.close();
3140    testSimplifyx(path);
3141}
3142
3143static void testEight2() {
3144    SkPath path;
3145    path.moveTo(0, 0);
3146    path.lineTo(2, 0);
3147    path.lineTo(0, 2);
3148    path.lineTo(2, 2);
3149    path.close();
3150    testSimplifyx(path);
3151}
3152
3153static void testEight3() {
3154    SkPath path;
3155    path.moveTo(0, 0);
3156    path.lineTo(0, 2);
3157    path.lineTo(2, 0);
3158    path.lineTo(2, 2);
3159    path.close();
3160    testSimplifyx(path);
3161}
3162
3163static void testEight4() {
3164    SkPath path;
3165    path.moveTo(0, 0);
3166    path.lineTo(2, 2);
3167    path.lineTo(2, 0);
3168    path.lineTo(0, 2);
3169    path.close();
3170    testSimplifyx(path);
3171}
3172
3173static void testEight5() {
3174    SkPath path;
3175    path.moveTo(1, 0);
3176    path.lineTo(1, 2);
3177    path.lineTo(0, 2);
3178    path.lineTo(2, 0);
3179    path.close();
3180    testSimplifyx(path);
3181}
3182
3183static void testEight6() {
3184    SkPath path;
3185    path.moveTo(1, 0);
3186    path.lineTo(2, 0);
3187    path.lineTo(0, 2);
3188    path.lineTo(1, 2);
3189    path.close();
3190    testSimplifyx(path);
3191}
3192
3193static void testEight7() {
3194    SkPath path;
3195    path.moveTo(0, 0);
3196    path.lineTo(0, 1);
3197    path.lineTo(2, 1);
3198    path.lineTo(2, 2);
3199    path.close();
3200    testSimplifyx(path);
3201}
3202
3203static void testEight8() {
3204    SkPath path;
3205    path.moveTo(0, 0);
3206    path.lineTo(2, 2);
3207    path.lineTo(2, 1);
3208    path.lineTo(0, 1);
3209    path.close();
3210    testSimplifyx(path);
3211}
3212
3213static void testEight9() {
3214    SkPath path;
3215    path.moveTo(1, 0);
3216    path.lineTo(1, 2);
3217    path.lineTo(2, 1);
3218    path.lineTo(0, 1);
3219    path.close();
3220    testSimplifyx(path);
3221}
3222
3223static void testEight10() {
3224    SkPath path;
3225    path.moveTo(1, 0);
3226    path.lineTo(0, 1);
3227    path.lineTo(2, 1);
3228    path.lineTo(1, 2);
3229    path.close();
3230    testSimplifyx(path);
3231}
3232
3233static void testQuadratic80() {
3234    SkPath path;
3235    path.moveTo(0, 0);
3236    path.quadTo(1, 0, 2, 3);
3237    path.lineTo(2, 3);
3238    path.close();
3239    path.moveTo(1, 0);
3240    path.lineTo(3, 0);
3241    path.quadTo(0, 1, 1, 1);
3242    path.close();
3243    testSimplifyx(path);
3244}
3245
3246static void testQuadratic81() {
3247    SkPath path;
3248    path.moveTo(0, 0);
3249    path.quadTo(2, 0, 1, 1);
3250    path.lineTo(1, 1);
3251    path.close();
3252    path.moveTo(0, 0);
3253    path.lineTo(0, 0);
3254    path.quadTo(2, 1, 0, 2);
3255    path.close();
3256    testSimplifyx(path);
3257}
3258
3259static void testQuadratic82() {
3260    SkPath path;
3261    path.moveTo(0, 0);
3262    path.quadTo(2, 0, 1, 1);
3263    path.lineTo(0, 3);
3264    path.close();
3265    path.moveTo(0, 0);
3266    path.lineTo(0, 0);
3267    path.quadTo(2, 1, 0, 2);
3268    path.close();
3269    testSimplifyx(path);
3270}
3271
3272static void testQuadratic83() {
3273    SkPath path;
3274    path.moveTo(0, 0);
3275    path.quadTo(0, 0, 2, 0);
3276    path.lineTo(2, 2);
3277    path.close();
3278    path.moveTo(0, 1);
3279    path.lineTo(0, 2);
3280    path.quadTo(2, 2, 1, 3);
3281    path.close();
3282    testSimplifyx(path);
3283}
3284
3285static void testQuadratic84() {
3286    SkPath path;
3287    path.moveTo(0, 0);
3288    path.quadTo(2, 0, 1, 1);
3289    path.lineTo(2, 1);
3290    path.close();
3291    path.moveTo(1, 0);
3292    path.lineTo(2, 0);
3293    path.quadTo(0, 1, 2, 2);
3294    path.close();
3295    testSimplifyx(path);
3296}
3297
3298static void testQuadratic85() {
3299    SkPath path;
3300    path.moveTo(0, 0);
3301    path.quadTo(3, 0, 1, 1);
3302    path.lineTo(1, 1);
3303    path.close();
3304    path.moveTo(1, 0);
3305    path.lineTo(3, 0);
3306    path.quadTo(0, 1, 1, 2);
3307    path.close();
3308    testSimplifyx(path);
3309}
3310
3311static void testQuadratic86() {
3312    SkPath path;
3313    path.moveTo(0, 0);
3314    path.quadTo(0, 1, 1, 1);
3315    path.lineTo(2, 3);
3316    path.close();
3317    path.moveTo(0, 0);
3318    path.lineTo(0, 0);
3319    path.quadTo(1, 1, 1, 3);
3320    path.close();
3321    testSimplifyx(path);
3322}
3323
3324static void testQuadratic87() {
3325    SkPath path;
3326    path.moveTo(0, 0);
3327    path.quadTo(2, 1, 0, 2);
3328    path.lineTo(2, 3);
3329    path.close();
3330    path.moveTo(0, 0);
3331    path.lineTo(1, 1);
3332    path.quadTo(0, 2, 3, 2);
3333    path.close();
3334    testSimplifyx(path);
3335}
3336
3337static void testQuadratic88() {
3338    SkPath path;
3339    path.moveTo(0, 0);
3340    path.quadTo(2, 1, 0, 2);
3341    path.lineTo(2, 2);
3342    path.close();
3343    path.moveTo(1, 0);
3344    path.lineTo(1, 1);
3345    path.quadTo(0, 2, 2, 2);
3346    path.close();
3347    testSimplifyx(path);
3348}
3349
3350static void testQuadratic89x() {
3351    SkPath path;
3352    path.setFillType(SkPath::kEvenOdd_FillType);
3353    path.moveTo(0, 0);
3354    path.quadTo(3, 1, 2, 2);
3355    path.lineTo(0, 3);
3356    path.close();
3357    path.moveTo(0, 0);
3358    path.lineTo(2, 1);
3359    path.quadTo(3, 1, 3, 3);
3360    path.close();
3361    testSimplifyx(path);
3362}
3363
3364static void testQuadratic90x() {
3365    SkPath path;
3366    path.setFillType(SkPath::kEvenOdd_FillType);
3367    path.moveTo(0, 0);
3368    path.quadTo(3, 0, 2, 2);
3369    path.lineTo(1, 3);
3370    path.close();
3371    path.moveTo(0, 0);
3372    path.lineTo(0, 1);
3373    path.quadTo(3, 2, 2, 3);
3374    path.close();
3375    testSimplifyx(path);
3376}
3377
3378static void testQuadratic91() {
3379    SkPath path;
3380    path.moveTo(0, 0);
3381    path.quadTo(3, 2, 2, 3);
3382    path.lineTo(2, 3);
3383    path.close();
3384    path.moveTo(0, 0);
3385    path.lineTo(1, 1);
3386    path.quadTo(2, 1, 2, 3);
3387    path.close();
3388    testSimplifyx(path);
3389}
3390
3391static void testQuadratic92x() {
3392    SkPath path;
3393    path.setFillType(SkPath::kEvenOdd_FillType);
3394    path.moveTo(1, 0);
3395    path.quadTo(3, 0, 2, 2);
3396    path.lineTo(2, 2);
3397    path.close();
3398    path.moveTo(2, 0);
3399    path.lineTo(0, 1);
3400    path.quadTo(3, 2, 2, 3);
3401    path.close();
3402    testSimplifyx(path);
3403}
3404
3405static void testLine82() {
3406    SkPath path;
3407    path.addRect(20, 0, 40, 40, SkPath::kCCW_Direction);
3408    path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3409    path.addRect(24, 32, 33, 36, SkPath::kCCW_Direction);
3410    testSimplifyx(path);
3411}
3412
3413static void testLine82a() {
3414    SkPath path;
3415    path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3416    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3417    path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3418    testSimplifyx(path);
3419}
3420
3421static void testLine82b() {
3422    SkPath path;
3423    path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3424    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3425    path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3426    testSimplifyx(path);
3427}
3428
3429static void testLine82c() {
3430    SkPath path;
3431    path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3432    path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3433    path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3434    testSimplifyx(path);
3435}
3436
3437static void testLine82d() {
3438    SkPath path;
3439    path.addRect(0, 0, 6, 10, SkPath::kCW_Direction);
3440    path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3441    path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3442    testSimplifyx(path);
3443}
3444
3445static void testLine82e() {
3446    SkPath path;
3447    path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3448    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3449    path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3450    testSimplifyx(path);
3451}
3452
3453static void testLine82f() {
3454    SkPath path;
3455    path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3456    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
3457    path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3458    testSimplifyx(path);
3459}
3460
3461static void testLine82g() {
3462    SkPath path;
3463    path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3464    path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3465    path.addRect(2, 6, 4, 8, SkPath::kCW_Direction);
3466    testSimplifyx(path);
3467}
3468
3469static void testLine82h() {
3470    SkPath path;
3471    path.addRect(0, 0, 6, 10, SkPath::kCCW_Direction);
3472    path.addRect(2, 2, 4, 4, SkPath::kCCW_Direction);
3473    path.addRect(2, 6, 4, 8, SkPath::kCCW_Direction);
3474    testSimplifyx(path);
3475}
3476
3477static void testLine83() {
3478    SkPath path;
3479path.addRect(10, 30, 30, 40, SkPath::kCCW_Direction);
3480path.addRect(0, 12, 12, 18, SkPath::kCCW_Direction);
3481path.addRect(4, 13, 13, 16, SkPath::kCCW_Direction);
3482    testSimplifyx(path);
3483}
3484
3485static void testLine84() {
3486    SkPath path;
3487    path.addRect(0, 12, 60, 30, SkPath::kCCW_Direction);
3488    path.addRect(10, 20, 40, 30, SkPath::kCW_Direction);
3489    path.addRect(0, 12, 12, 12, SkPath::kCW_Direction);
3490    path.addRect(4, 12, 13, 13, SkPath::kCW_Direction);
3491    testSimplifyx(path);
3492}
3493
3494static void testLine84x() {
3495    SkPath path;
3496    path.setFillType(SkPath::kEvenOdd_FillType);
3497    path.addRect(0, 12, 60, 30, SkPath::kCCW_Direction);
3498    path.addRect(10, 20, 40, 30, SkPath::kCCW_Direction);
3499    path.addRect(0, 12, 12, 12, SkPath::kCCW_Direction);
3500    path.addRect(4, 12, 13, 13, SkPath::kCCW_Direction);
3501    testSimplifyx(path);
3502}
3503
3504static void testLine85() {
3505    SkPath path;
3506    path.addRect(36, 0, 66, 60, SkPath::kCCW_Direction);
3507    path.addRect(20, 0, 40, 40, SkPath::kCCW_Direction);
3508    path.addRect(12, 0, 24, 24, SkPath::kCCW_Direction);
3509    path.addRect(32, 0, 36, 41, SkPath::kCCW_Direction);
3510    testSimplifyx(path);
3511}
3512
3513static void testQuadralateral1() {
3514    SkPath path;
3515    path.moveTo(0, 0);
3516    path.lineTo(0, 0);
3517    path.lineTo(0, 0);
3518    path.lineTo(3, 2);
3519    path.close();
3520    path.moveTo(0, 0);
3521    path.lineTo(2, 1);
3522    path.lineTo(2, 2);
3523    path.lineTo(2, 3);
3524    path.close();
3525    testSimplifyx(path);
3526}
3527
3528static void testCubic1() {
3529    SkPath path;
3530    path.moveTo(0, 0);
3531    path.cubicTo(0, 1, 1, 1, 1, 0);
3532    path.close();
3533    path.moveTo(1, 0);
3534    path.cubicTo(0, 0, 0, 1, 1, 1);
3535    path.close();
3536    testSimplifyx(path);
3537}
3538
3539static 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
3552static 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
3565static 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
3578static 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
3591static 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
3604static 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
3617static 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
3630static 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
3643static 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
3656static 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
3671static 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
3690static 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
3703static 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
3716static 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
3729static 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
3742static 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
3755static 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
3768static 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
3781static 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
3794static 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
3807static 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
3820static 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
3833static 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
3846static 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
3859static 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
3872static 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
3885static 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
3898static 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
3905static 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
3912static 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
3919static 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
3926static 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
3933static 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
3940static 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
3947static 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
3954static 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
3965static 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
3976static 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
3987static 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
3998static 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
4009static 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
4020static 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
4031static 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
4042static 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
4053static 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}
4061static 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
4074static 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
4087static 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
4100static 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
4113static 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
4126static 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
4139static 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
4152static 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
4165static 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
4178static 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
4189static 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
4202static 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
4215static 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
4228static 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
4241static 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
4254static 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 intersection
4271// if the line/cubic was a matching line/approx.quadratic then the missing intersection
4272// could have been detected
4273static 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
4287static 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
4300static 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
4313static 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
4326static 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
4339static 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
4352static 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
4365static 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
4378static 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
4391static 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
4404static 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
4417static 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
4430static 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
4443static 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
4456static 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
4469static 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
4482static 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
4495static 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
4508static 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
4521static 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
4534static 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
4547static 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
4560static 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
4573static 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
4586static 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
4599static 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
4612static 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
4624static 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
4637static 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
4649static 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
4662static 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
4673static void (*firstTest)() = testRectOp1d;
4674
4675static 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 unsortable
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
5100static const size_t testCount = sizeof(tests) / sizeof(tests[0]);
5101
5102
5103static 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
5124static const size_t subTestCount = sizeof(subTests) / sizeof(subTests[0]);
5125
5126static void (*firstSubTest)() = 0;
5127
5128static bool skipAll = false;
5129static bool runSubTestsFirst = false;
5130static bool runReverse = false;
5131static void (*stopTest)() = 0;
5132
5133void 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}
5195