Lines Matching refs:pathB

33     SkPath path, pathB;
38     pathB.setFillType(SkPath::kWinding_FillType);
39     pathB.moveTo(0,1);
40     pathB.cubicTo(0,1, 1,0, 2,0);
41     pathB.close();
42     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
46     SkPath path, pathB;
51     pathB.setFillType(SkPath::kWinding_FillType);
52     pathB.moveTo(0,1);
53     pathB.cubicTo(0,1, 2,0, 1,0);
54     pathB.close();
55     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
59     SkPath path, pathB;
64     pathB.setFillType(SkPath::kWinding_FillType);
65     pathB.moveTo(0,1);
66     pathB.cubicTo(0,1, 1,0, 3,2);
67     pathB.close();
68     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
72     SkPath path, pathB;
77     pathB.setFillType(SkPath::kWinding_FillType);
78     pathB.moveTo(0,1);
79     pathB.cubicTo(0,2, 1,0, 2,0);
80     pathB.close();
81     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
85     SkPath path, pathB;
90     pathB.setFillType(SkPath::kWinding_FillType);
91     pathB.moveTo(0,1);
92     pathB.cubicTo(0,3, 1,0, 6,0);
93     pathB.close();
94     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
98     SkPath path, pathB;
103     pathB.setFillType(SkPath::kWinding_FillType);
104     pathB.moveTo(0,1);
105     pathB.cubicTo(0,3, 1,0, 4,3);
106     pathB.close();
107     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
111     SkPath path, pathB;
116     pathB.setFillType(SkPath::kWinding_FillType);
117     pathB.moveTo(0,1);
118     pathB.cubicTo(0,4, 1,0, 5,0);
119     pathB.close();
120     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
124     SkPath path, pathB;
129     pathB.setFillType(SkPath::kWinding_FillType);
130     pathB.moveTo(0,1);
131     pathB.cubicTo(1,2, 1,0, 6,1);
132     pathB.close();
133     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
137     SkPath path, pathB;
143     pathB.setFillType(SkPath::kWinding_FillType);
144     pathB.moveTo(0,1);
145     pathB.quadTo(1,2, 1.4f,1);
146     pathB.quadTo(3,0.4f, 6,1);
147     pathB.close();
148     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
152     SkPath path, pathB;
160     pathB.setFillType(SkPath::kWinding_FillType);
161     pathB.moveTo(0,1);
162     pathB.lineTo(1,2);
163     pathB.lineTo(1.4f,1);
164     pathB.lineTo(3,0.4f);
165     pathB.lineTo(6,1);
166     pathB.close();
167     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
171     SkPath path, pathB;
176     pathB.setFillType(SkPath::kWinding_FillType);
177     pathB.moveTo(0,1);
178     pathB.cubicTo(1,2, 1,0, 2,1);
179     pathB.close();
180     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
184     SkPath path, pathB;
189     pathB.setFillType(SkPath::kWinding_FillType);
190     pathB.moveTo(0,1);
191     pathB.cubicTo(1,4, 1,0, 3,1);
192     pathB.close();
193     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
197     SkPath path, pathB;
202     pathB.setFillType(SkPath::kWinding_FillType);
203     pathB.moveTo(0,1);
204     pathB.cubicTo(1,5, 1,0, 4,3);
205     pathB.close();
206     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
210     SkPath path, pathB;
215     pathB.setFillType(SkPath::kWinding_FillType);
216     pathB.moveTo(0,1);
217     pathB.cubicTo(0,1, 1,0, 6,1);
218     pathB.close();
219     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
223     SkPath path, pathB;
228     pathB.setFillType(SkPath::kWinding_FillType);
229     pathB.moveTo(0,1);
230     pathB.cubicTo(3,5, 1,0, 5,4);
231     pathB.close();
232     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
236     SkPath path, pathB;
241     pathB.setFillType(SkPath::kWinding_FillType);
242     pathB.moveTo(0,2);
243     pathB.cubicTo(1,2, 1,0, 2,0);
244     pathB.close();
245     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
249     SkPath path, pathB;
254     pathB.setFillType(SkPath::kWinding_FillType);
255     pathB.moveTo(0,2);
256     pathB.cubicTo(1,2, 1,0, 6,3);
257     pathB.close();
258     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
262     SkPath path, pathB;
267     pathB.setFillType(SkPath::kWinding_FillType);
268     pathB.moveTo(0,3);
269     pathB.cubicTo(0,1, 2,0, 1,0);
270     pathB.close();
271     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
275     SkPath path, pathB;
280     pathB.setFillType(SkPath::kWinding_FillType);
281     pathB.moveTo(0,4);
282     pathB.cubicTo(1,2, 2,0, 2,0);
283     pathB.close();
284     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
288     SkPath path, pathB;
293     pathB.setFillType(SkPath::kWinding_FillType);
294     pathB.moveTo(0,2);
295     pathB.cubicTo(1,2, 1,0, 5,3);
296     pathB.close();
297     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
301     SkPath path, pathB;
306     pathB.setFillType(SkPath::kWinding_FillType);
307     pathB.moveTo(1,2);
308     pathB.cubicTo(2,6, 2,0, 1,0);
309     pathB.close();
310     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
314     SkPath path, pathB;
319     pathB.setFillType(SkPath::kWinding_FillType);
320     pathB.moveTo(0,6);
321     pathB.cubicTo(1,2, 1,0, 1,0);
322     pathB.close();
323     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
327     SkPath path, pathB;
332     pathB.setFillType(SkPath::kWinding_FillType);
333     pathB.moveTo(1,2);
334     pathB.cubicTo(5,6, 1,0, 1,0);
335     pathB.close();
336     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
340     SkPath path, pathB;
345     pathB.setFillType(SkPath::kWinding_FillType);
346     pathB.moveTo(0,3);
347     pathB.cubicTo(1,2, 1,0, 3,2);
348     pathB.close();
349     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
353     SkPath path, pathB;
358     pathB.setFillType(SkPath::kWinding_FillType);
359     pathB.moveTo(0,4);
360     pathB.cubicTo(1,2, 1,0, 2,1);
361     pathB.close();
362     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
366     SkPath path, pathB;
371     pathB.setFillType(SkPath::kWinding_FillType);
372     pathB.moveTo(0,2);
373     pathB.cubicTo(2,3, 1,0, 2,1);
374     pathB.close();
375     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
435     SkPath path, pathB;
439     pathB.setFillType(SkPath::kWinding_FillType);
440     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
441     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
442     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
446     SkPath path, pathB;
450     pathB.setFillType(SkPath::kEvenOdd_FillType);
451     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
452     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
453     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
457     SkPath path, pathB;
461     pathB.setFillType(SkPath::kWinding_FillType);
462     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
463     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
464     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
468     SkPath path, pathB;
472     pathB.setFillType(SkPath::kWinding_FillType);
473     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
474     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
475     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
479     SkPath path, pathB;
483     pathB.setFillType(SkPath::kWinding_FillType);
484     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
485     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
486     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
490     SkPath path, pathB;
494     pathB.setFillType(SkPath::kEvenOdd_FillType);
495     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
496     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
497     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
501     SkPath path, pathB;
505     pathB.setFillType(SkPath::kWinding_FillType);
506     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
507     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
508     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
512     SkPath path, pathB;
516     pathB.setFillType(SkPath::kEvenOdd_FillType);
517     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
518     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
519     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
523     SkPath path, pathB;
527     pathB.setFillType(SkPath::kWinding_FillType);
528     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
529     pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
530     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
534     SkPath path, pathB;
536     pathB.moveTo(577330, 1971.72f);
537     pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
538     pathB.close();
539     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
542     SkPath path, pathB;
547     pathB.setFillType(SkPath::kWinding_FillType);
548     pathB.moveTo(0,5);
549     pathB.cubicTo(2,3, 1,0, 4,2);
550     pathB.close();
551     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
555     SkPath path, pathB;
560     pathB.setFillType(SkPath::kWinding_FillType);
561     pathB.moveTo(0,4);
562     pathB.cubicTo(2,3, 1,0, 4,3);
563     pathB.close();
564     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
568     SkPath path, pathB;
573     pathB.setFillType(SkPath::kWinding_FillType);
574     pathB.moveTo(0,1);
575     pathB.cubicTo(2,5, 1,0, 6,3);
576     pathB.close();
577     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
581     SkPath path, pathB;
586     pathB.setFillType(SkPath::kWinding_FillType);
587     pathB.moveTo(0,6);
588     pathB.cubicTo(2,3, 1,0, 4,1);
589     pathB.close();
590     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
594     SkPath path, pathB;
599     pathB.setFillType(SkPath::kWinding_FillType);
600     pathB.moveTo(0,6);
601     pathB.cubicTo(2,4, 1,0, 5,2);
602     pathB.close();
603     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
607     SkPath path, pathB;
612     pathB.setFillType(SkPath::kWinding_FillType);
613     pathB.moveTo(0,6);
614     pathB.cubicTo(3,5, 1,0, 5,2);
615     pathB.close();
616     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
620     SkPath path, pathB;
625     pathB.setFillType(SkPath::kWinding_FillType);
626     pathB.moveTo(1,2);
627     pathB.cubicTo(0,4, 2,0, 3,0);
628     pathB.close();
629     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
633     SkPath path, pathB;
638     pathB.setFillType(SkPath::kWinding_FillType);
639     pathB.moveTo(1,2);
640     pathB.cubicTo(0,4, 2,0, 3,0);
641     pathB.close();
642     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
646     SkPath path, pathB;
651     pathB.setFillType(SkPath::kWinding_FillType);
652     pathB.moveTo(1,2);
653     pathB.cubicTo(0,4, 2,0, 3,0);
654     pathB.close();
655     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
659     SkPath path, pathB;
664     pathB.setFillType(SkPath::kWinding_FillType);
665     pathB.moveTo(0,6);
666     pathB.cubicTo(1,3, 1,0, 2,1);
667     pathB.close();
668     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
672     SkPath path, pathB;
677     pathB.setFillType(SkPath::kWinding_FillType);
678     pathB.moveTo(0,6);
679     pathB.cubicTo(1,3, 1,0, 2,1);
680     pathB.close();
681     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
685     SkPath path, pathB;
690     pathB.setFillType(SkPath::kWinding_FillType);
691     pathB.moveTo(1,2);
692     pathB.cubicTo(1,3, 1,0, 5,3);
693     pathB.close();
694     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
698     SkPath path, pathB;
703     pathB.setFillType(SkPath::kWinding_FillType);
704     pathB.moveTo(1,2);
705     pathB.cubicTo(0,4, 1,0, 5,1);
706     pathB.close();
707     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
711     SkPath path, pathB;
716     pathB.setFillType(SkPath::kWinding_FillType);
717     pathB.moveTo(0,2);
718     pathB.cubicTo(1,5, 1,0, 6,1);
719     pathB.close();
720     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
724     SkPath path, pathB;
729     pathB.setFillType(SkPath::kWinding_FillType);
730     pathB.moveTo(1,6);
731     pathB.cubicTo(3,4, 1,0, 6,2);
732     pathB.close();
733     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
737     SkPath path, pathB;
742     pathB.setFillType(SkPath::kWinding_FillType);
743     pathB.moveTo(2,3);
744     pathB.cubicTo(1,4, 1,0, 6,0);
745     pathB.close();
746     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
750     SkPath path, pathB;
755     pathB.setFillType(SkPath::kWinding_FillType);
756     pathB.moveTo(1,5);
757     pathB.cubicTo(3,4, 1,0, 3,2);
758     pathB.close();
759     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
763     SkPath path, pathB;
768     pathB.setFillType(SkPath::kWinding_FillType);
769     pathB.moveTo(2,3);
770     pathB.cubicTo(2,4, 1,0, 5,1);
771     pathB.close();
772     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
776     SkPath path, pathB;
781     pathB.setFillType(SkPath::kWinding_FillType);
782     pathB.moveTo(3,4);
783     pathB.cubicTo(4,6, 1,0, 6,2);
784     pathB.close();
785     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
789     SkPath path, pathB;
794     pathB.setFillType(SkPath::kWinding_FillType);
795     pathB.moveTo(5,6);
796     pathB.cubicTo(4,5, 1,0, 2,1);
797     pathB.close();
798     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
802     SkPath path, pathB;
807     pathB.setFillType(SkPath::kWinding_FillType);
808     pathB.moveTo(0,4);
809     pathB.cubicTo(1,3, 2,0, 2,1);
810     pathB.close();
811     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
815     SkPath path, pathB;
820     pathB.setFillType(SkPath::kWinding_FillType);
821     pathB.moveTo(0,4);
822     pathB.cubicTo(2,3, 2,0, 6,3);
823     pathB.close();
824     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
828     SkPath path, pathB;
833     pathB.setFillType(SkPath::kWinding_FillType);
834     pathB.moveTo(0,4);
835     pathB.cubicTo(2,3, 2,0, 4,2);
836     pathB.close();
837     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
841     SkPath path, pathB;
846     pathB.setFillType(SkPath::kWinding_FillType);
847     pathB.moveTo(0,5);
848     pathB.cubicTo(2,4, 2,0, 5,3);
849     pathB.close();
850     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
854     SkPath path, pathB;
859     pathB.setFillType(SkPath::kWinding_FillType);
860     pathB.moveTo(2,6);
861     pathB.cubicTo(4,5, 1,0, 6,1);
862     pathB.close();
863     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
867     SkPath path, pathB;
872     pathB.setFillType(SkPath::kWinding_FillType);
873     pathB.moveTo(1,5);
874     pathB.cubicTo(2,3, 2,0, 3,2);
875     pathB.close();
876     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
880     SkPath path, pathB;
885     pathB.setFillType(SkPath::kWinding_FillType);
886     pathB.moveTo(2,3);
887     pathB.cubicTo(1,4, 2,0, 5,1);
888     pathB.close();
889     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
893     SkPath path, pathB;
898     pathB.setFillType(SkPath::kWinding_FillType);
899     pathB.moveTo(0,5);
900     pathB.cubicTo(1,5, 3,0, 6,1);
901     pathB.close();
902     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
906     SkPath path, pathB;
911     pathB.setFillType(SkPath::kWinding_FillType);
912     pathB.moveTo(1,4);
913     pathB.cubicTo(0,6, 3,0, 2,1);
914     pathB.close();
915     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
919     SkPath path, pathB;
924     pathB.setFillType(SkPath::kWinding_FillType);
925     pathB.moveTo(4,5);
926     pathB.cubicTo(3,4, 2,0, 2,1);
927     pathB.close();
928     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
932     SkPath path, pathB;
937     pathB.setFillType(SkPath::kWinding_FillType);
938     pathB.moveTo(3,5);
939     pathB.cubicTo(1,2, 3,0, 2,1);
940     pathB.close();
941     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
945     SkPath path, pathB;
950     pathB.setFillType(SkPath::kWinding_FillType);
951     pathB.moveTo(4,5);
952     pathB.cubicTo(2,4, 4,0, 3,1);
953     pathB.close();
954     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
958     SkPath path, pathB;
963     pathB.setFillType(SkPath::kWinding_FillType);
964     pathB.moveTo(2,3);
965     pathB.cubicTo(0,5, 5,0, 3,1);
966     pathB.close();
967     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
971     SkPath path, pathB;
976     pathB.setFillType(SkPath::kWinding_FillType);
977     pathB.moveTo(0,5);
978     pathB.cubicTo(1,2, 1,0, 6,2);
979     pathB.close();
980     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
984     SkPath path, pathB;
989     pathB.setFillType(SkPath::kWinding_FillType);
990     pathB.moveTo(4,5);
991     pathB.cubicTo(4,6, 5,0, 5,0);
992     pathB.close();
993     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
997     SkPath path, pathB;
1002     pathB.setFillType(SkPath::kWinding_FillType);
1003     pathB.moveTo(5,6);
1004     pathB.cubicTo(3,5, 5,0, 4,3);
1005     pathB.close();
1006     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1010     SkPath path, pathB;
1015     pathB.setFillType(SkPath::kWinding_FillType);
1016     pathB.moveTo(0,4);
1017     pathB.cubicTo(1,4, 1,0, 6,5);
1018     pathB.close();
1019     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1023     SkPath path, pathB;
1028     pathB.setFillType(SkPath::kWinding_FillType);
1029     pathB.moveTo(0,6);
1030     pathB.cubicTo(2,5, 2,0, 6,4);
1031     pathB.close();
1032     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1036     SkPath path, pathB;
1041     pathB.setFillType(SkPath::kWinding_FillType);
1042     pathB.moveTo(2,3);
1043     pathB.cubicTo(1,6, 2,1, 5,0);
1044     pathB.close();
1045     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1049     SkPath path, pathB;
1054     pathB.setFillType(SkPath::kWinding_FillType);
1055     pathB.moveTo(3,5);
1056     pathB.cubicTo(4,5, 3,1, 6,5);
1057     pathB.close();
1058     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1062     SkPath path, pathB;
1067     pathB.setFillType(SkPath::kWinding_FillType);
1068     pathB.moveTo(2,3);
1069     pathB.cubicTo(3,5, 3,2, 4,0);
1070     pathB.close();
1071     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1075     SkPath path, pathB;
1080     pathB.moveTo(0,1);
1081     pathB.cubicTo(0,3, 1,0, 1,0);
1082     pathB.lineTo(0,1);
1083     pathB.close();
1084     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1088     SkPath path, pathB;
1093     pathB.moveTo(0,1);
1094     pathB.cubicTo(0,1, 1,0, 5,1);
1095     pathB.lineTo(0,1);
1096     pathB.close();
1097     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1101     SkPath path, pathB;
1106     pathB.moveTo(0,1);
1107     pathB.cubicTo(0,3, 1,0, 1,0);
1108     pathB.lineTo(0,1);
1109     pathB.close();
1110     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1114     SkPath path, pathB;
1119     pathB.setFillType(SkPath::kWinding_FillType);
1120     pathB.moveTo(2,4);
1121     pathB.cubicTo(3,5, 1,0, 6,2);
1122     pathB.close();
1123     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1127     SkPath path, pathB;
1132     pathB.moveTo(0,5);
1133     pathB.cubicTo(1,3, 5,3, 6,1);
1134     pathB.lineTo(0,5);
1135     pathB.close();
1136     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1140     SkPath path, pathB;
1144     pathB.moveTo(1,4);
1145     pathB.cubicTo(0,5, 5,0, 5,4);
1146     pathB.close();
1147     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1151     SkPath path, pathB;
1155     pathB.moveTo(1,3);
1156     pathB.cubicTo(0,2, 3,1, 1,0);
1157     pathB.close();
1158     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1226     SkPath pathB;
1227     pathB.setFillType(SkPath::kWinding_FillType);
1228     pathB.moveTo(189,4);
1229     pathB.lineTo(199,14);
1230     pathB.lineTo(236,14);
1231     pathB.lineTo(246,4);
1232     pathB.lineTo(189,4);
1233     pathB.close();
1234     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1246     SkPath pathB;
1247     pathB.setFillType(SkPath::kWinding_FillType);
1248     pathB.moveTo(258.000000f, 1028.00000f);
1249     pathB.lineTo(258.000000f, 1027.00000f);
1250     pathB.lineTo(823.000000f, 1027.00000f);
1251     pathB.lineTo(823.000000f, 1028.00000f);
1252     pathB.lineTo(258.000000f, 1028.00000f);
1253     pathB.close();
1254     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1278     SkPath pathB;
1279     pathB.setFillType(SkPath::kWinding_FillType);
1280     pathB.moveTo(717.000000f, 510.000000f);
1281     pathB.lineTo(760.000000f, 467.000000f);
1282     pathB.lineTo(930.000000f, 467.000000f);
1283     pathB.lineTo(973.000000f, 510.000000f);
1284     pathB.lineTo(717.000000f, 510.000000f);
1285     pathB.close();
1286     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1310     SkPath pathB;
1311     pathB.setFillType(SkPath::kWinding_FillType);
1312     pathB.moveTo(306.000000f, 590.000000f);
1313     pathB.lineTo(292.000000f, 604.000000f);
1314     pathB.lineTo(305.000000f, 617.000000f);
1315     pathB.lineTo(306.000000f, 617.000000f);
1316     pathB.lineTo(306.000000f, 590.000000f);
1317     pathB.close();
1318     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1334     SkPath pathB;
1335     pathB.setFillType(SkPath::kInverseWinding_FillType);
1336     pathB.moveTo(18.0000000f, 226.000000f);
1337     pathB.lineTo(1239.00000f, 226.000000f);
1338     pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1339     pathB.lineTo(1247.00000f, 252.000000f);
1340     pathB.lineTo(10.0000000f, 252.000000f);
1341     pathB.lineTo(10.0000000f, 234.000000f);
1342     pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1343     pathB.close();
1344     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1348     SkPath path, pathB;
1353     pathB.setFillType(SkPath::kWinding_FillType);
1354     pathB.moveTo(0,4);
1355     pathB.cubicTo(0,5, 1,0, 5,0);
1356     pathB.close();
1357     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1361     SkPath path, pathB;
1366     pathB.setFillType(SkPath::kWinding_FillType);
1367     pathB.moveTo(1,4);
1368     pathB.cubicTo(4,6, 1,0, 5,0);
1369     pathB.close();
1370     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1374     SkPath path, pathB;
1379     pathB.setFillType(SkPath::kWinding_FillType);
1380     pathB.moveTo(2,5);
1381     pathB.cubicTo(4,5, 1,0, 5,0);
1382     pathB.close();
1383     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1387     SkPath path, pathB;
1393     pathB.setFillType(SkPath::kWinding_FillType);
1394     pathB.moveTo(0,4);
1395     pathB.cubicTo(4,6, 1,0, 4,3);
1396     pathB.lineTo(0,4);
1397     pathB.close();
1398     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1402     SkPath path, pathB;
1408     pathB.setFillType(SkPath::kWinding_FillType);
1409     pathB.moveTo(1,5);
1410     pathB.cubicTo(1,5, 1,0, 5,1);
1411     pathB.lineTo(1,5);
1412     pathB.close();
1413     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1417     SkPath path, pathB;
1423     pathB.setFillType(SkPath::kWinding_FillType);
1424     pathB.moveTo(1,5);
1425     pathB.cubicTo(4,6, 1,0, 4,0);
1426     pathB.lineTo(1,5);
1427     pathB.close();
1428     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1432     SkPath path, pathB;
1437     pathB.setFillType(SkPath::kWinding_FillType);
1438     pathB.moveTo(0,2);
1439     pathB.cubicTo(3,5, 1,0, 2,0);
1440     pathB.close();
1441     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1445     SkPath path, pathB;
1451     pathB.setFillType(SkPath::kEvenOdd_FillType);
1452     pathB.moveTo(0,2);
1453     pathB.cubicTo(2,3, 1,0, 3,1);
1454     pathB.lineTo(0,2);
1455     pathB.close();
1456     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1460     SkPath path, pathB;
1466     pathB.setFillType(SkPath::kEvenOdd_FillType);
1467     pathB.moveTo(0,5);
1468     pathB.cubicTo(1,6, 6,1, 6,1);
1469     pathB.lineTo(0,5);
1470     pathB.close();
1471     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1475     SkPath path, pathB;
1480     pathB.setFillType(SkPath::kWinding_FillType);
1481     pathB.moveTo(0,1);
1482     pathB.cubicTo(4,6, 1,0, 3,1);
1483     pathB.close();
1484     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1488     SkPath path, pathB;
1494     pathB.setFillType(SkPath::kWinding_FillType);
1495     pathB.moveTo(1,2);
1496     pathB.cubicTo(3,4, 1,0, 3,2);
1497     pathB.lineTo(1,2);
1498     pathB.close();
1499     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1503     SkPath path, pathB;
1508     pathB.setFillType(SkPath::kWinding_FillType);
1509     pathB.moveTo(3,4);
1510     pathB.cubicTo(4,5, 1,0, 6,4);
1511     pathB.close();
1512     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1516     SkPath path, pathB;
1522     pathB.setFillType(SkPath::kWinding_FillType);
1523     pathB.moveTo(2,5);
1524     pathB.cubicTo(0,3, 1,0, 3,2);
1525     pathB.lineTo(2,5);
1526     pathB.close();
1527     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1531     SkPath path, pathB;
1537     pathB.setFillType(SkPath::kWinding_FillType);
1538     pathB.moveTo(1,2);
1539     pathB.cubicTo(1,4, 1,0, 3,0);
1540     pathB.lineTo(1,2);
1541     pathB.close();
1542     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1546     SkPath path, pathB;
1551     pathB.setFillType(SkPath::kWinding_FillType);
1552     pathB.moveTo(3,6);
1553     pathB.cubicTo(2,3, 4,0, 3,2);
1554     pathB.close();
1555     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1577     SkPath pathB;
1578     pathB.setFillType(SkPath::kWinding_FillType);
1579     pathB.moveTo(1247.00000f, 876.000000f);
1580     pathB.lineTo(1231.00000f, 892.000000f);
1581     pathB.lineTo(1246.00000f, 907.000000f);
1582     pathB.lineTo(1247.00000f, 907.000000f);
1583     pathB.lineTo(1247.00000f, 876.000000f);
1584     pathB.close();
1585     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1599     SkPath pathB;
1600     pathB.setFillType(SkPath::kInverseWinding_FillType);
1601     pathB.moveTo(132.000000f, 11415.0000f);
1602     pathB.lineTo(806.000000f, 11415.0000f);
1603     pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1604     pathB.lineTo(808.000000f, 11417.0000f);
1605     pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1606     pathB.lineTo(132.000000f, 11419.0000f);
1607     pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1608     pathB.lineTo(130.000000f, 11416.0000f);
1609     pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1610     pathB.close();
1611     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1633     SkPath pathB;
1634     pathB.setFillType(SkPath::kWinding_FillType);
1635     pathB.moveTo(156.000000f, 669.000000f);
1636     pathB.lineTo(178.500000f, 691.500000f);
1637     pathB.lineTo(230.500000f, 691.500000f);
1638     pathB.lineTo(253.000000f, 669.000000f);
1639     pathB.lineTo(156.000000f, 669.000000f);
1640     pathB.close();
1641     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1655     SkPath pathB;
1656     pathB.setFillType(SkPath::kEvenOdd_FillType);
1657     pathB.moveTo(161.000000f, 926.000000f);
1658     pathB.lineTo(1105.00000f, 926.000000f);
1659     pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1660     pathB.lineTo(1109.00000f, 956.000000f);
1661     pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1662     pathB.lineTo(161.000000f, 960.000000f);
1663     pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1664     pathB.lineTo(157.000000f, 930.000000f);
1665     pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1666     pathB.close();
1667     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1679     SkPath pathB;
1680     pathB.setFillType(SkPath::kWinding_FillType);
1681     pathB.moveTo(1006.69513f, 291.000000f);
1682     pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1683     pathB.lineTo(985.681519f, 531.000000f);
1684     pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1685     pathB.lineTo(259.304871f, 561.000000f);
1686     pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1687     pathB.lineTo(280.318420f, 321.000000f);
1688     pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1689     pathB.lineTo(1006.69513f, 291.000000f);
1690     pathB.close();
1691     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1707     SkPath pathB;
1708     pathB.setFillType(SkPath::kInverseWinding_FillType);
1709     pathB.moveTo(968.000000f, 14.0000000f);
1710     pathB.lineTo(1034.00000f, 14.0000000f);
1711     pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1712     pathB.lineTo(1039.00000f, 32.0000000f);
1713     pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1714     pathB.lineTo(968.000000f, 36.0000000f);
1715     pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1716     pathB.lineTo(963.000000f, 19.0000000f);
1717     pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1718     pathB.close();
1719     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1734     SkPath pathB;
1735     pathB.setFillType(SkPath::kWinding_FillType);
1736     pathB.moveTo(704.000000f, 3.00000000f);
1737     pathB.lineTo(704.000000f, 33.0000000f);
1738     pathB.lineTo(705.000000f, 33.0000000f);
1739     pathB.lineTo(719.500000f, 3.00000000f);
1740     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1760     SkPath pathB;
1761     pathB.setFillType(SkPath::kWinding_FillType);
1762     pathB.moveTo(1101.00000f, 6.00000000f);
1763     pathB.lineTo(1088.00000f, 6.00000000f);
1764     pathB.lineTo(1088.00000f, 19.0000000f);
1765     pathB.lineTo(1101.00000f, 32.0000000f);
1766     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1790     SkPath pathB;
1791     pathB.setFillType(SkPath::kWinding_FillType);
1792     pathB.moveTo(1036.00000f, 32.0000000f);
1793     pathB.lineTo(1049.00000f, 19.0000000f);
1794     pathB.lineTo(1073.00000f, 31.0000000f);
1795     pathB.lineTo(1074.00000f, 32.0000000f);
1796     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1805     SkPath pathB;
1806     pathB.setFillType(SkPath::kWinding_FillType);
1807     pathB.moveTo(0,1);
1808     pathB.cubicTo(2,6, 1,0, 6,1);
1809     pathB.close();
1810     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1826     SkPath pathB;
1827     pathB.setFillType(SkPath::kWinding_FillType);
1828     pathB.moveTo(258, 122);
1829     pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1830     pathB.lineTo(263, 284);
1831     pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1832     pathB.lineTo(96, 289);
1833     pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1834     pathB.lineTo(91, 127);
1835     pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1836     pathB.lineTo(258, 122);
1837     pathB.close();
1838     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1980     SkPath path, pathB;
1985     pathB.setFillType(SkPath::kWinding_FillType);
1986     pathB.moveTo(3, 4);
1987     pathB.cubicTo(4, 6, 4, 3, 5, 1);
1988     pathB.close();
1989     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2023     SkPath path, pathB;
2027     pathB.setFillType(SkPath::kWinding_FillType);
2028     pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2029     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2030     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2034     SkPath path, pathB;
2038     pathB.setFillType(SkPath::kWinding_FillType);
2039     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2040     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2041     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2045     SkPath path, pathB;
2057     pathB.setFillType(SkPath::kWinding_FillType);
2058     pathB.moveTo(1, 1);
2059     pathB.lineTo(3, 1);
2060     pathB.lineTo(3, 3);
2061     pathB.lineTo(1, 3);
2062     pathB.close();
2063     pathB.moveTo(2, 2);
2064     pathB.lineTo(3, 2);
2065     pathB.lineTo(3, 3);
2066     pathB.lineTo(2, 3);
2067     pathB.close();
2068     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2131     SkPath pathB;
2132     pathB.setFillType(SkPath::kWinding_FillType);
2133     pathB.moveTo(1340, 122);
2134     pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127);
2135     pathB.lineTo(1345, 284);
2136     pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289);
2137     pathB.lineTo(1178, 289);
2138     pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284);
2139     pathB.lineTo(1173, 127);
2140     pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122);
2141     pathB.lineTo(1340, 122);
2142     pathB.close();
2143     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2158     SkPath pathB;
2159     pathB.setFillType(SkPath::kEvenOdd_FillType);
2160     pathB.moveTo(1,2);
2161     pathB.lineTo(2,2);
2162     pathB.lineTo(2,4);
2163     pathB.lineTo(1,4);
2164     pathB.close();
2165     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2180     SkPath pathB;
2181     pathB.setFillType(SkPath::kEvenOdd_FillType);
2182     pathB.moveTo(1 - 1e-6f,2);
2183     pathB.lineTo(2 - 1e-6f,2);
2184     pathB.lineTo(2 - 1e-6f,4);
2185     pathB.lineTo(1 - 1e-6f,4);
2186     pathB.close();
2187     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2191     SkPath path, pathB;
2196     pathB.setFillType(SkPath::kEvenOdd_FillType);
2197     pathB.moveTo(2, 6);
2198     pathB.cubicTo(2, 5, 4, 0, 4, 3);
2199     pathB.close();
2200     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2204     SkPath path, pathB;
2209     pathB.setFillType(SkPath::kWinding_FillType);
2210     pathB.moveTo(0,2);
2211     pathB.cubicTo(4,6, 1,0, 2,0);
2212     pathB.close();
2213     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2217     SkPath path, pathB;
2222     pathB.setFillType(SkPath::kWinding_FillType);
2223     pathB.moveTo(0,5);
2224     pathB.cubicTo(4,6, 1,0, 5,2);
2225     pathB.close();
2226     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2230     SkPath path, pathB;
2235     pathB.setFillType(SkPath::kWinding_FillType);
2236     pathB.moveTo(0, 5);
2237     pathB.cubicTo(3, 6, 3, 0, 6, 1);
2238     pathB.close();
2239     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2243     SkPath path, pathB;
2248     pathB.setFillType(SkPath::kEvenOdd_FillType);
2249     pathB.moveTo(2, 5);
2250     pathB.cubicTo(1, 4, 5, 0, 2, 1);
2251     pathB.close();
2252     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2256     SkPath path, pathB;
2261     pathB.setFillType(SkPath::kWinding_FillType);
2262     pathB.moveTo(3, 6);
2263     pathB.cubicTo(0, 5, 6, 1, 3, 0);
2264     pathB.close();
2265     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2279     SkPath pathB;
2280     pathB.setFillType(SkPath::kWinding_FillType);
2281    pathB.moveTo(0, 312);
2282     pathB.lineTo(258, 312);
2283     pathB.lineTo(258, 348);
2284     pathB.lineTo(0, 348);
2285     pathB.close();
2286     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2302     SkPath pathB;
2303     pathB.setFillType(SkPath::kWinding_FillType);
2304     pathB.moveTo(0, 417);
2305     pathB.lineTo(105, 417);
2306     pathB.lineTo(105, 494);
2307     pathB.lineTo(0, 494);
2308     pathB.close();
2309     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2323     SkPath pathB;
2324     pathB.setFillType(SkPath::kWinding_FillType);
2325     pathB.moveTo(663.318542f, 374.100616f);
2326     pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f);
2327     pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f);
2328     pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f);
2329     pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f);
2330     pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f);
2331     pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f);
2332     pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f);
2333     pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f);
2334     pathB.close();
2335     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2354     SkPath pathB;
2355     pathB.setFillType(SkPath::kWinding_FillType);
2356     pathB.moveTo(-1, 920);
2357     pathB.lineTo(0, 920);
2358     pathB.lineTo(3, 927);
2359     pathB.lineTo(-1, 927);
2360     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2372     SkPath pathB;
2373     pathB.setFillType(SkPath::kInverseWinding_FillType);
2374     pathB.moveTo(333.866608f, 623.496155f);
2375     pathB.lineTo(613.368042f, 100.585754f);
2376     pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2377     pathB.lineTo(932.633057f, 269.854553f);
2378     pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2379     pathB.lineTo(653.631897f, 794.414307f);
2380     pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2381     pathB.lineTo(334.366943f, 625.145508f);
2382     pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2383     pathB.close();
2384     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2396     SkPath pathB;
2397     pathB.setFillType(SkPath::kWinding_FillType);
2398     pathB.moveTo(0, 312);
2399     pathB.lineTo(8.20486257e-015f, 178);
2400     pathB.lineTo(49, 178);
2401     pathB.lineTo(49, 312);
2402     pathB.close();
2403     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2415     SkPath pathB;
2416     pathB.setFillType(SkPath::kWinding_FillType);
2417     pathB.moveTo(283.407959f, 110.462646f);
2418     pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f);
2419     pathB.lineTo(286.537354f, 163.407959f);
2420     pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f);
2421     pathB.lineTo(233.592026f, 166.537338f);
2422     pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f);
2423     pathB.lineTo(230.462646f, 113.592026f);
2424     pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f);
2425     pathB.lineTo(283.407959f, 110.462646f);
2426     pathB.close();
2427     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2441     SkPath pathB;
2442     pathB.setFillType(SkPath::kWinding_FillType);
2443     pathB.moveTo(0, 482);
2444     pathB.lineTo(35, 482);
2445     pathB.lineTo(35, 683);
2446     pathB.lineTo(0, 683);
2447     pathB.close();
2448     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2466     SkPath pathB;
2467     pathB.setFillType(SkPath::kWinding_FillType);
2468     pathB.moveTo(317, 711);
2469     pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
2470     pathB.lineTo(327, 838);
2471     pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
2472     pathB.lineTo(155, 848);
2473     pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
2474     pathB.lineTo(145, 721);
2475     pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
2476     pathB.lineTo(317, 711);
2477     pathB.close();
2478     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2482     SkPath path, pathB;
2487     pathB.setFillType(SkPath::kWinding_FillType);
2488     pathB.moveTo(1, 4);
2489     pathB.cubicTo(4, 5, 1, 0, 6, 2);
2490     pathB.close();
2491     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2495     SkPath path, pathB;
2500     pathB.setFillType(SkPath::kWinding_FillType);
2501     pathB.moveTo(1, 4);
2502     pathB.cubicTo(3, 4, 1, 0, 6, 1);
2503     pathB.close();
2504     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2508     SkPath path, pathB;
2513     pathB.setFillType(SkPath::kEvenOdd_FillType);
2514     pathB.moveTo(0, 5);
2515     pathB.cubicTo(3, 5, 3, 0, 3, 2);
2516     pathB.close();
2517     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2529     SkPath pathB;
2530      pathB.setFillType(SkPath::kWinding_FillType);
2531     pathB.moveTo(613.368042f, 100.585754f);
2532     pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2533     pathB.lineTo(932.633057f, 269.854553f);
2534     pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2535     pathB.lineTo(653.631897f, 794.414307f);
2536     pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2537     pathB.lineTo(334.366943f, 625.145508f);
2538     pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2539     pathB.lineTo(613.368042f, 100.585754f);
2540      pathB.close();
2541     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2556     SkPath pathB;
2557     pathB.setFillType(SkPath::kInverseWinding_FillType);
2558     pathB.moveTo(803, 326);
2559     pathB.lineTo(955, 326);
2560     pathB.lineTo(955, 370);
2561     pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375);
2562     pathB.lineTo(808, 375);
2563     pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370);
2564     pathB.lineTo(803, 326);
2565     pathB.close();
2566     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2586     SkPath pathB;
2587     pathB.setFillType(SkPath::kWinding_FillType);
2588     pathB.moveTo(0, 482);
2589     pathB.lineTo(35, 482);
2590     pathB.lineTo(35, 683);
2591     pathB.lineTo(0, 683);
2592     pathB.close();
2593     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2605     SkPath pathB;
2606     pathB.setFillType(SkPath::kWinding_FillType);
2607     pathB.moveTo(934, 924);
2608     pathB.lineTo(1182, 924);
2609     pathB.lineTo(1182, 926);
2610     pathB.lineTo(934, 926);
2611     pathB.close();
2612     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2628     SkPath pathB;
2629     pathB.setFillType(SkPath::kWinding_FillType);
2630     pathB.moveTo(1103, 27);
2631     pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29);
2632     pathB.lineTo(1105, 54);
2633     pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56);
2634     pathB.lineTo(926, 56);
2635     pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54);
2636     pathB.lineTo(924, 29);
2637     pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27);
2638     pathB.lineTo(1103, 27);
2639     pathB.close();
2640     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2654     SkPath pathB;
2655     pathB.setFillType(SkPath::kWinding_FillType);
2656     pathB.moveTo(210, 190);
2657     pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f);
2658     pathB.quadTo(198.284271f, 210, 190, 210);
2659     pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f);
2660     pathB.quadTo(170, 198.284271f, 170, 190);
2661     pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f);
2662     pathB.quadTo(181.715729f, 170, 190, 170);
2663     pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f);
2664     pathB.quadTo(210, 181.715729f, 210, 190);
2665     pathB.close();
2666     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2678     SkPath pathB;
2679     pathB.setFillType(SkPath::kEvenOdd_FillType);
2680     pathB.moveTo(-1, -3);
2681     pathB.lineTo(-1, -3);
2682     pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47);
2683     pathB.lineTo(49, 47);
2684     pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97);
2685     pathB.lineTo(-1, 97);
2686     pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47);
2687     pathB.lineTo(-51, 47);
2688     pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3);
2689     pathB.close();
2690     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2702     SkPath pathB;
2703     pathB.setFillType(SkPath::kWinding_FillType);
2704     pathB.moveTo(575, 925);
2705     pathB.lineTo(693, 925);
2706     pathB.lineTo(693, 926);
2707     pathB.lineTo(575, 926);
2708     pathB.close();
2709     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2723     SkPath pathB;
2724     pathB.setFillType(SkPath::kWinding_FillType);
2725     pathB.moveTo(195, 785);
2726     pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
2727     pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
2728     pathB.lineTo(194, 1041);
2729     pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
2730     pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
2731     pathB.lineTo(195, 785);
2732     pathB.close();
2733     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2749     SkPath pathB;
2750     pathB.setFillType(SkPath::kWinding_FillType);
2751     pathB.moveTo(945.080994f, 597.161987f);
2752     pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
2753     pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
2754     pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
2755     pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
2756     pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
2757     pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
2758     pathB.close();
2759     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2771     SkPath pathB;
2772     pathB.setFillType(SkPath::kWinding_FillType);
2773     pathB.moveTo(0, 290);
2774     pathB.lineTo(-2.64514972e-014f, 146);
2775     pathB.lineTo(30, 146);
2776     pathB.lineTo(30, 290);
2777     pathB.close();
2778     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2794     SkPath pathB;
2795     pathB.setFillType(SkPath::kWinding_FillType);
2796     pathB.moveTo(883, 0);
2797     pathB.lineTo(1123, 0);
2798     pathB.lineTo(1123, 23);
2799     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2800     pathB.quadTo(1120.07104f, 28, 1118, 28);
2801     pathB.lineTo(888, 28);
2802     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2803     pathB.quadTo(883, 25.0710678f, 883, 23);
2804     pathB.close();
2805     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2821     SkPath pathB;
2822     pathB.setFillType(SkPath::kWinding_FillType);
2823     pathB.moveTo(883, 0);
2824     pathB.lineTo(1123, 0);
2825     pathB.lineTo(1123, 23);
2826     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2827     pathB.quadTo(1120.07104f, 28, 1118, 28);
2828     pathB.lineTo(888, 28);
2829     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2830     pathB.quadTo(883, 25.0710678f, 883, 23);
2831     pathB.close();
2832     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2844     SkPath pathB;
2845     pathB.setFillType(SkPath::kWinding_FillType);
2846     pathB.moveTo(899.200928f, 745.783997f);
2847     pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f);
2848     pathB.lineTo(895.432007f, 858.316284f);
2849     pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f);
2850     pathB.lineTo(918.799133f, 876.216003f);
2851     pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f);
2852     pathB.lineTo(922.567993f, 763.683716f);
2853     pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f);
2854     pathB.lineTo(899.200928f, 745.783997f);
2855     pathB.close();
2856     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2870     SkPath pathB;
2871     pathB.setFillType(SkPath::kInverseWinding_FillType);
2872     pathB.moveTo(400, 453);
2873     pathB.lineTo(1103, 453);
2874     pathB.lineTo(1103, 666);
2875     pathB.lineTo(406, 666);
2876     pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660);
2877     pathB.lineTo(400, 453);
2878     pathB.close();
2879     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2895     SkPath pathB;
2896     pathB.setFillType(SkPath::kWinding_FillType);
2897     pathB.moveTo(883, 0);
2898     pathB.lineTo(1123, 0);
2899     pathB.lineTo(1123, 23);
2900     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2901     pathB.quadTo(1120.07104f, 28, 1118, 28);
2902     pathB.lineTo(888, 28);
2903     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2904     pathB.quadTo(883, 25.0710678f, 883, 23);
2905     pathB.close();
2906     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2922     SkPath pathB;
2923     pathB.setFillType(SkPath::kWinding_FillType);
2924     pathB.moveTo(883, 0);
2925     pathB.lineTo(1123, 0);
2926     pathB.lineTo(1123, 23);
2927     pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2928     pathB.quadTo(1120.07104f, 28, 1118, 28);
2929     pathB.lineTo(888, 28);
2930     pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2931     pathB.quadTo(883, 25.0710678f, 883, 23);
2932     pathB.close();
2933     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2945     SkPath pathB;
2946     pathB.setFillType(SkPath::kWinding_FillType);
2947     pathB.moveTo(91, 917);
2948     pathB.lineTo(160, 917);
2949     pathB.lineTo(160, 918);
2950     pathB.lineTo(91, 918);
2951     pathB.close();
2952     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2965     SkPath pathB;
2966     pathB.setFillType(SkPath::kWinding_FillType);
2967     pathB.moveTo(1139, 231);
2968     pathB.lineTo(1138, 231);
2969     pathB.lineTo(633, 6101);
2970     pathB.lineTo(1139, 6607);
2971     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2975     SkPath path, pathB;
2980     pathB.setFillType(SkPath::kEvenOdd_FillType);
2981     pathB.moveTo(1, 5);
2982     pathB.cubicTo(2, 3, 2, 0, 3, 2);
2983     pathB.close();
2984     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2988     SkPath path, pathB;
2993     pathB.setFillType(SkPath::kEvenOdd_FillType);
2994     pathB.moveTo(3, 6);
2995     pathB.cubicTo(0, 5, 6, 1, 3, 0);
2996     pathB.close();
2997     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3001     SkPath path, pathB;
3006     pathB.setFillType(SkPath::kEvenOdd_FillType);
3007     pathB.moveTo(1, 2);
3008     pathB.cubicTo(1, 2, 2, 0, 6, 0);
3009     pathB.close();
3010     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3014     SkPath path, pathB;
3019     pathB.setFillType(SkPath::kEvenOdd_FillType);
3020     pathB.moveTo(1, 4);
3021     pathB.cubicTo(3, 6, 3, 0, 6, 3);
3022     pathB.close();
3023     testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3027     SkPath path, pathB;
3032     pathB.setFillType(SkPath::kWinding_FillType);
3033     pathB.moveTo(5,6);
3034     pathB.cubicTo(4,5, 6,3, 3,0);
3035     pathB.close();
3036     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3040     SkPath path, pathB;
3045     pathB.setFillType(SkPath::kWinding_FillType);
3046     pathB.moveTo(1,2);
3047     pathB.cubicTo(2,4, 1,0, 2,0);
3048     pathB.close();
3049     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3053     SkPath path, pathB;
3058     pathB.setFillType(SkPath::kWinding_FillType);
3059     pathB.moveTo(1, 2);
3060     pathB.cubicTo(3, 5, 1, 0, 3, 2);
3061     pathB.close();
3062     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3066     SkPath path, pathB;
3071     pathB.setFillType(SkPath::kWinding_FillType);
3072     pathB.moveTo(0,1);
3073     pathB.cubicTo(0,3, 1,0, 2,1);
3074     pathB.close();
3075     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3079     SkPath path, pathB;
3084     pathB.setFillType(SkPath::kWinding_FillType);
3085     pathB.moveTo(0,2);
3086     pathB.cubicTo(1,2, 1,0, 5,1);
3087     pathB.close();
3088     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3092     SkPath path, pathB;
3097     pathB.setFillType(SkPath::kWinding_FillType);
3098     pathB.moveTo(0,4);
3099     pathB.cubicTo(1,6, 1,0, 6,0);
3100     pathB.close();
3101     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3105     SkPath path, pathB;
3110     pathB.setFillType(SkPath::kWinding_FillType);
3111     pathB.moveTo(5,6);
3112     pathB.cubicTo(0,2, 1,0, 4,0);
3113     pathB.close();
3114     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3118     SkPath path, pathB;
3123     pathB.setFillType(SkPath::kWinding_FillType);
3124     pathB.moveTo(1, 2);
3125     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3126     pathB.close();
3127     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3131     SkPath path, pathB;
3136     pathB.setFillType(SkPath::kWinding_FillType);
3137     pathB.moveTo(1, 2);
3138     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3139     pathB.close();
3140     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3144     SkPath path, pathB;
3149     pathB.setFillType(SkPath::kWinding_FillType);
3150     pathB.moveTo(1, 2);
3151     pathB.cubicTo(0, 2, 1, 0, 6, 4);
3152     pathB.close();
3153     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3157     SkPath path, pathB;
3162     pathB.setFillType(SkPath::kWinding_FillType);
3163     pathB.moveTo(3,6);
3164     pathB.cubicTo(4,5, 1,0, 5,4);
3165     pathB.close();
3166     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3170     SkPath path, pathB;
3174     pathB.setFillType(SkPath::kEvenOdd_FillType);
3175     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3176     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3177     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3181     SkPath path, pathB;
3186     pathB.setFillType(SkPath::kWinding_FillType);
3187     pathB.moveTo(1,4);
3188     pathB.cubicTo(1,3, 4,1, 5,0);
3189     pathB.close();
3190     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3194     SkPath path, pathB;
3199     pathB.setFillType(SkPath::kEvenOdd_FillType);
3200     pathB.moveTo(2, 3);
3201     pathB.cubicTo(3, 6, 4, 1, 5, 4);
3202     pathB.close();
3203     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3207     SkPath path, pathB;
3212     pathB.setFillType(SkPath::kEvenOdd_FillType);
3213     pathB.moveTo(0, 6);
3214     pathB.cubicTo(1, 5, 4, 1, 5, 1);
3215     pathB.close();
3216     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3220     SkPath path, pathB;
3225     pathB.setFillType(SkPath::kEvenOdd_FillType);
3226     pathB.moveTo(2, 3);
3227     pathB.cubicTo(1, 6, 5, 1, 4, 0);
3228     pathB.close();
3229     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3233     SkPath path, pathB;
3238     pathB.setFillType(SkPath::kWinding_FillType);
3239     pathB.moveTo(1,4);
3240     pathB.cubicTo(1,3, 4,1, 5,0);
3241     pathB.close();
3242     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3246     SkPath path, pathB;
3251     pathB.setFillType(SkPath::kWinding_FillType);
3252     pathB.moveTo(0,5);
3253     pathB.cubicTo(1,2, 1,0, 6,1);
3254     pathB.close();
3255     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3259     SkPath path, pathB;
3264     pathB.setFillType(SkPath::kWinding_FillType);
3265     pathB.moveTo(4,6);
3266     pathB.cubicTo(0,1, 4,2, 3,2);
3267     pathB.close();
3268     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3272     SkPath path, pathB;
3276     pathB.moveTo(3,5);
3277     pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
3278     pathB.close();
3279     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3283     SkPath path, pathB;
3288     pathB.setFillType(SkPath::kWinding_FillType);
3289     pathB.moveTo(1, 3);
3290     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3291     pathB.close();
3292     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3296     SkPath path, pathB;
3301     pathB.setFillType(SkPath::kWinding_FillType);
3302     pathB.moveTo(1, 3);
3303     pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3304     pathB.close();
3307     CubicPathToQuads(pathB, &qPathB);
3312     SkPath path, pathB;
3317     pathB.moveTo(0, 0);
3318     pathB.quadTo(8, 1, 4, 8);
3319     pathB.close();
3320     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3382     SkPath path, pathB;
3394     pathB.setFillType(SkPath::kEvenOdd_FillType);
3395     pathB.moveTo(0, 0);
3396     pathB.lineTo(1, 0);
3397     pathB.lineTo(1, 1);
3398     pathB.lineTo(0, 1);
3399     pathB.close();
3400     pathB.moveTo(0, 0);
3401     pathB.lineTo(2, 0);
3402     pathB.lineTo(2, 2);
3403     pathB.lineTo(0, 2);
3404     pathB.close();
3405     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3409     SkPath path, pathB;
3421     pathB.setFillType(SkPath::kWinding_FillType);
3422     pathB.moveTo(3, 3);
3423     pathB.lineTo(6, 3);
3424     pathB.lineTo(6, 6);
3425     pathB.lineTo(3, 6);
3426     pathB.close();
3427     pathB.moveTo(3, 3);
3428     pathB.lineTo(4, 3);
3429     pathB.lineTo(4, 4);
3430     pathB.lineTo(3, 4);
3431     pathB.close();
3432     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3436     SkPath path, pathB;
3440     pathB.setFillType(SkPath::kWinding_FillType);
3441     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3442     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3443     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3447     SkPath path, pathB;
3451     pathB.setFillType(SkPath::kWinding_FillType);
3452     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3453     pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
3454     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3506     SkPath path, pathB;
3511     pathB.setFillType(SkPath::kWinding_FillType);
3512     pathB.moveTo(1,2);
3513     pathB.cubicTo(3,5, 1,0, 4,3);
3514     pathB.close();
3516     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3529     SkPath path, pathB;
3533     pathB.setFillType(SkPath::kEvenOdd_FillType);
3534     pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3535     pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
3536     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3540     SkPath path, pathB;
3545     pathB.setFillType(SkPath::kWinding_FillType);
3546     pathB.moveTo(0,2);
3547     pathB.cubicTo(0,2, 1,0, 6,4);
3548     pathB.close();
3549     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3553     SkPath path, pathB;
3558     pathB.setFillType(SkPath::kWinding_FillType);
3559     pathB.moveTo(0,6);
3560     pathB.cubicTo(0,1, 1,0, 5,4);
3561     pathB.close();
3562     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3566     SkPath path, pathB;
3571     pathB.setFillType(SkPath::kWinding_FillType);
3572     pathB.moveTo(1,5);
3573     pathB.cubicTo(2,6, 1,0, 6,4);
3574     pathB.close();
3575     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3579     SkPath path, pathB;
3583     pathB.moveTo(1,5);
3584     pathB.cubicTo(-5.66666651f,3.33333349f, 8.83333302f,2.33333349f, 0,1);
3585     pathB.close();
3586     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3606     SkPath path, pathB;
3612     pathB.moveTo(q2[0].fPts[0].asSkPoint());
3613     pathB.quadTo(q2[0].fPts[1].asSkPoint(), q2[0].fPts[2].asSkPoint());
3614     pathB.quadTo(q2[1].fPts[1].asSkPoint(), q2[1].fPts[2].asSkPoint());
3615     pathB.close();
3616     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3620     SkPath path, pathB;
3624     pathB.moveTo(3,4);
3625     pathB.cubicTo(3.f,4.f, 4.5f,1.5f, 0,1);
3626     pathB.close();
3627     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3631     SkPath path, pathB;
3635     pathB.moveTo(3,5);
3636     pathB.cubicTo(-3.66666651f,0, 10.5f,-1.66666651f, 0,1);
3637     pathB.close();
3638     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3642     SkPath path, pathB;
3646     pathB.moveTo(1,5);
3647     pathB.cubicTo(1,4, 0.833333313f,3, 0,5);
3648     pathB.close();
3649     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3655     SkPath path, pathB;
3661     SkParsePath::FromSVGString(strB, &pathB);
3662     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3666     SkPath path, pathB;
3671     pathB.setFillType(SkPath::kWinding_FillType);
3672     pathB.moveTo(1,2);
3673     pathB.cubicTo(1,3, 1,0, 5,3);
3674     pathB.close();
3675     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3679     SkPath path, pathB;
3684     pathB.setFillType(SkPath::kWinding_FillType);
3685     pathB.moveTo(1,2);
3686     pathB.cubicTo(0,4, 1,0, 4,2);
3687     pathB.close();
3688     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3692     SkPath path, pathB;
3697     pathB.setFillType(SkPath::kWinding_FillType);
3698     pathB.moveTo(2,3);
3699     pathB.cubicTo(3,4, 1,0, 4,3);
3700     pathB.close();
3701     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3706     SkPath path, pathB;
3711     pathB.setFillType(SkPath::kWinding_FillType);
3712     pathB.moveTo(1,4);
3713     pathB.cubicTo(0,4, 1,0, 5,3);
3714     pathB.close();
3715     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3719     SkPath path, pathB;
3724     pathB.setFillType(SkPath::kWinding_FillType);
3725     pathB.moveTo(0,2);
3726     pathB.cubicTo(0,6, 1,0, 5,1);
3727     pathB.close();
3728     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3732     SkPath path, pathB;
3736     pathB.moveTo(1,2);
3737     pathB.cubicTo(1,1.66666663f, 0.833333313f,1.33333325f, 0,2);
3738     pathB.close();
3739     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3743     SkPath path, pathB;
3747     pathB.moveTo(1,3);
3748     pathB.cubicTo(-1.66666675f,1.66666663f, 4.16666651f,1.00000012f, 0,1);
3749     pathB.close();
3750     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3754     SkPath path, pathB;
3759     pathB.setFillType(SkPath::kWinding_FillType);
3760     pathB.moveTo(0,6);
3761     pathB.cubicTo(0,3, 1,0, 5,1);
3762     pathB.close();
3763     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3767     SkPath path, pathB;
3772     pathB.setFillType(SkPath::kWinding_FillType);
3773     pathB.moveTo(1,3);
3774     pathB.cubicTo(2,6, 1,0, 6,3);
3775     pathB.close();
3776     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3780     SkPath path, pathB;
3785     pathB.setFillType(SkPath::kWinding_FillType);
3786     pathB.moveTo(0,6);
3787     pathB.cubicTo(1,2, 1,0, 3,0);
3788     pathB.close();
3789     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3793     SkPath path, pathB;
3798     pathB.setFillType(SkPath::kWinding_FillType);
3799     pathB.moveTo(0,6);
3800     pathB.cubicTo(0,3, 1,0, 5,1);
3801     pathB.close();
3802     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3806     SkPath path, pathB;
3811     pathB.setFillType(SkPath::kWinding_FillType);
3812     pathB.moveTo(2,3);
3813     pathB.cubicTo(2,5, 1,0, 3,0);
3814     pathB.close();
3815     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3819     SkPath path, pathB;
3824     pathB.setFillType(SkPath::kWinding_FillType);
3825     pathB.moveTo(0,2);
3826     pathB.cubicTo(1,2, 6,5, 4,3);
3827     pathB.close();
3828     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3832     SkPath path, pathB;
3837     pathB.setFillType(SkPath::kWinding_FillType);
3838     pathB.moveTo(0,3);
3839     pathB.cubicTo(1,2, 6,5, 6,4);
3840     pathB.close();
3841     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3865     SkPath path, pathB;
3871     pathB.setFillType(SkPath::kWinding_FillType);
3872     pathB.moveTo(0,3);
3875     pathB.close();
3876     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3880     SkPath path, pathB;
3885     pathB.setFillType(SkPath::kWinding_FillType);
3886     pathB.moveTo(0,3);
3887     pathB.cubicTo(2,6, 1,0, 4,3);
3888     pathB.close();
3889     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3893     SkPath path, pathB;
3896     pathB.setFillType(SkPath::kWinding_FillType);
3897     pathB.addCircle(0, 1, 1, SkPath::kCW_Direction);
3898     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3902     SkPath path, pathB;
3905     pathB.setFillType(SkPath::kWinding_FillType);
3906     pathB.addCircle(0, 4, 3, SkPath::kCW_Direction);
3907     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3911     SkPath path, pathB;
3955     SkPath path, pathB;
3959     pathB.moveTo(3,4);
3960     pathB.cubicTo(-1,0, 8.5f,-2.5f, 0,1);
3961     pathB.close();
3962     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3966     SkPath path, pathB;
3970     pathB.setFillType(SkPath::kEvenOdd_FillType);
3971     pathB.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
3972     pathB.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3973     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3977     SkPath path, pathB;
3981     pathB.moveTo(1,4);
3982     pathB.cubicTo(-3.83333325f,0.166666627f, 6,-1, 0,1);
3983     pathB.close();
3984     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3988     SkPath path, pathB;
3992     pathB.moveTo(1,3);
3993     pathB.cubicTo(-2.5f,0, 3.33333325f,-0.666666627f, 0,1);
3994     pathB.close();
3995     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3999     SkPath path, pathB;
4002     pathB.setFillType(SkPath::kWinding_FillType);
4003     pathB.addCircle(3, 5, 3, SkPath::kCW_Direction);
4004     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4008     SkPath path, pathB;
4012     pathB.moveTo(1,2);
4013     pathB.cubicTo(1,2, -3.66666651f,13.333334f, 5,6);
4014     pathB.close();
4015     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4019     SkPath path, pathB;
4023     pathB.moveTo(1,3);
4024     pathB.cubicTo(-1.83333349f,1.33333337f, 4,-1, 0,1);
4025     pathB.close();
4026     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4030     SkPath path, pathB;
4035     pathB.setFillType(SkPath::kWinding_FillType);
4036     pathB.moveTo(0,3);
4037     pathB.cubicTo(2,3, 6,5, 4,3);
4038     pathB.close();
4039     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4043     SkPath path, pathB;
4047     pathB.moveTo(0,6);
4048     pathB.cubicTo(-3.16666675f,3.66666675f, 6.33333349f,3.33333349f, 1,2);
4049     pathB.close();
4050     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4054     SkPath path, pathB;
4059     pathB.setFillType(SkPath::kWinding_FillType);
4060     pathB.moveTo(0,5);
4061     pathB.cubicTo(1,4, 6,5, 6,5);
4062     pathB.close();
4063     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4067     SkPath path, pathB;
4072     pathB.setFillType(SkPath::kWinding_FillType);
4073     pathB.moveTo(0,6);
4074     pathB.cubicTo(1,3, 6,5, 6,5);
4075     pathB.close();
4076     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4080     SkPath path, pathB;
4085     pathB.setFillType(SkPath::kWinding_FillType);
4086     pathB.moveTo(0,6);
4087     pathB.cubicTo(1,4, 6,5, 6,5);
4088     pathB.close();
4089     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4093     SkPath path, pathB;
4098     pathB.setFillType(SkPath::kWinding_FillType);
4099     pathB.moveTo(0,5);
4100     pathB.cubicTo(1,3, 6,5, 6,5);
4101     pathB.close();
4102     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4106     SkPath path, pathB;
4111     pathB.setFillType(SkPath::kWinding_FillType);
4112     pathB.moveTo(0,5);
4113     pathB.cubicTo(1,3, 6,5, 6,5);
4114     pathB.close();
4115     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4119     SkPath path, pathB;
4124     pathB.setFillType(SkPath::kWinding_FillType);
4125     pathB.moveTo(0, 1);
4126     pathB.cubicTo(2, 3, 5, 0, 6, 3);
4127     pathB.close();
4128     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4132     SkPath path, pathB;
4137     pathB.setFillType(SkPath::kWinding_FillType);
4138     pathB.moveTo(0, 1);
4139     pathB.cubicTo(2, 4, 5, 0, 6, 3);
4140     pathB.close();
4141     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4146     SkPath path, pathB;
4151     pathB.setFillType(SkPath::kWinding_FillType);
4152     pathB.moveTo(1,3);
4153     pathB.cubicTo(1,5, 2,0, 4,0);
4154     pathB.close();
4155     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4159     SkPath path, pathB;
4164     pathB.setFillType(SkPath::kWinding_FillType);
4165     pathB.moveTo(4,5);
4166     pathB.cubicTo(2,3, 2,0, 2,1);
4167     pathB.close();
4168     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4172     SkPath path, pathB;
4177     pathB.setFillType(SkPath::kWinding_FillType);
4178     pathB.moveTo(4,6);
4179     pathB.cubicTo(2,3, 2,0, 2,1);
4180     pathB.close();
4181     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4185     SkPath path, pathB;
4190     pathB.addRect(4,11, 13,16);
4191     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4195     SkPath path, pathB;
4200     pathB.addRect(4,11, 13,16);
4201     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4205     SkPath path, pathB;
4210     pathB.addRect(4,11, 13,16);
4211     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4215     SkPath path, pathB;
4220     pathB.addRect(4,11, 13,16);
4221     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4225     SkPath path, pathB;
4230     pathB.addRect(4,11, 13,16);
4231     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4235     SkPath path, pathB;
4240     pathB.addRect(4,11, 13,16);
4241     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4245     SkPath path, pathB;
4250     pathB.setFillType(SkPath::kWinding_FillType);
4251     pathB.moveTo(0, 2);
4252     pathB.cubicTo(0, 2, -1.66666663f, 2.16666675f, 0, 3);
4253     pathB.close();
4254     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4258     SkPath path, pathB;
4263     pathB.setFillType(SkPath::kWinding_FillType);
4264     pathB.moveTo(0, 2);
4265     pathB.cubicTo(0, 2, 0.166666672f, 2.66666675f, 1, 2);
4266     pathB.close();
4267     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4271     SkPath path, pathB;
4276     pathB.setFillType(SkPath::kWinding_FillType);
4277     pathB.moveTo(1,2);
4278     pathB.cubicTo(0,1, 6,5, 5,2);
4279     pathB.close();
4280     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4284     SkPath path, pathB;
4289     pathB.setFillType(SkPath::kWinding_FillType);
4290     pathB.moveTo(2, 4);
4291     pathB.cubicTo(0, 4, 5, 3, 5, 1);
4292     pathB.close();
4293     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4297     SkPath path, pathB;
4302     pathB.setFillType(SkPath::kWinding_FillType);
4303     pathB.moveTo(1, 5);
4304     pathB.cubicTo(1, 3, 6, 2, 4, 2);
4305     pathB.close();
4306     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4310     SkPath path, pathB;
4315     pathB.setFillType(SkPath::kWinding_FillType);
4316     pathB.moveTo(1, 5);
4317     pathB.cubicTo(2, 3, 5, 2, 4, 2);
4318     pathB.close();
4319     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4323     SkPath path, pathB;
4328     pathB.setFillType(SkPath::kWinding_FillType);
4329     pathB.moveTo(1, 3);
4330     pathB.cubicTo(1, 5, 4, 2, 6, 2);
4331     pathB.close();
4332     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4336     SkPath path, pathB;
4341     pathB.setFillType(SkPath::kWinding_FillType);
4342     pathB.moveTo(1, 4);
4343     pathB.cubicTo(1, 5, 4, 2, 6, 1);
4344     pathB.close();
4345     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4349     SkPath path, pathB;
4354     pathB.setFillType(SkPath::kWinding_FillType);
4355     pathB.moveTo(2, 3);
4356     pathB.cubicTo(1, 5, 4, 2, 5, 2);
4357     pathB.close();
4358     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4362     SkPath path, pathB;
4367     pathB.setFillType(SkPath::kWinding_FillType);
4368     pathB.moveTo(3, 5);
4369     pathB.cubicTo(1, 5, 4, 2, 4, 0);
4370     pathB.close();
4371     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4375     SkPath path, pathB;
4380     pathB.setFillType(SkPath::kWinding_FillType);
4381     pathB.moveTo(2, 4);
4382     pathB.cubicTo(2, 5, 3, 2, 5, 1);
4383     pathB.close();
4384     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4388     SkPath path, pathB;
4393     pathB.setFillType(SkPath::kWinding_FillType);
4394     pathB.moveTo(1, 3);
4395     pathB.cubicTo(0, 3, 3, 2, 4, 0);
4396     pathB.close();
4397     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4401     SkPath path, pathB;
4406     pathB.setFillType(SkPath::kWinding_FillType);
4407     pathB.moveTo(0, 4);
4408     pathB.cubicTo(2, 4, 5, 1, 5, 3);
4409     pathB.close();
4410     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4414     SkPath path, pathB;
4419     pathB.setFillType(SkPath::kWinding_FillType);
4420     pathB.moveTo(0, 5);
4421     pathB.cubicTo(2, 4, 5, 1, 5, 2);
4422     pathB.close();
4423     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4427     SkPath path, pathB;
4432     pathB.setFillType(SkPath::kWinding_FillType);
4433     pathB.moveTo(1, 4);
4434     pathB.cubicTo(2, 4, 5, 1, 4, 3);
4435     pathB.close();
4436     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4440     SkPath path, pathB;
4445     pathB.setFillType(SkPath::kWinding_FillType);
4446     pathB.moveTo(0, 4);
4447     pathB.cubicTo(0, 2, 5, 1, 3, 1);
4448     pathB.close();
4449     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4453     SkPath path, pathB;
4458     pathB.setFillType(SkPath::kWinding_FillType);
4459     pathB.moveTo(2, 5);
4460     pathB.cubicTo(2, 4, 5, 1, 3, 2);
4461     pathB.close();
4462     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4466     SkPath path, pathB;
4471     pathB.setFillType(SkPath::kWinding_FillType);
4472     pathB.moveTo(2,6);
4473     pathB.cubicTo(2,4, 5,1, 3,1);
4474     pathB.close();
4475     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4479     SkPath path, pathB;
4484     pathB.setFillType(SkPath::kWinding_FillType);
4485     pathB.moveTo(0, 6);
4486     pathB.cubicTo(2, 3, 2, 1, 3, 0);
4487     pathB.close();
4488     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4492     SkPath path, pathB;
4497     pathB.setFillType(SkPath::kWinding_FillType);
4498     pathB.moveTo(0, 2);
4499     pathB.cubicTo(0.833333313f, 2, 1, 3.66666651f, 1, 2);
4500     pathB.close();
4501     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4505     SkPath path, pathB;
4510     pathB.setFillType(SkPath::kWinding_FillType);
4511     pathB.moveTo(0, 2);
4512     pathB.cubicTo(0.833333313f, 2, 1, 4, 1, 2);
4513     pathB.close();
4514     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4518     SkPath path, pathB;
4523     pathB.setFillType(SkPath::kWinding_FillType);
4524     pathB.moveTo(0, 3);
4525     pathB.cubicTo(0.833333313f, 3, 1, 4.66666651f, 1, 3);
4526     pathB.close();
4527     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4531     SkPath path, pathB;
4536     pathB.setFillType(SkPath::kWinding_FillType);
4537     pathB.moveTo(0, 1);
4538     pathB.cubicTo(6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f, 1, 5);
4539     pathB.close();
4540     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4544     SkPath path, pathB;
4549     pathB.setFillType(SkPath::kWinding_FillType);
4550     pathB.moveTo(0, 2);
4551     pathB.cubicTo(0.833333313f, 2, 1, 3, 1, 2);
4552     pathB.close();
4553     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4557     SkPath path, pathB;
4562     pathB.setFillType(SkPath::kWinding_FillType);
4563     pathB.moveTo(0, 5);
4564     pathB.cubicTo(0.833333313f, 5, 1, 7, 1, 5);
4565     pathB.close();
4566     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4570     SkPath path, pathB;
4575     pathB.setFillType(SkPath::kWinding_FillType);
4576     pathB.moveTo(0, 2);
4577     pathB.cubicTo(6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f, 1, 6);
4578     pathB.close();
4579     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4583     SkPath path, pathB;
4588     pathB.setFillType(SkPath::kWinding_FillType);
4589     pathB.moveTo(0, 3);
4590     pathB.cubicTo(0.833333313f, 3, 1, 4.33333349f, 1, 3);
4591     pathB.close();
4592     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4596     SkPath path, pathB;
4601     pathB.setFillType(SkPath::kWinding_FillType);
4602     pathB.moveTo(1, 3);
4603     pathB.cubicTo(1.83333337f, 3, 2, 4.66666651f, 2, 3);
4604     pathB.close();
4605     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4609     SkPath path, pathB;
4614     pathB.setFillType(SkPath::kWinding_FillType);
4615     pathB.moveTo(0, 4);
4616     pathB.cubicTo(1.66666663f, 4, 2, 7.33333302f, 2, 4);
4617     pathB.close();
4618     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4622     SkPath path, pathB;
4627     pathB.setFillType(SkPath::kWinding_FillType);
4628     pathB.moveTo(0, 4);
4629     pathB.cubicTo(1.66666663f, 4, 2, 8, 2, 4);
4630     pathB.close();
4631     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4635     SkPath path, pathB;
4640     pathB.setFillType(SkPath::kWinding_FillType);
4641     pathB.moveTo(1, 5);
4642     pathB.cubicTo(1.83333337f, 5, 2, 6.66666651f, 2, 5);
4643     pathB.close();
4644     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4648     SkPath path, pathB;
4653     pathB.setFillType(SkPath::kWinding_FillType);
4654     pathB.moveTo(1, 6);
4655     pathB.cubicTo(1.83333337f, 6, 2, 8, 2, 6);
4656     pathB.close();
4657     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4661     SkPath path, pathB;
4666     pathB.setFillType(SkPath::kWinding_FillType);
4667     pathB.moveTo(1, 2);
4668     pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4669     pathB.close();
4670     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4687         SkPath path, pathB;
4692         pathB.setFillType(SkPath::kWinding_FillType);
4693         pathB.moveTo(pts[4]);
4694         pathB.cubicTo(pts[5], pts[6], pts[7]);
4695         pathB.close();
4696         bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4708     SkPath path, pathB;
4713     pathB.setFillType(SkPath::kWinding_FillType);
4714     pathB.moveTo(1, 2);
4715     pathB.cubicTo(7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f, 2, 6);
4716     pathB.close();
4719     CubicPathToQuads(pathB, &qPathB);
4724     SkPath path, pathB;
4729     pathB.setFillType(SkPath::kWinding_FillType);
4730     pathB.moveTo(0, 4);
4731     pathB.cubicTo(2.5f, 4, 3, 9, 3, 4);
4732     pathB.close();
4733     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4737     SkPath path, pathB;
4742     pathB.setFillType(SkPath::kWinding_FillType);
4743     pathB.moveTo(0, 4);
4744     pathB.cubicTo(2.5f, 4, 3, 10, 3, 4);
4745     pathB.close();
4746     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4750     SkPath path, pathB;
4755     pathB.setFillType(SkPath::kWinding_FillType);
4756     pathB.moveTo(1, 4);
4757     pathB.cubicTo(2.66666675f, 4, 3, 8, 3, 4);
4758     pathB.close();
4759     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4763     SkPath path, pathB;
4768     pathB.setFillType(SkPath::kWinding_FillType);
4769     pathB.moveTo(1, 4);
4770     pathB.cubicTo(1.83333337f, 4, 2, 5.33333349f, 2, 4);
4771     pathB.close();
4772     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4776     SkPath path, pathB;
4781     pathB.setFillType(SkPath::kWinding_FillType);
4782     pathB.moveTo(2, 4);
4783     pathB.cubicTo(2.83333325f, 4, 3, 6, 3, 4);
4784     pathB.close();
4785     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4789     SkPath path, pathB;
4794     pathB.setFillType(SkPath::kWinding_FillType);
4795     pathB.moveTo(0, 5);
4796     pathB.cubicTo(2.5f, 5, 3, 10, 3, 5);
4797     pathB.close();
4798     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4802     SkPath path, pathB;
4807     pathB.setFillType(SkPath::kWinding_FillType);
4808     pathB.moveTo(0, 5);
4809     pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4810     pathB.close();
4811     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4815     SkPath path, pathB;
4820     pathB.setFillType(SkPath::kWinding_FillType);
4821     pathB.moveTo(0, 5);
4822     pathB.cubicTo(2.5f, 5, 3, 11, 3, 5);
4823     pathB.close();
4826     CubicPathToQuads(pathB, &qPathB);
4831     SkPath path, pathB;
4836     pathB.setFillType(SkPath::kWinding_FillType);
4837     pathB.moveTo(0, 1);
4838     pathB.cubicTo(7.33333302f, 5.33333349f, -7, 7, 1, 5);
4839     pathB.close();
4840     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4844     SkPath path, pathB;
4849     pathB.setFillType(SkPath::kWinding_FillType);
4850     pathB.moveTo(0, 2);
4851     pathB.cubicTo(7.33333302f, 6.33333302f, -7, 8, 1, 6);
4852     pathB.close();
4853     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4857     SkPath path, pathB;
4862     pathB.setFillType(SkPath::kWinding_FillType);
4863     pathB.moveTo(1, 2);
4864     pathB.cubicTo(8.33333302f, 6.33333302f, -6, 8, 2, 6);
4865     pathB.close();
4866     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4872     SkPath path, pathB;
4877     pathB.setFillType(SkPath::kWinding_FillType);
4878     pathB.moveTo(0, 1);
4879     pathB.cubicTo(6, 5.83333302f, -4, 8, 2, 4);
4880     pathB.close();
4881     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4885     SkPath path, pathB;
4890     pathB.setFillType(SkPath::kWinding_FillType);
4891     pathB.moveTo(0, 1);
4892     pathB.cubicTo(9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f, 2, 6);
4893     pathB.close();
4894     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4898     SkPath path, pathB;
4903     pathB.setFillType(SkPath::kWinding_FillType);
4904     pathB.moveTo(1, 4);
4905     pathB.cubicTo(-0.166666687f, 2.66666675f, 1.66666675f, 2, 0, 2);
4906     pathB.close();
4907     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4911     SkPath path, pathB;
4916     pathB.setFillType(SkPath::kWinding_FillType);
4917     pathB.moveTo(1, 5);
4918     pathB.cubicTo(-0.166666687f, 3.66666675f, 1.66666675f, 3, 0, 3);
4919     pathB.close();
4920     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4924     SkPath path, pathB;
4929     pathB.setFillType(SkPath::kWinding_FillType);
4930     pathB.moveTo(2, 4);
4931     pathB.cubicTo(0.833333313f, 2.66666675f, 2.66666675f, 2, 1, 2);
4932     pathB.close();
4933     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4937     SkPath path, pathB;
4942     pathB.setFillType(SkPath::kWinding_FillType);
4943     pathB.moveTo(2, 5);
4944     pathB.cubicTo(0.833333313f, 3.66666675f, 2.66666675f, 3, 1, 3);
4945     pathB.close();
4946     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4950     SkPath path, pathB;
4955     pathB.setFillType(SkPath::kWinding_FillType);
4956     pathB.moveTo(3, 5);
4957     pathB.cubicTo(1.83333325f, 3.66666675f, 3.66666651f, 3, 2, 3);
4958     pathB.close();
4959     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4963     SkPath path, pathB;
4968     pathB.setFillType(SkPath::kWinding_FillType);
4969     pathB.moveTo(1, 4);
4970     pathB.cubicTo(0, 3, 1.66666675f, 2, 0, 2);
4971     pathB.close();
4972     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4976     SkPath path, pathB;
4981     pathB.setFillType(SkPath::kWinding_FillType);
4982     pathB.moveTo(1, 5);
4983     pathB.cubicTo(0, 4, 1.66666675f, 3, 0, 3);
4984     pathB.close();
4985     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4989     SkPath path, pathB;
4994     pathB.setFillType(SkPath::kWinding_FillType);
4995     pathB.moveTo(2, 4);
4996     pathB.cubicTo(0.99999994f, 3, 2.66666675f, 2, 1, 2);
4997     pathB.close();
4998     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5002     SkPath path, pathB;
5007     pathB.setFillType(SkPath::kWinding_FillType);
5008     pathB.moveTo(2, 5);
5009     pathB.cubicTo(0.99999994f, 4, 2.66666675f, 3, 1, 3);
5010     pathB.close();
5011     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5015     SkPath path, pathB;
5020     pathB.setFillType(SkPath::kWinding_FillType);
5021     pathB.moveTo(3, 5);
5022     pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5023     pathB.close();
5024     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5028     SkPath path, pathB;
5033     pathB.setFillType(SkPath::kWinding_FillType);
5034     pathB.moveTo(3, 5);
5035     pathB.cubicTo(2, 4, 3.66666651f, 3, 2, 3);
5036     pathB.close();
5039     CubicPathToQuads(pathB, &qPathB);
5047     SkPath path, pathB;
5052     pathB.setFillType(SkPath::kWinding_FillType);
5053     pathB.moveTo(1, 2);
5054     pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5055     pathB.close();
5056     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5060     SkPath path, pathB;
5065     pathB.setFillType(SkPath::kWinding_FillType);
5066     pathB.moveTo(1, 2);
5067     pathB.cubicTo(7.33333302f, 1.66666663f, -7.5f, 2, 0, 6);
5068     pathB.close();
5071     CubicPathToQuads(pathB, &qPathB);
5079     SkPath path, pathB;
5084     pathB.setFillType(SkPath::kWinding_FillType);
5085     pathB.moveTo(0, 3);
5086     pathB.cubicTo(1, 3, 1, 0, 4, 1);
5087     pathB.close();
5088     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5092     SkPath path, pathB;
5097     pathB.setFillType(SkPath::kWinding_FillType);
5098     pathB.moveTo(1, 5);
5099     pathB.cubicTo(-6.33333302f, 0.666666627f, 8, -1, 0, 1);
5100     pathB.close();
5101     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5105     SkPath path, pathB;
5110     pathB.setFillType(SkPath::kWinding_FillType);
5111     pathB.moveTo(1, 6);
5112     pathB.cubicTo(-6.33333302f, 1.66666663f, 8, 0, 0, 2);
5113     pathB.close();
5114     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5118     SkPath path, pathB;
5123     pathB.setFillType(SkPath::kWinding_FillType);
5124     pathB.moveTo(2, 4);
5125     pathB.cubicTo(-4, -0.833333254f, 6, -3, 0, 1);
5126     pathB.close();
5127     testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5131     SkPath path, pathB;
5136     pathB.setFillType(SkPath::kWinding_FillType);
5137     pathB.moveTo(1, 3);
5138     pathB.cubicTo(2, 6, 4, 3, 5, 2);
5139     pathB.close();
5140     testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5144     SkPath path, pathB;
5149     pathB.setFillType(SkPath::kWinding_FillType);
5150     pathB.moveTo(3, 4);
5151     pathB.cubicTo(2, 5, 3, 1, 6, 2);
5152     pathB.close();
5153     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5530     SkPath pathB;
5531     pathB.addRect(0,0, 300,16);
5532     testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);