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