Lines Matching full:path
12 PathTest_Private(SkPath* path)
13 : fPath(path) {}
22 static void path_edit(const SkPoint& from, const SkPoint& to, SkPath* path) {
23 PathTest_Private testPath(path);
24 for (int index = 0; index < path->countPoints(); ++index) {
25 if (SkDPoint::ApproximatelyEqual(path->getPoint(index), from)) {
33 SkPath path, pathB;
34 path.setFillType(SkPath::kWinding_FillType);
35 path.moveTo(0,1);
36 path.cubicTo(0,2, 1,0, 1,0);
37 path.close();
42 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
46 SkPath path, pathB;
47 path.setFillType(SkPath::kWinding_FillType);
48 path.moveTo(0,2);
49 path.cubicTo(0,1, 1,0, 1,0);
50 path.close();
55 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
59 SkPath path, pathB;
60 path.setFillType(SkPath::kWinding_FillType);
61 path.moveTo(0,1);
62 path.cubicTo(2,3, 1,0, 1,0);
63 path.close();
68 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
72 SkPath path, pathB;
73 path.setFillType(SkPath::kWinding_FillType);
74 path.moveTo(0,1);
75 path.cubicTo(0,2, 1,0, 2,0);
76 path.close();
81 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
85 SkPath path, pathB;
86 path.setFillType(SkPath::kWinding_FillType);
87 path.moveTo(0,1);
88 path.cubicTo(0,6, 1,0, 3,0);
89 path.close();
94 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
98 SkPath path, pathB;
99 path.setFillType(SkPath::kWinding_FillType);
100 path.moveTo(0,1);
101 path.cubicTo(3,4, 1,0, 3,0);
102 path.close();
107 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
111 SkPath path, pathB;
112 path.setFillType(SkPath::kWinding_FillType);
113 path.moveTo(0,1);
114 path.cubicTo(0,5, 1,0, 4,0);
115 path.close();
120 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
124 SkPath path, pathB;
125 path.setFillType(SkPath::kWinding_FillType);
126 path.moveTo(0,1);
127 path.cubicTo(1,6, 1,0, 2,1);
128 path.close();
133 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
137 SkPath path, pathB;
138 path.setFillType(SkPath::kWinding_FillType);
139 path.moveTo(0,1);
140 path.quadTo(1,6, 1.5f,1);
141 path.quadTo(1.5f,0.5f, 2,1);
142 path.close();
148 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
152 SkPath path, pathB;
153 path.setFillType(SkPath::kWinding_FillType);
154 path.moveTo(0,1);
155 path.lineTo(1,6);
156 path.lineTo(1.5f,1);
157 path.lineTo(1.8f,0.8f);
158 path.lineTo(2,1);
159 path.close();
167 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
171 SkPath path, pathB;
172 path.setFillType(SkPath::kWinding_FillType);
173 path.moveTo(0,1);
174 path.cubicTo(1,2, 1,0, 2,1);
175 path.close();
180 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
184 SkPath path, pathB;
185 path.setFillType(SkPath::kWinding_FillType);
186 path.moveTo(0,1);
187 path.cubicTo(1,3, 1,0, 4,1);
188 path.close();
193 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
197 SkPath path, pathB;
198 path.setFillType(SkPath::kWinding_FillType);
199 path.moveTo(0,1);
200 path.cubicTo(3,4, 1,0, 5,1);
201 path.close();
206 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
210 SkPath path, pathB;
211 path.setFillType(SkPath::kWinding_FillType);
212 path.moveTo(0,1);
213 path.cubicTo(1,6, 1,0, 1,0);
214 path.close();
219 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
223 SkPath path, pathB;
224 path.setFillType(SkPath::kWinding_FillType);
225 path.moveTo(0,1);
226 path.cubicTo(4,5, 1,0, 5,3);
227 path.close();
232 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
236 SkPath path, pathB;
237 path.setFillType(SkPath::kWinding_FillType);
238 path.moveTo(0,1);
239 path.cubicTo(0,2, 2,0, 2,1);
240 path.close();
245 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
249 SkPath path, pathB;
250 path.setFillType(SkPath::kWinding_FillType);
251 path.moveTo(0,1);
252 path.cubicTo(3,6, 2,0, 2,1);
253 path.close();
258 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
262 SkPath path, pathB;
263 path.setFillType(SkPath::kWinding_FillType);
264 path.moveTo(0,2);
265 path.cubicTo(0,1, 3,0, 1,0);
266 path.close();
271 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
275 SkPath path, pathB;
276 path.setFillType(SkPath::kWinding_FillType);
277 path.moveTo(0,2);
278 path.cubicTo(0,2, 4,0, 2,1);
279 path.close();
284 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
288 SkPath path, pathB;
289 path.setFillType(SkPath::kWinding_FillType);
290 path.moveTo(0,1);
291 path.cubicTo(3,5, 2,0, 2,1);
292 path.close();
297 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
301 SkPath path, pathB;
302 path.setFillType(SkPath::kWinding_FillType);
303 path.moveTo(0,2);
304 path.cubicTo(0,1, 2,1, 6,2);
305 path.close();
310 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
314 SkPath path, pathB;
315 path.setFillType(SkPath::kWinding_FillType);
316 path.moveTo(0,1);
317 path.cubicTo(0,1, 6,0, 2,1);
318 path.close();
323 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
327 SkPath path, pathB;
328 path.setFillType(SkPath::kWinding_FillType);
329 path.moveTo(0,1);
330 path.cubicTo(0,1, 2,1, 6,5);
331 path.close();
336 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
340 SkPath path, pathB;
341 path.setFillType(SkPath::kWinding_FillType);
342 path.moveTo(0,1);
343 path.cubicTo(2,3, 3,0, 2,1);
344 path.close();
349 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
353 SkPath path, pathB;
354 path.setFillType(SkPath::kWinding_FillType);
355 path.moveTo(0,1);
356 path.cubicTo(1,2, 4,0, 2,1);
357 path.close();
362 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
366 SkPath path, pathB;
367 path.setFillType(SkPath::kWinding_FillType);
368 path.moveTo(0,1);
369 path.cubicTo(1,2, 2,0, 3,2);
370 path.close();
375 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
435 SkPath path, pathB;
436 path.setFillType(SkPath::kWinding_FillType);
437 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
438 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
442 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
446 SkPath path, pathB;
447 path.setFillType(SkPath::kWinding_FillType);
448 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
449 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
453 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
457 SkPath path, pathB;
458 path.setFillType(SkPath::kWinding_FillType);
459 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
460 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
464 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
468 SkPath path, pathB;
469 path.setFillType(SkPath::kWinding_FillType);
470 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
471 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
475 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
479 SkPath path, pathB;
480 path.setFillType(SkPath::kWinding_FillType);
481 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
482 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
486 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
490 SkPath path, pathB;
491 path.setFillType(SkPath::kEvenOdd_FillType);
492 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
493 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
497 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
501 SkPath path, pathB;
502 path.setFillType(SkPath::kEvenOdd_FillType);
503 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
504 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
508 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
512 SkPath path, pathB;
513 path.setFillType(SkPath::kEvenOdd_FillType);
514 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
515 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
519 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
523 SkPath path, pathB;
524 path.setFillType(SkPath::kEvenOdd_FillType);
525 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
526 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
530 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
534 SkPath path, pathB;
535 path.addRect(0, 0, 640, 480);
539 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
542 SkPath path, pathB;
543 path.setFillType(SkPath::kWinding_FillType);
544 path.moveTo(0,1);
545 path.cubicTo(2,4, 5,0, 3,2);
546 path.close();
551 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
555 SkPath path, pathB;
556 path.setFillType(SkPath::kWinding_FillType);
557 path.moveTo(0,1);
558 path.cubicTo(3,4, 4,0, 3,2);
559 path.close();
564 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
568 SkPath path, pathB;
569 path.setFillType(SkPath::kWinding_FillType);
570 path.moveTo(0,1);
571 path.cubicTo(3,6, 1,0, 5,2);
572 path.close();
577 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
581 SkPath path, pathB;
582 path.setFillType(SkPath::kWinding_FillType);
583 path.moveTo(0,1);
584 path.cubicTo(1,4, 6,0, 3,2);
585 path.close();
590 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
594 SkPath path, pathB;
595 path.setFillType(SkPath::kWinding_FillType);
596 path.moveTo(0,1);
597 path.cubicTo(2,5, 6,0, 4,2);
598 path.close();
603 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
607 SkPath path, pathB;
608 path.setFillType(SkPath::kWinding_FillType);
609 path.moveTo(0,1);
610 path.cubicTo(2,5, 6,0, 5,3);
611 path.close();
616 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
620 SkPath path, pathB;
621 path.setFillType(SkPath::kWinding_FillType);
622 path.moveTo(0,2);
623 path.cubicTo(0,3, 2,1, 4,0);
624 path.close();
629 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
633 SkPath path, pathB;
634 path.setFillType(SkPath::kWinding_FillType);
635 path.moveTo(0,2);
636 path.cubicTo(0,3, 2,1, 4,0);
637 path.close();
642 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
646 SkPath path, pathB;
647 path.setFillType(SkPath::kWinding_FillType);
648 path.moveTo(0,2);
649 path.cubicTo(0,3, 2,1, 4,0);
650 path.close();
655 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
659 SkPath path, pathB;
660 path.setFillType(SkPath::kWinding_FillType);
661 path.moveTo(0,1);
662 path.cubicTo(1,2, 6,0, 3,1);
663 path.close();
668 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
672 SkPath path, pathB;
673 path.setFillType(SkPath::kWinding_FillType);
674 path.moveTo(0,1);
675 path.cubicTo(1,2, 6,0, 3,1);
676 path.close();
681 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
685 SkPath path, pathB;
686 path.setFillType(SkPath::kWinding_FillType);
687 path.moveTo(0,1);
688 path.cubicTo(3,5, 2,1, 3,1);
689 path.close();
694 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
698 SkPath path, pathB;
699 path.setFillType(SkPath::kWinding_FillType);
700 path.moveTo(0,1);
701 path.cubicTo(1,5, 2,1, 4,0);
702 path.close();
707 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
711 SkPath path, pathB;
712 path.setFillType(SkPath::kWinding_FillType);
713 path.moveTo(0,1);
714 path.cubicTo(1,6, 2,0, 5,1);
715 path.close();
720 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
724 SkPath path, pathB;
725 path.setFillType(SkPath::kWinding_FillType);
726 path.moveTo(0,1);
727 path.cubicTo(2,6, 6,1, 4,3);
728 path.close();
733 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
737 SkPath path, pathB;
738 path.setFillType(SkPath::kWinding_FillType);
739 path.moveTo(0,1);
740 path.cubicTo(0,6, 3,2, 4,1);
741 path.close();
746 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
750 SkPath path, pathB;
751 path.setFillType(SkPath::kWinding_FillType);
752 path.moveTo(0,1);
753 path.cubicTo(2,3, 5,1, 4,3);
754 path.close();
759 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
763 SkPath path, pathB;
764 path.setFillType(SkPath::kWinding_FillType);
765 path.moveTo(0,1);
766 path.cubicTo(1,5, 3,2, 4,2);
767 path.close();
772 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
776 SkPath path, pathB;
777 path.setFillType(SkPath::kWinding_FillType);
778 path.moveTo(0,1);
779 path.cubicTo(2,6, 4,3, 6,4);
780 path.close();
785 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
789 SkPath path, pathB;
790 path.setFillType(SkPath::kWinding_FillType);
791 path.moveTo(0,1);
792 path.cubicTo(1,2, 6,5, 5,4);
793 path.close();
798 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
802 SkPath path, pathB;
803 path.setFillType(SkPath::kWinding_FillType);
804 path.moveTo(0,2);
805 path.cubicTo(1,2, 4,0, 3,1);
806 path.close();
811 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
815 SkPath path, pathB;
816 path.setFillType(SkPath::kWinding_FillType);
817 path.moveTo(0,2);
818 path.cubicTo(3,6, 4,0, 3,2);
819 path.close();
824 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
828 SkPath path, pathB;
829 path.setFillType(SkPath::kWinding_FillType);
830 path.moveTo(0,2);
831 path.cubicTo(2,4, 4,0, 3,2);
832 path.close();
837 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
841 SkPath path, pathB;
842 path.setFillType(SkPath::kWinding_FillType);
843 path.moveTo(0,2);
844 path.cubicTo(3,5, 5,0, 4,2);
845 path.close();
850 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
854 SkPath path, pathB;
855 path.setFillType(SkPath::kWinding_FillType);
856 path.moveTo(0,1);
857 path.cubicTo(1,6, 6,2, 5,4);
858 path.close();
863 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
867 SkPath path, pathB;
868 path.setFillType(SkPath::kWinding_FillType);
869 path.moveTo(0,2);
870 path.cubicTo(2,3, 5,1, 3,2);
871 path.close();
876 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
880 SkPath path, pathB;
881 path.setFillType(SkPath::kWinding_FillType);
882 path.moveTo(0,2);
883 path.cubicTo(1,5, 3,2, 4,1);
884 path.close();
889 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
893 SkPath path, pathB;
894 path.setFillType(SkPath::kWinding_FillType);
895 path.moveTo(0,3);
896 path.cubicTo(1,6, 5,0, 5,1);
897 path.close();
902 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
906 SkPath path, pathB;
907 path.setFillType(SkPath::kWinding_FillType);
908 path.moveTo(0,3);
909 path.cubicTo(1,2, 4,1, 6,0);
910 path.close();
915 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
919 SkPath path, pathB;
920 path.setFillType(SkPath::kWinding_FillType);
921 path.moveTo(0,2);
922 path.cubicTo(1,2, 5,4, 4,3);
923 path.close();
928 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
932 SkPath path, pathB;
933 path.setFillType(SkPath::kWinding_FillType);
934 path.moveTo(0,3);
935 path.cubicTo(1,2, 5,3, 2,1);
936 path.close();
941 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
945 SkPath path, pathB;
946 path.setFillType(SkPath::kWinding_FillType);
947 path.moveTo(0,4);
948 path.cubicTo(1,3, 5,4, 4,2);
949 path.close();
954 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
958 SkPath path, pathB;
959 path.setFillType(SkPath::kWinding_FillType);
960 path.moveTo(0,5);
961 path.cubicTo(1,3, 3,2, 5,0);
962 path.close();
967 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
971 SkPath path, pathB;
972 path.setFillType(SkPath::kWinding_FillType);
973 path.moveTo(0,1);
974 path.cubicTo(2,6, 5,0, 2,1);
975 path.close();
980 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
984 SkPath path, pathB;
985 path.setFillType(SkPath::kWinding_FillType);
986 path.moveTo(0,5);
987 path.cubicTo(0,5, 5,4, 6,4);
988 path.close();
993 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
997 SkPath path, pathB;
998 path.setFillType(SkPath::kWinding_FillType);
999 path.moveTo(0,5);
1000 path.cubicTo(3,4, 6,5, 5,3);
1001 path.close();
1006 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1010 SkPath path, pathB;
1011 path.setFillType(SkPath::kWinding_FillType);
1012 path.moveTo(0,1);
1013 path.cubicTo(5,6, 4,0, 4,1);
1014 path.close();
1019 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1023 SkPath path, pathB;
1024 path.setFillType(SkPath::kWinding_FillType);
1025 path.moveTo(0,2);
1026 path.cubicTo(4,6, 6,0, 5,2);
1027 path.close();
1032 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1036 SkPath path, pathB;
1037 path.setFillType(SkPath::kWinding_FillType);
1038 path.moveTo(1,2);
1039 path.cubicTo(0,5, 3,2, 6,1);
1040 path.close();
1045 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1049 SkPath path, pathB;
1050 path.setFillType(SkPath::kWinding_FillType);
1051 path.moveTo(1,3);
1052 path.cubicTo(5,6, 5,3, 5,4);
1053 path.close();
1058 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1062 SkPath path, pathB;
1063 path.setFillType(SkPath::kWinding_FillType);
1064 path.moveTo(2,3);
1065 path.cubicTo(0,4, 3,2, 5,3);
1066 path.close();
1071 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1075 SkPath path, pathB;
1076 path.moveTo(0,1);
1077 path.cubicTo(0,1, 1,0, 3,0);
1078 path.lineTo(0,1);
1079 path.close();
1084 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1088 SkPath path, pathB;
1089 path.moveTo(0,1);
1090 path.cubicTo(1,5, 1,0, 1,0);
1091 path.lineTo(0,1);
1092 path.close();
1097 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1101 SkPath path, pathB;
1102 path.moveTo(0,1);
1103 path.cubicTo(0,1, 1,0, 3,0);
1104 path.lineTo(0,1);
1105 path.close();
1110 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1114 SkPath path, pathB;
1115 path.setFillType(SkPath::kWinding_FillType);
1116 path.moveTo(0,1);
1117 path.cubicTo(2,6, 4,2, 5,3);
1118 path.close();
1123 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1127 SkPath path, pathB;
1128 path.moveTo(3,5);
1129 path.cubicTo(1,6, 5,0, 3,1);
1130 path.lineTo(3,5);
1131 path.close();
1136 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1140 SkPath path, pathB;
1141 path.moveTo(0,5);
1142 path.cubicTo(4,5, 4,1, 5,0);
1143 path.close();
1147 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1151 SkPath path, pathB;
1152 path.moveTo(1,3);
1153 path.cubicTo(0,1, 3,1, 2,0);
1154 path.close();
1158 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1195 SkPath path;
1196 path.setFillType(SkPath::kInverseEvenOdd_FillType);
1198 testPathOp(reporter, path, paths[index], ops[index], filename);
1199 Op(path, paths[index], ops[index], &path);
1204 SkPath path;
1205 path.setFillType(SkPath::kEvenOdd_FillType);
1206 path.moveTo(189,7);
1207 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1208 path.lineTo(243,4);
1209 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1210 path.lineTo(246,21);
1211 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1212 path.lineTo(192,24);
1213 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1214 path.lineTo(189,7);
1215 path.close();
1216 path.moveTo(191,8);
1217 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1218 path.lineTo(242,6);
1219 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1220 path.lineTo(244,20);
1221 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1222 path.lineTo(193,22);
1223 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1224 path.lineTo(191,8);
1225 path.close();
1234 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1238 SkPath path;
1239 path.setFillType(SkPath::kEvenOdd_FillType);
1240 path.moveTo(253.000000f, 11757.0000f);
1241 path.lineTo(253.000000f, 222.000000f);
1242 path.lineTo(823.000000f, 222.000000f);
1243 path.lineTo(823.000000f, 11757.0000f);
1244 path.lineTo(253.000000f, 11757.0000f);
1245 path.close();
1254 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1258 SkPath path;
1259 path.setFillType(SkPath::kEvenOdd_FillType);
1260 path.moveTo(717.000000f, 507.000000f);
1261 path.lineTo(717.000000f, 425.000000f);
1262 path.lineTo(973.000000f, 425.000000f);
1263 path.lineTo(973.000000f, 507.000000f);
1264 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1265 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1266 path.lineTo(720.000000f, 510.000000f);
1267 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1268 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1269 path.close();
1270 path.moveTo(719.000000f, 426.000000f);
1271 path.lineTo(971.000000f, 426.000000f);
1272 path.lineTo(971.000000f, 506.000000f);
1273 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1274 path.lineTo(721.000000f, 508.000000f);
1275 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1276 path.lineTo(719.000000f, 426.000000f);
1277 path.close();
1286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1290 SkPath path;
1291 path.setFillType(SkPath::kEvenOdd_FillType);
1292 path.moveTo(230.756805f, 591.756775f);
1293 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1294 path.lineTo(300.000000f, 590.000000f);
1295 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1296 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1297 path.lineTo(306.000000f, 617.000000f);
1298 path.lineTo(229.000000f, 617.000000f);
1299 path.lineTo(229.000000f, 596.000000f);
1300 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1301 path.close();
1302 path.moveTo(231.000000f, 597.000000f);
1303 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1304 path.lineTo(299.000000f, 592.000000f);
1305 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1306 path.lineTo(304.000000f, 616.000000f);
1307 path.lineTo(231.000000f, 616.000000f);
1308 path.lineTo(231.000000f, 597.000000f);
1309 path.close();
1318 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1322 SkPath path;
1323 path.setFillType(SkPath::kEvenOdd_FillType);
1324 path.moveTo(18.0000000f, 226.000000f);
1325 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1326 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1327 path.lineTo(10.0000000f, 253.000000f);
1328 path.lineTo(1247.00000f, 253.000000f);
1329 path.lineTo(1247.00000f, 234.000000f);
1330 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1331 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1332 path.lineTo(18.0000000f, 226.000000f);
1333 path.close();
1344 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1348 SkPath path, pathB;
1349 path.setFillType(SkPath::kWinding_FillType);
1350 path.moveTo(0,1);
1351 path.cubicTo(0,5, 4,0, 5,0);
1352 path.close();
1357 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1361 SkPath path, pathB;
1362 path.setFillType(SkPath::kWinding_FillType);
1363 path.moveTo(0,1);
1364 path.cubicTo(0,5, 4,1, 6,4);
1365 path.close();
1370 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1374 SkPath path, pathB;
1375 path.setFillType(SkPath::kWinding_FillType);
1376 path.moveTo(0,1);
1377 path.cubicTo(0,5, 5,2, 5,4);
1378 path.close();
1383 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1387 SkPath path, pathB;
1388 path.setFillType(SkPath::kWinding_FillType);
1389 path.moveTo(0,1);
1390 path.cubicTo(3,4, 4,0, 6,4);
1391 path.lineTo(0,1);
1392 path.close();
1398 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1402 SkPath path, pathB;
1403 path.setFillType(SkPath::kWinding_FillType);
1404 path.moveTo(0,1);
1405 path.cubicTo(1,5, 5,1, 5,1);
1406 path.lineTo(0,1);
1407 path.close();
1413 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1417 SkPath path, pathB;
1418 path.setFillType(SkPath::kWinding_FillType);
1419 path.moveTo(0,1);
1420 path.cubicTo(0,4, 5,1, 6,4);
1421 path.lineTo(0,1);
1422 path.close();
1428 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1432 SkPath path, pathB;
1433 path.setFillType(SkPath::kWinding_FillType);
1434 path.moveTo(0,1);
1435 path.cubicTo(0,2, 2,0, 5,3);
1436 path.close();
1441 testPathOp(reporter, path
1445 SkPath path, pathB;
1446 path.setFillType(SkPath::kEvenOdd_FillType);
1447 path.moveTo(0,1);
1448 path.cubicTo(1,3, 2,0, 3,2);
1449 path.lineTo(0,1);
1450 path.close();
1456 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1460 SkPath path, pathB;
1461 path.setFillType(SkPath::kEvenOdd_FillType);
1462 path.moveTo(1,6);
1463 path.cubicTo(1,6, 5,0, 6,1);
1464 path.lineTo(1,6);
1465 path.close();
1471 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
1475 SkPath path, pathB;
1476 path.setFillType(SkPath::kWinding_FillType);
1477 path.moveTo(0,1);
1478 path.cubicTo(1,3, 1,0, 6,4);
1479 path.close();
1484 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1488 SkPath path, pathB;
1489 path.setFillType(SkPath::kWinding_FillType);
1490 path.moveTo(0,1);
1491 path.cubicTo(2,3, 2,1, 4,3);
1492 path.lineTo(0,1);
1493 path.close();
1499 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1503 SkPath path, pathB;
1504 path.setFillType(SkPath::kWinding_FillType);
1505 path.moveTo(0,1);
1506 path.cubicTo(4,6, 4,3, 5,4);
1507 path.close();
1512 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1516 SkPath path, pathB;
1517 path.setFillType(SkPath::kEvenOdd_FillType);
1518 path.moveTo(0,1);
1519 path.cubicTo(2,3, 5,2, 3,0);
1520 path.lineTo(0,1);
1521 path.close();
1527 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1531 SkPath path, pathB;
1532 path.setFillType(SkPath::kWinding_FillType);
1533 path.moveTo(0,1);
1534 path.cubicTo(0,3, 2,1, 4,1);
1535 path.lineTo(0,1);
1536 path.close();
1542 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1546 SkPath path, pathB;
1547 path.setFillType(SkPath::kWinding_FillType);
1548 path.moveTo(0,4);
1549 path.cubicTo(2,3, 6,3, 3,2);
1550 path.close();
1555 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1559 SkPath path;
1560 path.setFillType(SkPath::kEvenOdd_FillType);
1561 path.moveTo(1126.17114f, 877.171204f);
1562 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1563 path.lineTo(1243.00000f, 876.000000f);
1564 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1565 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1566 path.lineTo(1247.00000f, 907.000000f);
1567 path.lineTo(1246.00000f, 907.000000f);
1568 path.lineTo(1246.00000f, 880.000000f);
1569 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1570 path.lineTo(1129.00000f, 877.000000f);
1571 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1572 path.lineTo(1126.00000f, 907.000000f);
1573 path.lineTo(1125.00000f, 907.000000f);
1574 path.lineTo(1125.00000f, 880.000000f);
1575 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1576 path.close();
1585 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1589 SkPath path;
1590 path.setFillType(SkPath::kEvenOdd_FillType);
1591 path.moveTo(134.000000f, 11414.0000f);
1592 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1593 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1594 path.lineTo(806.000000f, 11419.0000f);
1595 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1596 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1597 path.lineTo(134.000000f, 11414.0000f);
1598 path.close();
1611 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1615 SkPath path;
1616 path.setFillType(SkPath::kEvenOdd_FillType);
1617 path.moveTo(157.464005f, 670.463989f);
1618 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1619 path.lineTo(248.000000f, 669.000000f);
1620 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1621 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1622 path.lineTo(253.000000f, 706.000000f);
1623 path.lineTo(251.000000f, 706.000000f);
1624 path.lineTo(251.000000f, 675.000000f);
1625 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1626 path.lineTo(162.000000f, 671.000000f);
1627 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1628 path.lineTo(158.000000f, 706.000000f);
1629 path.lineTo(156.000000f, 706.000000f);
1630 path.lineTo(156.000000f, 674.000000f);
1631 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1632 path.close();
1641 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1645 SkPath path;
1646 path.setFillType(SkPath::kEvenOdd_FillType);
1647 path.moveTo(161.000000f, 925.000000f);
1648 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1649 path.lineTo(158.000000f, 926.000000f);
1650 path.lineTo(1108.00000f, 926.000000f);
1651 path.lineTo(1108.00000f, 925.999634f);
1652 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1653 path.lineTo(161.000000f, 925.000000f);
1654 path.close();
1667 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1671 SkPath path;
1672 path.setFillType(SkPath::kEvenOdd_FillType);
1673 path.moveTo(286.695129f, 291.000000f);
1674 path.lineTo(229.304855f, 561.000000f);
1675 path.lineTo(979.304871f, 561.000000f);
1676 path.lineTo(1036.69507f, 291.000000f);
1677 path.lineTo(286.695129f, 291.000000f);
1678 path.close();
1691 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1695 SkPath path;
1696 path.setFillType(SkPath::kEvenOdd_FillType);
1697 path.moveTo(968.000000f, 14.0000000f);
1698 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1699 path.lineTo(963.000000f, 32.0000000f);
1700 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1701 path.lineTo(1034.00000f, 37.0000000f);
1702 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1703 path.lineTo(1039.00000f, 19.0000000f);
1704 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1705 path.lineTo(968.000000f, 14.0000000f);
1706 path.close();
1719 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1723 SkPath path;
1724 path.setFillType(SkPath::kEvenOdd_FillType);
1725 path.moveTo(708.099182f, 7.09919119f);
1726 path.lineTo(708.099182f, 7.09920025f);
1727 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1728 path.lineTo(704.000000f, 33.0000000f);
1729 path.lineTo(705.000000f, 33.0000000f);
1730 path.lineTo(705.000000f, 17.0000000f);
1731 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1732 path.lineTo(708.099182f, 7.09919119f);
1733 path.close();
1740 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1744 SkPath path;
1745 path.setFillType(SkPath::kEvenOdd_FillType);
1746 path.moveTo(1099.82886f, 7.17117119f);
1747 path.lineTo(1099.12134f, 7.87867832f);
1748 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1749 path.lineTo(1100.00000f, 28.0000000f);
1750 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1751 path.lineTo(1088.00000f, 31.0000000f);
1752 path.lineTo(1088.00000f, 32.0000000f);
1753 path.lineTo(1097.00000f, 32.0000000f);
1754 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1755 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1756 path.lineTo(1101.00000f, 10.0000000f);
1757 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1758 path.lineTo(1099.82886f, 7.17117119f);
1759 path.close();
1766 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1770 SkPath path;
1771 path.setFillType(SkPath::kEvenOdd_FillType);
1772 path.moveTo(1037.17114f, 7.17119980f);
1773 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1774 path.lineTo(1074.00000f, 6.00000000f);
1775 path.lineTo(1074.00000f, 32.0000000f);
1776 path.lineTo(1040.00000f, 32.0000000f);
1777 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1778 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1779 path.lineTo(1036.00000f, 10.0000000f);
1780 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1781 path.close();
1782 path.moveTo(1037.00000f, 10.0000000f);
1783 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1784 path.lineTo(1073.00000f, 7.00000000f);
1785 path.lineTo(1073.00000f, 31.0000000f);
1786 path.lineTo(1040.00000f, 31.0000000f);
1787 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1788 path.lineTo(1037.00000f, 10.0000000f);
1789 path.close();
1796 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1800 SkPath path;
1801 path.setFillType(SkPath::kWinding_FillType);
1802 path.moveTo(0,1);
1803 path.cubicTo(1,6, 1,0, 6,2);
1804 path.close();
1810 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
1814 SkPath path;
1815 path.setFillType(SkPath::kEvenOdd_FillType);
1816 path.moveTo(96, 122);
1817 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1818 path.lineTo(94.1715698f, 125.17157f);
1819 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1820 path.lineTo(257, 124);
1821 path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1822 path
1823 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1824 path.lineTo(96, 122);
1825 path.close();
1838 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
1980 SkPath path, pathB;
1981 path.setFillType(SkPath::kWinding_FillType);
1982 path.moveTo(3, 4);
1983 path.cubicTo(1, 5, 4, 3, 6, 4);
1984 path.close();
1989 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2023 SkPath path, pathB;
2024 path.setFillType(SkPath::kWinding_FillType);
2025 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2026 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
2030 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2034 SkPath path, pathB;
2035 path.setFillType(SkPath::kEvenOdd_FillType);
2036 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2037 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
2041 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2045 SkPath path, pathB;
2046 path.setFillType(SkPath::kEvenOdd_FillType);
2047 path.moveTo(0, 0);
2048 path.lineTo(3, 0);
2049 path.lineTo(3, 3);
2050 path.lineTo(0, 3);
2051 path.close();
2052 path.moveTo(2, 2);
2053 path.lineTo(3, 2);
2054 path.lineTo(3, 3);
2055 path.lineTo(2, 3);
2056 path.close();
2068 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
2123 SkPath path;
2124 path.setFillType(SkPath::kEvenOdd_FillType);
2125 path.moveTo(1173, 284);
2126 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2127 path.lineTo(1174, 123.999496f);
2128 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2129 path.lineTo(1173, 284);
2130 path.close();
2143 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2147 SkPath path;
2148 path.setFillType(SkPath::kEvenOdd_FillType);
2149 path.moveTo(0,0);
2150 path.lineTo(3,0);
2151 path.lineTo(3,2);
2152 path.lineTo(1,2);
2153 path.lineTo(1,1);
2154 path.lineTo(2,1);
2155 path.lineTo(2,3);
2156 path.lineTo(0,3);
2157 path.close();
2165 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2169 SkPath path;
2170 path.setFillType(SkPath::kEvenOdd_FillType);
2171 path.moveTo(0,0);
2172 path.lineTo(3,0);
2173 path.lineTo(3,2);
2174 path.lineTo(1,2);
2175 path.lineTo(1,1);
2176 path.lineTo(2,1);
2177 path.lineTo(2,3);
2178 path.lineTo(0,3);
2179 path.close();
2187 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2191 SkPath path, pathB;
2192 path.setFillType(SkPath::kWinding_FillType);
2193 path.moveTo(0, 4);
2194 path.cubicTo(3, 4, 6, 2, 5, 2);
2195 path.close();
2200 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2204 SkPath path
2205 path.setFillType(SkPath::kWinding_FillType);
2206 path.moveTo(0,1);
2207 path.cubicTo(0,2, 2,0, 6,4);
2208 path.close();
2213 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2217 SkPath path, pathB;
2218 path.setFillType(SkPath::kWinding_FillType);
2219 path.moveTo(0,1);
2220 path.cubicTo(2,5, 5,0, 6,4);
2221 path.close();
2226 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2230 SkPath path, pathB;
2231 path.setFillType(SkPath::kWinding_FillType);
2232 path.moveTo(0, 3);
2233 path.cubicTo(1, 6, 5, 0, 6, 3);
2234 path.close();
2239 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2243 SkPath path, pathB;
2244 path.setFillType(SkPath::kEvenOdd_FillType);
2245 path.moveTo(0, 5);
2246 path.cubicTo(1, 2, 5, 2, 4, 1);
2247 path.close();
2252 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2256 SkPath path, pathB;
2257 path.setFillType(SkPath::kWinding_FillType);
2258 path.moveTo(1, 6);
2259 path.cubicTo(0, 3, 6, 3, 5, 0);
2260 path.close();
2265 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2269 SkPath path;
2270 path.setFillType(SkPath::kEvenOdd_FillType);
2271 path.moveTo(-1.24344979e-014f, 348);
2272 path.lineTo(258, 348);
2273 path.lineTo(258, 322);
2274 path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2275 path.quadTo(252.142136f, 312, 248, 312);
2276 path.lineTo(1.77635684e-015f, 312);
2277 path.lineTo(-1.24344979e-014f, 348);
2278 path.close();
2286 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2290 SkPath path;
2291 path.setFillType(SkPath::kEvenOdd_FillType);
2292 path.moveTo(1.99840144e-015f, 494);
2293 path.lineTo(97, 494);
2294 path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2295 path.quadTo(105, 489.313721f, 105, 486);
2296 path.lineTo(105, 425);
2297 path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2298 path.quadTo(100.313705f, 417, 97, 417);
2299 path.lineTo(2.22044605e-016f, 417);
2300 path.lineTo(1.99840144e-015f, 494);
2301 path.close();
2309 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2313 SkPath path;
2314 path.setFillType(SkPath::kEvenOdd_FillType);
2315 path.moveTo(670.537415f, 285);
2316 path.lineTo(670.387451f, 285);
2317 path.lineTo(596.315186f, 314.850708f);
2318 path.lineTo(626.19696f, 389);
2319 path.lineTo(626.346863f, 389);
2320 path.lineTo(700.419189f, 359.149261f);
2321 path.lineTo(670.537415f, 285);
2322 path.close();
2335 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2339 SkPath path;
2340 path.setFillType(SkPath::kEvenOdd_FillType);
2341 path.moveTo(1.45716772e-016f, 924.336121f);
2342 path.lineTo(-1.11022302e-016f, 920);
2343 path.lineTo(6, 920);
2344 path.lineTo(6, 926);
2345 path.lineTo(1.66389287f, 926);
2346 path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2347 path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2348 path.close();
2349 path.moveTo(1, 921);
2350 path.lineTo(5, 921);
2351 path.lineTo(5, 925);
2352 path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2353 path.close();
2360 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2364 SkPath path;
2365 path.setFillType(SkPath::kEvenOdd_FillType);
2366 path.moveTo(320.097229f, 628.573669f);
2367 path.lineTo(610.227173f, 85.7786865f);
2368 path.lineTo(946.652588f, 265.601807f);
2369 path.lineTo(656.522644f, 808.39679f);
2370 path.lineTo(320.097229f, 628.573669f);
2371 path.close();
2384 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2388 SkPath path;
2389 path.setFillType(SkPath::kEvenOdd_FillType);
2390 path.moveTo(0, 926);
2391 path.lineTo(0, 0);
2392 path.lineTo(1280, 0);
2393 path.lineTo(1280, 926);
2394 path.lineTo(0, 926);
2395 path.close();
2403 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2407 SkPath path;
2408 path.setFillType(SkPath::kEvenOdd_FillType);
2409 path.moveTo(205.605804f, 142.334625f);
2410 path.lineTo(254.665359f, 85.6058044f);
2411 path.lineTo(311.394196f, 134.665359f);
2412 path.lineTo(262.334625f, 191.39418f);
2413 path.lineTo(205.605804f, 142.334625f);
2414 path.close();
2427 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2431 SkPath path;
2432 path.setFillType(SkPath::kEvenOdd_FillType);
2433 path.moveTo(-4.4408921e-016f, 682.5f);
2434 path.lineTo(30.5f, 682.5f);
2435 path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2436 path.lineTo(34.5f, 486.5f);
2437 path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2438 path.lineTo(0, 482.5f);
2439 path.lineTo(-4.4408921e-016f, 682.5f);
2440 path.close();
2448 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2452 SkPath path;
2453 path.setFillType(SkPath::kEvenOdd_FillType);
2454 path.moveTo(324.071075f, 845.071045f);
2455 path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2456 path.lineTo(325, 842.127197f);
2457 path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2458 path.lineTo(324.071075f, 845.071045f);
2459 path.close();
2460 path.moveTo(323.363953f, 714.636047f);
2461 path.lineTo(324.071075f, 713.928955f);
2462 path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2463 path.lineTo(325, 716.872803f);
2464 path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2465 path.close();
2478 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2482 SkPath path, pathB;
2483 path.setFillType(SkPath::kWinding_FillType);
2484 path.moveTo(0, 1);
2485 path.cubicTo(2, 6, 4, 1, 5, 4);
2486 path.close();
2491 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2495 SkPath path, pathB;
2496 path.setFillType(SkPath::kWinding_FillType);
2497 path.moveTo(0, 1);
2498 path.cubicTo(1, 6, 4, 1, 4, 3);
2499 path.close();
2504 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
2508 SkPath path, pathB;
2509 path.setFillType(SkPath::kEvenOdd_FillType);
2510 path.moveTo(0, 3);
2511 path.cubicTo(2, 3, 5, 0, 5, 3);
2512 path.close();
2517 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2521 SkPath path;
2522 path.setFillType(SkPath::kEvenOdd_FillType);
2523 path.moveTo(333.292084f, 624.570984f);
2524 path.lineTo(614.229797f, 98.9735107f);
2525 path.lineTo(933.457764f, 269.604431f);
2526 path.lineTo(652.52002f, 795.201904f);
2527 path.lineTo(333.292084f, 624.570984f);
2528 path.close();
2541 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2545 SkPath path;
2546 path.setFillType(SkPath::kEvenOdd_FillType);
2547 path.moveTo(802, 367);
2548 path.lineTo(802, 324);
2549 path.lineTo(956, 324);
2550 path.lineTo(956, 371);
2551 path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2552 path.quadTo(953.071045f, 376, 951, 376);
2553 path.lineTo(811, 376);
2554 path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2555 path.close();
2566 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2570 SkPath path;
2571 path.setFillType(SkPath::kEvenOdd_FillType);
2572 path.moveTo(-2.220446e-018f, 483.5f);
2573 path.lineTo(0, 482.5f);
2574 path.lineTo(30.5f, 482.5f);
2575 path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2576 path.lineTo(34.5f, 678.5f);
2577 path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2578 path.lineTo(-4.4408921e-016f, 682.5f);
2579 path.lineTo(-4.41868766e-016f, 681.5f);
2580 path.lineTo(30.5f, 681.5f);
2581 path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2582 path.lineTo(33.5f, 486.5f);
2583 path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2584 path.lineTo(-2.220446e-018f, 483.5f);
2585 path.close();
2593 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2597 SkPath path;
2598 path.setFillType(SkPath::kEvenOdd_FillType);
2599 path.moveTo(1182.00037f, 926);
2600 path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2601 path.lineTo(938, 924);
2602 path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2603 path.lineTo(1182.00037f, 926);
2604 path.close();
2612 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2616 SkPath path;
2617 path.setFillType(SkPath::kEvenOdd_FillType);
2618 path.moveTo(925, 27);
2619 path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2620 path.lineTo(924, 55);
2621 path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2622 path.lineTo(1103, 56);
2623 path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2624 path.lineTo(1104, 28);
2625 path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2626 path.lineTo(925, 27);
2627 path.close();
2640 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2644 SkPath path;
2645 path.setFillType(SkPath::kEvenOdd_FillType);
2646 path.moveTo(190, 170);
2647 path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2648 path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2649 path.lineTo(370, 210);
2650 path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2651 path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2652 path.lineTo(190, 170);
2653 path.close();
2666 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2670 SkPath path;
2671 path.setFillType(SkPath::kEvenOdd_FillType);
2672 path.moveTo(47.8780937f, 58);
2673 path.lineTo(0, 58);
2674 path.lineTo(-8.65973959e-015f, 96.9914017f);
2675 path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2676 path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2677 path.close();
2690 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2694 SkPath path;
2695 path.setFillType(SkPath::kEvenOdd_FillType);
2696 path.moveTo(693.000488f, 926);
2697 path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2698 path.lineTo(578, 925);
2699 path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2700 path.lineTo(693.000488f, 926);
2701 path.close();
2709 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2713 SkPath path;
2714 path.setFillType(SkPath::kEvenOdd_FillType);
2715 path.moveTo(195, 785);
2716 path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2717 path.lineTo(67, 913);
2718 path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2719 path.lineTo(322, 926);
2720 path.lineTo(322, 896.048035f);
2721 path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2722 path.close();
2733 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2737 SkPath path;
2738 path.setFillType(SkPath::kEvenOdd_FillType);
2739 path.moveTo(945, 597);
2740 path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2741 path.quadTo(870, 640.93396f, 870, 672);
2742 path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2743 path.quadTo(913.93396f, 747, 945, 747);
2744 path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2745 path.quadTo(1020, 703.06604f, 1020, 672);
2746 path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2747 path.quadTo(976.06604f, 597, 945, 597);
2748 path.close();
2759 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2763 SkPath path;
2764 path.setFillType(SkPath::kEvenOdd_FillType);
2765 path.moveTo(0, 926);
2766 path.lineTo(0, 0);
2767 path.lineTo(1265, 0);
2768 path.lineTo(1265, 926);
2769 path.lineTo(0, 926);
2770 path.close();
2778 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2782 SkPath path;
2783 path.setFillType(SkPath::kEvenOdd_FillType);
2784 path.moveTo(883, 23);
2785 path.lineTo(883, 0);
2786 path.lineTo(1122.5f, 0);
2787 path.lineTo(1122.5f, 25.2136822f);
2788 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2789 path.quadTo(1120.07104f, 28, 1118, 28);
2790 path.lineTo(888, 28);
2791 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2792 path.quadTo(883, 25.0710678f, 883, 23);
2793 path.close();
2805 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2809 SkPath path;
2810 path.setFillType(SkPath::kEvenOdd_FillType);
2811 path.moveTo(883, 23);
2812 path.lineTo(883, 0);
2813 path.lineTo(1122.5f, 0);
2814 path.lineTo(1122.5f, 25.2136822f);
2815 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2816 path.quadTo(1120.07104f, 28, 1118, 28);
2817 path.lineTo(888, 28);
2818 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2819 path.quadTo(883, 25.0710678f, 883, 23);
2820 path.close();
2832 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2836 SkPath path;
2837 path.setFillType(SkPath::kEvenOdd_FillType);
2838 path.moveTo(896, 745.38678f);
2839 path.lineTo(896, 873.38678f);
2840 path.lineTo(922.567993f, 876.683716f);
2841 path.lineTo(922.567993f, 748.683716f);
2842 path.lineTo(896, 745.38678f);
2843 path.close();
2856 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2860 SkPath path;
2861 path.setFillType(SkPath::kEvenOdd_FillType);
2862 path.moveTo(1104, 453);
2863 path.lineTo(399, 453);
2864 path.lineTo(399, 657);
2865 path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2866 path.lineTo(1095, 666);
2867 path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2868 path.lineTo(1104, 453);
2869 path.close();
2879 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2883 SkPath path;
2884 path.setFillType(SkPath::kEvenOdd_FillType);
2885 path.moveTo(883, 23);
2886 path.lineTo(883, 0);
2887 path.lineTo(1122.5f, 0);
2888 path.lineTo(1122.5f, 25.2136822f);
2889 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2890 path.quadTo(1120.07104f, 28, 1118, 28);
2891 path.lineTo(888, 28);
2892 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2893 path.quadTo(883, 25.0710678f, 883, 23);
2894 path.close();
2906 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2910 SkPath path;
2911 path.setFillType(SkPath::kEvenOdd_FillType);
2912 path.moveTo(883, 23);
2913 path.lineTo(883, 0);
2914 path.lineTo(1122.5f, 0);
2915 path.lineTo(1122.5f, 25.2136822f);
2916 path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2917 path.quadTo(1120.07104f, 28, 1118, 28);
2918 path.lineTo(888, 28);
2919 path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2920 path.quadTo(883, 25.0710678f, 883, 23);
2921 path.close();
2933 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2937 SkPath path;
2938 path.setFillType(SkPath::kEvenOdd_FillType);
2939 path.moveTo(160.000488f, 918);
2940 path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2941 path.lineTo(94, 917);
2942 path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2943 path.lineTo(160.000488f, 918);
2944 path.close();
2952 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2956 SkPath path;
2957 path.setFillType(SkPath::kEvenOdd_FillType);
2958 path.moveTo(1138, 231);
2959 path.lineTo(1137, 243.625748f);
2960 path.lineTo(1137, 926);
2961 path.lineTo(1139, 926);
2962 path.lineTo(1139, 231);
2963 path.lineTo(1138, 231);
2964 path.close();
2971 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
2975 SkPath path, pathB;
2976 path.setFillType(SkPath::kEvenOdd_FillType);
2977 path.moveTo(0, 2);
2978 path.cubicTo(2, 3, 5, 1, 3, 2);
2979 path.close();
2984 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
2988 SkPath path, pathB;
2989 path.setFillType(SkPath::kEvenOdd_FillType);
2990 path.moveTo(1, 6);
2991 path.cubicTo(0, 3, 6, 3, 5, 0);
2992 path.close();
2997 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3001 SkPath path, pathB;
3002 path.setFillType(SkPath::kEvenOdd_FillType);
3003 path.moveTo(0, 2);
3004 path.cubicTo(0, 6, 2, 1, 2, 1);
3005 path.close();
3010 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3014 SkPath path, pathB;
3015 path.setFillType(SkPath::kEvenOdd_FillType);
3016 path.moveTo(0, 3);
3017 path.cubicTo(3, 6, 4, 1, 6, 3);
3018 path.close();
3023 testPathOp(reporter, path, pathB, kXOR_SkPathOp, filename);
3027 SkPath path, pathB;
3028 path.setFillType(SkPath::kWinding_FillType);
3029 path.moveTo(3,6);
3030 path.cubicTo(0,3, 6,5, 5,4);
3031 path.close();
3036 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3040 SkPath path, pathB;
3041 path.setFillType(SkPath::kWinding_FillType);
3042 path.moveTo(0,1);
3043 path.cubicTo(0,2, 2,1, 4,2);
3044 path.close();
3049 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3053 SkPath path, pathB;
3054 path.setFillType(SkPath::kWinding_FillType);
3055 path.moveTo(0, 1);
3056 path.cubicTo(2, 3, 2, 1, 5, 3);
3057 path.close();
3062 testPathOp(reporter, path
3066 SkPath path, pathB;
3067 path.setFillType(SkPath::kWinding_FillType);
3068 path.moveTo(0,1);
3069 path.cubicTo(1,2, 1,0, 3,0);
3070 path.close();
3075 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3079 SkPath path, pathB;
3080 path.setFillType(SkPath::kWinding_FillType);
3081 path.moveTo(0,1);
3082 path.cubicTo(1,5, 2,0, 2,1);
3083 path.close();
3088 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3092 SkPath path, pathB;
3093 path.setFillType(SkPath::kWinding_FillType);
3094 path.moveTo(0,1);
3095 path.cubicTo(0,6, 4,0, 6,1);
3096 path.close();
3101 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3105 SkPath path, pathB;
3106 path.setFillType(SkPath::kWinding_FillType);
3107 path.moveTo(0,1);
3108 path.cubicTo(0,4, 6,5, 2,0);
3109 path.close();
3114 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3118 SkPath path, pathB;
3119 path.setFillType(SkPath::kWinding_FillType);
3120 path.moveTo(0, 1);
3121 path.cubicTo(4, 6, 2, 1, 2, 0);
3122 path.close();
3127 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3131 SkPath path, pathB;
3132 path.setFillType(SkPath::kWinding_FillType);
3133 path.moveTo(0, 1);
3134 path.cubicTo(4, 6, 2, 1, 2, 0);
3135 path.close();
3140 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3144 SkPath path, pathB;
3145 path.setFillType(SkPath::kWinding_FillType);
3146 path.moveTo(0, 1);
3147 path.cubicTo(4, 6, 2, 1, 2, 0);
3148 path.close();
3153 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3157 SkPath path, pathB;
3158 path.setFillType(SkPath::kWinding_FillType);
3159 path.moveTo(0,1);
3160 path.cubicTo(4,5, 6,3, 5,4);
3161 path.close();
3166 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3170 SkPath path, pathB;
3171 path.setFillType(SkPath::kEvenOdd_FillType);
3172 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3173 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3177 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3181 SkPath path, pathB;
3182 path.setFillType(SkPath::kWinding_FillType);
3183 path.moveTo(1,4);
3184 path.cubicTo(0,5, 4,1, 3,1);
3185 path.close();
3190 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3194 SkPath path, pathB;
3195 path.setFillType(SkPath::kEvenOdd_FillType);
3196 path.moveTo(1, 4);
3197 path.cubicTo(4, 5, 3, 2, 6, 3);
3198 path.close();
3203 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3207 SkPath path, pathB;
3208 path.setFillType(SkPath::kEvenOdd_FillType);
3209 path.moveTo(1, 4);
3210 path.cubicTo(1, 5, 6, 0, 5, 1);
3211 path.close();
3216 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3220 SkPath path, pathB;
3221 path.setFillType(SkPath::kEvenOdd_FillType);
3222 path.moveTo(1, 5);
3223 path.cubicTo(0, 4, 3, 2, 6, 1);
3224 path.close();
3229 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3233 SkPath path, pathB;
3234 path.setFillType(SkPath::kWinding_FillType);
3235 path.moveTo(1,4);
3236 path.cubicTo(0,5, 4,1, 3,1);
3237 path.close();
3242 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3246 SkPath path, pathB;
3247 path.setFillType(SkPath::kWinding_FillType);
3248 path.moveTo(0,1);
3249 path.cubicTo(1,6, 5,0, 2,1);
3250 path.close();
3255 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3259 SkPath path, pathB;
3260 path.setFillType(SkPath::kWinding_FillType);
3261 path.moveTo(2,4);
3262 path.cubicTo(2,3, 6,4, 1,0);
3263 path.close();
3268 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3272 SkPath path, pathB;
3273 path.moveTo(2,4);
3274 path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3275 path.close();
3279 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3283 SkPath path, pathB;
3284 path.setFillType(SkPath::kWinding_FillType);
3285 path.moveTo(0, 1);
3286 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3287 path.close();
3292 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3296 SkPath path, pathB;
3297 path.setFillType(SkPath::kWinding_FillType);
3298 path.moveTo(0, 1);
3299 path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3300 path.close();
3306 CubicPathToQuads(path, &qPath);
3312 SkPath path, pathB;
3313 path.moveTo(0, 0);
3314 path.quadTo(1, 8, 3, 5);
3315 path.lineTo(8, 1);
3316 path.close();
3320 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3382 SkPath path, pathB;
3383 path.setFillType(SkPath::kEvenOdd_FillType);
3384 path.moveTo(0, 0);
3385 path.lineTo(1, 0);
3386 path.lineTo(1, 1);
3387 path.lineTo(0, 1);
3388 path.close();
3389 path.moveTo(0, 0);
3390 path.lineTo(6, 0);
3391 path.lineTo(6, 6);
3392 path.lineTo(0, 6);
3393 path.close();
3405 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3409 SkPath path, pathB;
3410 path.setFillType(SkPath::kEvenOdd_FillType);
3411 path.moveTo(0, 0);
3412 path.lineTo(4, 0);
3413 path.lineTo(4, 4);
3414 path.lineTo(0, 4);
3415 path.close();
3416 path.moveTo(3, 3);
3417 path.lineTo(4, 3);
3418 path.lineTo(4, 4);
3419 path.lineTo(3, 4);
3420 path.close();
3432 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3436 SkPath path, pathB;
3437 path.setFillType(SkPath::kEvenOdd_FillType);
3438 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3439 path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3443 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3447 SkPath path, pathB;
3448 path.setFillType(SkPath::kEvenOdd_FillType);
3449 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3450 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3454 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3506 SkPath path, pathB;
3507 path.setFillType(SkPath::kWinding_FillType);
3508 path.moveTo(0,1);
3509 path.cubicTo(3,4, 2,1, 5,3);
3510 path.close();
3515 SkPath path2(path);
3516 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3520 SkPath path, path2;
3521 path.addRect(0, 0, 60, 60, SkPath::kCCW_Direction);
3522 path.addRect(30, 20, 50, 50, SkPath::kCCW_Direction);
3523 path.addRect(24, 20, 36, 30, SkPath::kCCW_Direction);
3524 // path.addRect(32, 24, 36, 41, SkPath::kCCW_Direction);
3525 testPathOp(reporter, path, path2, kUnion_SkPathOp, filename);
3529 SkPath path, pathB;
3530 path.setFillType(SkPath::kWinding_FillType);
3531 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3532 path.addRect(4, 4, 5, 5, SkPath::kCW_Direction);
3536 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3540 SkPath path, pathB;
3541 path.setFillType(SkPath::kWinding_FillType);
3542 path.moveTo(0,1);
3543 path.cubicTo(4,6, 2,0, 2,0);
3544 path.close();
3549 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3553 SkPath path, pathB;
3554 path.setFillType(SkPath::kWinding_FillType);
3555 path.moveTo(0,1);
3556 path.cubicTo(4,5, 6,0, 1,0);
3557 path.close();
3562 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3566 SkPath path, pathB;
3567 path.setFillType(SkPath::kWinding_FillType);
3568 path.moveTo(0,1);
3569 path.cubicTo(4,6, 5,1, 6,2);
3570 path.close();
3575 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3579 SkPath path, pathB;
3580 path.moveTo(0,1);
3581 path.cubicTo(1,5, -5.66666651f,3.33333349f, 8.83333302f,2.33333349f);
3582 path.close();
3586 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3606 SkPath path, pathB;
3607 path.moveTo(q1a[0].fPts[0].asSkPoint());
3608 path.quadTo(q1a[0].fPts[1].asSkPoint(), q1a[0].fPts[2].asSkPoint());
3609 path.quadTo(q1a[1].fPts[1].asSkPoint(), q1a[1].fPts[2].asSkPoint());
3610 path.quadTo(q1[1].fPts[1].asSkPoint(), q1[1].fPts[2].asSkPoint());
3611 path.close();
3616 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3620 SkPath path, pathB;
3621 path.moveTo(0,1);
3622 path.cubicTo(3,4, 3.f,4.f, 4.5f,1.5f);
3623 path.close();
3627 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3631 SkPath path, pathB;
3632 path.moveTo(0,1);
3633 path.cubicTo(3,5, -3.66666651f,0, 10.5f,-1.66666651f);
3634 path.close();
3638 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3642 SkPath path, pathB;
3643 path.moveTo(0,5);
3644 path.cubicTo(1,5, 1,4, 0.833333313f,3);
3645 path.close();
3649 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3655 SkPath path, pathB;
3658 SkParsePath::FromSVGString(str, &path);
3662 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
3666 SkPath path, pathB;
3667 path.setFillType(SkPath::kWinding_FillType);
3668 path.moveTo(0,1);
3669 path.cubicTo(3,5, 2,1, 3,1);
3670 path.close();
3675 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3679 SkPath path, pathB;
3680 path.setFillType(SkPath::kWinding_FillType);
3681 path.moveTo(0,1);
3682 path.cubicTo(2,4, 2,1, 4,0);
3683 path.close();
3688 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3692 SkPath path, pathB;
3693 path.setFillType(SkPath::kWinding_FillType);
3694 path.moveTo(0,1);
3695 path.cubicTo(3,4, 3,2, 4,3);
3696 path.close();
3701 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3706 SkPath path, pathB;
3707 path.setFillType(SkPath::kWinding_FillType);
3708 path.moveTo(0,1);
3709 path.cubicTo(3,5, 4,1, 4,0);
3710 path.close();
3715 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3719 SkPath path, pathB;
3720 path.setFillType(SkPath::kWinding_FillType);
3721 path.moveTo(0,1);
3722 path.cubicTo(1,5, 2,0, 6,0);
3723 path.close();
3728 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3732 SkPath path, pathB;
3733 path.moveTo(0,2);
3734 path.cubicTo(1,2, 1,1.66666663f, 0.833333313f,1.33333325f);
3735 path.close();
3739 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3743 SkPath path, pathB;
3744 path.moveTo(0,1);
3745 path.cubicTo(1,3, -1.66666675f,1.66666663f, 4.16666651f,1.00000012f);
3746 path.close();
3750 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3754 SkPath path, pathB;
3755 path.setFillType(SkPath::kWinding_FillType);
3756 path.moveTo(0,1);
3757 path.cubicTo(1,5, 6,0, 3,0);
3758 path.close();
3763 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3767 SkPath path, pathB;
3768 path.setFillType(SkPath::kWinding_FillType);
3769 path.moveTo(0,1);
3770 path.cubicTo(3,6, 3,1, 6,2);
3771 path.close();
3776 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3780 SkPath path, pathB;
3781 path.setFillType(SkPath::kWinding_FillType);
3782 path.moveTo(0,1);
3783 path.cubicTo(0,3, 6,0, 2,1);
3784 path.close();
3789 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3793 SkPath path, pathB;
3794 path.setFillType(SkPath::kWinding_FillType);
3795 path.moveTo(0,1);
3796 path.cubicTo(1,5, 6,0, 3,0);
3797 path.close();
3802 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3806 SkPath path, pathB;
3807 path.setFillType(SkPath::kWinding_FillType);
3808 path.moveTo(0,1);
3809 path.cubicTo(0,3, 3,2, 5,2);
3810 path.close();
3815 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3819 SkPath path, pathB;
3820 path.setFillType(SkPath::kWinding_FillType);
3821 path.moveTo(5,6);
3822 path.cubicTo(3,4, 2,0, 2,1);
3823 path.close();
3828 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3832 SkPath path, pathB;
3833 path.setFillType(SkPath::kWinding_FillType);
3834 path.moveTo(5,6);
3835 path.cubicTo(4,6, 3,0, 2,1);
3836 path.close();
3841 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3846 static void complex_to_quads(const SkPoint pts[], SkPath* path) {
3857 path->quadTo(q1[1].asSkPoint(), q1[2].asSkPoint());
3858 path->quadTo(q2[1].asSkPoint(), q2[2].asSkPoint());
3860 path->cubicTo(pts[1], pts[2], pts[3]);
3865 SkPath path, pathB;
3866 path.setFillType(SkPath::kWinding_FillType);
3867 path.moveTo(5,6);
3869 complex_to_quads(pts, &path);
3870 path.close();
3874 complex_to_quads(pts2, &path);
3876 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3880 SkPath path, pathB;
3881 path.setFillType(SkPath::kWinding_FillType);
3882 path.moveTo(0,1);
3883 path.cubicTo(3,4, 3,0, 6,2);
3884 path.close();
3889 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3893 SkPath path, pathB;
3894 path.setFillType(SkPath::kWinding_FillType);
3895 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
3898 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3902 SkPath path, pathB;
3903 path.setFillType(SkPath::kWinding_FillType);
3904 path.addCircle(0, 1, 4, SkPath::kCCW_Direction);
3907 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3911 SkPath path, pathB;
3912 path.setFillType(SkPath::kEvenOdd_FillType);
3913 path.moveTo(20.65f, 5.65f);
3914 path.conicTo(20.65f, 1.13612f, 25.1404f, 0.65f, 0.888488f);
3915 path.lineTo(25.65f, 0.65f);
3916 path.lineTo(26.1596f, 0.67604f);
3917 path.conicTo(30.65f, 1.13612f, 30.65f, 5.65f, 0.888488f);
3918 path.lineTo(30.65f, 25.65f);
3919 path.conicTo(30.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3920 path.lineTo(20.65f, 20.65f);
3921 path.lineTo(20.65f, 5.65f);
3922 path.close();
3923 path.moveTo(20.65f, 20.65f);
3924 path.lineTo(5.65f, 20.65f);
3925 path.conicTo(0.65f, 20.65f, 0.65f, 25.65f, 0.707107f);
3926 path.lineTo(0.65f, 45.65f);
3927 path.conicTo(0.65f, 50.65f, 5.65f, 50.65f, 0.707107f);
3928 path.lineTo(25.65f, 50.65f);
3929 path.conicTo(30.65f, 50.65f, 30.65f, 45.65f, 0.707107f);
3930 path.lineTo(30.65f, 25.65f);
3931 path.conicTo(30.65f, 30.65f, 25.65f, 30.65f, 0.707107f);
3932 path.conicTo(20.65f, 30.65f, 20.65f, 25.65f, 0.707107f);
3933 path.lineTo(20.65f, 20.65f);
3934 path.close();
3935 SkPath path1(path);
3937 path.reset();
3938 path.setFillType(SkPath::kWinding_FillType);
3939 path.moveTo(20.65f, 45.65f);
3940 path.lineTo(20.65f, 25.65f);
3941 path.conicTo(20.65f, 20.65f, 25.65f, 20.65f, 0.707107f);
3942 path.lineTo(45.65f, 20.65f);
3943 path.conicTo(50.65f, 20.65f, 50.65f, 25.65f, 0.707107f);
3944 path.lineTo(50.65f, 45.65f);
3945 path.conicTo(50.65f, 50.65f, 45.65f, 50.65f, 0.707107f);
3946 path.lineTo(25.65f, 50.65f);
3947 path.conicTo(20.65f, 50.65f, 20.65f, 45.65f, 0.707107f);
3948 path.close();
3949 SkPath path2(path);
3955 SkPath path, pathB;
3956 path.moveTo(0,1);
3957 path.cubicTo(3,4, -1,0, 8.5f,-2.5f);
3958 path.close();
3962 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3966 SkPath path, pathB;
3967 path.setFillType(SkPath::kWinding_FillType);
3968 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3969 path.addRect(5, 5, 6, 6, SkPath::kCW_Direction);
3973 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
3977 SkPath path, pathB;
3978 path.moveTo(0,1);
3979 path.cubicTo(1,4, -3.83333325f,0.166666627f, 6,-1);
3980 path.close();
3984 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3988 SkPath path, pathB;
3989 path.moveTo(0,1);
3990 path.cubicTo(1,3, -2.5f,0, 3.33333325f,-0.666666627f);
3991 path.close();
3995 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
3999 SkPath path, pathB;
4000 path.setFillType(SkPath::kWinding_FillType);
4001 path.addCircle(0, 1, 2, SkPath::kCCW_Direction);
4004 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4008 SkPath path, pathB;
4009 path.moveTo(5,6);
4010 path.cubicTo(1,2, 1,2, -3.66666651f,13.333334f);
4011 path.close();
4015 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4019 SkPath path, pathB;
4020 path.moveTo(0,1);
4021 path.cubicTo(1,3, -1.83333349f,1.33333337f, 4,-1);
4022 path.close();
4026 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4030 SkPath path, pathB;
4031 path.setFillType(SkPath::kWinding_FillType);
4032 path.moveTo(5,6);
4033 path.cubicTo(3,4, 3,0, 3,2);
4034 path.close();
4039 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4043 SkPath path, pathB;
4044 path.moveTo(1,2);
4045 path.cubicTo(0,6, -3.16666675f,3.66666675f, 6.33333349f,3.33333349f);
4046 path.close();
4050 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4054 SkPath path, pathB;
4055 path.setFillType(SkPath::kWinding_FillType);
4056 path.moveTo(5,6);
4057 path.cubicTo(5,6, 5,0, 4,1);
4058 path.close();
4063 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4067 SkPath path, pathB;
4068 path.setFillType(SkPath::kWinding_FillType);
4069 path.moveTo(5,6);
4070 path.cubicTo(5,6, 6,0, 3,1);
4071 path.close();
4076 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4080 SkPath path, pathB;
4081 path.setFillType(SkPath::kWinding_FillType);
4082 path.moveTo(5,6);
4083 path.cubicTo(5,6, 6,0, 4,1);
4084 path.close();
4089 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4093 SkPath path, pathB;
4094 path.setFillType(SkPath::kWinding_FillType);
4095 path.moveTo(5,6);
4096 path.cubicTo(5,6, 5,0, 3,1);
4097 path.close();
4102 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4106 SkPath path, pathB;
4107 path.setFillType(SkPath::kWinding_FillType);
4108 path.moveTo(5,6);
4109 path.quadTo(5,0, 3,1);
4110 path.close();
4115 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4119 SkPath path, pathB;
4120 path.setFillType(SkPath::kWinding_FillType);
4121 path.moveTo(0, 5);
4122 path.cubicTo(3, 6, 1, 0, 3, 2);
4123 path.close();
4128 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4132 SkPath path, pathB;
4133 path.setFillType(SkPath::kWinding_FillType);
4134 path.moveTo(0, 5);
4135 path.cubicTo(3, 6, 1, 0, 4, 2);
4136 path.close();
4141 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4146 SkPath path, pathB;
4147 path.setFillType(SkPath::kWinding_FillType);
4148 path.moveTo(0,2);
4149 path.cubicTo(0,4, 3,1, 5,1);
4150 path.close();
4155 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4159 SkPath path, pathB;
4160 path.setFillType(SkPath::kWinding_FillType);
4161 path.moveTo(0,2);
4162 path.cubicTo(1,2, 5,4, 3,2);
4163 path.close();
4168 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4172 SkPath path, pathB;
4173 path.setFillType(SkPath::kWinding_FillType);
4174 path.moveTo(0,2);
4175 path.cubicTo(1,2, 6,4, 3,2);
4176 path.close();
4181 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4185 SkPath path, pathB;
4186 path.moveTo(6,15);
4187 path.quadTo(16,0, 8,4);
4188 path.quadTo(2,7, 12,12);
4189 path.close();
4191 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4195 SkPath path, pathB;
4196 path.moveTo(5,12);
4197 path.quadTo(15,7, 9,4);
4198 path.quadTo(1,0, 11,15);
4199 path.close();
4201 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4205 SkPath path, pathB;
4206 path.moveTo(12,12);
4207 path.quadTo(2,7, 8,4);
4208 path.quadTo(16,0, 6,15);
4209 path.close();
4211 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4215 SkPath path, pathB;
4216 path.moveTo(11,15);
4217 path.quadTo(1,0, 9,4);
4218 path.quadTo(15,7, 5,12);
4219 path.close();
4221 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4225 SkPath path, pathB;
4226 path.moveTo(11,13);
4227 path.quadTo(4,4, 8,4);
4228 path.quadTo(12,4, 5,13);
4229 path.close();
4231 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4235 SkPath path, pathB;
4236 path.moveTo(5,13);
4237 path.quadTo(12,4, 8,4);
4238 path.quadTo(4,4, 11,13);
4239 path.close();
4241 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4245 SkPath path, pathB;
4246 path.setFillType(SkPath::kWinding_FillType);
4247 path.moveTo(0, 3);
4248 path.cubicTo(0, 2, 0, 2, -1.66666663f, 2.16666675f);
4249 path.close();
4254 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4258 SkPath path, pathB;
4259 path.setFillType(SkPath::kWinding_FillType);
4260 path.moveTo(1, 2);
4261 path.cubicTo(0, 2, 0, 2, 0.166666672f, 2.66666675f);
4262 path.close();
4267 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4271 SkPath path, pathB;
4272 path.setFillType(SkPath::kWinding_FillType);
4273 path.moveTo(5,6);
4274 path.cubicTo(2,5, 2,1, 1,0);
4275 path.close();
4280 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4284 SkPath path, pathB;
4285 path.setFillType(SkPath::kWinding_FillType);
4286 path.moveTo(3, 5);
4287 path.cubicTo(1, 5, 4, 2, 4, 0);
4288 path.close();
4293 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4297 SkPath path, pathB;
4298 path.setFillType(SkPath::kWinding_FillType);
4299 path.moveTo(2, 6);
4300 path.cubicTo(2, 4, 5, 1, 3, 1);
4301 path.close();
4306 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4310 SkPath path, pathB;
4311 path.setFillType(SkPath::kWinding_FillType);
4312 path.moveTo(2, 5);
4313 path.cubicTo(2, 4, 5, 1, 3, 2);
4314 path.close();
4319 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4323 SkPath path, pathB;
4324 path.setFillType(SkPath::kWinding_FillType);
4325 path.moveTo(2, 4);
4326 path.cubicTo(2, 6, 3, 1, 5, 1);
4327 path.close();
4332 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4336 SkPath path, pathB;
4337 path.setFillType(SkPath::kWinding_FillType);
4338 path.moveTo(2, 4);
4339 path.cubicTo(1, 6, 4, 1, 5, 1);
4340 path.close();
4345 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
4349 SkPath path, pathB;
4350 path.setFillType(SkPath::kWinding_FillType);
4351 path.moveTo(2, 4);
4352 path.cubicTo(2, 5, 3, 2, 5, 1);
4353 path.close();
4358 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4362 SkPath path, pathB;
4363 path.setFillType(SkPath::kWinding_FillType);
4364 path.moveTo(2, 4);
4365 path.cubicTo(0, 4, 5, 3, 5, 1);
4366 path.close();
4371 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4375 SkPath path, pathB;
4376 path.setFillType(SkPath::kWinding_FillType);
4377 path.moveTo(2, 3);
4378 path.cubicTo(1, 5, 4, 2, 5, 2);
4379 path.close();
4384 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4388 SkPath path, pathB;
4389 path.setFillType(SkPath::kWinding_FillType);
4390 path.moveTo(2, 3);
4391 path.cubicTo(0, 4, 3, 1, 3, 0);
4392 path.close();
4397 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4401 SkPath path, pathB;
4402 path.setFillType(SkPath::kWinding_FillType);
4403 path.moveTo(1, 5);
4404 path.cubicTo(3, 5, 4, 0, 4, 2);
4405 path.close();
4410 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4414 SkPath path, pathB;
4415 path.setFillType(SkPath::kWinding_FillType);
4416 path.moveTo(1, 5);
4417 path.cubicTo(2, 5, 5, 0, 4, 2);
4418 path.close();
4423 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4427 SkPath path, pathB;
4428 path.setFillType(SkPath::kWinding_FillType);
4429 path.moveTo(1, 5);
4430 path.cubicTo(3, 4, 4, 1, 4, 2);
4431 path.close();
4436 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4440 SkPath path, pathB;
4441 path.setFillType(SkPath::kWinding_FillType);
4442 path.moveTo(1, 5);
4443 path.cubicTo(1, 3, 4, 0, 2, 0);
4444 path.close();
4449 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4453 SkPath path, pathB;
4454 path.setFillType(SkPath::kWinding_FillType);
4455 path.moveTo(1, 5);
4456 path.cubicTo(2, 3, 5, 2, 4, 2);
4457 path.close();
4462 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4466 SkPath path, pathB;
4467 path.setFillType(SkPath::kWinding_FillType);
4468 path.moveTo(1,5);
4469 path.cubicTo(1,3, 6,2, 4,2);
4470 path.close();
4475 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4479 SkPath path, pathB;
4480 path.setFillType(SkPath::kWinding_FillType);
4481 path.moveTo(1, 2);
4482 path.cubicTo(0, 3, 6, 0, 3, 2);
4483 path.close();
4488 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
4492 SkPath path, pathB;
4493 path.setFillType(SkPath::kWinding_FillType);
4494 path.moveTo(1, 2);
4495 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3.66666651f);
4496 path.close();
4501 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4505 SkPath path, pathB;
4506 path.setFillType(SkPath::kWinding_FillType);
4507 path.moveTo(1, 2);
4508 path.cubicTo(0, 2, 0.833333313f, 2, 1, 4);
4509 path.close();
4514 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4518 SkPath path, pathB;
4519 path.setFillType(SkPath::kWinding_FillType);
4520 path.moveTo(1, 3);
4521 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.66666651f);
4522 path.close();
4527 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4531 SkPath path, pathB;
4532 path.setFillType(SkPath::kWinding_FillType);
4533 path.moveTo(1, 5);
4534 path.cubicTo(0, 1, 6.16666698f, 5.66666698f, -5.66666651f, 6.66666651f);
4535 path.close();
4540 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4544 SkPath path, pathB;
4545 path.setFillType(SkPath::kWinding_FillType);
4546 path.moveTo(1, 2);
4547 path.cubicTo(0, 2, 0.833333313f, 2, 1, 3);
4548 path.close();
4553 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4557 SkPath path, pathB;
4558 path.setFillType(SkPath::kWinding_FillType);
4559 path.moveTo(1, 5);
4560 path.cubicTo(0, 5, 0.833333313f, 5, 1, 7);
4561 path.close();
4566 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4570 SkPath path, pathB;
4571 path.setFillType(SkPath::kWinding_FillType);
4572 path.moveTo(1, 6);
4573 path.cubicTo(0, 2, 6.16666698f, 6.66666698f, -5.66666651f, 7.66666651f);
4574 path.close();
4579 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4583 SkPath path, pathB;
4584 path.setFillType(SkPath::kWinding_FillType);
4585 path.moveTo(1, 3);
4586 path.cubicTo(0, 3, 0.833333313f, 3, 1, 4.33333349f);
4587 path.close();
4592 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4596 SkPath path, pathB;
4597 path.setFillType(SkPath::kWinding_FillType);
4598 path.moveTo(2, 3);
4599 path.cubicTo(1, 3, 1.83333337f, 3, 2, 4.66666651f);
4600 path.close();
4605 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4609 SkPath path, pathB;
4610 path.setFillType(SkPath::kWinding_FillType);
4611 path.moveTo(2, 4);
4612 path.cubicTo(0, 4, 1.66666663f, 4, 2, 7.33333302f);
4613 path.close();
4618 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4622 SkPath path, pathB;
4623 path.setFillType(SkPath::kWinding_FillType);
4624 path.moveTo(2, 4);
4625 path.cubicTo(0, 4, 1.66666663f, 4, 2, 8);
4626 path.close();
4631 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4635 SkPath path, pathB;
4636 path.setFillType(SkPath::kWinding_FillType);
4637 path.moveTo(2, 5);
4638 path.cubicTo(1, 5, 1.83333337f, 5, 2, 6.66666651f);
4639 path.close();
4644 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4648 SkPath path, pathB;
4649 path.setFillType(SkPath::kWinding_FillType);
4650 path.moveTo(2, 6);
4651 path.cubicTo(1, 6, 1.83333337f, 6, 2, 8);
4652 path.close();
4657 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4661 SkPath path, pathB;
4662 path.setFillType(SkPath::kWinding_FillType);
4663 path.moveTo(2, 6);
4664 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4665 path.close();
4670 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4687 SkPath path, pathB;
4688 path.setFillType(SkPath::kWinding_FillType);
4689 path.moveTo(pts[0]);
4690 path.cubicTo(pts[1], pts[2], pts[3]);
4691 path.close();
4696 bool result = testPathOp(reporter, path, pathB, kIntersect_SkPathOp, name.c_str());
4708 SkPath path, pathB;
4709 path.setFillType(SkPath::kWinding_FillType);
4710 path.moveTo(2, 6);
4711 path.cubicTo(1, 2, 7.16666698f, 6.66666698f, -4.66666651f, 7.66666651f);
4712 path.close();
4718 CubicPathToQuads(path, &qPath);
4724 SkPath path, pathB;
4725 path.setFillType(SkPath::kWinding_FillType);
4726 path.moveTo(3, 4);
4727 path.cubicTo(0, 4, 2.5f, 4, 3, 9);
4728 path.close();
4733 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4737 SkPath path, pathB;
4738 path.setFillType(SkPath::kWinding_FillType);
4739 path.moveTo(3, 4);
4740 path.cubicTo(0, 4, 2.5f, 4, 3, 10);
4741 path.close();
4746 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4750 SkPath path, pathB;
4751 path.setFillType(SkPath::kWinding_FillType);
4752 path.moveTo(3, 4);
4753 path.cubicTo(1, 4, 2.66666675f, 4, 3, 8);
4754 path.close();
4759 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4763 SkPath path, pathB;
4764 path.setFillType(SkPath::kWinding_FillType);
4765 path.moveTo(2, 4);
4766 path.cubicTo(1, 4, 1.83333337f, 4, 2, 5.33333349f);
4767 path.close();
4772 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4776 SkPath path, pathB;
4777 path.setFillType(SkPath::kWinding_FillType);
4778 path.moveTo(3, 4);
4779 path.cubicTo(2, 4, 2.83333325f, 4, 3, 6);
4780 path.close();
4785 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4789 SkPath path, pathB;
4790 path.setFillType(SkPath::kWinding_FillType);
4791 path.moveTo(3, 5);
4792 path.cubicTo(0, 5, 2.5f, 5, 3, 10);
4793 path.close();
4798 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4802 SkPath path, pathB;
4803 path.setFillType(SkPath::kWinding_FillType);
4804 path.moveTo(3, 5);
4805 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4806 path.close();
4811 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4815 SkPath path, pathB;
4816 path.setFillType(SkPath::kWinding_FillType);
4817 path.moveTo(3, 5);
4818 path.cubicTo(0, 5, 2.5f, 5, 3, 11);
4819 path.close();
4825 CubicPathToQuads(path, &qPath);
4831 SkPath path, pathB;
4832 path.setFillType(SkPath::kWinding_FillType);
4833 path.moveTo(1, 5);
4834 path.cubicTo(0, 1, 7.33333302f, 5.33333349f, -7, 7);
4835 path.close();
4840 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4844 SkPath path, pathB;
4845 path.setFillType(SkPath::kWinding_FillType);
4846 path.moveTo(1, 6);
4847 path.cubicTo(0, 2, 7.33333302f, 6.33333302f, -7, 8);
4848 path.close();
4853 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4857 SkPath path, pathB;
4858 path.setFillType(SkPath::kWinding_FillType);
4859 path.moveTo(2, 6);
4860 path.cubicTo(1, 2, 8.33333302f, 6.33333302f, -6, 8);
4861 path.close();
4866 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4872 SkPath path, pathB;
4873 path.setFillType(SkPath::kWinding_FillType);
4874 path.moveTo(2, 4);
4875 path.cubicTo(0, 1, 6, 5.83333302f, -4, 8);
4876 path.close();
4881 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4885 SkPath path, pathB;
4886 path.setFillType(SkPath::kWinding_FillType);
4887 path.moveTo(2, 6);
4888 path.cubicTo(0, 1, 9.33333302f, 6.83333302f, -8.33333302f, 9.16666603f);
4889 path.close();
4894 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4898 SkPath path, pathB;
4899 path.setFillType(SkPath::kWinding_FillType);
4900 path.moveTo(0, 2);
4901 path.cubicTo(1, 4, -0.166666687f, 2.66666675f, 1.66666675f, 2);
4902 path.close();
4907 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4911 SkPath path, pathB;
4912 path.setFillType(SkPath::kWinding_FillType);
4913 path.moveTo(0, 3);
4914 path.cubicTo(1, 5, -0.166666687f, 3.66666675f, 1.66666675f, 3);
4915 path.close();
4920 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4924 SkPath path, pathB;
4925 path.setFillType(SkPath::kWinding_FillType);
4926 path.moveTo(1, 2);
4927 path.cubicTo(2, 4, 0.833333313f, 2.66666675f, 2.66666675f, 2);
4928 path.close();
4933 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4937 SkPath path, pathB;
4938 path.setFillType(SkPath::kWinding_FillType);
4939 path.moveTo(1, 3);
4940 path.cubicTo(2, 5, 0.833333313f, 3.66666675f, 2.66666675f, 3);
4941 path.close();
4946 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4950 SkPath path, pathB;
4951 path.setFillType(SkPath::kWinding_FillType);
4952 path.moveTo(2, 3);
4953 path.cubicTo(3, 5, 1.83333325f, 3.66666675f, 3.66666651f, 3);
4954 path.close();
4959 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4963 SkPath path, pathB;
4964 path.setFillType(SkPath::kWinding_FillType);
4965 path.moveTo(0, 2);
4966 path.cubicTo(1, 4, 0, 3, 1.66666675f, 2);
4967 path.close();
4972 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4976 SkPath path, pathB;
4977 path.setFillType(SkPath::kWinding_FillType);
4978 path.moveTo(0, 3);
4979 path.cubicTo(1, 5, 0, 4, 1.66666675f, 3);
4980 path.close();
4985 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
4989 SkPath path, pathB;
4990 path.setFillType(SkPath::kWinding_FillType);
4991 path.moveTo(1, 2);
4992 path.cubicTo(2, 4, 0.99999994f, 3, 2.66666675f, 2);
4993 path.close();
4998 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5002 SkPath path, pathB;
5003 path.setFillType(SkPath::kWinding_FillType);
5004 path.moveTo(1, 3);
5005 path.cubicTo(2, 5, 0.99999994f, 4, 2.66666675f, 3);
5006 path.close();
5011 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5015 SkPath path, pathB;
5016 path.setFillType(SkPath::kWinding_FillType);
5017 path.moveTo(2, 3);
5018 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5019 path.close();
5024 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5028 SkPath path, pathB;
5029 path.setFillType(SkPath::kWinding_FillType);
5030 path.moveTo(2, 3);
5031 path.cubicTo(3, 5, 2, 4, 3.66666651f, 3);
5032 path.close();
5038 CubicPathToQuads(path, &qPath);
5047 SkPath path, pathB;
5048 path.setFillType(SkPath::kWinding_FillType);
5049 path.moveTo(0, 6);
5050 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5051 path.close();
5056 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5060 SkPath path, pathB;
5061 path.setFillType(SkPath::kWinding_FillType);
5062 path.moveTo(0, 6);
5063 path.cubicTo(1, 2, 7.33333302f, 1.66666663f, -7.5f, 2);
5064 path.close();
5070 CubicPathToQuads(path, &qPath);
5079 SkPath path, pathB;
5080 path.setFillType(SkPath::kWinding_FillType);
5081 path.moveTo(0, 1);
5082 path.cubicTo(1, 4, 3, 0, 3, 1);
5083 path.close();
5088 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5092 SkPath path, pathB;
5093 path.setFillType(SkPath::kWinding_FillType);
5094 path.moveTo(0, 1);
5095 path.cubicTo(1, 5, -6.33333302f, 0.666666627f, 8, -1);
5096 path.close();
5101 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5105 SkPath path, pathB;
5106 path.setFillType(SkPath::kWinding_FillType);
5107 path.moveTo(0, 2);
5108 path.cubicTo(1, 6, -6.33333302f, 1.66666663f, 8, 0);
5109 path.close();
5114 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5118 SkPath path, pathB;
5119 path.setFillType(SkPath::kWinding_FillType);
5120 path.moveTo(0, 1);
5121 path.cubicTo(2, 4, -4, -0.833333254f, 6, -3);
5122 path.close();
5127 testPathOp(reporter, path, pathB, kIntersect_SkPathOp, filename);
5131 SkPath path, pathB;
5132 path.setFillType(SkPath::kWinding_FillType);
5133 path.moveTo(3, 4);
5134 path.cubicTo(2, 5, 3, 1, 6, 2);
5135 path.close();
5140 testPathOp(reporter, path, pathB, kDifference_SkPathOp, filename);
5144 SkPath path, pathB;
5145 path.setFillType(SkPath::kWinding_FillType);
5146 path.moveTo(1, 3);
5147 path.cubicTo(2, 6, 4, 3, 5, 2);
5148 path.close();
5153 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5528 SkPath path;
5529 path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
5532 testPathOp(reporter, path, pathB, kUnion_SkPathOp, filename);
5579 SkPath path;
5580 path.setFillType((SkPath::FillType) 0);
5581 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5582 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5583 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
5584 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
5585 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
5586 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5587 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5588 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
5589 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
5590 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
5591 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5592 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5593 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
5594 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5595 path.close();
5597 SkPath path1(path);
5598 path.reset();
5599 path.setFillType((SkPath::FillType) 0);
5600 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5601 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5602 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
5603 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
5604 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
5605 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
5606 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
5607 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
5608 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
5609 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
5610 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
5611 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
5612 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
5613 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
5614 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
5615 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
5616 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
5617 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5618 path.close();
5620 SkPath path2(path);
5625 SkPath path;
5626 path.setFillType((SkPath::FillType) 0);
5627 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5628 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5629 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
5630 path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
5631 path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
5632 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5633 path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
5634 path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
5635 path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
5636 path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
5637 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5638 path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
5639 path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
5640 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5641 path.close();
5643 SkPath path1(path);
5644 path.reset();
5645 path.setFillType((SkPath::FillType) 0);
5646 path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5647 path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
5648 path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
5649 path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
5650 path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
5651 path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
5652 path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
5653 path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
5654 path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
5655 path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
5656 path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
5657 path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
5658 path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
5659 path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
5660 path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
5661 path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
5662 path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
5663 path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
5664 path.close();
5666 SkPath path2(path);
5671 SkPath path;
5672 path.setFillType((SkPath::FillType) 1);
5673 path.moveTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
5674 path.lineTo(SkBits2Float(0x43480000), SkBits2Float(0x43520000));
5675 path.lineTo(SkBits2Float(0x42200000), SkBits2Float(0x42c80000));
5676 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42c80000)); // 2.22222e+022f
5677 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43520000)); // 2.22222e+022f
5678 path.lineTo(SkBits2Float(0x430c0000), SkBits2Float(0x42200000));
5679 path.close();
5681 SkPath path1(path);
5682 path.reset();
5683 path.setFillType((SkPath::FillType) 0);
5684 path.moveTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
5685 path.lineTo(SkBits2Float(0x435c0000), SkBits2Float(0x43660000));
5686 path.lineTo(SkBits2Float(0x42700000), SkBits2Float(0x42f00000));
5687 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x42f00000)); // 2.22222e+022f
5688 path.lineTo(SkBits2Float(0x64969569), SkBits2Float(0x43660000)); // 2.22222e+022f
5689 path.lineTo(SkBits2Float(0x43200000), SkBits2Float(0x42700000));
5690 path.close();
5692 SkPath path2(path);
5697 SkPath path;
5698 path.setFillType((SkPath::FillType) 0);
5699 path.moveTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
5700 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
5701 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
5702 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000));
5703 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000));
5704 path.quadTo(SkBits2Float(0xff000001), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000), SkBits2Float(0xffc00000));
5705 path.quadTo(SkBits2Float(0xffc00000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xff000001));
5706 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xff000001), SkBits2Float(0x7f800000), SkBits2Float(0xffc00000));
5707 path.quadTo(SkBits2Float(0x7f800000), SkBits2Float(0xffc00000), SkBits2Float(0x7f800000), SkBits2Float(0x7f800000));
5708 path.close();
5710 SkPath path1(path);
5711 path.reset();
5712 path.setFillType((SkPath::FillType) 0);
5714 SkPath path2(path);
