1/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7#include "PathOpsExtendedTest.h"
8#include "PathOpsTestCommon.h"
9
10#define TEST(name) { name, #name }
11
12static void cubicOp1d(skiatest::Reporter* reporter, const char* filename) {
13    SkPath path, pathB;
14    path.setFillType(SkPath::kWinding_FillType);
15    path.moveTo(0,1);
16    path.cubicTo(0,2, 1,0, 1,0);
17    path.close();
18    pathB.setFillType(SkPath::kWinding_FillType);
19    pathB.moveTo(0,1);
20    pathB.cubicTo(0,1, 1,0, 2,0);
21    pathB.close();
22    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
23}
24
25static void cubicOp2d(skiatest::Reporter* reporter, const char* filename) {
26    SkPath path, pathB;
27    path.setFillType(SkPath::kWinding_FillType);
28    path.moveTo(0,2);
29    path.cubicTo(0,1, 1,0, 1,0);
30    path.close();
31    pathB.setFillType(SkPath::kWinding_FillType);
32    pathB.moveTo(0,1);
33    pathB.cubicTo(0,1, 2,0, 1,0);
34    pathB.close();
35    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
36}
37
38static void cubicOp3d(skiatest::Reporter* reporter, const char* filename) {
39    SkPath path, pathB;
40    path.setFillType(SkPath::kWinding_FillType);
41    path.moveTo(0,1);
42    path.cubicTo(2,3, 1,0, 1,0);
43    path.close();
44    pathB.setFillType(SkPath::kWinding_FillType);
45    pathB.moveTo(0,1);
46    pathB.cubicTo(0,1, 1,0, 3,2);
47    pathB.close();
48    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
49}
50
51static void cubicOp5d(skiatest::Reporter* reporter, const char* filename) {
52    SkPath path, pathB;
53    path.setFillType(SkPath::kWinding_FillType);
54    path.moveTo(0,1);
55    path.cubicTo(0,2, 1,0, 2,0);
56    path.close();
57    pathB.setFillType(SkPath::kWinding_FillType);
58    pathB.moveTo(0,1);
59    pathB.cubicTo(0,2, 1,0, 2,0);
60    pathB.close();
61    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
62}
63
64static void cubicOp6d(skiatest::Reporter* reporter, const char* filename) {
65    SkPath path, pathB;
66    path.setFillType(SkPath::kWinding_FillType);
67    path.moveTo(0,1);
68    path.cubicTo(0,6, 1,0, 3,0);
69    path.close();
70    pathB.setFillType(SkPath::kWinding_FillType);
71    pathB.moveTo(0,1);
72    pathB.cubicTo(0,3, 1,0, 6,0);
73    pathB.close();
74    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
75}
76
77static void cubicOp7d(skiatest::Reporter* reporter, const char* filename) {
78    SkPath path, pathB;
79    path.setFillType(SkPath::kWinding_FillType);
80    path.moveTo(0,1);
81    path.cubicTo(3,4, 1,0, 3,0);
82    path.close();
83    pathB.setFillType(SkPath::kWinding_FillType);
84    pathB.moveTo(0,1);
85    pathB.cubicTo(0,3, 1,0, 4,3);
86    pathB.close();
87    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
88}
89
90static void cubicOp8d(skiatest::Reporter* reporter, const char* filename) {
91    SkPath path, pathB;
92    path.setFillType(SkPath::kWinding_FillType);
93    path.moveTo(0,1);
94    path.cubicTo(0,5, 1,0, 4,0);
95    path.close();
96    pathB.setFillType(SkPath::kWinding_FillType);
97    pathB.moveTo(0,1);
98    pathB.cubicTo(0,4, 1,0, 5,0);
99    pathB.close();
100    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
101}
102
103static void cubicOp9d(skiatest::Reporter* reporter, const char* filename) {
104    SkPath path, pathB;
105    path.setFillType(SkPath::kWinding_FillType);
106    path.moveTo(0,1);
107    path.cubicTo(1,6, 1,0, 2,1);
108    path.close();
109    pathB.setFillType(SkPath::kWinding_FillType);
110    pathB.moveTo(0,1);
111    pathB.cubicTo(1,2, 1,0, 6,1);
112    pathB.close();
113    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
114}
115
116static void quadOp9d(skiatest::Reporter* reporter, const char* filename) {
117    SkPath path, pathB;
118    path.setFillType(SkPath::kWinding_FillType);
119    path.moveTo(0,1);
120    path.quadTo(1,6, 1.5f,1);
121    path.quadTo(1.5f,0.5f, 2,1);
122    path.close();
123    pathB.setFillType(SkPath::kWinding_FillType);
124    pathB.moveTo(0,1);
125    pathB.quadTo(1,2, 1.4f,1);
126    pathB.quadTo(3,0.4f, 6,1);
127    pathB.close();
128    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
129}
130
131static void lineOp9d(skiatest::Reporter* reporter, const char* filename) {
132    SkPath path, pathB;
133    path.setFillType(SkPath::kWinding_FillType);
134    path.moveTo(0,1);
135    path.lineTo(1,6);
136    path.lineTo(1.5f,1);
137    path.lineTo(1.8f,0.8f);
138    path.lineTo(2,1);
139    path.close();
140    pathB.setFillType(SkPath::kWinding_FillType);
141    pathB.moveTo(0,1);
142    pathB.lineTo(1,2);
143    pathB.lineTo(1.4f,1);
144    pathB.lineTo(3,0.4f);
145    pathB.lineTo(6,1);
146    pathB.close();
147    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
148}
149
150static void cubicOp1i(skiatest::Reporter* reporter, const char* filename) {
151    SkPath path, pathB;
152    path.setFillType(SkPath::kWinding_FillType);
153    path.moveTo(0,1);
154    path.cubicTo(1,2, 1,0, 2,1);
155    path.close();
156    pathB.setFillType(SkPath::kWinding_FillType);
157    pathB.moveTo(0,1);
158    pathB.cubicTo(1,2, 1,0, 2,1);
159    pathB.close();
160    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
161}
162
163static void cubicOp10d(skiatest::Reporter* reporter, const char* filename) {
164    SkPath path, pathB;
165    path.setFillType(SkPath::kWinding_FillType);
166    path.moveTo(0,1);
167    path.cubicTo(1,3, 1,0, 4,1);
168    path.close();
169    pathB.setFillType(SkPath::kWinding_FillType);
170    pathB.moveTo(0,1);
171    pathB.cubicTo(1,4, 1,0, 3,1);
172    pathB.close();
173    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
174}
175
176static void cubicOp11d(skiatest::Reporter* reporter, const char* filename) {
177    SkPath path, pathB;
178    path.setFillType(SkPath::kWinding_FillType);
179    path.moveTo(0,1);
180    path.cubicTo(3,4, 1,0, 5,1);
181    path.close();
182    pathB.setFillType(SkPath::kWinding_FillType);
183    pathB.moveTo(0,1);
184    pathB.cubicTo(1,5, 1,0, 4,3);
185    pathB.close();
186    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
187}
188
189static void cubicOp12d(skiatest::Reporter* reporter, const char* filename) {
190    SkPath path, pathB;
191    path.setFillType(SkPath::kWinding_FillType);
192    path.moveTo(0,1);
193    path.cubicTo(1,6, 1,0, 1,0);
194    path.close();
195    pathB.setFillType(SkPath::kWinding_FillType);
196    pathB.moveTo(0,1);
197    pathB.cubicTo(0,1, 1,0, 6,1);
198    pathB.close();
199    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
200}
201
202static void cubicOp13d(skiatest::Reporter* reporter, const char* filename) {
203    SkPath path, pathB;
204    path.setFillType(SkPath::kWinding_FillType);
205    path.moveTo(0,1);
206    path.cubicTo(4,5, 1,0, 5,3);
207    path.close();
208    pathB.setFillType(SkPath::kWinding_FillType);
209    pathB.moveTo(0,1);
210    pathB.cubicTo(3,5, 1,0, 5,4);
211    pathB.close();
212    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
213}
214
215static void cubicOp14d(skiatest::Reporter* reporter, const char* filename) {
216    SkPath path, pathB;
217    path.setFillType(SkPath::kWinding_FillType);
218    path.moveTo(0,1);
219    path.cubicTo(0,2, 2,0, 2,1);
220    path.close();
221    pathB.setFillType(SkPath::kWinding_FillType);
222    pathB.moveTo(0,2);
223    pathB.cubicTo(1,2, 1,0, 2,0);
224    pathB.close();
225    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
226}
227
228static void cubicOp15d(skiatest::Reporter* reporter, const char* filename) {
229    SkPath path, pathB;
230    path.setFillType(SkPath::kWinding_FillType);
231    path.moveTo(0,1);
232    path.cubicTo(3,6, 2,0, 2,1);
233    path.close();
234    pathB.setFillType(SkPath::kWinding_FillType);
235    pathB.moveTo(0,2);
236    pathB.cubicTo(1,2, 1,0, 6,3);
237    pathB.close();
238    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
239}
240
241static void cubicOp16d(skiatest::Reporter* reporter, const char* filename) {
242    SkPath path, pathB;
243    path.setFillType(SkPath::kWinding_FillType);
244    path.moveTo(0,2);
245    path.cubicTo(0,1, 3,0, 1,0);
246    path.close();
247    pathB.setFillType(SkPath::kWinding_FillType);
248    pathB.moveTo(0,3);
249    pathB.cubicTo(0,1, 2,0, 1,0);
250    pathB.close();
251    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
252}
253
254static void cubicOp17d(skiatest::Reporter* reporter, const char* filename) {
255    SkPath path, pathB;
256    path.setFillType(SkPath::kWinding_FillType);
257    path.moveTo(0,2);
258    path.cubicTo(0,2, 4,0, 2,1);
259    path.close();
260    pathB.setFillType(SkPath::kWinding_FillType);
261    pathB.moveTo(0,4);
262    pathB.cubicTo(1,2, 2,0, 2,0);
263    pathB.close();
264    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
265}
266
267static void cubicOp18d(skiatest::Reporter* reporter, const char* filename) {
268    SkPath path, pathB;
269    path.setFillType(SkPath::kWinding_FillType);
270    path.moveTo(0,1);
271    path.cubicTo(3,5, 2,0, 2,1);
272    path.close();
273    pathB.setFillType(SkPath::kWinding_FillType);
274    pathB.moveTo(0,2);
275    pathB.cubicTo(1,2, 1,0, 5,3);
276    pathB.close();
277    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
278}
279
280static void cubicOp19i(skiatest::Reporter* reporter, const char* filename) {
281    SkPath path, pathB;
282    path.setFillType(SkPath::kWinding_FillType);
283    path.moveTo(0,2);
284    path.cubicTo(0,1, 2,1, 6,2);
285    path.close();
286    pathB.setFillType(SkPath::kWinding_FillType);
287    pathB.moveTo(1,2);
288    pathB.cubicTo(2,6, 2,0, 1,0);
289    pathB.close();
290    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
291}
292
293static void cubicOp20d(skiatest::Reporter* reporter, const char* filename) {
294    SkPath path, pathB;
295    path.setFillType(SkPath::kWinding_FillType);
296    path.moveTo(0,1);
297    path.cubicTo(0,1, 6,0, 2,1);
298    path.close();
299    pathB.setFillType(SkPath::kWinding_FillType);
300    pathB.moveTo(0,6);
301    pathB.cubicTo(1,2, 1,0, 1,0);
302    pathB.close();
303    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
304}
305
306static void cubicOp21d(skiatest::Reporter* reporter, const char* filename) {
307    SkPath path, pathB;
308    path.setFillType(SkPath::kWinding_FillType);
309    path.moveTo(0,1);
310    path.cubicTo(0,1, 2,1, 6,5);
311    path.close();
312    pathB.setFillType(SkPath::kWinding_FillType);
313    pathB.moveTo(1,2);
314    pathB.cubicTo(5,6, 1,0, 1,0);
315    pathB.close();
316    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
317}
318
319static void cubicOp22d(skiatest::Reporter* reporter, const char* filename) {
320    SkPath path, pathB;
321    path.setFillType(SkPath::kWinding_FillType);
322    path.moveTo(0,1);
323    path.cubicTo(2,3, 3,0, 2,1);
324    path.close();
325    pathB.setFillType(SkPath::kWinding_FillType);
326    pathB.moveTo(0,3);
327    pathB.cubicTo(1,2, 1,0, 3,2);
328    pathB.close();
329    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
330}
331
332static void cubicOp23d(skiatest::Reporter* reporter, const char* filename) {
333    SkPath path, pathB;
334    path.setFillType(SkPath::kWinding_FillType);
335    path.moveTo(0,1);
336    path.cubicTo(1,2, 4,0, 2,1);
337    path.close();
338    pathB.setFillType(SkPath::kWinding_FillType);
339    pathB.moveTo(0,4);
340    pathB.cubicTo(1,2, 1,0, 2,1);
341    pathB.close();
342    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
343}
344
345static void cubicOp24d(skiatest::Reporter* reporter, const char* filename) {
346    SkPath path, pathB;
347    path.setFillType(SkPath::kWinding_FillType);
348    path.moveTo(0,1);
349    path.cubicTo(1,2, 2,0, 3,2);
350    path.close();
351    pathB.setFillType(SkPath::kWinding_FillType);
352    pathB.moveTo(0,2);
353    pathB.cubicTo(2,3, 1,0, 2,1);
354    pathB.close();
355    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
356}
357
358static void testIntersect1(skiatest::Reporter* reporter, const char* filename) {
359    SkPath one, two;
360    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
361    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
362    testPathOp(reporter, one, two, kIntersect_PathOp, filename);
363}
364
365static void testUnion1(skiatest::Reporter* reporter, const char* filename) {
366    SkPath one, two;
367    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
368    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
369    testPathOp(reporter, one, two, kUnion_PathOp, filename);
370}
371
372static void testDiff1(skiatest::Reporter* reporter, const char* filename) {
373    SkPath one, two;
374    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
375    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
376    testPathOp(reporter, one, two, kDifference_PathOp, filename);
377}
378
379static void testXor1(skiatest::Reporter* reporter, const char* filename) {
380    SkPath one, two;
381    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
382    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
383    testPathOp(reporter, one, two, kXOR_PathOp, filename);
384}
385
386static void testIntersect2(skiatest::Reporter* reporter, const char* filename) {
387    SkPath one, two;
388    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
389    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
390    testPathOp(reporter, one, two, kIntersect_PathOp, filename);
391}
392
393static void testUnion2(skiatest::Reporter* reporter, const char* filename) {
394    SkPath one, two;
395    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
396    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
397    testPathOp(reporter, one, two, kUnion_PathOp, filename);
398}
399
400static void testDiff2(skiatest::Reporter* reporter, const char* filename) {
401    SkPath one, two;
402    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
403    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
404    testPathOp(reporter, one, two, kDifference_PathOp, filename);
405}
406
407static void testXor2(skiatest::Reporter* reporter, const char* filename) {
408    SkPath one, two;
409    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
410    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
411    testPathOp(reporter, one, two, kXOR_PathOp, filename);
412}
413
414static void testOp1d(skiatest::Reporter* reporter, const char* filename) {
415    SkPath path, pathB;
416    path.setFillType(SkPath::kWinding_FillType);
417    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
418    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
419    pathB.setFillType(SkPath::kWinding_FillType);
420    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
421    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
422    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
423}
424
425static void testOp2d(skiatest::Reporter* reporter, const char* filename) {
426    SkPath path, pathB;
427    path.setFillType(SkPath::kWinding_FillType);
428    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
429    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
430    pathB.setFillType(SkPath::kEvenOdd_FillType);
431    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
432    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
433    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
434}
435
436static void testOp3d(skiatest::Reporter* reporter, const char* filename) {
437    SkPath path, pathB;
438    path.setFillType(SkPath::kWinding_FillType);
439    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
440    path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
441    pathB.setFillType(SkPath::kWinding_FillType);
442    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
443    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
444    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
445}
446
447static void testOp1u(skiatest::Reporter* reporter, const char* filename) {
448    SkPath path, pathB;
449    path.setFillType(SkPath::kWinding_FillType);
450    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
451    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
452    pathB.setFillType(SkPath::kWinding_FillType);
453    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
454    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
455    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
456}
457
458static void testOp4d(skiatest::Reporter* reporter, const char* filename) {
459    SkPath path, pathB;
460    path.setFillType(SkPath::kWinding_FillType);
461    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
462    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
463    pathB.setFillType(SkPath::kWinding_FillType);
464    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
465    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
466    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
467}
468
469static void testOp5d(skiatest::Reporter* reporter, const char* filename) {
470    SkPath path, pathB;
471    path.setFillType(SkPath::kEvenOdd_FillType);
472    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
473    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
474    pathB.setFillType(SkPath::kEvenOdd_FillType);
475    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
476    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
477    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
478}
479
480static void testOp6d(skiatest::Reporter* reporter, const char* filename) {
481    SkPath path, pathB;
482    path.setFillType(SkPath::kEvenOdd_FillType);
483    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
484    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
485    pathB.setFillType(SkPath::kWinding_FillType);
486    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
487    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
488    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
489}
490
491static void testOp7d(skiatest::Reporter* reporter, const char* filename) {
492    SkPath path, pathB;
493    path.setFillType(SkPath::kEvenOdd_FillType);
494    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
495    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
496    pathB.setFillType(SkPath::kEvenOdd_FillType);
497    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
498    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
499    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
500}
501
502static void testOp2u(skiatest::Reporter* reporter, const char* filename) {
503    SkPath path, pathB;
504    path.setFillType(SkPath::kEvenOdd_FillType);
505    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
506    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
507    pathB.setFillType(SkPath::kWinding_FillType);
508    pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
509    pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
510    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
511}
512
513static void testOp8d(skiatest::Reporter* reporter, const char* filename) {
514    SkPath path, pathB;
515    path.addRect(0, 0, 640, 480);
516    pathB.moveTo(577330, 1971.72f);
517    pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
518    pathB.close();
519    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
520}
521static void cubicOp25i(skiatest::Reporter* reporter, const char* filename) {
522    SkPath path, pathB;
523    path.setFillType(SkPath::kWinding_FillType);
524    path.moveTo(0,1);
525    path.cubicTo(2,4, 5,0, 3,2);
526    path.close();
527    pathB.setFillType(SkPath::kWinding_FillType);
528    pathB.moveTo(0,5);
529    pathB.cubicTo(2,3, 1,0, 4,2);
530    pathB.close();
531    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
532}
533
534static void cubicOp26d(skiatest::Reporter* reporter, const char* filename) {
535    SkPath path, pathB;
536    path.setFillType(SkPath::kWinding_FillType);
537    path.moveTo(0,1);
538    path.cubicTo(3,4, 4,0, 3,2);
539    path.close();
540    pathB.setFillType(SkPath::kWinding_FillType);
541    pathB.moveTo(0,4);
542    pathB.cubicTo(2,3, 1,0, 4,3);
543    pathB.close();
544    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
545}
546
547static void cubicOp27d(skiatest::Reporter* reporter, const char* filename) {
548    SkPath path, pathB;
549    path.setFillType(SkPath::kWinding_FillType);
550    path.moveTo(0,1);
551    path.cubicTo(3,6, 1,0, 5,2);
552    path.close();
553    pathB.setFillType(SkPath::kWinding_FillType);
554    pathB.moveTo(0,1);
555    pathB.cubicTo(2,5, 1,0, 6,3);
556    pathB.close();
557    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
558}
559
560static void cubicOp28u(skiatest::Reporter* reporter, const char* filename) {
561    SkPath path, pathB;
562    path.setFillType(SkPath::kWinding_FillType);
563    path.moveTo(0,1);
564    path.cubicTo(1,4, 6,0, 3,2);
565    path.close();
566    pathB.setFillType(SkPath::kWinding_FillType);
567    pathB.moveTo(0,6);
568    pathB.cubicTo(2,3, 1,0, 4,1);
569    pathB.close();
570    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
571}
572
573static void cubicOp29d(skiatest::Reporter* reporter, const char* filename) {
574    SkPath path, pathB;
575    path.setFillType(SkPath::kWinding_FillType);
576    path.moveTo(0,1);
577    path.cubicTo(2,5, 6,0, 4,2);
578    path.close();
579    pathB.setFillType(SkPath::kWinding_FillType);
580    pathB.moveTo(0,6);
581    pathB.cubicTo(2,4, 1,0, 5,2);
582    pathB.close();
583    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
584}
585
586static void cubicOp30d(skiatest::Reporter* reporter, const char* filename) {
587    SkPath path, pathB;
588    path.setFillType(SkPath::kWinding_FillType);
589    path.moveTo(0,1);
590    path.cubicTo(2,5, 6,0, 5,3);
591    path.close();
592    pathB.setFillType(SkPath::kWinding_FillType);
593    pathB.moveTo(0,6);
594    pathB.cubicTo(3,5, 1,0, 5,2);
595    pathB.close();
596    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
597}
598
599static void cubicOp31d(skiatest::Reporter* reporter, const char* filename) {
600    SkPath path, pathB;
601    path.setFillType(SkPath::kWinding_FillType);
602    path.moveTo(0,2);
603    path.cubicTo(0,3, 2,1, 4,0);
604    path.close();
605    pathB.setFillType(SkPath::kWinding_FillType);
606    pathB.moveTo(1,2);
607    pathB.cubicTo(0,4, 2,0, 3,0);
608    pathB.close();
609    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
610}
611
612static void cubicOp31u(skiatest::Reporter* reporter, const char* filename) {
613    SkPath path, pathB;
614    path.setFillType(SkPath::kWinding_FillType);
615    path.moveTo(0,2);
616    path.cubicTo(0,3, 2,1, 4,0);
617    path.close();
618    pathB.setFillType(SkPath::kWinding_FillType);
619    pathB.moveTo(1,2);
620    pathB.cubicTo(0,4, 2,0, 3,0);
621    pathB.close();
622    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
623}
624
625static void cubicOp31x(skiatest::Reporter* reporter, const char* filename) {
626    SkPath path, pathB;
627    path.setFillType(SkPath::kWinding_FillType);
628    path.moveTo(0,2);
629    path.cubicTo(0,3, 2,1, 4,0);
630    path.close();
631    pathB.setFillType(SkPath::kWinding_FillType);
632    pathB.moveTo(1,2);
633    pathB.cubicTo(0,4, 2,0, 3,0);
634    pathB.close();
635    testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
636}
637
638static void cubicOp32d(skiatest::Reporter* reporter, const char* filename) {
639    SkPath path, pathB;
640    path.setFillType(SkPath::kWinding_FillType);
641    path.moveTo(0,1);
642    path.cubicTo(1,2, 6,0, 3,1);
643    path.close();
644    pathB.setFillType(SkPath::kWinding_FillType);
645    pathB.moveTo(0,6);
646    pathB.cubicTo(1,3, 1,0, 2,1);
647    pathB.close();
648    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
649}
650
651static void cubicOp33i(skiatest::Reporter* reporter, const char* filename) {
652    SkPath path, pathB;
653    path.setFillType(SkPath::kWinding_FillType);
654    path.moveTo(0,1);
655    path.cubicTo(1,2, 6,0, 3,1);
656    path.close();
657    pathB.setFillType(SkPath::kWinding_FillType);
658    pathB.moveTo(0,6);
659    pathB.cubicTo(1,3, 1,0, 2,1);
660    pathB.close();
661    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
662}
663
664static void cubicOp34d(skiatest::Reporter* reporter, const char* filename) {
665    SkPath path, pathB;
666    path.setFillType(SkPath::kWinding_FillType);
667    path.moveTo(0,1);
668    path.cubicTo(3,5, 2,1, 3,1);
669    path.close();
670    pathB.setFillType(SkPath::kWinding_FillType);
671    pathB.moveTo(1,2);
672    pathB.cubicTo(1,3, 1,0, 5,3);
673    pathB.close();
674    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
675}
676
677static void cubicOp35d(skiatest::Reporter* reporter, const char* filename) {
678    SkPath path, pathB;
679    path.setFillType(SkPath::kWinding_FillType);
680    path.moveTo(0,1);
681    path.cubicTo(1,5, 2,1, 4,0);
682    path.close();
683    pathB.setFillType(SkPath::kWinding_FillType);
684    pathB.moveTo(1,2);
685    pathB.cubicTo(0,4, 1,0, 5,1);
686    pathB.close();
687    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
688}
689
690static void cubicOp36u(skiatest::Reporter* reporter, const char* filename) {
691    SkPath path, pathB;
692    path.setFillType(SkPath::kWinding_FillType);
693    path.moveTo(0,1);
694    path.cubicTo(1,6, 2,0, 5,1);
695    path.close();
696    pathB.setFillType(SkPath::kWinding_FillType);
697    pathB.moveTo(0,2);
698    pathB.cubicTo(1,5, 1,0, 6,1);
699    pathB.close();
700    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
701}
702
703static void cubicOp37d(skiatest::Reporter* reporter, const char* filename) {
704    SkPath path, pathB;
705    path.setFillType(SkPath::kWinding_FillType);
706    path.moveTo(0,1);
707    path.cubicTo(2,6, 6,1, 4,3);
708    path.close();
709    pathB.setFillType(SkPath::kWinding_FillType);
710    pathB.moveTo(1,6);
711    pathB.cubicTo(3,4, 1,0, 6,2);
712    pathB.close();
713    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
714}
715
716// this fails to detect a cubic/cubic intersection
717// the slight overlap is missed when the cubics are approximated by quadratics
718// and the subsequent line/cubic intersection also (correctly) misses the intersection
719// if the line/cubic was a matching line/approx.quadratic then the missing intersection
720// could have been detected
721static void cubicOp38d(skiatest::Reporter* reporter, const char* filename) {
722    SkPath path, pathB;
723    path.setFillType(SkPath::kWinding_FillType);
724    path.moveTo(0,1);
725    path.cubicTo(0,6, 3,2, 4,1);
726    path.close();
727    pathB.setFillType(SkPath::kWinding_FillType);
728    pathB.moveTo(2,3);
729    pathB.cubicTo(1,4, 1,0, 6,0);
730    pathB.close();
731    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
732}
733
734static void cubicOp39d(skiatest::Reporter* reporter, const char* filename) {
735    SkPath path, pathB;
736    path.setFillType(SkPath::kWinding_FillType);
737    path.moveTo(0,1);
738    path.cubicTo(2,3, 5,1, 4,3);
739    path.close();
740    pathB.setFillType(SkPath::kWinding_FillType);
741    pathB.moveTo(1,5);
742    pathB.cubicTo(3,4, 1,0, 3,2);
743    pathB.close();
744    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
745}
746
747static void cubicOp40d(skiatest::Reporter* reporter, const char* filename) {
748    SkPath path, pathB;
749    path.setFillType(SkPath::kWinding_FillType);
750    path.moveTo(0,1);
751    path.cubicTo(1,5, 3,2, 4,2);
752    path.close();
753    pathB.setFillType(SkPath::kWinding_FillType);
754    pathB.moveTo(2,3);
755    pathB.cubicTo(2,4, 1,0, 5,1);
756    pathB.close();
757    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
758}
759
760static void cubicOp41i(skiatest::Reporter* reporter, const char* filename) {
761    SkPath path, pathB;
762    path.setFillType(SkPath::kWinding_FillType);
763    path.moveTo(0,1);
764    path.cubicTo(2,6, 4,3, 6,4);
765    path.close();
766    pathB.setFillType(SkPath::kWinding_FillType);
767    pathB.moveTo(3,4);
768    pathB.cubicTo(4,6, 1,0, 6,2);
769    pathB.close();
770    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
771}
772
773static void cubicOp42d(skiatest::Reporter* reporter, const char* filename) {
774    SkPath path, pathB;
775    path.setFillType(SkPath::kWinding_FillType);
776    path.moveTo(0,1);
777    path.cubicTo(1,2, 6,5, 5,4);
778    path.close();
779    pathB.setFillType(SkPath::kWinding_FillType);
780    pathB.moveTo(5,6);
781    pathB.cubicTo(4,5, 1,0, 2,1);
782    pathB.close();
783    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
784}
785
786static void cubicOp43d(skiatest::Reporter* reporter, const char* filename) {
787    SkPath path, pathB;
788    path.setFillType(SkPath::kWinding_FillType);
789    path.moveTo(0,2);
790    path.cubicTo(1,2, 4,0, 3,1);
791    path.close();
792    pathB.setFillType(SkPath::kWinding_FillType);
793    pathB.moveTo(0,4);
794    pathB.cubicTo(1,3, 2,0, 2,1);
795    pathB.close();
796    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
797}
798
799static void cubicOp44d(skiatest::Reporter* reporter, const char* filename) {
800    SkPath path, pathB;
801    path.setFillType(SkPath::kWinding_FillType);
802    path.moveTo(0,2);
803    path.cubicTo(3,6, 4,0, 3,2);
804    path.close();
805    pathB.setFillType(SkPath::kWinding_FillType);
806    pathB.moveTo(0,4);
807    pathB.cubicTo(2,3, 2,0, 6,3);
808    pathB.close();
809    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
810}
811
812static void cubicOp45d(skiatest::Reporter* reporter, const char* filename) {
813    SkPath path, pathB;
814    path.setFillType(SkPath::kWinding_FillType);
815    path.moveTo(0,2);
816    path.cubicTo(2,4, 4,0, 3,2);
817    path.close();
818    pathB.setFillType(SkPath::kWinding_FillType);
819    pathB.moveTo(0,4);
820    pathB.cubicTo(2,3, 2,0, 4,2);
821    pathB.close();
822    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
823}
824
825static void cubicOp46d(skiatest::Reporter* reporter, const char* filename) {
826    SkPath path, pathB;
827    path.setFillType(SkPath::kWinding_FillType);
828    path.moveTo(0,2);
829    path.cubicTo(3,5, 5,0, 4,2);
830    path.close();
831    pathB.setFillType(SkPath::kWinding_FillType);
832    pathB.moveTo(0,5);
833    pathB.cubicTo(2,4, 2,0, 5,3);
834    pathB.close();
835    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
836}
837
838static void cubicOp47d(skiatest::Reporter* reporter, const char* filename) {
839    SkPath path, pathB;
840    path.setFillType(SkPath::kWinding_FillType);
841    path.moveTo(0,1);
842    path.cubicTo(1,6, 6,2, 5,4);
843    path.close();
844    pathB.setFillType(SkPath::kWinding_FillType);
845    pathB.moveTo(2,6);
846    pathB.cubicTo(4,5, 1,0, 6,1);
847    pathB.close();
848    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
849}
850
851static void cubicOp48d(skiatest::Reporter* reporter, const char* filename) {
852    SkPath path, pathB;
853    path.setFillType(SkPath::kWinding_FillType);
854    path.moveTo(0,2);
855    path.cubicTo(2,3, 5,1, 3,2);
856    path.close();
857    pathB.setFillType(SkPath::kWinding_FillType);
858    pathB.moveTo(1,5);
859    pathB.cubicTo(2,3, 2,0, 3,2);
860    pathB.close();
861    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
862}
863
864static void cubicOp49d(skiatest::Reporter* reporter, const char* filename) {
865    SkPath path, pathB;
866    path.setFillType(SkPath::kWinding_FillType);
867    path.moveTo(0,2);
868    path.cubicTo(1,5, 3,2, 4,1);
869    path.close();
870    pathB.setFillType(SkPath::kWinding_FillType);
871    pathB.moveTo(2,3);
872    pathB.cubicTo(1,4, 2,0, 5,1);
873    pathB.close();
874    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
875}
876
877static void cubicOp50d(skiatest::Reporter* reporter, const char* filename) {
878    SkPath path, pathB;
879    path.setFillType(SkPath::kWinding_FillType);
880    path.moveTo(0,3);
881    path.cubicTo(1,6, 5,0, 5,1);
882    path.close();
883    pathB.setFillType(SkPath::kWinding_FillType);
884    pathB.moveTo(0,5);
885    pathB.cubicTo(1,5, 3,0, 6,1);
886    pathB.close();
887    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
888}
889
890static void cubicOp51d(skiatest::Reporter* reporter, const char* filename) {
891    SkPath path, pathB;
892    path.setFillType(SkPath::kWinding_FillType);
893    path.moveTo(0,3);
894    path.cubicTo(1,2, 4,1, 6,0);
895    path.close();
896    pathB.setFillType(SkPath::kWinding_FillType);
897    pathB.moveTo(1,4);
898    pathB.cubicTo(0,6, 3,0, 2,1);
899    pathB.close();
900    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
901}
902
903static void cubicOp52d(skiatest::Reporter* reporter, const char* filename) {
904    SkPath path, pathB;
905    path.setFillType(SkPath::kWinding_FillType);
906    path.moveTo(0,2);
907    path.cubicTo(1,2, 5,4, 4,3);
908    path.close();
909    pathB.setFillType(SkPath::kWinding_FillType);
910    pathB.moveTo(4,5);
911    pathB.cubicTo(3,4, 2,0, 2,1);
912    pathB.close();
913    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
914}
915
916static void cubicOp53d(skiatest::Reporter* reporter, const char* filename) {
917    SkPath path, pathB;
918    path.setFillType(SkPath::kWinding_FillType);
919    path.moveTo(0,3);
920    path.cubicTo(1,2, 5,3, 2,1);
921    path.close();
922    pathB.setFillType(SkPath::kWinding_FillType);
923    pathB.moveTo(3,5);
924    pathB.cubicTo(1,2, 3,0, 2,1);
925    pathB.close();
926    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
927}
928
929static void cubicOp54d(skiatest::Reporter* reporter, const char* filename) {
930    SkPath path, pathB;
931    path.setFillType(SkPath::kWinding_FillType);
932    path.moveTo(0,4);
933    path.cubicTo(1,3, 5,4, 4,2);
934    path.close();
935    pathB.setFillType(SkPath::kWinding_FillType);
936    pathB.moveTo(4,5);
937    pathB.cubicTo(2,4, 4,0, 3,1);
938    pathB.close();
939    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
940}
941
942static void cubicOp55d(skiatest::Reporter* reporter, const char* filename) {
943    SkPath path, pathB;
944    path.setFillType(SkPath::kWinding_FillType);
945    path.moveTo(0,5);
946    path.cubicTo(1,3, 3,2, 5,0);
947    path.close();
948    pathB.setFillType(SkPath::kWinding_FillType);
949    pathB.moveTo(2,3);
950    pathB.cubicTo(0,5, 5,0, 3,1);
951    pathB.close();
952    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
953}
954
955static void cubicOp56d(skiatest::Reporter* reporter, const char* filename) {
956    SkPath path, pathB;
957    path.setFillType(SkPath::kWinding_FillType);
958    path.moveTo(0,1);
959    path.cubicTo(2,6, 5,0, 2,1);
960    path.close();
961    pathB.setFillType(SkPath::kWinding_FillType);
962    pathB.moveTo(0,5);
963    pathB.cubicTo(1,2, 1,0, 6,2);
964    pathB.close();
965    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
966}
967
968static void cubicOp57d(skiatest::Reporter* reporter, const char* filename) {
969    SkPath path, pathB;
970    path.setFillType(SkPath::kWinding_FillType);
971    path.moveTo(0,5);
972    path.cubicTo(0,5, 5,4, 6,4);
973    path.close();
974    pathB.setFillType(SkPath::kWinding_FillType);
975    pathB.moveTo(4,5);
976    pathB.cubicTo(4,6, 5,0, 5,0);
977    pathB.close();
978    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
979}
980
981static void cubicOp58d(skiatest::Reporter* reporter, const char* filename) {
982    SkPath path, pathB;
983    path.setFillType(SkPath::kWinding_FillType);
984    path.moveTo(0,5);
985    path.cubicTo(3,4, 6,5, 5,3);
986    path.close();
987    pathB.setFillType(SkPath::kWinding_FillType);
988    pathB.moveTo(5,6);
989    pathB.cubicTo(3,5, 5,0, 4,3);
990    pathB.close();
991    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
992}
993
994static void cubicOp59d(skiatest::Reporter* reporter, const char* filename) {
995    SkPath path, pathB;
996    path.setFillType(SkPath::kWinding_FillType);
997    path.moveTo(0,1);
998    path.cubicTo(5,6, 4,0, 4,1);
999    path.close();
1000    pathB.setFillType(SkPath::kWinding_FillType);
1001    pathB.moveTo(0,4);
1002    pathB.cubicTo(1,4, 1,0, 6,5);
1003    pathB.close();
1004    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1005}
1006
1007static void cubicOp60d(skiatest::Reporter* reporter, const char* filename) {
1008    SkPath path, pathB;
1009    path.setFillType(SkPath::kWinding_FillType);
1010    path.moveTo(0,2);
1011    path.cubicTo(4,6, 6,0, 5,2);
1012    path.close();
1013    pathB.setFillType(SkPath::kWinding_FillType);
1014    pathB.moveTo(0,6);
1015    pathB.cubicTo(2,5, 2,0, 6,4);
1016    pathB.close();
1017    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1018}
1019
1020static void cubicOp61d(skiatest::Reporter* reporter, const char* filename) {
1021    SkPath path, pathB;
1022    path.setFillType(SkPath::kWinding_FillType);
1023    path.moveTo(1,2);
1024    path.cubicTo(0,5, 3,2, 6,1);
1025    path.close();
1026    pathB.setFillType(SkPath::kWinding_FillType);
1027    pathB.moveTo(2,3);
1028    pathB.cubicTo(1,6, 2,1, 5,0);
1029    pathB.close();
1030    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1031}
1032
1033static void cubicOp62d(skiatest::Reporter* reporter, const char* filename) {
1034    SkPath path, pathB;
1035    path.setFillType(SkPath::kWinding_FillType);
1036    path.moveTo(1,3);
1037    path.cubicTo(5,6, 5,3, 5,4);
1038    path.close();
1039    pathB.setFillType(SkPath::kWinding_FillType);
1040    pathB.moveTo(3,5);
1041    pathB.cubicTo(4,5, 3,1, 6,5);
1042    pathB.close();
1043    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1044}
1045
1046static void cubicOp63d(skiatest::Reporter* reporter, const char* filename) {
1047    SkPath path, pathB;
1048    path.setFillType(SkPath::kWinding_FillType);
1049    path.moveTo(2,3);
1050    path.cubicTo(0,4, 3,2, 5,3);
1051    path.close();
1052    pathB.setFillType(SkPath::kWinding_FillType);
1053    pathB.moveTo(2,3);
1054    pathB.cubicTo(3,5, 3,2, 4,0);
1055    pathB.close();
1056    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1057}
1058
1059static void cubicOp64d(skiatest::Reporter* reporter, const char* filename) {
1060    SkPath path, pathB;
1061    path.moveTo(0,1);
1062    path.cubicTo(0,1, 1,0, 3,0);
1063    path.lineTo(0,1);
1064    path.close();
1065    pathB.moveTo(0,1);
1066    pathB.cubicTo(0,3, 1,0, 1,0);
1067    pathB.lineTo(0,1);
1068    pathB.close();
1069    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1070}
1071
1072static void cubicOp65d(skiatest::Reporter* reporter, const char* filename) {
1073    SkPath path, pathB;
1074    path.moveTo(0,1);
1075    path.cubicTo(1,5, 1,0, 1,0);
1076    path.lineTo(0,1);
1077    path.close();
1078    pathB.moveTo(0,1);
1079    pathB.cubicTo(0,1, 1,0, 5,1);
1080    pathB.lineTo(0,1);
1081    pathB.close();
1082    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1083}
1084
1085static void rectOp1d(skiatest::Reporter* reporter, const char* filename) {
1086    SkPath path, pathB;
1087    path.moveTo(0,1);
1088    path.cubicTo(0,1, 1,0, 3,0);
1089    path.lineTo(0,1);
1090    path.close();
1091    pathB.moveTo(0,1);
1092    pathB.cubicTo(0,3, 1,0, 1,0);
1093    pathB.lineTo(0,1);
1094    pathB.close();
1095    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1096}
1097
1098static void cubicOp66u(skiatest::Reporter* reporter, const char* filename) {
1099    SkPath path, pathB;
1100    path.setFillType(SkPath::kWinding_FillType);
1101    path.moveTo(0,1);
1102    path.cubicTo(2,6, 4,2, 5,3);
1103    path.close();
1104    pathB.setFillType(SkPath::kWinding_FillType);
1105    pathB.moveTo(2,4);
1106    pathB.cubicTo(3,5, 1,0, 6,2);
1107    pathB.close();
1108    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1109}
1110
1111static void cubicOp67u(skiatest::Reporter* reporter, const char* filename) {
1112    SkPath path, pathB;
1113    path.moveTo(3,5);
1114    path.cubicTo(1,6, 5,0, 3,1);
1115    path.lineTo(3,5);
1116    path.close();
1117    pathB.moveTo(0,5);
1118    pathB.cubicTo(1,3, 5,3, 6,1);
1119    pathB.lineTo(0,5);
1120    pathB.close();
1121    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1122}
1123
1124static void cubicOp68u(skiatest::Reporter* reporter, const char* filename) {
1125    SkPath path, pathB;
1126    path.moveTo(0,5);
1127    path.cubicTo(4,5, 4,1, 5,0);
1128    path.close();
1129    pathB.moveTo(1,4);
1130    pathB.cubicTo(0,5, 5,0, 5,4);
1131    pathB.close();
1132    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1133}
1134
1135static void cubicOp69d(skiatest::Reporter* reporter, const char* filename) {
1136    SkPath path, pathB;
1137    path.moveTo(1,3);
1138    path.cubicTo(0,1, 3,1, 2,0);
1139    path.close();
1140    pathB.moveTo(1,3);
1141    pathB.cubicTo(0,2, 3,1, 1,0);
1142    pathB.close();
1143    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1144}
1145
1146SkPathOp ops[] = {
1147    kUnion_PathOp,
1148    kXOR_PathOp,
1149    kReverseDifference_PathOp,
1150    kXOR_PathOp,
1151    kReverseDifference_PathOp,
1152};
1153
1154static void rRect1(skiatest::Reporter* reporter, const char* filename) {
1155    SkScalar xA = 0.65f;
1156    SkScalar xB = 10.65f;
1157    SkScalar xC = 20.65f;
1158    SkScalar xD = 30.65f;
1159    SkScalar xE = 40.65f;
1160    SkScalar xF = 50.65f;
1161
1162    SkScalar yA = 0.65f;
1163    SkScalar yB = 10.65f;
1164    SkScalar yC = 20.65f;
1165    SkScalar yD = 30.65f;
1166    SkScalar yE = 40.65f;
1167    SkScalar yF = 50.65f;
1168    SkPath paths[5];
1169    SkRect rects[5];
1170    rects[0].set(xB, yB, xE, yE);
1171    paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5));  // red
1172    rects[1].set(xA, yA, xD, yD);
1173    paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5));  // green
1174    rects[2].set(xC, yA, xF, yD);
1175    paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5));  // blue
1176    rects[3].set(xA, yC, xD, yF);
1177    paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5));  // yellow
1178    rects[4].set(xC, yC, xF, yF);
1179    paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5));  // cyan
1180    SkPath path;
1181    path.setFillType(SkPath::kInverseEvenOdd_FillType);
1182    for (int index = 0; index < 5; ++index) {
1183        testPathOp(reporter, path, paths[index], ops[index], filename);
1184        Op(path, paths[index], ops[index], &path);
1185    }
1186}
1187
1188static void skp1(skiatest::Reporter* reporter, const char* filename) {
1189    SkPath path;
1190    path.setFillType(SkPath::kEvenOdd_FillType);
1191    path.moveTo(189,7);
1192    path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1193    path.lineTo(243,4);
1194    path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1195    path.lineTo(246,21);
1196    path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1197    path.lineTo(192,24);
1198    path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1199    path.lineTo(189,7);
1200    path.close();
1201    path.moveTo(191,8);
1202    path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1203    path.lineTo(242,6);
1204    path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1205    path.lineTo(244,20);
1206    path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1207    path.lineTo(193,22);
1208    path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1209    path.lineTo(191,8);
1210    path.close();
1211    SkPath pathB;
1212    pathB.setFillType(SkPath::kWinding_FillType);
1213    pathB.moveTo(189,4);
1214    pathB.lineTo(199,14);
1215    pathB.lineTo(236,14);
1216    pathB.lineTo(246,4);
1217    pathB.lineTo(189,4);
1218    pathB.close();
1219    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1220}
1221
1222static void skp2(skiatest::Reporter* reporter, const char* filename) {
1223    SkPath path;
1224    path.setFillType(SkPath::kEvenOdd_FillType);
1225    path.moveTo(253.000000f, 11757.0000f);
1226    path.lineTo(253.000000f, 222.000000f);
1227    path.lineTo(823.000000f, 222.000000f);
1228    path.lineTo(823.000000f, 11757.0000f);
1229    path.lineTo(253.000000f, 11757.0000f);
1230    path.close();
1231    SkPath pathB;
1232    pathB.setFillType(SkPath::kWinding_FillType);
1233    pathB.moveTo(258.000000f, 1028.00000f);
1234    pathB.lineTo(258.000000f, 1027.00000f);
1235    pathB.lineTo(823.000000f, 1027.00000f);
1236    pathB.lineTo(823.000000f, 1028.00000f);
1237    pathB.lineTo(258.000000f, 1028.00000f);
1238    pathB.close();
1239    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1240}
1241
1242static void skp3(skiatest::Reporter* reporter, const char* filename) {
1243    SkPath path;
1244    path.setFillType(SkPath::kEvenOdd_FillType);
1245    path.moveTo(717.000000f, 507.000000f);
1246    path.lineTo(717.000000f, 425.000000f);
1247    path.lineTo(973.000000f, 425.000000f);
1248    path.lineTo(973.000000f, 507.000000f);
1249    path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1250    path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1251    path.lineTo(720.000000f, 510.000000f);
1252    path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1253    path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1254    path.close();
1255    path.moveTo(719.000000f, 426.000000f);
1256    path.lineTo(971.000000f, 426.000000f);
1257    path.lineTo(971.000000f, 506.000000f);
1258    path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1259    path.lineTo(721.000000f, 508.000000f);
1260    path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1261    path.lineTo(719.000000f, 426.000000f);
1262    path.close();
1263    SkPath pathB;
1264    pathB.setFillType(SkPath::kWinding_FillType);
1265    pathB.moveTo(717.000000f, 510.000000f);
1266    pathB.lineTo(760.000000f, 467.000000f);
1267    pathB.lineTo(930.000000f, 467.000000f);
1268    pathB.lineTo(973.000000f, 510.000000f);
1269    pathB.lineTo(717.000000f, 510.000000f);
1270    pathB.close();
1271    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1272}
1273
1274static void skp4(skiatest::Reporter* reporter, const char* filename) {
1275    SkPath path;
1276    path.setFillType(SkPath::kEvenOdd_FillType);
1277    path.moveTo(230.756805f, 591.756775f);
1278    path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1279    path.lineTo(300.000000f, 590.000000f);
1280    path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1281    path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1282    path.lineTo(306.000000f, 617.000000f);
1283    path.lineTo(229.000000f, 617.000000f);
1284    path.lineTo(229.000000f, 596.000000f);
1285    path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1286    path.close();
1287    path.moveTo(231.000000f, 597.000000f);
1288    path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1289    path.lineTo(299.000000f, 592.000000f);
1290    path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1291    path.lineTo(304.000000f, 616.000000f);
1292    path.lineTo(231.000000f, 616.000000f);
1293    path.lineTo(231.000000f, 597.000000f);
1294    path.close();
1295    SkPath pathB;
1296    pathB.setFillType(SkPath::kWinding_FillType);
1297    pathB.moveTo(306.000000f, 590.000000f);
1298    pathB.lineTo(292.000000f, 604.000000f);
1299    pathB.lineTo(305.000000f, 617.000000f);
1300    pathB.lineTo(306.000000f, 617.000000f);
1301    pathB.lineTo(306.000000f, 590.000000f);
1302    pathB.close();
1303    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1304}
1305
1306static void skp5(skiatest::Reporter* reporter, const char* filename) {
1307    SkPath path;
1308    path.setFillType(SkPath::kEvenOdd_FillType);
1309    path.moveTo(18.0000000f, 226.000000f);
1310    path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1311    path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1312    path.lineTo(10.0000000f, 253.000000f);
1313    path.lineTo(1247.00000f, 253.000000f);
1314    path.lineTo(1247.00000f, 234.000000f);
1315    path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1316    path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1317    path.lineTo(18.0000000f, 226.000000f);
1318    path.close();
1319    SkPath pathB;
1320    pathB.setFillType(SkPath::kInverseWinding_FillType);
1321    pathB.moveTo(18.0000000f, 226.000000f);
1322    pathB.lineTo(1239.00000f, 226.000000f);
1323    pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1324    pathB.lineTo(1247.00000f, 252.000000f);
1325    pathB.lineTo(10.0000000f, 252.000000f);
1326    pathB.lineTo(10.0000000f, 234.000000f);
1327    pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1328    pathB.close();
1329    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1330}
1331
1332static void cubicOp70d(skiatest::Reporter* reporter, const char* filename) {
1333    SkPath path, pathB;
1334    path.setFillType(SkPath::kWinding_FillType);
1335    path.moveTo(0,1);
1336    path.cubicTo(0,5, 4,0, 5,0);
1337    path.close();
1338    pathB.setFillType(SkPath::kWinding_FillType);
1339    pathB.moveTo(0,4);
1340    pathB.cubicTo(0,5, 1,0, 5,0);
1341    pathB.close();
1342    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1343}
1344
1345static void cubicOp71d(skiatest::Reporter* reporter, const char* filename) {
1346    SkPath path, pathB;
1347    path.setFillType(SkPath::kWinding_FillType);
1348    path.moveTo(0,1);
1349    path.cubicTo(0,5, 4,1, 6,4);
1350    path.close();
1351    pathB.setFillType(SkPath::kWinding_FillType);
1352    pathB.moveTo(1,4);
1353    pathB.cubicTo(4,6, 1,0, 5,0);
1354    pathB.close();
1355    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1356}
1357
1358static void cubicOp72i(skiatest::Reporter* reporter, const char* filename) {
1359    SkPath path, pathB;
1360    path.setFillType(SkPath::kWinding_FillType);
1361    path.moveTo(0,1);
1362    path.cubicTo(0,5, 5,2, 5,4);
1363    path.close();
1364    pathB.setFillType(SkPath::kWinding_FillType);
1365    pathB.moveTo(2,5);
1366    pathB.cubicTo(4,5, 1,0, 5,0);
1367    pathB.close();
1368    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1369}
1370
1371static void cubicOp73d(skiatest::Reporter* reporter, const char* filename) {
1372    SkPath path, pathB;
1373    path.setFillType(SkPath::kWinding_FillType);
1374    path.moveTo(0,1);
1375    path.cubicTo(3,4, 4,0, 6,4);
1376    path.lineTo(0,1);
1377    path.close();
1378    pathB.setFillType(SkPath::kWinding_FillType);
1379    pathB.moveTo(0,4);
1380    pathB.cubicTo(4,6, 1,0, 4,3);
1381    pathB.lineTo(0,4);
1382    pathB.close();
1383    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1384}
1385
1386static void cubicOp74d(skiatest::Reporter* reporter, const char* filename) {
1387    SkPath path, pathB;
1388    path.setFillType(SkPath::kWinding_FillType);
1389    path.moveTo(0,1);
1390    path.cubicTo(1,5, 5,1, 5,1);
1391    path.lineTo(0,1);
1392    path.close();
1393    pathB.setFillType(SkPath::kWinding_FillType);
1394    pathB.moveTo(1,5);
1395    pathB.cubicTo(1,5, 1,0, 5,1);
1396    pathB.lineTo(1,5);
1397    pathB.close();
1398    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1399}
1400
1401static void cubicOp75d(skiatest::Reporter* reporter, const char* filename) {
1402    SkPath path, pathB;
1403    path.setFillType(SkPath::kWinding_FillType);
1404    path.moveTo(0,1);
1405    path.cubicTo(0,4, 5,1, 6,4);
1406    path.lineTo(0,1);
1407    path.close();
1408    pathB.setFillType(SkPath::kWinding_FillType);
1409    pathB.moveTo(1,5);
1410    pathB.cubicTo(4,6, 1,0, 4,0);
1411    pathB.lineTo(1,5);
1412    pathB.close();
1413    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1414}
1415
1416static void cubicOp76u(skiatest::Reporter* reporter, const char* filename) {
1417    SkPath path, pathB;
1418    path.setFillType(SkPath::kWinding_FillType);
1419    path.moveTo(0,1);
1420    path.cubicTo(0,2, 2,0, 5,3);
1421    path.close();
1422    pathB.setFillType(SkPath::kWinding_FillType);
1423    pathB.moveTo(0,2);
1424    pathB.cubicTo(3,5, 1,0, 2,0);
1425    pathB.close();
1426    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1427}
1428
1429static void cubicOp77i(skiatest::Reporter* reporter, const char* filename) {
1430    SkPath path, pathB;
1431    path.setFillType(SkPath::kEvenOdd_FillType);
1432    path.moveTo(0,1);
1433    path.cubicTo(1,3, 2,0, 3,2);
1434    path.lineTo(0,1);
1435    path.close();
1436    pathB.setFillType(SkPath::kEvenOdd_FillType);
1437    pathB.moveTo(0,2);
1438    pathB.cubicTo(2,3, 1,0, 3,1);
1439    pathB.lineTo(0,2);
1440    pathB.close();
1441    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1442}
1443
1444static void cubicOp78u(skiatest::Reporter* reporter, const char* filename) {
1445    SkPath path, pathB;
1446    path.setFillType(SkPath::kEvenOdd_FillType);
1447    path.moveTo(1,6);
1448    path.cubicTo(1,6, 5,0, 6,1);
1449    path.lineTo(1,6);
1450    path.close();
1451    pathB.setFillType(SkPath::kEvenOdd_FillType);
1452    pathB.moveTo(0,5);
1453    pathB.cubicTo(1,6, 6,1, 6,1);
1454    pathB.lineTo(0,5);
1455    pathB.close();
1456    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
1457}
1458
1459static void cubicOp79u(skiatest::Reporter* reporter, const char* filename) {
1460    SkPath path, pathB;
1461    path.setFillType(SkPath::kWinding_FillType);
1462    path.moveTo(0,1);
1463    path.cubicTo(1,3, 1,0, 6,4);
1464    path.close();
1465    pathB.setFillType(SkPath::kWinding_FillType);
1466    pathB.moveTo(0,1);
1467    pathB.cubicTo(4,6, 1,0, 3,1);
1468    pathB.close();
1469    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1470}
1471
1472static void cubicOp80i(skiatest::Reporter* reporter, const char* filename) {
1473    SkPath path, pathB;
1474    path.setFillType(SkPath::kWinding_FillType);
1475    path.moveTo(0,1);
1476    path.cubicTo(2,3, 2,1, 4,3);
1477    path.lineTo(0,1);
1478    path.close();
1479    pathB.setFillType(SkPath::kWinding_FillType);
1480    pathB.moveTo(1,2);
1481    pathB.cubicTo(3,4, 1,0, 3,2);
1482    pathB.lineTo(1,2);
1483    pathB.close();
1484    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1485}
1486
1487static void cubicOp81d(skiatest::Reporter* reporter, const char* filename) {
1488    SkPath path, pathB;
1489    path.setFillType(SkPath::kWinding_FillType);
1490    path.moveTo(0,1);
1491    path.cubicTo(4,6, 4,3, 5,4);
1492    path.close();
1493    pathB.setFillType(SkPath::kWinding_FillType);
1494    pathB.moveTo(3,4);
1495    pathB.cubicTo(4,5, 1,0, 6,4);
1496    pathB.close();
1497    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1498}
1499
1500static void cubicOp82i(skiatest::Reporter* reporter, const char* filename) {
1501    SkPath path, pathB;
1502    path.setFillType(SkPath::kEvenOdd_FillType);
1503    path.moveTo(0,1);
1504    path.cubicTo(2,3, 5,2, 3,0);
1505    path.lineTo(0,1);
1506    path.close();
1507    pathB.setFillType(SkPath::kWinding_FillType);
1508    pathB.moveTo(2,5);
1509    pathB.cubicTo(0,3, 1,0, 3,2);
1510    pathB.lineTo(2,5);
1511    pathB.close();
1512    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1513}
1514
1515static void cubicOp83i(skiatest::Reporter* reporter, const char* filename) {
1516    SkPath path, pathB;
1517    path.setFillType(SkPath::kWinding_FillType);
1518    path.moveTo(0,1);
1519    path.cubicTo(0,3, 2,1, 4,1);
1520    path.lineTo(0,1);
1521    path.close();
1522    pathB.setFillType(SkPath::kWinding_FillType);
1523    pathB.moveTo(1,2);
1524    pathB.cubicTo(1,4, 1,0, 3,0);
1525    pathB.lineTo(1,2);
1526    pathB.close();
1527    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1528}
1529
1530static void cubicOp84d(skiatest::Reporter* reporter, const char* filename) {
1531    SkPath path, pathB;
1532    path.setFillType(SkPath::kWinding_FillType);
1533    path.moveTo(0,4);
1534    path.cubicTo(2,3, 6,3, 3,2);
1535    path.close();
1536    pathB.setFillType(SkPath::kWinding_FillType);
1537    pathB.moveTo(3,6);
1538    pathB.cubicTo(2,3, 4,0, 3,2);
1539    pathB.close();
1540    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1541}
1542
1543static void skpClip1(skiatest::Reporter* reporter, const char* filename) {
1544    SkPath path;
1545    path.setFillType(SkPath::kEvenOdd_FillType);
1546    path.moveTo(1126.17114f, 877.171204f);
1547    path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1548    path.lineTo(1243.00000f, 876.000000f);
1549    path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1550    path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1551    path.lineTo(1247.00000f, 907.000000f);
1552    path.lineTo(1246.00000f, 907.000000f);
1553    path.lineTo(1246.00000f, 880.000000f);
1554    path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1555    path.lineTo(1129.00000f, 877.000000f);
1556    path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1557    path.lineTo(1126.00000f, 907.000000f);
1558    path.lineTo(1125.00000f, 907.000000f);
1559    path.lineTo(1125.00000f, 880.000000f);
1560    path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1561    path.close();
1562    SkPath pathB;
1563    pathB.setFillType(SkPath::kWinding_FillType);
1564    pathB.moveTo(1247.00000f, 876.000000f);
1565    pathB.lineTo(1231.00000f, 892.000000f);
1566    pathB.lineTo(1246.00000f, 907.000000f);
1567    pathB.lineTo(1247.00000f, 907.000000f);
1568    pathB.lineTo(1247.00000f, 876.000000f);
1569    pathB.close();
1570    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1571}
1572
1573static void skpClip2(skiatest::Reporter* reporter, const char* filename) {
1574    SkPath path;
1575    path.setFillType(SkPath::kEvenOdd_FillType);
1576    path.moveTo(134.000000f, 11414.0000f);
1577    path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1578    path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1579    path.lineTo(806.000000f, 11419.0000f);
1580    path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1581    path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1582    path.lineTo(134.000000f, 11414.0000f);
1583    path.close();
1584    SkPath pathB;
1585    pathB.setFillType(SkPath::kInverseWinding_FillType);
1586    pathB.moveTo(132.000000f, 11415.0000f);
1587    pathB.lineTo(806.000000f, 11415.0000f);
1588    pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1589    pathB.lineTo(808.000000f, 11417.0000f);
1590    pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1591    pathB.lineTo(132.000000f, 11419.0000f);
1592    pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1593    pathB.lineTo(130.000000f, 11416.0000f);
1594    pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1595    pathB.close();
1596    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1597}
1598
1599static void skp96prezzi1(skiatest::Reporter* reporter, const char* filename) {
1600    SkPath path;
1601    path.setFillType(SkPath::kEvenOdd_FillType);
1602    path.moveTo(157.464005f, 670.463989f);
1603    path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1604    path.lineTo(248.000000f, 669.000000f);
1605    path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1606    path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1607    path.lineTo(253.000000f, 706.000000f);
1608    path.lineTo(251.000000f, 706.000000f);
1609    path.lineTo(251.000000f, 675.000000f);
1610    path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1611    path.lineTo(162.000000f, 671.000000f);
1612    path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1613    path.lineTo(158.000000f, 706.000000f);
1614    path.lineTo(156.000000f, 706.000000f);
1615    path.lineTo(156.000000f, 674.000000f);
1616    path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1617    path.close();
1618    SkPath pathB;
1619    pathB.setFillType(SkPath::kWinding_FillType);
1620    pathB.moveTo(156.000000f, 669.000000f);
1621    pathB.lineTo(178.500000f, 691.500000f);
1622    pathB.lineTo(230.500000f, 691.500000f);
1623    pathB.lineTo(253.000000f, 669.000000f);
1624    pathB.lineTo(156.000000f, 669.000000f);
1625    pathB.close();
1626    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1627}
1628
1629static void skpancestry_com1(skiatest::Reporter* reporter, const char* filename) {
1630    SkPath path;
1631    path.setFillType(SkPath::kEvenOdd_FillType);
1632    path.moveTo(161.000000f, 925.000000f);
1633    path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1634    path.lineTo(158.000000f, 926.000000f);
1635    path.lineTo(1108.00000f, 926.000000f);
1636    path.lineTo(1108.00000f, 925.999634f);
1637    path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1638    path.lineTo(161.000000f, 925.000000f);
1639    path.close();
1640    SkPath pathB;
1641    pathB.setFillType(SkPath::kEvenOdd_FillType);
1642    pathB.moveTo(161.000000f, 926.000000f);
1643    pathB.lineTo(1105.00000f, 926.000000f);
1644    pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1645    pathB.lineTo(1109.00000f, 956.000000f);
1646    pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1647    pathB.lineTo(161.000000f, 960.000000f);
1648    pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1649    pathB.lineTo(157.000000f, 930.000000f);
1650    pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1651    pathB.close();
1652    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1653}
1654
1655static void skpeldorado_com_ua1(skiatest::Reporter* reporter, const char* filename) {
1656    SkPath path;
1657    path.setFillType(SkPath::kEvenOdd_FillType);
1658    path.moveTo(286.695129f, 291.000000f);
1659    path.lineTo(229.304855f, 561.000000f);
1660    path.lineTo(979.304871f, 561.000000f);
1661    path.lineTo(1036.69507f, 291.000000f);
1662    path.lineTo(286.695129f, 291.000000f);
1663    path.close();
1664    SkPath pathB;
1665    pathB.setFillType(SkPath::kWinding_FillType);
1666    pathB.moveTo(1006.69513f, 291.000000f);
1667    pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1668    pathB.lineTo(985.681519f, 531.000000f);
1669    pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1670    pathB.lineTo(259.304871f, 561.000000f);
1671    pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1672    pathB.lineTo(280.318420f, 321.000000f);
1673    pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1674    pathB.lineTo(1006.69513f, 291.000000f);
1675    pathB.close();
1676    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1677}
1678
1679static void skpbyte_com1(skiatest::Reporter* reporter, const char* filename) {
1680    SkPath path;
1681    path.setFillType(SkPath::kEvenOdd_FillType);
1682    path.moveTo(968.000000f, 14.0000000f);
1683    path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1684    path.lineTo(963.000000f, 32.0000000f);
1685    path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1686    path.lineTo(1034.00000f, 37.0000000f);
1687    path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1688    path.lineTo(1039.00000f, 19.0000000f);
1689    path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1690    path.lineTo(968.000000f, 14.0000000f);
1691    path.close();
1692    SkPath pathB;
1693    pathB.setFillType(SkPath::kInverseWinding_FillType);
1694    pathB.moveTo(968.000000f, 14.0000000f);
1695    pathB.lineTo(1034.00000f, 14.0000000f);
1696    pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1697    pathB.lineTo(1039.00000f, 32.0000000f);
1698    pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1699    pathB.lineTo(968.000000f, 36.0000000f);
1700    pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1701    pathB.lineTo(963.000000f, 19.0000000f);
1702    pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1703    pathB.close();
1704    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1705}
1706
1707static void skphealth_com76(skiatest::Reporter* reporter, const char* filename) {
1708    SkPath path;
1709    path.setFillType(SkPath::kEvenOdd_FillType);
1710    path.moveTo(708.099182f, 7.09919119f);
1711    path.lineTo(708.099182f, 7.09920025f);
1712    path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1713    path.lineTo(704.000000f, 33.0000000f);
1714    path.lineTo(705.000000f, 33.0000000f);
1715    path.lineTo(705.000000f, 17.0000000f);
1716    path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1717    path.lineTo(708.099182f, 7.09919119f);
1718    path.close();
1719    SkPath pathB;
1720    pathB.setFillType(SkPath::kWinding_FillType);
1721    pathB.moveTo(704.000000f, 3.00000000f);
1722#if 0
1723    pathB.lineTo(719.500000f, 3.00000000f);
1724    pathB.lineTo(705.000000f, 33.0000000f);
1725    pathB.lineTo(704.000000f, 33.0000000f);
1726    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1727#else
1728    pathB.lineTo(704.000000f, 33.0000000f);
1729    pathB.lineTo(705.000000f, 33.0000000f);
1730    pathB.lineTo(719.500000f, 3.00000000f);
1731    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1732#endif
1733}
1734
1735static void skpahrefs_com88(skiatest::Reporter* reporter, const char* filename) {
1736    SkPath path;
1737    path.setFillType(SkPath::kEvenOdd_FillType);
1738    path.moveTo(1099.82886f, 7.17117119f);
1739    path.lineTo(1099.12134f, 7.87867832f);
1740    path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1741    path.lineTo(1100.00000f, 28.0000000f);
1742    path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1743    path.lineTo(1088.00000f, 31.0000000f);
1744    path.lineTo(1088.00000f, 32.0000000f);
1745    path.lineTo(1097.00000f, 32.0000000f);
1746    path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1747    path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1748    path.lineTo(1101.00000f, 10.0000000f);
1749    path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1750    path.lineTo(1099.82886f, 7.17117119f);
1751    path.close();
1752    SkPath pathB;
1753    pathB.setFillType(SkPath::kWinding_FillType);
1754    pathB.moveTo(1101.00000f, 6.00000000f);
1755    pathB.lineTo(1088.00000f, 6.00000000f);
1756    pathB.lineTo(1088.00000f, 19.0000000f);
1757    pathB.lineTo(1101.00000f, 32.0000000f);
1758    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1759}
1760
1761static void skpahrefs_com29(skiatest::Reporter* reporter, const char* filename) {
1762    SkPath path;
1763    path.setFillType(SkPath::kEvenOdd_FillType);
1764    path.moveTo(1037.17114f, 7.17119980f);
1765    path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1766    path.lineTo(1074.00000f, 6.00000000f);
1767    path.lineTo(1074.00000f, 32.0000000f);
1768    path.lineTo(1040.00000f, 32.0000000f);
1769    path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1770    path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1771    path.lineTo(1036.00000f, 10.0000000f);
1772    path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1773    path.close();
1774    path.moveTo(1037.00000f, 10.0000000f);
1775    path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1776    path.lineTo(1073.00000f, 7.00000000f);
1777    path.lineTo(1073.00000f, 31.0000000f);
1778    path.lineTo(1040.00000f, 31.0000000f);
1779    path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1780    path.lineTo(1037.00000f, 10.0000000f);
1781    path.close();
1782    SkPath pathB;
1783    pathB.setFillType(SkPath::kWinding_FillType);
1784    pathB.moveTo(1036.00000f, 32.0000000f);
1785    pathB.lineTo(1049.00000f, 19.0000000f);
1786    pathB.lineTo(1073.00000f, 31.0000000f);
1787    pathB.lineTo(1074.00000f, 32.0000000f);
1788    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1789}
1790
1791static void cubicOp85d(skiatest::Reporter* reporter, const char* filename) {
1792    SkPath path;
1793    path.setFillType(SkPath::kWinding_FillType);
1794    path.moveTo(0,1);
1795    path.cubicTo(1,6, 1,0, 6,2);
1796    path.close();
1797    SkPath pathB;
1798    pathB.setFillType(SkPath::kWinding_FillType);
1799    pathB.moveTo(0,1);
1800    pathB.cubicTo(2,6, 1,0, 6,1);
1801    pathB.close();
1802    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
1803}
1804
1805// this fails because the pair of nearly coincident cubics intersect at the ends
1806// but the line connected to one of the cubics at the same point does not intersect
1807// the other
1808static void skpkkiste_to98(skiatest::Reporter* reporter, const char* filename) {
1809    SkPath path;
1810    path.setFillType(SkPath::kEvenOdd_FillType);
1811    path.moveTo(96, 122);
1812    path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1813    path.lineTo(94.1715698f, 125.17157f);
1814    path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1815    path.lineTo(257, 124);
1816    path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1817    path.lineTo(261.535522f, 123.46447f);
1818    path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1819    path.lineTo(96, 122);
1820    path.close();
1821    SkPath pathB;
1822    pathB.setFillType(SkPath::kWinding_FillType);
1823    pathB.moveTo(258, 122);
1824    pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1825    pathB.lineTo(263, 284);
1826    pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1827    pathB.lineTo(96, 289);
1828    pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1829    pathB.lineTo(91, 127);
1830    pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1831    pathB.lineTo(258, 122);
1832    pathB.close();
1833    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1834}
1835
1836static void issue1417(skiatest::Reporter* reporter, const char* filename) {
1837    SkPath path1;
1838    path1.moveTo(122.58908843994140625f, 82.2836456298828125f);
1839    path1.quadTo(129.8215789794921875f, 80, 138, 80);
1840    path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f);
1841    path1.lineTo(161.1764678955078125f, 100);
1842    path1.lineTo(161.1764678955078125f, 100);
1843    path1.lineTo(115.29412078857421875f, 100);
1844    path1.lineTo(115.29412078857421875f, 100);
1845    path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1846    path1.lineTo(122.58908843994140625f, 82.2836456298828125f);
1847    path1.close();
1848    path1.moveTo(98.68194580078125f, 140.343841552734375f);
1849    path1.lineTo(115.29412078857421875f, 100);
1850    path1.lineTo(115.29412078857421875f, 100);
1851    path1.lineTo(97.9337615966796875f, 100);
1852    path1.lineTo(97.9337615966796875f, 100);
1853    path1.quadTo(88, 112.94264984130859375f, 88, 130);
1854    path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f);
1855    path1.lineTo(98.68194580078125f, 140.343841552734375f);
1856    path1.lineTo(98.68194580078125f, 140.343841552734375f);
1857    path1.close();
1858    path1.moveTo(136.969696044921875f, 166.6666717529296875f);
1859    path1.lineTo(98.68194580078125f, 140.343841552734375f);
1860    path1.lineTo(98.68194580078125f, 140.343841552734375f);
1861    path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1862    path1.lineTo(93.45894622802734375f, 153.02825927734375f);
1863    path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f);
1864    path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f);
1865    path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1866    path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1867    path1.close();
1868    path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1869    path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1870    path1.lineTo(136.969696044921875f, 166.6666717529296875f);
1871    path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1872    path1.lineTo(153.15728759765625f, 177.7956390380859375f);
1873    path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f);
1874    path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f);
1875    path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1876    path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1877    path1.close();
1878    path1.moveTo(175.8309783935546875f, 141.5211334228515625f);
1879    path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1880    path1.lineTo(187.8782806396484375f, 133.7258148193359375f);
1881    path1.quadTo(188, 131.8880615234375f, 188, 130);
1882    path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100);
1883    path1.lineTo(161.1764678955078125f, 100);
1884    path1.lineTo(161.1764678955078125f, 100);
1885    path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1886    path1.lineTo(175.8309783935546875f, 141.5211334228515625f);
1887    path1.close();
1888
1889    SkPath path2;
1890    path2.moveTo(174.117645263671875f, 100);
1891    path2.lineTo(161.1764678955078125f, 100);
1892    path2.lineTo(161.1764678955078125f, 100);
1893    path2.lineTo(155.1280364990234375f, 82.86279296875f);
1894    path2.lineTo(155.1280364990234375f, 82.86279296875f);
1895    path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f);
1896    path2.lineTo(143.5294189453125f, 100);
1897    path2.lineTo(143.5294189453125f, 100);
1898    path2.lineTo(161.1764678955078125f, 100);
1899    path2.lineTo(161.1764678955078125f, 100);
1900    path2.lineTo(168.23529052734375f, 120);
1901    path2.lineTo(168.23529052734375f, 120);
1902    path2.lineTo(181.1764678955078125f, 120);
1903    path2.lineTo(181.1764678955078125f, 120);
1904    path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1905    path2.lineTo(186.3661956787109375f, 134.7042236328125f);
1906    path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1907    path2.lineTo(187.8782806396484375f, 133.7258148193359375f);
1908    path2.quadTo(188, 131.8880615234375f, 188, 130);
1909    path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120);
1910    path2.lineTo(181.1764678955078125f, 120);
1911    path2.lineTo(181.1764678955078125f, 120);
1912    path2.lineTo(174.117645263671875f, 100);
1913    path2.lineTo(174.117645263671875f, 100);
1914    path2.close();
1915    path2.moveTo(88.91983795166015625f, 120);
1916    path2.lineTo(107.0588226318359375f, 120);
1917    path2.lineTo(107.0588226318359375f, 120);
1918    path2.lineTo(98.68194580078125f, 140.343841552734375f);
1919    path2.lineTo(98.68194580078125f, 140.343841552734375f);
1920    path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1921    path2.lineTo(88.08148956298828125f, 133.0560302734375f);
1922    path2.quadTo(88, 131.544830322265625f, 88, 130);
1923    path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120);
1924    path2.close();
1925    path2.moveTo(96.67621612548828125f, 145.21490478515625f);
1926    path2.lineTo(98.68194580078125f, 140.343841552734375f);
1927    path2.lineTo(98.68194580078125f, 140.343841552734375f);
1928    path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1929    path2.lineTo(120.68767547607421875f, 155.4727783203125f);
1930    path2.lineTo(118.68194580078125f, 160.343841552734375f);
1931    path2.lineTo(118.68194580078125f, 160.343841552734375f);
1932    path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1933    path2.lineTo(96.67621612548828125f, 145.21490478515625f);
1934    path2.close();
1935    path2.moveTo(113.232177734375f, 173.5789947509765625f);
1936    path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f);
1937    path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1938    path2.lineTo(132.2864990234375f, 169.6969757080078125f);
1939    path2.lineTo(118.68194580078125f, 160.343841552734375f);
1940    path2.lineTo(118.68194580078125f, 160.343841552734375f);
1941    path2.lineTo(113.232177734375f, 173.5789947509765625f);
1942    path2.lineTo(113.232177734375f, 173.5789947509765625f);
1943    path2.close();
1944
1945    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
1946}
1947
1948static void issue1418(skiatest::Reporter* reporter, const char* filename) {
1949    SkPath path1;
1950    path1.moveTo(0, 0);
1951    path1.lineTo(1, 0);
1952    path1.lineTo(1, 0);
1953    path1.lineTo(1, 1);
1954    path1.lineTo(1, 1);
1955    path1.lineTo(0, 1);
1956    path1.lineTo(0, 1);
1957    path1.lineTo(0, 0);
1958    path1.lineTo(0, 0);
1959    path1.close();
1960
1961    SkPath path2;
1962    path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f);
1963    path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f);
1964    path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f);
1965    path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0);
1966    path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f);
1967    path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f);
1968    path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f);
1969    path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0);
1970    path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f);
1971    testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
1972}
1973
1974static void cubicOp85i(skiatest::Reporter* reporter, const char* filename) {
1975    SkPath path, pathB;
1976    path.setFillType(SkPath::kWinding_FillType);
1977    path.moveTo(3, 4);
1978    path.cubicTo(1, 5, 4, 3, 6, 4);
1979    path.close();
1980    pathB.setFillType(SkPath::kWinding_FillType);
1981    pathB.moveTo(3, 4);
1982    pathB.cubicTo(4, 6, 4, 3, 5, 1);
1983    pathB.close();
1984    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
1985}
1986
1987static void issue1418b(skiatest::Reporter* reporter, const char* filename) {
1988    SkPath path1;
1989    path1.moveTo(0, 0);
1990    path1.lineTo(1, 0);
1991    path1.lineTo(1, 1);
1992    path1.lineTo(0, 1);
1993    path1.lineTo(0, 0);
1994    path1.close();
1995    path1.setFillType(SkPath::kWinding_FillType);
1996    SkPath path2;
1997    path2.moveTo(0.646446645f, -0.353553414f);
1998    path2.quadTo(0.792893291f, -0.50000006f, 1.00000012f, -0.50000006f);
1999    path2.quadTo(1.20710683f, -0.50000006f, 1.35355353f, -0.353553414f);
2000    path2.quadTo(1.50000012f, -0.207106799f, 1.50000012f, 0);
2001    path2.quadTo(1.50000012f, 0.207106799f, 1.35355353f, 0.353553414f);
2002    path2.quadTo(1.20710683f, 0.50000006f, 1.00000012f, 0.50000006f);
2003    path2.quadTo(0.792893291f, 0.50000006f, 0.646446645f, 0.353553414f);
2004    path2.quadTo(0.50000006f, 0.207106799f, 0.50000006f, 0);
2005    path2.quadTo(0.50000006f, -0.207106799f, 0.646446645f, -0.353553414f);
2006    path2.close();
2007    path2.moveTo(1.00000012f, 0.50000006f);
2008    path2.lineTo(1.00000012f, 1.00000012f);
2009    path2.lineTo(0.50000006f, 1.00000012f);
2010    path2.quadTo(0.50000006f, 0.792893291f, 0.646446645f, 0.646446645f);
2011    path2.quadTo(0.792893291f, 0.50000006f, 1.00000012f, 0.50000006f);
2012    path2.close();
2013    path2.setFillType(SkPath::kEvenOdd_FillType);
2014    testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
2015}
2016
2017static void rectOp1i(skiatest::Reporter* reporter, const char* filename) {
2018    SkPath path, pathB;
2019    path.setFillType(SkPath::kWinding_FillType);
2020    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2021    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
2022    pathB.setFillType(SkPath::kWinding_FillType);
2023    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2024    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2025    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2026}
2027
2028static void rectOp2i(skiatest::Reporter* reporter, const char* filename) {
2029    SkPath path, pathB;
2030    path.setFillType(SkPath::kEvenOdd_FillType);
2031    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
2032    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
2033    pathB.setFillType(SkPath::kWinding_FillType);
2034    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2035    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
2036    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2037}
2038
2039static void rectOp3x(skiatest::Reporter* reporter, const char* filename) {
2040    SkPath path, pathB;
2041    path.setFillType(SkPath::kEvenOdd_FillType);
2042    path.moveTo(0, 0);
2043    path.lineTo(3, 0);
2044    path.lineTo(3, 3);
2045    path.lineTo(0, 3);
2046    path.close();
2047    path.moveTo(2, 2);
2048    path.lineTo(3, 2);
2049    path.lineTo(3, 3);
2050    path.lineTo(2, 3);
2051    path.close();
2052    pathB.setFillType(SkPath::kWinding_FillType);
2053    pathB.moveTo(1, 1);
2054    pathB.lineTo(3, 1);
2055    pathB.lineTo(3, 3);
2056    pathB.lineTo(1, 3);
2057    pathB.close();
2058    pathB.moveTo(2, 2);
2059    pathB.lineTo(3, 2);
2060    pathB.lineTo(3, 3);
2061    pathB.lineTo(2, 3);
2062    pathB.close();
2063    testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
2064}
2065
2066// this fails to generate two interior line segments
2067// an earlier pathops succeeded, but still failed to generate one interior line segment
2068// (but was saved by assemble, which works around a single line missing segment)
2069static void issue1435(skiatest::Reporter* reporter, const char* filename) {
2070    SkPath path1;
2071    path1.moveTo(160, 60);
2072    path1.lineTo(220, 230);
2073    path1.lineTo(60, 120);
2074    path1.lineTo(260, 120);
2075    path1.lineTo(90, 230);
2076    path1.lineTo(160, 60);
2077    path1.close();
2078    path1.setFillType(SkPath::kEvenOdd_FillType);
2079
2080    SkPath path2;
2081    path2.moveTo(142.589081f, 102.283646f);
2082    path2.quadTo(149.821579f, 100, 158, 100);
2083    path2.quadTo(167.156921f, 100, 175.128036f, 102.862793f);
2084    path2.lineTo(181.176468f, 120);
2085    path2.lineTo(135.294128f, 120);
2086    path2.lineTo(142.589081f, 102.283646f);
2087    path2.close();
2088    path2.moveTo(118.681946f, 160.343842f);
2089    path2.lineTo(135.294128f, 120);
2090    path2.lineTo(117.933762f, 120);
2091    path2.quadTo(108, 132.942657f, 108, 150);
2092    path2.quadTo(108, 151.54483f, 108.08149f, 153.05603f);
2093    path2.lineTo(118.681946f, 160.343842f);
2094    path2.close();
2095    path2.moveTo(156.969696f, 186.666672f);
2096    path2.lineTo(118.681946f, 160.343842f);
2097    path2.lineTo(113.458946f, 173.028259f);
2098    path2.quadTo(116.94117f, 179.651855f, 122.644661f, 185.355347f);
2099    path2.quadTo(130.792465f, 193.503143f, 140.817978f, 197.117783f);
2100    path2.lineTo(156.969696f, 186.666672f);
2101    path2.close();
2102    path2.moveTo(195.830978f, 161.521133f);
2103    path2.lineTo(156.969696f, 186.666672f);
2104    path2.lineTo(173.157288f, 197.795639f);
2105    path2.quadTo(184.392426f, 194.318268f, 193.355347f, 185.355347f);
2106    path2.quadTo(197.805817f, 180.904861f, 200.903809f, 175.894165f);
2107    path2.lineTo(195.830978f, 161.521133f);
2108    path2.close();
2109    path2.moveTo(195.830978f, 161.521133f);
2110    path2.lineTo(207.878281f, 153.725815f);
2111    path2.quadTo(208, 151.888062f, 208, 150);
2112    path2.quadTo(208, 132.942657f, 198.066238f, 120);
2113    path2.lineTo(181.176468f, 120);
2114    path2.lineTo(195.830978f, 161.521133f);
2115    path2.close();
2116    path2.setFillType(SkPath::kEvenOdd_FillType);
2117    testPathOp(reporter, path1, path2, kIntersect_PathOp, filename);
2118}
2119
2120static void skpkkiste_to716(skiatest::Reporter* reporter, const char* filename) {
2121    SkPath path;
2122    path.setFillType(SkPath::kEvenOdd_FillType);
2123    path.moveTo(1173, 284);
2124    path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f);
2125    path.lineTo(1174, 123.999496f);
2126    path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127);
2127    path.lineTo(1173, 284);
2128    path.close();
2129    SkPath pathB;
2130    pathB.setFillType(SkPath::kWinding_FillType);
2131    pathB.moveTo(1340, 122);
2132    pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127);
2133    pathB.lineTo(1345, 284);
2134    pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289);
2135    pathB.lineTo(1178, 289);
2136    pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284);
2137    pathB.lineTo(1173, 127);
2138    pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122);
2139    pathB.lineTo(1340, 122);
2140    pathB.close();
2141    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2142}
2143
2144static void loopEdge1(skiatest::Reporter* reporter, const char* filename) {
2145    SkPath path;
2146    path.setFillType(SkPath::kEvenOdd_FillType);
2147    path.moveTo(0,0);
2148    path.lineTo(3,0);
2149    path.lineTo(3,2);
2150    path.lineTo(1,2);
2151    path.lineTo(1,1);
2152    path.lineTo(2,1);
2153    path.lineTo(2,3);
2154    path.lineTo(0,3);
2155    path.close();
2156    SkPath pathB;
2157    pathB.setFillType(SkPath::kEvenOdd_FillType);
2158    pathB.moveTo(1,2);
2159    pathB.lineTo(2,2);
2160    pathB.lineTo(2,4);
2161    pathB.lineTo(1,4);
2162    pathB.close();
2163    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2164}
2165
2166static void loopEdge2(skiatest::Reporter* reporter, const char* filename) {
2167    SkPath path;
2168    path.setFillType(SkPath::kEvenOdd_FillType);
2169    path.moveTo(0,0);
2170    path.lineTo(3,0);
2171    path.lineTo(3,2);
2172    path.lineTo(1,2);
2173    path.lineTo(1,1);
2174    path.lineTo(2,1);
2175    path.lineTo(2,3);
2176    path.lineTo(0,3);
2177    path.close();
2178    SkPath pathB;
2179    pathB.setFillType(SkPath::kEvenOdd_FillType);
2180    pathB.moveTo(1 - 1e-6f,2);
2181    pathB.lineTo(2 - 1e-6f,2);
2182    pathB.lineTo(2 - 1e-6f,4);
2183    pathB.lineTo(1 - 1e-6f,4);
2184    pathB.close();
2185    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2186}
2187
2188static void cubicOp86i(skiatest::Reporter* reporter, const char* filename) {
2189    SkPath path, pathB;
2190    path.setFillType(SkPath::kWinding_FillType);
2191    path.moveTo(0, 4);
2192    path.cubicTo(3, 4, 6, 2, 5, 2);
2193    path.close();
2194    pathB.setFillType(SkPath::kEvenOdd_FillType);
2195    pathB.moveTo(2, 6);
2196    pathB.cubicTo(2, 5, 4, 0, 4, 3);
2197    pathB.close();
2198    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2199}
2200
2201static void cubicOp87u(skiatest::Reporter* reporter, const char* filename) {
2202    SkPath path, pathB;
2203    path.setFillType(SkPath::kWinding_FillType);
2204    path.moveTo(0,1);
2205    path.cubicTo(0,2, 2,0, 6,4);
2206    path.close();
2207    pathB.setFillType(SkPath::kWinding_FillType);
2208    pathB.moveTo(0,2);
2209    pathB.cubicTo(4,6, 1,0, 2,0);
2210    pathB.close();
2211    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2212}
2213
2214static void cubicOp88u(skiatest::Reporter* reporter, const char* filename) {
2215    SkPath path, pathB;
2216    path.setFillType(SkPath::kWinding_FillType);
2217    path.moveTo(0,1);
2218    path.cubicTo(2,5, 5,0, 6,4);
2219    path.close();
2220    pathB.setFillType(SkPath::kWinding_FillType);
2221    pathB.moveTo(0,5);
2222    pathB.cubicTo(4,6, 1,0, 5,2);
2223    pathB.close();
2224    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2225}
2226
2227static void cubicOp89u(skiatest::Reporter* reporter, const char* filename) {
2228    SkPath path, pathB;
2229    path.setFillType(SkPath::kWinding_FillType);
2230    path.moveTo(0, 3);
2231    path.cubicTo(1, 6, 5, 0, 6, 3);
2232    path.close();
2233    pathB.setFillType(SkPath::kWinding_FillType);
2234    pathB.moveTo(0, 5);
2235    pathB.cubicTo(3, 6, 3, 0, 6, 1);
2236    pathB.close();
2237    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2238}
2239
2240static void cubicOp90u(skiatest::Reporter* reporter, const char* filename) {
2241    SkPath path, pathB;
2242    path.setFillType(SkPath::kEvenOdd_FillType);
2243    path.moveTo(0, 5);
2244    path.cubicTo(1, 2, 5, 2, 4, 1);
2245    path.close();
2246    pathB.setFillType(SkPath::kEvenOdd_FillType);
2247    pathB.moveTo(2, 5);
2248    pathB.cubicTo(1, 4, 5, 0, 2, 1);
2249    pathB.close();
2250    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2251}
2252
2253static void cubicOp91u(skiatest::Reporter* reporter, const char* filename) {
2254    SkPath path, pathB;
2255    path.setFillType(SkPath::kWinding_FillType);
2256    path.moveTo(1, 6);
2257    path.cubicTo(0, 3, 6, 3, 5, 0);
2258    path.close();
2259    pathB.setFillType(SkPath::kWinding_FillType);
2260    pathB.moveTo(3, 6);
2261    pathB.cubicTo(0, 5, 6, 1, 3, 0);
2262    pathB.close();
2263    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2264}
2265
2266static void skpaaalgarve_org53(skiatest::Reporter* reporter, const char* filename) {  //  add t cancel
2267    SkPath path;
2268    path.setFillType(SkPath::kEvenOdd_FillType);
2269   path.moveTo(-1.24344979e-014f, 348);
2270    path.lineTo(258, 348);
2271    path.lineTo(258, 322);
2272    path.quadTo(258, 317.857849f, 255.072006f, 314.928009f);
2273    path.quadTo(252.142136f, 312, 248, 312);
2274    path.lineTo(1.77635684e-015f, 312);
2275    path.lineTo(-1.24344979e-014f, 348);
2276    path.close();
2277    SkPath pathB;
2278    pathB.setFillType(SkPath::kWinding_FillType);
2279   pathB.moveTo(0, 312);
2280    pathB.lineTo(258, 312);
2281    pathB.lineTo(258, 348);
2282    pathB.lineTo(0, 348);
2283    pathB.close();
2284    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2285}
2286
2287static void skpabcspark_ca103(skiatest::Reporter* reporter, const char* filename) {  //  add t cancel
2288    SkPath path;
2289    path.setFillType(SkPath::kEvenOdd_FillType);
2290    path.moveTo(1.99840144e-015f, 494);
2291    path.lineTo(97, 494);
2292    path.quadTo(100.313705f, 494, 102.6576f, 491.657593f);
2293    path.quadTo(105, 489.313721f, 105, 486);
2294    path.lineTo(105, 425);
2295    path.quadTo(105, 421.686279f, 102.6576f, 419.342407f);
2296    path.quadTo(100.313705f, 417, 97, 417);
2297    path.lineTo(2.22044605e-016f, 417);
2298    path.lineTo(1.99840144e-015f, 494);
2299    path.close();
2300    SkPath pathB;
2301    pathB.setFillType(SkPath::kWinding_FillType);
2302    pathB.moveTo(0, 417);
2303    pathB.lineTo(105, 417);
2304    pathB.lineTo(105, 494);
2305    pathB.lineTo(0, 494);
2306    pathB.close();
2307    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2308}
2309
2310static void skpacesoftech_com47(skiatest::Reporter* reporter, const char* filename) {  // partial coincidence
2311    SkPath path;
2312    path.setFillType(SkPath::kEvenOdd_FillType);
2313    path.moveTo(670.537415f, 285);
2314    path.lineTo(670.387451f, 285);
2315    path.lineTo(596.315186f, 314.850708f);
2316    path.lineTo(626.19696f, 389);
2317    path.lineTo(626.346863f, 389);
2318    path.lineTo(700.419189f, 359.149261f);
2319    path.lineTo(670.537415f, 285);
2320    path.close();
2321    SkPath pathB;
2322    pathB.setFillType(SkPath::kWinding_FillType);
2323    pathB.moveTo(663.318542f, 374.100616f);
2324    pathB.quadTo(647.950989f, 380.293671f, 632.705322f, 373.806305f);
2325    pathB.quadTo(617.459595f, 367.318909f, 611.266541f, 351.951355f);
2326    pathB.quadTo(605.073486f, 336.58374f, 611.560913f, 321.338074f);
2327    pathB.quadTo(618.048279f, 306.092407f, 633.415833f, 299.899353f);
2328    pathB.quadTo(648.783447f, 293.706299f, 664.029114f, 300.193665f);
2329    pathB.quadTo(679.27478f, 306.68103f, 685.467834f, 322.048645f);
2330    pathB.quadTo(691.660889f, 337.416199f, 685.173523f, 352.661896f);
2331    pathB.quadTo(678.686157f, 367.907562f, 663.318542f, 374.100616f);
2332    pathB.close();
2333    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2334}
2335
2336static void skpact_com43(skiatest::Reporter* reporter, const char* filename) {  // bridge op
2337    SkPath path;
2338    path.setFillType(SkPath::kEvenOdd_FillType);
2339    path.moveTo(1.45716772e-016f, 924.336121f);
2340    path.lineTo(-1.11022302e-016f, 920);
2341    path.lineTo(6, 920);
2342    path.lineTo(6, 926);
2343    path.lineTo(1.66389287f, 926);
2344    path.quadTo(1.18842196f, 925.674561f, 0.756800175f, 925.243225f);
2345    path.quadTo(0.325406998f, 924.811523f, 1.45716772e-016f, 924.336121f);
2346    path.close();
2347    path.moveTo(1, 921);
2348    path.lineTo(5, 921);
2349    path.lineTo(5, 925);
2350    path.cubicTo(2.79086018f, 925, 1, 923.209167f, 1, 921);
2351    path.close();
2352    SkPath pathB;
2353    pathB.setFillType(SkPath::kWinding_FillType);
2354    pathB.moveTo(-1, 920);
2355    pathB.lineTo(0, 920);
2356    pathB.lineTo(3, 927);
2357    pathB.lineTo(-1, 927);
2358    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2359}
2360
2361static void skpadbox_lt8(skiatest::Reporter* reporter, const char* filename) {  // zero span
2362    SkPath path;
2363    path.setFillType(SkPath::kEvenOdd_FillType);
2364    path.moveTo(320.097229f, 628.573669f);
2365    path.lineTo(610.227173f, 85.7786865f);
2366    path.lineTo(946.652588f, 265.601807f);
2367    path.lineTo(656.522644f, 808.39679f);
2368    path.lineTo(320.097229f, 628.573669f);
2369    path.close();
2370    SkPath pathB;
2371    pathB.setFillType(SkPath::kInverseWinding_FillType);
2372    pathB.moveTo(333.866608f, 623.496155f);
2373    pathB.lineTo(613.368042f, 100.585754f);
2374    pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2375    pathB.lineTo(932.633057f, 269.854553f);
2376    pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2377    pathB.lineTo(653.631897f, 794.414307f);
2378    pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2379    pathB.lineTo(334.366943f, 625.145508f);
2380    pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2381    pathB.close();
2382    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2383}
2384
2385static void skpadindex_de4(skiatest::Reporter* reporter, const char* filename) {  // find chase op
2386    SkPath path;
2387    path.setFillType(SkPath::kEvenOdd_FillType);
2388    path.moveTo(0, 926);
2389    path.lineTo(0, 0);
2390    path.lineTo(1280, 0);
2391    path.lineTo(1280, 926);
2392    path.lineTo(0, 926);
2393    path.close();
2394    SkPath pathB;
2395    pathB.setFillType(SkPath::kWinding_FillType);
2396    pathB.moveTo(0, 312);
2397    pathB.lineTo(8.20486257e-015f, 178);
2398    pathB.lineTo(49, 178);
2399    pathB.lineTo(49, 312);
2400    pathB.close();
2401    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2402}
2403
2404static void skpadithya_putr4_blogspot_com551(skiatest::Reporter* reporter, const char* filename) { // calc common
2405    SkPath path;
2406    path.setFillType(SkPath::kEvenOdd_FillType);
2407    path.moveTo(205.605804f, 142.334625f);
2408    path.lineTo(254.665359f, 85.6058044f);
2409    path.lineTo(311.394196f, 134.665359f);
2410    path.lineTo(262.334625f, 191.39418f);
2411    path.lineTo(205.605804f, 142.334625f);
2412    path.close();
2413    SkPath pathB;
2414    pathB.setFillType(SkPath::kWinding_FillType);
2415    pathB.moveTo(283.407959f, 110.462646f);
2416    pathB.cubicTo(298.864319f, 123.829437f, 300.558258f, 147.195221f, 287.191467f, 162.651581f);
2417    pathB.lineTo(286.537354f, 163.407959f);
2418    pathB.cubicTo(273.170563f, 178.864334f, 249.804779f, 180.558258f, 234.348419f, 167.191467f);
2419    pathB.lineTo(233.592026f, 166.537338f);
2420    pathB.cubicTo(218.135666f, 153.170547f, 216.441727f, 129.804779f, 229.808517f, 114.348412f);
2421    pathB.lineTo(230.462646f, 113.592026f);
2422    pathB.cubicTo(243.829437f, 98.1356659f, 267.195221f, 96.4417267f, 282.651581f, 109.808517f);
2423    pathB.lineTo(283.407959f, 110.462646f);
2424    pathB.close();
2425    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2426}
2427
2428static void skpadspert_de11(skiatest::Reporter* reporter, const char* filename) {  // mark and chase winding
2429    SkPath path;
2430    path.setFillType(SkPath::kEvenOdd_FillType);
2431    path.moveTo(-4.4408921e-016f, 682.5f);
2432    path.lineTo(30.5f, 682.5f);
2433    path.cubicTo(32.709137f, 682.5f, 34.5f, 680.709167f, 34.5f, 678.5f);
2434    path.lineTo(34.5f, 486.5f);
2435    path.cubicTo(34.5f, 484.290863f, 32.709137f, 482.5f, 30.5f, 482.5f);
2436    path.lineTo(0, 482.5f);
2437    path.lineTo(-4.4408921e-016f, 682.5f);
2438    path.close();
2439    SkPath pathB;
2440    pathB.setFillType(SkPath::kWinding_FillType);
2441    pathB.moveTo(0, 482);
2442    pathB.lineTo(35, 482);
2443    pathB.lineTo(35, 683);
2444    pathB.lineTo(0, 683);
2445    pathB.close();
2446    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2447}
2448
2449static void skpaiaigames_com870(skiatest::Reporter* reporter, const char* filename) {  // cubic/cubic intersect
2450    SkPath path;
2451    path.setFillType(SkPath::kEvenOdd_FillType);
2452    path.moveTo(324.071075f, 845.071045f);
2453    path.cubicTo(324.405151f, 844.737f, 324.715668f, 844.379395f, 325, 844.000977f);
2454    path.lineTo(325, 842.127197f);
2455    path.cubicTo(324.571411f, 842.956238f, 324.017761f, 843.710144f, 323.363953f, 844.363953f);
2456    path.lineTo(324.071075f, 845.071045f);
2457    path.close();
2458    path.moveTo(323.363953f, 714.636047f);
2459    path.lineTo(324.071075f, 713.928955f);
2460    path.cubicTo(324.405151f, 714.263f, 324.715668f, 714.620605f, 325, 714.999023f);
2461    path.lineTo(325, 716.872803f);
2462    path.cubicTo(324.571411f, 716.043762f, 324.017761f, 715.289856f, 323.363953f, 714.636047f);
2463    path.close();
2464    SkPath pathB;
2465    pathB.setFillType(SkPath::kWinding_FillType);
2466    pathB.moveTo(317, 711);
2467    pathB.cubicTo(322.522858f, 711, 327, 715.477173f, 327, 721);
2468    pathB.lineTo(327, 838);
2469    pathB.cubicTo(327, 843.522827f, 322.522858f, 848, 317, 848);
2470    pathB.lineTo(155, 848);
2471    pathB.cubicTo(149.477158f, 848, 145, 843.522827f, 145, 838);
2472    pathB.lineTo(145, 721);
2473    pathB.cubicTo(145, 715.477173f, 149.477158f, 711, 155, 711);
2474    pathB.lineTo(317, 711);
2475    pathB.close();
2476    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2477}
2478
2479static void cubicOp92i(skiatest::Reporter* reporter, const char* filename) {
2480    SkPath path, pathB;
2481    path.setFillType(SkPath::kWinding_FillType);
2482    path.moveTo(0, 1);
2483    path.cubicTo(2, 6, 4, 1, 5, 4);
2484    path.close();
2485    pathB.setFillType(SkPath::kWinding_FillType);
2486    pathB.moveTo(1, 4);
2487    pathB.cubicTo(4, 5, 1, 0, 6, 2);
2488    pathB.close();
2489    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2490}
2491
2492static void cubicOp93d(skiatest::Reporter* reporter, const char* filename) {
2493    SkPath path, pathB;
2494    path.setFillType(SkPath::kWinding_FillType);
2495    path.moveTo(0, 1);
2496    path.cubicTo(1, 6, 4, 1, 4, 3);
2497    path.close();
2498    pathB.setFillType(SkPath::kWinding_FillType);
2499    pathB.moveTo(1, 4);
2500    pathB.cubicTo(3, 4, 1, 0, 6, 1);
2501    pathB.close();
2502    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
2503}
2504
2505static void cubicOp94u(skiatest::Reporter* reporter, const char* filename) {
2506    SkPath path, pathB;
2507    path.setFillType(SkPath::kEvenOdd_FillType);
2508    path.moveTo(0, 3);
2509    path.cubicTo(2, 3, 5, 0, 5, 3);
2510    path.close();
2511    pathB.setFillType(SkPath::kEvenOdd_FillType);
2512    pathB.moveTo(0, 5);
2513    pathB.cubicTo(3, 5, 3, 0, 3, 2);
2514    pathB.close();
2515    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2516}
2517
2518static void skpadbox_lt15(skiatest::Reporter* reporter, const char* filename) {
2519    SkPath path;
2520    path.setFillType(SkPath::kEvenOdd_FillType);
2521    path.moveTo(333.292084f, 624.570984f);
2522    path.lineTo(614.229797f, 98.9735107f);
2523    path.lineTo(933.457764f, 269.604431f);
2524    path.lineTo(652.52002f, 795.201904f);
2525    path.lineTo(333.292084f, 624.570984f);
2526    path.close();
2527    SkPath pathB;
2528     pathB.setFillType(SkPath::kWinding_FillType);
2529    pathB.moveTo(613.368042f, 100.585754f);
2530    pathB.cubicTo(613.685303f, 99.9921265f, 614.423767f, 99.7681885f, 615.017395f, 100.085449f);
2531    pathB.lineTo(932.633057f, 269.854553f);
2532    pathB.cubicTo(933.226685f, 270.171875f, 933.450623f, 270.910278f, 933.133301f, 271.503906f);
2533    pathB.lineTo(653.631897f, 794.414307f);
2534    pathB.cubicTo(653.314636f, 795.007935f, 652.576172f, 795.231934f, 651.982544f, 794.914612f);
2535    pathB.lineTo(334.366943f, 625.145508f);
2536    pathB.cubicTo(333.773315f, 624.828247f, 333.549286f, 624.089783f, 333.866608f, 623.496155f);
2537    pathB.lineTo(613.368042f, 100.585754f);
2538     pathB.close();
2539    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2540}
2541
2542static void skpadoption_org196(skiatest::Reporter* reporter, const char* filename) {
2543    SkPath path;
2544    path.setFillType(SkPath::kEvenOdd_FillType);
2545    path.moveTo(802, 367);
2546    path.lineTo(802, 324);
2547    path.lineTo(956, 324);
2548    path.lineTo(956, 371);
2549    path.quadTo(956, 373.071075f, 954.536011f, 374.536011f);
2550    path.quadTo(953.071045f, 376, 951, 376);
2551    path.lineTo(811, 376);
2552    path.cubicTo(806.029419f, 376, 802, 371.970551f, 802, 367);
2553    path.close();
2554    SkPath pathB;
2555    pathB.setFillType(SkPath::kInverseWinding_FillType);
2556    pathB.moveTo(803, 326);
2557    pathB.lineTo(955, 326);
2558    pathB.lineTo(955, 370);
2559    pathB.cubicTo(955, 372.761414f, 952.761414f, 375, 950, 375);
2560    pathB.lineTo(808, 375);
2561    pathB.cubicTo(805.238586f, 375, 803, 372.761414f, 803, 370);
2562    pathB.lineTo(803, 326);
2563    pathB.close();
2564    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2565}
2566
2567static void skpadspert_net23(skiatest::Reporter* reporter, const char* filename) {
2568    SkPath path;
2569    path.setFillType(SkPath::kEvenOdd_FillType);
2570    path.moveTo(-2.220446e-018f, 483.5f);
2571    path.lineTo(0, 482.5f);
2572    path.lineTo(30.5f, 482.5f);
2573    path.cubicTo(32.709137f, 482.5f, 34.5f, 484.290863f, 34.5f, 486.5f);
2574    path.lineTo(34.5f, 678.5f);
2575    path.cubicTo(34.5f, 680.709167f, 32.709137f, 682.5f, 30.5f, 682.5f);
2576    path.lineTo(-4.4408921e-016f, 682.5f);
2577    path.lineTo(-4.41868766e-016f, 681.5f);
2578    path.lineTo(30.5f, 681.5f);
2579    path.cubicTo(32.1568565f, 681.5f, 33.5f, 680.15686f, 33.5f, 678.5f);
2580    path.lineTo(33.5f, 486.5f);
2581    path.cubicTo(33.5f, 484.84314f, 32.1568565f, 483.5f, 30.5f, 483.5f);
2582    path.lineTo(-2.220446e-018f, 483.5f);
2583    path.close();
2584    SkPath pathB;
2585    pathB.setFillType(SkPath::kWinding_FillType);
2586    pathB.moveTo(0, 482);
2587    pathB.lineTo(35, 482);
2588    pathB.lineTo(35, 683);
2589    pathB.lineTo(0, 683);
2590    pathB.close();
2591    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2592}
2593
2594static void skpadventistmission_org572(skiatest::Reporter* reporter, const char* filename) {
2595    SkPath path;
2596    path.setFillType(SkPath::kEvenOdd_FillType);
2597    path.moveTo(1182.00037f, 926);
2598    path.cubicTo(1181.08813f, 924.785583f, 1179.63586f, 924, 1178, 924);
2599    path.lineTo(938, 924);
2600    path.cubicTo(936.364197f, 924, 934.911865f, 924.785583f, 933.999634f, 926);
2601    path.lineTo(1182.00037f, 926);
2602    path.close();
2603    SkPath pathB;
2604    pathB.setFillType(SkPath::kWinding_FillType);
2605    pathB.moveTo(934, 924);
2606    pathB.lineTo(1182, 924);
2607    pathB.lineTo(1182, 926);
2608    pathB.lineTo(934, 926);
2609    pathB.close();
2610    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2611}
2612
2613static void skpagentxsites_com55(skiatest::Reporter* reporter, const char* filename) {
2614    SkPath path;
2615    path.setFillType(SkPath::kEvenOdd_FillType);
2616    path.moveTo(925, 27);
2617    path.cubicTo(924.447693f, 27, 924, 27.4477158f, 924, 28);
2618    path.lineTo(924, 55);
2619    path.cubicTo(924, 55.5522842f, 924.447693f, 56, 925, 56);
2620    path.lineTo(1103, 56);
2621    path.cubicTo(1103.55225f, 56, 1104, 55.5522842f, 1104, 55);
2622    path.lineTo(1104, 28);
2623    path.cubicTo(1104, 27.4477158f, 1103.55225f, 27, 1103, 27);
2624    path.lineTo(925, 27);
2625    path.close();
2626    SkPath pathB;
2627    pathB.setFillType(SkPath::kWinding_FillType);
2628    pathB.moveTo(1103, 27);
2629    pathB.cubicTo(1104.10461f, 27, 1105, 27.8954315f, 1105, 29);
2630    pathB.lineTo(1105, 54);
2631    pathB.cubicTo(1105, 55.1045685f, 1104.10461f, 56, 1103, 56);
2632    pathB.lineTo(926, 56);
2633    pathB.cubicTo(924.895447f, 56, 924, 55.1045685f, 924, 54);
2634    pathB.lineTo(924, 29);
2635    pathB.cubicTo(924, 27.8954315f, 924.895447f, 27, 926, 27);
2636    pathB.lineTo(1103, 27);
2637    pathB.close();
2638    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2639}
2640
2641static void skpbakosoft_com10(skiatest::Reporter* reporter, const char* filename) {
2642    SkPath path;
2643    path.setFillType(SkPath::kEvenOdd_FillType);
2644    path.moveTo(190, 170);
2645    path.cubicTo(178.9543f, 170, 170, 178.9543f, 170, 190);
2646    path.cubicTo(170, 201.0457f, 178.9543f, 210, 190, 210);
2647    path.lineTo(370, 210);
2648    path.cubicTo(381.045685f, 210, 390, 201.0457f, 390, 190);
2649    path.cubicTo(390, 178.9543f, 381.045685f, 170, 370, 170);
2650    path.lineTo(190, 170);
2651    path.close();
2652    SkPath pathB;
2653    pathB.setFillType(SkPath::kWinding_FillType);
2654    pathB.moveTo(210, 190);
2655    pathB.quadTo(210, 198.284271f, 204.142136f, 204.142136f);
2656    pathB.quadTo(198.284271f, 210, 190, 210);
2657    pathB.quadTo(181.715729f, 210, 175.857864f, 204.142136f);
2658    pathB.quadTo(170, 198.284271f, 170, 190);
2659    pathB.quadTo(170, 181.715729f, 175.857864f, 175.857864f);
2660    pathB.quadTo(181.715729f, 170, 190, 170);
2661    pathB.quadTo(198.284271f, 170, 204.142136f, 175.857864f);
2662    pathB.quadTo(210, 181.715729f, 210, 190);
2663    pathB.close();
2664    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2665}
2666
2667static void skpbambootheme_com12(skiatest::Reporter* reporter, const char* filename) {
2668    SkPath path;
2669    path.setFillType(SkPath::kEvenOdd_FillType);
2670    path.moveTo(47.8780937f, 58);
2671    path.lineTo(0, 58);
2672    path.lineTo(-8.65973959e-015f, 96.9914017f);
2673    path.quadTo(20.0654926f, 96.6451874f, 34.3553391f, 82.3553391f);
2674    path.quadTo(44.9466133f, 71.764061f, 47.8780937f, 58);
2675    path.close();
2676    SkPath pathB;
2677    pathB.setFillType(SkPath::kEvenOdd_FillType);
2678    pathB.moveTo(-1, -3);
2679    pathB.lineTo(-1, -3);
2680    pathB.cubicTo(26.6142502f, -3, 49, 19.3857498f, 49, 47);
2681    pathB.lineTo(49, 47);
2682    pathB.cubicTo(49, 74.6142502f, 26.6142502f, 97, -1, 97);
2683    pathB.lineTo(-1, 97);
2684    pathB.cubicTo(-28.6142502f, 97, -51, 74.6142502f, -51, 47);
2685    pathB.lineTo(-51, 47);
2686    pathB.cubicTo(-51, 19.3857498f, -28.6142502f, -3, -1, -3);
2687    pathB.close();
2688    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2689}
2690
2691static void skpakmmos_ru100(skiatest::Reporter* reporter, const char* filename) {
2692    SkPath path;
2693    path.setFillType(SkPath::kEvenOdd_FillType);
2694    path.moveTo(693.000488f, 926);
2695    path.cubicTo(692.164734f, 925.37207f, 691.125793f, 925, 690, 925);
2696    path.lineTo(578, 925);
2697    path.cubicTo(576.874207f, 925, 575.835266f, 925.37207f, 574.999512f, 926);
2698    path.lineTo(693.000488f, 926);
2699    path.close();
2700    SkPath pathB;
2701    pathB.setFillType(SkPath::kWinding_FillType);
2702    pathB.moveTo(575, 925);
2703    pathB.lineTo(693, 925);
2704    pathB.lineTo(693, 926);
2705    pathB.lineTo(575, 926);
2706    pathB.close();
2707    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2708}
2709
2710static void skpcarpetplanet_ru22(skiatest::Reporter* reporter, const char* filename) {
2711    SkPath path;
2712    path.setFillType(SkPath::kEvenOdd_FillType);
2713    path.moveTo(195, 785);
2714    path.cubicTo(124.307556f, 785, 67, 841.859863f, 67, 912);
2715    path.lineTo(67, 913);
2716    path.cubicTo(67, 917.388916f, 67.2243805f, 921.725769f, 67.662384f, 926);
2717    path.lineTo(322, 926);
2718    path.lineTo(322, 896.048035f);
2719    path.cubicTo(314.09201f, 833.437622f, 260.247131f, 785, 195, 785);
2720    path.close();
2721    SkPath pathB;
2722    pathB.setFillType(SkPath::kWinding_FillType);
2723    pathB.moveTo(195, 785);
2724    pathB.cubicTo(265.140167f, 785, 322, 842.307556f, 322, 913);
2725    pathB.cubicTo(322, 983.692444f, 265.140167f, 1041, 195, 1041);
2726    pathB.lineTo(194, 1041);
2727    pathB.cubicTo(123.85984f, 1041, 67, 983.692444f, 67, 913);
2728    pathB.cubicTo(67, 842.307556f, 123.85984f, 785, 194, 785);
2729    pathB.lineTo(195, 785);
2730    pathB.close();
2731    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2732}
2733
2734// this fails because cubic/quad misses an intersection (failure is isolated in c/q int test)
2735static void skpcarrot_is24(skiatest::Reporter* reporter, const char* filename) {
2736    if (!FLAGS_runFail) {
2737        return;
2738    }
2739    SkPath path;
2740    path.setFillType(SkPath::kEvenOdd_FillType);
2741    path.moveTo(945, 597);
2742    path.quadTo(913.93396f, 597, 891.96698f, 618.96698f);
2743    path.quadTo(870, 640.93396f, 870, 672);
2744    path.quadTo(870, 703.06604f, 891.96698f, 725.03302f);
2745    path.quadTo(913.93396f, 747, 945, 747);
2746    path.quadTo(976.06604f, 747, 998.03302f, 725.03302f);
2747    path.quadTo(1020, 703.06604f, 1020, 672);
2748    path.quadTo(1020, 640.93396f, 998.03302f, 618.96698f);
2749    path.quadTo(976.06604f, 597, 945, 597);
2750    path.close();
2751    SkPath pathB;
2752    pathB.setFillType(SkPath::kWinding_FillType);
2753    pathB.moveTo(945.080994f, 597.161987f);
2754    pathB.cubicTo(903.659973f, 597.161987f, 870.080994f, 630.73999f, 870.080994f, 672.161987f);
2755    pathB.cubicTo(870.080994f, 676.096008f, 870.387024f, 679.957031f, 870.971008f, 683.726013f);
2756    pathB.cubicTo(876.53302f, 719.656006f, 907.593994f, 747.161987f, 945.080994f, 747.161987f);
2757    pathB.cubicTo(982.567993f, 747.161987f, 1013.62903f, 719.656006f, 1019.19104f, 683.726013f);
2758    pathB.cubicTo(1019.77502f, 679.955017f, 1020.08099f, 676.094971f, 1020.08099f, 672.161987f);
2759    pathB.cubicTo(1020.08002f, 630.73999f, 986.502014f, 597.161987f, 945.080994f, 597.161987f);
2760    pathB.close();
2761    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2762}
2763
2764static void skpbangalorenest_com4(skiatest::Reporter* reporter, const char* filename) {
2765    SkPath path;
2766    path.setFillType(SkPath::kEvenOdd_FillType);
2767    path.moveTo(0, 926);
2768    path.lineTo(0, 0);
2769    path.lineTo(1265, 0);
2770    path.lineTo(1265, 926);
2771    path.lineTo(0, 926);
2772    path.close();
2773    SkPath pathB;
2774    pathB.setFillType(SkPath::kWinding_FillType);
2775    pathB.moveTo(0, 290);
2776    pathB.lineTo(-2.64514972e-014f, 146);
2777    pathB.lineTo(30, 146);
2778    pathB.lineTo(30, 290);
2779    pathB.close();
2780    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2781}
2782
2783static void skpbenzoteh_ru152(skiatest::Reporter* reporter, const char* filename) {
2784    SkPath path;
2785    path.setFillType(SkPath::kEvenOdd_FillType);
2786    path.moveTo(883, 23);
2787    path.lineTo(883, 0);
2788    path.lineTo(1122.5f, 0);
2789    path.lineTo(1122.5f, 25.2136822f);
2790    path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2791    path.quadTo(1120.07104f, 28, 1118, 28);
2792    path.lineTo(888, 28);
2793    path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2794    path.quadTo(883, 25.0710678f, 883, 23);
2795    path.close();
2796    SkPath pathB;
2797    pathB.setFillType(SkPath::kWinding_FillType);
2798    pathB.moveTo(883, 0);
2799    pathB.lineTo(1123, 0);
2800    pathB.lineTo(1123, 23);
2801    pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2802    pathB.quadTo(1120.07104f, 28, 1118, 28);
2803    pathB.lineTo(888, 28);
2804    pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2805    pathB.quadTo(883, 25.0710678f, 883, 23);
2806    pathB.close();
2807    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2808}
2809
2810static void skpbestred_ru37(skiatest::Reporter* reporter, const char* filename) {
2811    SkPath path;
2812    path.setFillType(SkPath::kEvenOdd_FillType);
2813    path.moveTo(883, 23);
2814    path.lineTo(883, 0);
2815    path.lineTo(1122.5f, 0);
2816    path.lineTo(1122.5f, 25.2136822f);
2817    path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2818    path.quadTo(1120.07104f, 28, 1118, 28);
2819    path.lineTo(888, 28);
2820    path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2821    path.quadTo(883, 25.0710678f, 883, 23);
2822    path.close();
2823    SkPath pathB;
2824    pathB.setFillType(SkPath::kWinding_FillType);
2825    pathB.moveTo(883, 0);
2826    pathB.lineTo(1123, 0);
2827    pathB.lineTo(1123, 23);
2828    pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2829    pathB.quadTo(1120.07104f, 28, 1118, 28);
2830    pathB.lineTo(888, 28);
2831    pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2832    pathB.quadTo(883, 25.0710678f, 883, 23);
2833    pathB.close();
2834    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2835}
2836
2837static void skpbingoentertainment_net189(skiatest::Reporter* reporter, const char* filename) {
2838    SkPath path;
2839    path.setFillType(SkPath::kEvenOdd_FillType);
2840    path.moveTo(896, 745.38678f);
2841    path.lineTo(896, 873.38678f);
2842    path.lineTo(922.567993f, 876.683716f);
2843    path.lineTo(922.567993f, 748.683716f);
2844    path.lineTo(896, 745.38678f);
2845    path.close();
2846    SkPath pathB;
2847    pathB.setFillType(SkPath::kWinding_FillType);
2848    pathB.moveTo(899.200928f, 745.783997f);
2849    pathB.cubicTo(897.119385f, 745.525696f, 895.432007f, 752.031982f, 895.432007f, 760.316284f);
2850    pathB.lineTo(895.432007f, 858.316284f);
2851    pathB.cubicTo(895.432007f, 866.600586f, 897.119385f, 873.525696f, 899.200928f, 873.783997f);
2852    pathB.lineTo(918.799133f, 876.216003f);
2853    pathB.cubicTo(920.880615f, 876.474304f, 922.567993f, 869.968018f, 922.567993f, 861.683716f);
2854    pathB.lineTo(922.567993f, 763.683716f);
2855    pathB.cubicTo(922.567993f, 755.399414f, 920.880615f, 748.474304f, 918.799133f, 748.216003f);
2856    pathB.lineTo(899.200928f, 745.783997f);
2857    pathB.close();
2858    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2859}
2860
2861static void skpcarrefour_ro62(skiatest::Reporter* reporter, const char* filename) {
2862    SkPath path;
2863    path.setFillType(SkPath::kEvenOdd_FillType);
2864    path.moveTo(1104, 453);
2865    path.lineTo(399, 453);
2866    path.lineTo(399, 657);
2867    path.cubicTo(399, 661.970581f, 403.029449f, 666, 408, 666);
2868    path.lineTo(1095, 666);
2869    path.cubicTo(1099.97058f, 666, 1104, 661.970581f, 1104, 657);
2870    path.lineTo(1104, 453);
2871    path.close();
2872    SkPath pathB;
2873    pathB.setFillType(SkPath::kInverseWinding_FillType);
2874    pathB.moveTo(400, 453);
2875    pathB.lineTo(1103, 453);
2876    pathB.lineTo(1103, 666);
2877    pathB.lineTo(406, 666);
2878    pathB.cubicTo(402.686279f, 666, 400, 663.313721f, 400, 660);
2879    pathB.lineTo(400, 453);
2880    pathB.close();
2881    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2882}
2883
2884static void skpcaffelavazzait_com_ua21(skiatest::Reporter* reporter, const char* filename) {
2885    SkPath path;
2886    path.setFillType(SkPath::kEvenOdd_FillType);
2887    path.moveTo(883, 23);
2888    path.lineTo(883, 0);
2889    path.lineTo(1122.5f, 0);
2890    path.lineTo(1122.5f, 25.2136822f);
2891    path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2892    path.quadTo(1120.07104f, 28, 1118, 28);
2893    path.lineTo(888, 28);
2894    path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2895    path.quadTo(883, 25.0710678f, 883, 23);
2896    path.close();
2897    SkPath pathB;
2898    pathB.setFillType(SkPath::kWinding_FillType);
2899    pathB.moveTo(883, 0);
2900    pathB.lineTo(1123, 0);
2901    pathB.lineTo(1123, 23);
2902    pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2903    pathB.quadTo(1120.07104f, 28, 1118, 28);
2904    pathB.lineTo(888, 28);
2905    pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2906    pathB.quadTo(883, 25.0710678f, 883, 23);
2907    pathB.close();
2908    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2909}
2910
2911static void skpcamcorder_kz21(skiatest::Reporter* reporter, const char* filename) {
2912    SkPath path;
2913    path.setFillType(SkPath::kEvenOdd_FillType);
2914    path.moveTo(883, 23);
2915    path.lineTo(883, 0);
2916    path.lineTo(1122.5f, 0);
2917    path.lineTo(1122.5f, 25.2136822f);
2918    path.quadTo(1122.14441f, 25.9271851f, 1121.53601f, 26.5359993f);
2919    path.quadTo(1120.07104f, 28, 1118, 28);
2920    path.lineTo(888, 28);
2921    path.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2922    path.quadTo(883, 25.0710678f, 883, 23);
2923    path.close();
2924    SkPath pathB;
2925    pathB.setFillType(SkPath::kWinding_FillType);
2926    pathB.moveTo(883, 0);
2927    pathB.lineTo(1123, 0);
2928    pathB.lineTo(1123, 23);
2929    pathB.quadTo(1123, 25.0710678f, 1121.53601f, 26.5359993f);
2930    pathB.quadTo(1120.07104f, 28, 1118, 28);
2931    pathB.lineTo(888, 28);
2932    pathB.quadTo(885.928955f, 28, 884.463989f, 26.5359993f);
2933    pathB.quadTo(883, 25.0710678f, 883, 23);
2934    pathB.close();
2935    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2936}
2937
2938static void skpcavablar_net563(skiatest::Reporter* reporter, const char* filename) {
2939    SkPath path;
2940    path.setFillType(SkPath::kEvenOdd_FillType);
2941    path.moveTo(160.000488f, 918);
2942    path.cubicTo(159.164749f, 917.37207f, 158.125824f, 917, 157, 917);
2943    path.lineTo(94, 917);
2944    path.cubicTo(92.874176f, 917, 91.8352661f, 917.37207f, 90.9995193f, 918);
2945    path.lineTo(160.000488f, 918);
2946    path.close();
2947    SkPath pathB;
2948    pathB.setFillType(SkPath::kWinding_FillType);
2949    pathB.moveTo(91, 917);
2950    pathB.lineTo(160, 917);
2951    pathB.lineTo(160, 918);
2952    pathB.lineTo(91, 918);
2953    pathB.close();
2954    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2955}
2956
2957static void skpinsomnia_gr72(skiatest::Reporter* reporter, const char* filename) {
2958    SkPath path;
2959    path.setFillType(SkPath::kEvenOdd_FillType);
2960    path.moveTo(1138, 231);
2961    path.lineTo(1137, 243.625748f);
2962    path.lineTo(1137, 926);
2963    path.lineTo(1139, 926);
2964    path.lineTo(1139, 231);
2965    path.lineTo(1138, 231);
2966    path.close();
2967    SkPath pathB;
2968    pathB.setFillType(SkPath::kWinding_FillType);
2969    pathB.moveTo(1139, 231);
2970    pathB.lineTo(1138, 231);
2971    pathB.lineTo(633, 6101);
2972    pathB.lineTo(1139, 6607);
2973    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
2974}
2975
2976static void cubicOp95u(skiatest::Reporter* reporter, const char* filename) {
2977    SkPath path, pathB;
2978    path.setFillType(SkPath::kEvenOdd_FillType);
2979    path.moveTo(0, 2);
2980    path.cubicTo(2, 3, 5, 1, 3, 2);
2981    path.close();
2982    pathB.setFillType(SkPath::kEvenOdd_FillType);
2983    pathB.moveTo(1, 5);
2984    pathB.cubicTo(2, 3, 2, 0, 3, 2);
2985    pathB.close();
2986    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
2987}
2988
2989static void cubicOp96d(skiatest::Reporter* reporter, const char* filename) {
2990    SkPath path, pathB;
2991    path.setFillType(SkPath::kEvenOdd_FillType);
2992    path.moveTo(1, 6);
2993    path.cubicTo(0, 3, 6, 3, 5, 0);
2994    path.close();
2995    pathB.setFillType(SkPath::kEvenOdd_FillType);
2996    pathB.moveTo(3, 6);
2997    pathB.cubicTo(0, 5, 6, 1, 3, 0);
2998    pathB.close();
2999    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3000}
3001
3002static void cubicOp97x(skiatest::Reporter* reporter, const char* filename) {
3003    SkPath path, pathB;
3004    path.setFillType(SkPath::kEvenOdd_FillType);
3005    path.moveTo(0, 2);
3006    path.cubicTo(0, 6, 2, 1, 2, 1);
3007    path.close();
3008    pathB.setFillType(SkPath::kEvenOdd_FillType);
3009    pathB.moveTo(1, 2);
3010    pathB.cubicTo(1, 2, 2, 0, 6, 0);
3011    pathB.close();
3012    testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
3013}
3014
3015static void cubicOp98x(skiatest::Reporter* reporter, const char* filename) {
3016    SkPath path, pathB;
3017    path.setFillType(SkPath::kEvenOdd_FillType);
3018    path.moveTo(0, 3);
3019    path.cubicTo(3, 6, 4, 1, 6, 3);
3020    path.close();
3021    pathB.setFillType(SkPath::kEvenOdd_FillType);
3022    pathB.moveTo(1, 4);
3023    pathB.cubicTo(3, 6, 3, 0, 6, 3);
3024    pathB.close();
3025    testPathOp(reporter, path, pathB, kXOR_PathOp, filename);
3026}
3027
3028static void cubicOp99(skiatest::Reporter* reporter, const char* filename) {
3029    SkPath path, pathB;
3030    path.setFillType(SkPath::kWinding_FillType);
3031    path.moveTo(3,6);
3032    path.cubicTo(0,3, 6,5, 5,4);
3033    path.close();
3034    pathB.setFillType(SkPath::kWinding_FillType);
3035    pathB.moveTo(5,6);
3036    pathB.cubicTo(4,5, 6,3, 3,0);
3037    pathB.close();
3038    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3039}
3040
3041static void cubicOp100(skiatest::Reporter* reporter, const char* filename) {
3042    SkPath path, pathB;
3043    path.setFillType(SkPath::kWinding_FillType);
3044    path.moveTo(0,1);
3045    path.cubicTo(0,2, 2,1, 4,2);
3046    path.close();
3047    pathB.setFillType(SkPath::kWinding_FillType);
3048    pathB.moveTo(1,2);
3049    pathB.cubicTo(2,4, 1,0, 2,0);
3050    pathB.close();
3051    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3052}
3053
3054static void cubicOp101(skiatest::Reporter* reporter, const char* filename) {
3055    SkPath path, pathB;
3056    path.setFillType(SkPath::kWinding_FillType);
3057    path.moveTo(0, 1);
3058    path.cubicTo(2, 3, 2, 1, 5, 3);
3059    path.close();
3060    pathB.setFillType(SkPath::kWinding_FillType);
3061    pathB.moveTo(1, 2);
3062    pathB.cubicTo(3, 5, 1, 0, 3, 2);
3063    pathB.close();
3064    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3065}
3066
3067static void cubicOp102(skiatest::Reporter* reporter, const char* filename) {
3068    SkPath path, pathB;
3069    path.setFillType(SkPath::kWinding_FillType);
3070    path.moveTo(0,1);
3071    path.cubicTo(1,2, 1,0, 3,0);
3072    path.close();
3073    pathB.setFillType(SkPath::kWinding_FillType);
3074    pathB.moveTo(0,1);
3075    pathB.cubicTo(0,3, 1,0, 2,1);
3076    pathB.close();
3077    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3078}
3079
3080static void cubicOp103(skiatest::Reporter* reporter, const char* filename) {
3081    SkPath path, pathB;
3082    path.setFillType(SkPath::kWinding_FillType);
3083    path.moveTo(0,1);
3084    path.cubicTo(1,5, 2,0, 2,1);
3085    path.close();
3086    pathB.setFillType(SkPath::kWinding_FillType);
3087    pathB.moveTo(0,2);
3088    pathB.cubicTo(1,2, 1,0, 5,1);
3089    pathB.close();
3090    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3091}
3092
3093static void cubicOp104(skiatest::Reporter* reporter, const char* filename) {
3094    SkPath path, pathB;
3095    path.setFillType(SkPath::kWinding_FillType);
3096    path.moveTo(0,1);
3097    path.cubicTo(0,6, 4,0, 6,1);
3098    path.close();
3099    pathB.setFillType(SkPath::kWinding_FillType);
3100    pathB.moveTo(0,4);
3101    pathB.cubicTo(1,6, 1,0, 6,0);
3102    pathB.close();
3103    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3104}
3105
3106static void cubicOp105(skiatest::Reporter* reporter, const char* filename) {
3107    SkPath path, pathB;
3108    path.setFillType(SkPath::kWinding_FillType);
3109    path.moveTo(0,1);
3110    path.cubicTo(0,4, 6,5, 2,0);
3111    path.close();
3112    pathB.setFillType(SkPath::kWinding_FillType);
3113    pathB.moveTo(5,6);
3114    pathB.cubicTo(0,2, 1,0, 4,0);
3115    pathB.close();
3116    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3117}
3118
3119static void cubicOp106(skiatest::Reporter* reporter, const char* filename) {
3120    SkPath path, pathB;
3121    path.setFillType(SkPath::kWinding_FillType);
3122    path.moveTo(0, 1);
3123    path.cubicTo(4, 6, 2, 1, 2, 0);
3124    path.close();
3125    pathB.setFillType(SkPath::kWinding_FillType);
3126    pathB.moveTo(1, 2);
3127    pathB.cubicTo(0, 2, 1, 0, 6, 4);
3128    pathB.close();
3129    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3130}
3131
3132static void cubicOp107(skiatest::Reporter* reporter, const char* filename) {
3133    SkPath path, pathB;
3134    path.setFillType(SkPath::kWinding_FillType);
3135    path.moveTo(0, 1);
3136    path.cubicTo(4, 6, 2, 1, 2, 0);
3137    path.close();
3138    pathB.setFillType(SkPath::kWinding_FillType);
3139    pathB.moveTo(1, 2);
3140    pathB.cubicTo(0, 2, 1, 0, 6, 4);
3141    pathB.close();
3142    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3143}
3144
3145static void cubicOp108(skiatest::Reporter* reporter, const char* filename) {
3146    SkPath path, pathB;
3147    path.setFillType(SkPath::kWinding_FillType);
3148    path.moveTo(0, 1);
3149    path.cubicTo(4, 6, 2, 1, 2, 0);
3150    path.close();
3151    pathB.setFillType(SkPath::kWinding_FillType);
3152    pathB.moveTo(1, 2);
3153    pathB.cubicTo(0, 2, 1, 0, 6, 4);
3154    pathB.close();
3155    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3156}
3157
3158static void cubicOp109(skiatest::Reporter* reporter, const char* filename) {
3159    SkPath path, pathB;
3160    path.setFillType(SkPath::kWinding_FillType);
3161    path.moveTo(0,1);
3162    path.cubicTo(4,5, 6,3, 5,4);
3163    path.close();
3164    pathB.setFillType(SkPath::kWinding_FillType);
3165    pathB.moveTo(3,6);
3166    pathB.cubicTo(4,5, 1,0, 5,4);
3167    pathB.close();
3168    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3169}
3170
3171static void cubicOp110(skiatest::Reporter* reporter, const char* filename) {
3172    SkPath path, pathB;
3173    path.setFillType(SkPath::kEvenOdd_FillType);
3174    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3175    path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3176    pathB.setFillType(SkPath::kEvenOdd_FillType);
3177    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3178    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3179    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3180}
3181
3182static void cubicOp111(skiatest::Reporter* reporter, const char* filename) {
3183    SkPath path, pathB;
3184    path.setFillType(SkPath::kWinding_FillType);
3185    path.moveTo(1,4);
3186    path.cubicTo(0,5, 4,1, 3,1);
3187    path.close();
3188    pathB.setFillType(SkPath::kWinding_FillType);
3189    pathB.moveTo(1,4);
3190    pathB.cubicTo(1,3, 4,1, 5,0);
3191    pathB.close();
3192    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3193}
3194
3195static void xOp1u(skiatest::Reporter* reporter, const char* filename) {
3196    SkPath path, pathB;
3197    path.setFillType(SkPath::kEvenOdd_FillType);
3198    path.moveTo(1, 4);
3199    path.cubicTo(4, 5, 3, 2, 6, 3);
3200    path.close();
3201    pathB.setFillType(SkPath::kEvenOdd_FillType);
3202    pathB.moveTo(2, 3);
3203    pathB.cubicTo(3, 6, 4, 1, 5, 4);
3204    pathB.close();
3205    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3206}
3207
3208static void xOp1i(skiatest::Reporter* reporter, const char* filename) {
3209    SkPath path, pathB;
3210    path.setFillType(SkPath::kEvenOdd_FillType);
3211    path.moveTo(1, 4);
3212    path.cubicTo(1, 5, 6, 0, 5, 1);
3213    path.close();
3214    pathB.setFillType(SkPath::kEvenOdd_FillType);
3215    pathB.moveTo(0, 6);
3216    pathB.cubicTo(1, 5, 4, 1, 5, 1);
3217    pathB.close();
3218    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3219}
3220
3221static void xOp2i(skiatest::Reporter* reporter, const char* filename) {
3222    SkPath path, pathB;
3223    path.setFillType(SkPath::kEvenOdd_FillType);
3224    path.moveTo(1, 5);
3225    path.cubicTo(0, 4, 3, 2, 6, 1);
3226    path.close();
3227    pathB.setFillType(SkPath::kEvenOdd_FillType);
3228    pathB.moveTo(2, 3);
3229    pathB.cubicTo(1, 6, 5, 1, 4, 0);
3230    pathB.close();
3231    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3232}
3233
3234static void xOp3i(skiatest::Reporter* reporter, const char* filename) {
3235    SkPath path, pathB;
3236    path.setFillType(SkPath::kWinding_FillType);
3237    path.moveTo(1,4);
3238    path.cubicTo(0,5, 4,1, 3,1);
3239    path.close();
3240    pathB.setFillType(SkPath::kWinding_FillType);
3241    pathB.moveTo(1,4);
3242    pathB.cubicTo(1,3, 4,1, 5,0);
3243    pathB.close();
3244    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3245}
3246
3247static void findFirst1(skiatest::Reporter* reporter, const char* filename) {
3248    SkPath path, pathB;
3249    path.setFillType(SkPath::kWinding_FillType);
3250    path.moveTo(0,1);
3251    path.cubicTo(1,6, 5,0, 2,1);
3252    path.close();
3253    pathB.setFillType(SkPath::kWinding_FillType);
3254    pathB.moveTo(0,5);
3255    pathB.cubicTo(1,2, 1,0, 6,1);
3256    pathB.close();
3257    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3258}
3259
3260// triggers addSimpleAngle with non-zero argument
3261static void cubicOp112(skiatest::Reporter* reporter, const char* filename) {
3262    SkPath path, pathB;
3263    path.setFillType(SkPath::kWinding_FillType);
3264    path.moveTo(2,4);
3265    path.cubicTo(2,3, 6,4, 1,0);
3266    path.close();
3267    pathB.setFillType(SkPath::kWinding_FillType);
3268    pathB.moveTo(4,6);
3269    pathB.cubicTo(0,1, 4,2, 3,2);
3270    pathB.close();
3271    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3272}
3273
3274static void cubicOp113(skiatest::Reporter* reporter, const char* filename) {
3275    SkPath path, pathB;
3276    path.moveTo(2,4);
3277    path.cubicTo(3,5, 2.33333325f,4.33333349f, 3.83333325f,3.83333349f);
3278    path.close();
3279    pathB.moveTo(3,5);
3280    pathB.cubicTo(2.33333325f,4.33333349f, 3.83333325f,3.83333349f, 2,4);
3281    pathB.close();
3282    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3283}
3284
3285static void cubicOp114(skiatest::Reporter* reporter, const char* filename) {
3286    if (!FLAGS_runFail) {
3287        return;
3288    }
3289    SkPath path, pathB;
3290    path.setFillType(SkPath::kWinding_FillType);
3291    path.moveTo(0, 1);
3292    path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3293    path.close();
3294    pathB.setFillType(SkPath::kWinding_FillType);
3295    pathB.moveTo(1, 3);
3296    pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3297    pathB.close();
3298    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3299}
3300
3301static void cubicOp114asQuad(skiatest::Reporter* reporter, const char* filename) {
3302    SkPath path, pathB;
3303    path.setFillType(SkPath::kWinding_FillType);
3304    path.moveTo(0, 1);
3305    path.cubicTo(1, 3, -1, 2, 3.5f, 1.33333337f);
3306    path.close();
3307    pathB.setFillType(SkPath::kWinding_FillType);
3308    pathB.moveTo(1, 3);
3309    pathB.cubicTo(-1, 2, 3.5f, 1.33333337f, 0, 1);
3310    pathB.close();
3311    SkPath qPath, qPathB;
3312    CubicPathToQuads(path, &qPath);
3313    CubicPathToQuads(pathB, &qPathB);
3314    testPathOp(reporter, qPath, qPathB, kIntersect_PathOp, filename);
3315}
3316
3317static void quadOp10i(skiatest::Reporter* reporter, const char* filename) {
3318    SkPath path, pathB;
3319    path.moveTo(0, 0);
3320    path.quadTo(1, 8, 3, 5);
3321    path.lineTo(8, 1);
3322    path.close();
3323    pathB.moveTo(0, 0);
3324    pathB.quadTo(8, 1, 4, 8);
3325    pathB.close();
3326    testPathOp(reporter, path, pathB, kIntersect_PathOp, filename);
3327}
3328
3329static void kari1(skiatest::Reporter* reporter, const char* filename) {
3330    SkPath path1;
3331    path1.moveTo(39.9375, -5.8359375);
3332    path1.lineTo(40.625, -5.7890625);
3333    path1.lineTo(37.7109375, 1.3515625);
3334    path1.lineTo(37.203125, 0.9609375);
3335    path1.close();
3336
3337    SkPath path2;
3338    path2.moveTo(37.52734375f, -1.44140625f);
3339    path2.cubicTo(37.8736991882324f, -1.69921875f, 38.1640625f, -2.140625f, 38.3984375f, -2.765625f);
3340    path2.lineTo(38.640625f, -2.609375f);
3341    path2.cubicTo(38.53125f, -1.89583337306976f, 38.0664443969727f, -0.154893040657043f, 38.0664443969727f, -0.154893040657043f);
3342    path2.cubicTo(38.0664443969727f, -0.154893040657043f, 37.1809883117676f, -1.18359375f, 37.52734375, -1.44140625f);
3343    path2.close();
3344
3345    testPathOp(reporter, path1, path2, kDifference_PathOp, filename);
3346}
3347
3348static void issue2504(skiatest::Reporter* reporter, const char* filename) {
3349    SkPath path1;
3350    path1.moveTo(34.2421875, -5.976562976837158203125);
3351    path1.lineTo(35.453121185302734375, 0);
3352    path1.lineTo(31.9375, 0);
3353    path1.close();
3354
3355    SkPath path2;
3356    path2.moveTo(36.71843719482421875, 0.8886508941650390625);
3357    path2.cubicTo(36.71843719482421875, 0.8886508941650390625,
3358                  35.123386383056640625, 0.554015457630157470703125,
3359                  34.511409759521484375, -0.1152553558349609375);
3360    path2.cubicTo(33.899425506591796875, -0.7845261096954345703125,
3361                  34.53484344482421875, -5.6777553558349609375,
3362                  34.53484344482421875, -5.6777553558349609375);
3363    path2.close();
3364    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3365}
3366
3367static void issue2540(skiatest::Reporter* reporter, const char* filename) {
3368    SkPath path1;
3369    path1.moveTo(26.5054988861083984375, 85.73960113525390625);
3370    path1.cubicTo(84.19739532470703125, 17.77140045166015625, 16.93920135498046875, 101.86199951171875, 12.631000518798828125, 105.24700164794921875);
3371    path1.cubicTo(11.0819997787475585937500000, 106.46399688720703125, 11.5260000228881835937500000, 104.464996337890625, 11.5260000228881835937500000, 104.464996337890625);
3372    path1.lineTo(23.1654987335205078125, 89.72879791259765625);
3373    path1.cubicTo(23.1654987335205078125, 89.72879791259765625, -10.1713008880615234375, 119.9160003662109375, -17.1620006561279296875, 120.8249969482421875);
3374    path1.cubicTo(-19.1149997711181640625, 121.07900238037109375, -18.0380001068115234375, 119.79299163818359375, -18.0380001068115234375, 119.79299163818359375);
3375    path1.cubicTo(-18.0380001068115234375, 119.79299163818359375, 14.22100067138671875, 90.60700225830078125, 26.5054988861083984375, 85.73960113525390625);
3376    path1.close();
3377
3378    SkPath path2;
3379    path2.moveTo(-25.077999114990234375, 124.9120025634765625);
3380    path2.cubicTo(-25.077999114990234375, 124.9120025634765625, -25.9509983062744140625, 125.95400238037109375, -24.368999481201171875, 125.7480010986328125);
3381    path2.cubicTo(-16.06999969482421875, 124.66899871826171875, 1.2680000066757202148437500, 91.23999786376953125, 37.264003753662109375, 95.35400390625);
3382    path2.cubicTo(37.264003753662109375, 95.35400390625, 11.3710002899169921875, 83.7339935302734375, -25.077999114990234375, 124.9120025634765625);
3383    path2.close();
3384    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3385}
3386
3387static void rects1(skiatest::Reporter* reporter, const char* filename) {
3388    SkPath path, pathB;
3389    path.setFillType(SkPath::kEvenOdd_FillType);
3390    path.moveTo(0, 0);
3391    path.lineTo(1, 0);
3392    path.lineTo(1, 1);
3393    path.lineTo(0, 1);
3394    path.close();
3395    path.moveTo(0, 0);
3396    path.lineTo(6, 0);
3397    path.lineTo(6, 6);
3398    path.lineTo(0, 6);
3399    path.close();
3400    pathB.setFillType(SkPath::kEvenOdd_FillType);
3401    pathB.moveTo(0, 0);
3402    pathB.lineTo(1, 0);
3403    pathB.lineTo(1, 1);
3404    pathB.lineTo(0, 1);
3405    pathB.close();
3406    pathB.moveTo(0, 0);
3407    pathB.lineTo(2, 0);
3408    pathB.lineTo(2, 2);
3409    pathB.lineTo(0, 2);
3410    pathB.close();
3411    testPathOp(reporter, path, pathB, kUnion_PathOp, filename);
3412}
3413
3414static void rects2(skiatest::Reporter* reporter, const char* filename) {
3415    SkPath path, pathB;
3416    path.setFillType(SkPath::kEvenOdd_FillType);
3417    path.moveTo(0, 0);
3418    path.lineTo(4, 0);
3419    path.lineTo(4, 4);
3420    path.lineTo(0, 4);
3421    path.close();
3422    path.moveTo(3, 3);
3423    path.lineTo(4, 3);
3424    path.lineTo(4, 4);
3425    path.lineTo(3, 4);
3426    path.close();
3427    pathB.setFillType(SkPath::kWinding_FillType);
3428    pathB.moveTo(3, 3);
3429    pathB.lineTo(6, 3);
3430    pathB.lineTo(6, 6);
3431    pathB.lineTo(3, 6);
3432    pathB.close();
3433    pathB.moveTo(3, 3);
3434    pathB.lineTo(4, 3);
3435    pathB.lineTo(4, 4);
3436    pathB.lineTo(3, 4);
3437    pathB.close();
3438    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3439}
3440
3441static void rects3(skiatest::Reporter* reporter, const char* filename) {
3442    SkPath path, pathB;
3443    path.setFillType(SkPath::kEvenOdd_FillType);
3444    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3445    path.addRect(0, 0, 4, 4, SkPath::kCW_Direction);
3446    pathB.setFillType(SkPath::kWinding_FillType);
3447    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3448    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3449    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3450}
3451
3452static void rects4(skiatest::Reporter* reporter, const char* filename) {
3453    SkPath path, pathB;
3454    path.setFillType(SkPath::kEvenOdd_FillType);
3455    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
3456    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3457    pathB.setFillType(SkPath::kWinding_FillType);
3458    pathB.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
3459    pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
3460    testPathOp(reporter, path, pathB, kDifference_PathOp, filename);
3461}
3462
3463static void issue2753(skiatest::Reporter* reporter, const char* filename) {
3464    if (!FLAGS_runFail) {
3465        return;
3466    }
3467    SkPath path1;
3468    path1.moveTo(142.701f, 110.568f);
3469    path1.lineTo(142.957f, 100);
3470    path1.lineTo(153.835f, 100);
3471    path1.lineTo(154.592f, 108.188f);
3472    path1.cubicTo(154.592f, 108.188f, 153.173f, 108.483f, 152.83f, 109.412f);
3473    path1.cubicTo(152.83f, 109.412f, 142.701f, 110.568f, 142.701f, 110.568f);
3474    path1.close();
3475
3476    SkPath path2;
3477    path2.moveTo(39, 124.001f);
3478    path2.cubicTo(39, 124.001f, 50.6f, 117.001f, 50.6f, 117.001f);
3479    path2.cubicTo(50.6f, 117.001f, 164.601f, 85.2f, 188.201f, 117.601f);
3480    path2.cubicTo(188.201f, 117.601f, 174.801f, 93, 39, 124.001f);
3481    path2.close();
3482
3483    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3484}
3485
3486static void issue2808(skiatest::Reporter* reporter, const char* filename) {
3487    SkPath path1, path2;
3488
3489	path1.moveTo(509.20300293f, 385.601989746f);
3490	path1.quadTo(509.20300293f, 415.68838501f, 487.928710938f, 436.96270752f);
3491	path1.quadTo(466.654388428f, 458.236999512f, 436.567993164f, 458.236999512f);
3492	path1.quadTo(406.4815979f, 458.236999512f, 385.207275391f, 436.96270752f);
3493	path1.quadTo(363.932983398f, 415.68838501f, 363.932983398f, 385.601989746f);
3494	path1.quadTo(363.932983398f, 355.515594482f, 385.207275391f, 334.241271973f);
3495	path1.quadTo(406.4815979f, 312.96697998f, 436.567993164f, 312.96697998f);
3496	path1.quadTo(466.654388428f, 312.96697998f, 487.928710938f, 334.241271973f);
3497	path1.quadTo(509.20300293f, 355.515594482f, 509.20300293f, 385.601989746f);
3498	path1.close();
3499
3500	path2.moveTo(449.033996582f, 290.87298584f);
3501	path2.quadTo(449.033996582f, 301.028259277f, 441.853149414f, 308.209106445f);
3502	path2.quadTo(434.672271729f, 315.389984131f, 424.516998291f, 315.389984131f);
3503	path2.quadTo(414.361724854f, 315.389984131f, 407.180847168f, 308.209106445f);
3504	path2.quadTo(400, 301.028259277f, 400, 290.87298584f);
3505	path2.quadTo(400, 280.717712402f, 407.180847168f, 273.536865234f);
3506	path2.quadTo(414.361724854f, 266.355987549f, 424.516998291f, 266.355987549f);
3507	path2.quadTo(434.672271729f, 266.355987549f, 441.853149414f, 273.536865234f);
3508	path2.quadTo(449.033996582f, 280.717712402f, 449.033996582f, 290.87298584f);
3509	path2.close();
3510
3511    testPathOp(reporter, path1, path2, kUnion_PathOp, filename);
3512}
3513
3514static void (*firstTest)(skiatest::Reporter* , const char* filename) = 0;
3515static void (*stopTest)(skiatest::Reporter* , const char* filename) = 0;
3516
3517static struct TestDesc tests[] = {
3518    TEST(issue2753),  // FIXME: pair of cubics miss intersection
3519    TEST(cubicOp114),  // FIXME: curve with inflection is ordered the wrong way
3520    TEST(issue2808),
3521    TEST(cubicOp114asQuad),
3522    TEST(rects4),
3523    TEST(rects3),
3524    TEST(rects2),
3525    TEST(rects1),
3526    TEST(issue2540),
3527    TEST(issue2504),
3528    TEST(kari1),
3529    TEST(quadOp10i),
3530    TEST(cubicOp113),
3531    // fails because a cubic/quadratic intersection is missed
3532    // the internal quad/quad is far enough away from the real cubic/quad that it is rejected
3533    TEST(skpcarrot_is24),
3534    TEST(issue1417),
3535    TEST(cubicOp112),
3536    TEST(skpadspert_net23),
3537    TEST(skpadspert_de11),
3538    TEST(findFirst1),
3539    TEST(xOp2i),
3540    TEST(xOp3i),
3541    TEST(xOp1u),
3542    TEST(xOp1i),
3543    TEST(cubicOp111),
3544    TEST(cubicOp110),
3545    TEST(cubicOp109),
3546    TEST(cubicOp108),
3547    TEST(cubicOp107),
3548    TEST(cubicOp106),
3549    TEST(cubicOp105),
3550    TEST(cubicOp104),
3551    TEST(cubicOp103),
3552    TEST(cubicOp102),
3553    TEST(cubicOp101),
3554    TEST(cubicOp100),
3555    TEST(cubicOp99),
3556    TEST(issue1435),
3557    TEST(cubicOp98x),
3558    TEST(cubicOp97x),
3559    TEST(skpcarpetplanet_ru22),  // cubic/cubic intersect detects unwanted coincidence
3560    TEST(cubicOp96d),
3561    TEST(cubicOp95u),
3562    TEST(skpadbox_lt15),
3563    TEST(skpagentxsites_com55),
3564    TEST(skpadventistmission_org572),
3565    TEST(skpadoption_org196),
3566    TEST(skpbambootheme_com12),
3567    TEST(skpbakosoft_com10),
3568    TEST(skpakmmos_ru100),
3569    TEST(skpbangalorenest_com4),
3570    TEST(skpbingoentertainment_net189),
3571    TEST(skpbestred_ru37),
3572    TEST(skpbenzoteh_ru152),
3573    TEST(skpcamcorder_kz21),
3574    TEST(skpcaffelavazzait_com_ua21),
3575    TEST(skpcarrefour_ro62),
3576    TEST(skpcavablar_net563),
3577    TEST(skpinsomnia_gr72),
3578    TEST(skpadbox_lt8),
3579    TEST(skpact_com43),
3580    TEST(skpacesoftech_com47),
3581    TEST(skpabcspark_ca103),
3582    TEST(cubicOp94u),
3583    TEST(cubicOp93d),
3584    TEST(cubicOp92i),
3585    TEST(skpadithya_putr4_blogspot_com551),
3586    TEST(skpadindex_de4),
3587    TEST(skpaiaigames_com870),
3588    TEST(skpaaalgarve_org53),
3589    TEST(skpkkiste_to716),
3590    TEST(cubicOp91u),
3591    TEST(cubicOp90u),
3592    TEST(cubicOp89u),
3593    TEST(cubicOp88u),
3594    TEST(cubicOp87u),
3595    TEST(cubicOp86i),
3596    TEST(loopEdge2),
3597    TEST(loopEdge1),
3598    TEST(rectOp3x),
3599    TEST(rectOp2i),
3600    TEST(rectOp1i),
3601    TEST(issue1418b),
3602    TEST(cubicOp85i),
3603    TEST(issue1418),
3604    TEST(skpkkiste_to98),
3605    TEST(skpahrefs_com29),
3606    TEST(cubicOp85d),
3607    TEST(skpahrefs_com88),
3608    TEST(skphealth_com76),
3609    TEST(skpancestry_com1),
3610    TEST(skpbyte_com1),
3611    TEST(skpeldorado_com_ua1),
3612    TEST(skp96prezzi1),
3613    TEST(skpClip2),
3614    TEST(skpClip1),
3615    TEST(cubicOp84d),
3616    TEST(cubicOp83i),
3617    TEST(cubicOp82i),
3618    TEST(cubicOp81d),
3619    TEST(cubicOp80i),
3620    TEST(cubicOp79u),
3621    TEST(cubicOp78u),
3622    TEST(cubicOp77i),
3623    TEST(cubicOp76u),
3624    TEST(cubicOp75d),
3625    TEST(cubicOp74d),
3626    TEST(cubicOp73d),
3627    TEST(cubicOp72i),
3628    TEST(cubicOp71d),
3629    TEST(skp5),
3630    TEST(skp4),
3631    TEST(skp3),
3632    TEST(skp2),
3633    TEST(skp1),
3634    TEST(rRect1),
3635    TEST(cubicOp70d),
3636    TEST(cubicOp69d),
3637    TEST(cubicOp68u),
3638    TEST(cubicOp67u),
3639    TEST(cubicOp66u),
3640    TEST(rectOp1d),
3641    TEST(cubicOp65d),
3642    TEST(cubicOp64d),
3643    TEST(cubicOp63d),
3644    TEST(cubicOp62d),
3645    TEST(cubicOp61d),
3646    TEST(cubicOp60d),
3647    TEST(cubicOp59d),
3648    TEST(cubicOp58d),
3649    TEST(cubicOp57d),
3650    TEST(cubicOp56d),
3651    TEST(cubicOp55d),
3652    TEST(cubicOp54d),
3653    TEST(cubicOp53d),
3654    TEST(cubicOp52d),
3655    TEST(cubicOp51d),
3656    TEST(cubicOp50d),
3657    TEST(cubicOp49d),
3658    TEST(cubicOp48d),
3659    TEST(cubicOp47d),
3660    TEST(cubicOp46d),
3661    TEST(cubicOp45d),
3662    TEST(cubicOp44d),
3663    TEST(cubicOp43d),
3664    TEST(cubicOp42d),
3665    TEST(cubicOp41i),
3666    TEST(cubicOp40d),
3667    TEST(cubicOp39d),
3668    TEST(cubicOp38d),
3669    TEST(cubicOp37d),
3670    TEST(cubicOp36u),
3671    TEST(cubicOp35d),
3672    TEST(cubicOp34d),
3673    TEST(cubicOp33i),
3674    TEST(cubicOp32d),
3675    TEST(cubicOp31d),
3676    TEST(cubicOp31x),
3677    TEST(cubicOp31u),
3678    TEST(cubicOp30d),
3679    TEST(cubicOp29d),
3680    TEST(cubicOp28u),
3681    TEST(cubicOp27d),
3682    TEST(cubicOp26d),
3683    TEST(cubicOp25i),
3684    TEST(testOp8d),
3685    TEST(testDiff1),
3686    TEST(testIntersect1),
3687    TEST(testUnion1),
3688    TEST(testXor1),
3689    TEST(testDiff2),
3690    TEST(testIntersect2),
3691    TEST(testUnion2),
3692    TEST(testXor2),
3693    TEST(testOp1d),
3694    TEST(testOp2d),
3695    TEST(testOp3d),
3696    TEST(testOp1u),
3697    TEST(testOp4d),
3698    TEST(testOp5d),
3699    TEST(testOp6d),
3700    TEST(testOp7d),
3701    TEST(testOp2u),
3702
3703    TEST(cubicOp24d),
3704    TEST(cubicOp23d),
3705    TEST(cubicOp22d),
3706    TEST(cubicOp21d),
3707    TEST(cubicOp20d),
3708    TEST(cubicOp19i),
3709    TEST(cubicOp18d),
3710    TEST(cubicOp17d),
3711    TEST(cubicOp16d),
3712    TEST(cubicOp15d),
3713    TEST(cubicOp14d),
3714    TEST(cubicOp13d),
3715    TEST(cubicOp12d),
3716    TEST(cubicOp11d),
3717    TEST(cubicOp10d),
3718    TEST(cubicOp1i),
3719    TEST(cubicOp9d),
3720    TEST(quadOp9d),
3721    TEST(lineOp9d),
3722    TEST(cubicOp8d),
3723    TEST(cubicOp7d),
3724    TEST(cubicOp6d),
3725    TEST(cubicOp5d),
3726    TEST(cubicOp3d),
3727    TEST(cubicOp2d),
3728    TEST(cubicOp1d),
3729};
3730
3731static const size_t testCount = SK_ARRAY_COUNT(tests);
3732
3733static struct TestDesc subTests[] = {
3734    TEST(cubicOp58d),
3735    TEST(cubicOp53d),
3736};
3737
3738static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
3739
3740static void (*firstSubTest)(skiatest::Reporter* , const char* filename) = 0;
3741
3742static bool runSubTests = false;
3743static bool runSubTestsFirst = false;
3744static bool runReverse = false;
3745
3746DEF_TEST(PathOpsOp, reporter) {
3747#if DEBUG_SHOW_TEST_NAME
3748    strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
3749#endif
3750    if (runSubTests && runSubTestsFirst) {
3751        RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
3752    }
3753    RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
3754    if (runSubTests && !runSubTestsFirst) {
3755        RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
3756    }
3757}
3758
3759static void bufferOverflow(skiatest::Reporter* reporter, const char* filename) {
3760    SkPath path;
3761    path.addRect(0,0, 300,170141183460469231731687303715884105728.f);
3762    SkPath pathB;
3763    pathB.addRect(0,0, 300,16);
3764    testPathFailOp(reporter, path, pathB, kUnion_PathOp, filename);
3765}
3766
3767// m 100,0 60,170 -160,-110 200,0 -170,11000000000 z
3768static void fuzz433(skiatest::Reporter* reporter, const char* filename) {
3769    SkPath path1, path2;
3770    path1.moveTo(100,0);
3771    path1.lineTo(60,170);
3772    path1.lineTo(-160,-110);
3773    path1.lineTo(200,0);
3774    path1.lineTo(-170,11000000000.0f);
3775    path1.close();
3776
3777    path2.moveTo(100 + 20,0 + 20);
3778    path2.lineTo(60 + 20,170 + 20);
3779    path2.lineTo(-160 + 20,-110 + 20);
3780    path2.lineTo(200 + 20,0 + 20);
3781    path2.lineTo(-170 + 20,11000000000.0f + 20);
3782    path2.close();
3783
3784    testPathFailOp(reporter, path1, path2, kIntersect_PathOp, filename);
3785}
3786
3787static void fuzz433b(skiatest::Reporter* reporter, const char* filename) {
3788    SkPath path1, path2;
3789    path1.setFillType(SkPath::kEvenOdd_FillType);
3790    path1.moveTo(140, 40);
3791    path1.lineTo(200, 210);
3792    path1.lineTo(40, 100);
3793    path1.lineTo(240, 100);
3794    path1.lineTo(70, 1.1e+10f);
3795    path1.lineTo(140, 40);
3796    path1.close();
3797
3798    path1.setFillType(SkPath::kWinding_FillType);
3799    path2.moveTo(190, 60);
3800    path2.lineTo(250, 230);
3801    path2.lineTo(90, 120);
3802    path2.lineTo(290, 120);
3803    path2.lineTo(120, 1.1e+10f);
3804    path2.lineTo(190, 60);
3805    path2.close();
3806
3807    testPathFailOp(reporter, path1, path2, kUnion_PathOp, filename);
3808}
3809
3810static void fuzz487a(skiatest::Reporter* reporter, const char* filename) {
3811    SkPath path;
3812    path.setFillType((SkPath::FillType) 0);
3813path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
3814path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
3815path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
3816path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
3817path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
3818path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
3819path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
3820path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
3821path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
3822path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
3823path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
3824path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
3825path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(0x434d3333), SkBits2Float(0x4364e667), SkBits2Float(0x4346b333), SkBits2Float(0x4364e667), SkBits2Float(0x43400000));
3826path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
3827path.close();
3828
3829    SkPath path1(path);
3830    path.reset();
3831    path.setFillType((SkPath::FillType) 0);
3832path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
3833path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
3834path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x42a20000), SkBits2Float(0x43016667), SkBits2Float(0x4287cccd), SkBits2Float(0x42ea999a), SkBits2Float(0x4273999a));
3835path.lineTo(SkBits2Float(0x4306cccd), SkBits2Float(0x41f5999a));
3836path.cubicTo(SkBits2Float(0x42f76667), SkBits2Float(0x41c26667), SkBits2Float(0x42dd999a), SkBits2Float(0x41a4cccd), SkBits2Float(0x42c23334), SkBits2Float(0x41a4cccd));
3837path.lineTo(SkBits2Float(0x42c23334), SkBits2Float(0x425e0000));
3838path.cubicTo(SkBits2Float(0x42a43334), SkBits2Float(0x425e0000), SkBits2Float(0x428a0001), SkBits2Float(0x427ecccd), SkBits2Float(0x42780002), SkBits2Float(0x4297999a));
3839path.lineTo(SkBits2Float(0x41fccccd), SkBits2Float(0x42693333));
3840path.cubicTo(SkBits2Float(0x41c9999a), SkBits2Float(0x428acccd), SkBits2Float(0x41ac0000), SkBits2Float(0x42a4999a), SkBits2Float(0x41ac0000), SkBits2Float(0x42c00000));
3841path.lineTo(SkBits2Float(0x4261999a), SkBits2Float(0x42c00000));
3842path.cubicTo(SkBits2Float(0x4261999a), SkBits2Float(0x42de0000), SkBits2Float(0x42813333), SkBits2Float(0x42f83333), SkBits2Float(0x42996666), SkBits2Float(0x4303199a));
3843path.cubicTo(SkBits2Float(0x4272cccc), SkBits2Float(0x4303199a), SkBits2Float(0x423d3332), SkBits2Float(0x430de667), SkBits2Float(0x422d9999), SkBits2Float(0x431cb334));
3844path.lineTo(SkBits2Float(0x7086a1dc), SkBits2Float(0x42eecccd));
3845path.lineTo(SkBits2Float(0x41eb3333), SkBits2Float(0xc12ccccd));
3846path.lineTo(SkBits2Float(0x42053333), SkBits2Float(0xc1cccccd));
3847path.lineTo(SkBits2Float(0x42780000), SkBits2Float(0xc18f3334));
3848path.cubicTo(SkBits2Float(0x43206666), SkBits2Float(0x43134ccd), SkBits2Float(0x43213333), SkBits2Float(0x430db333), SkBits2Float(0x43213333), SkBits2Float(0x43080000));
3849path.lineTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
3850path.close();
3851
3852    SkPath path2(path);
3853    testPathFailOp(reporter, path1, path2, (SkPathOp) 2, filename);
3854}
3855
3856static void fuzz487b(skiatest::Reporter* reporter, const char* filename) {
3857    SkPath path;
3858    path.setFillType((SkPath::FillType) 0);
3859path.moveTo(SkBits2Float(0x432c8000), SkBits2Float(0x42c00000));
3860path.lineTo(SkBits2Float(0x4309999a), SkBits2Float(0x42c00000));
3861path.cubicTo(SkBits2Float(0x4309999a), SkBits2Float(0x429a6666), SkBits2Float(0x42f9999a), SkBits2Float(0x4275999a), SkBits2Float(0x42d70001), SkBits2Float(0x42633333));
3862path.lineTo(SkBits2Float(0x42e90001), SkBits2Float(0x41b8cccc));
3863path.cubicTo(SkBits2Float(0x42dc6667), SkBits2Float(0x41ab3332), SkBits2Float(0x42cf3334), SkBits2Float(0x41a3ffff), SkBits2Float(0x42c20001), SkBits2Float(0x41a3ffff));
3864path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
3865path.lineTo(SkBits2Float(0x42c20001), SkBits2Float(0x425d999a));
3866path.cubicTo(SkBits2Float(0x429c6668), SkBits2Float(0x425d999a), SkBits2Float(0x4279999c), SkBits2Float(0x42886667), SkBits2Float(0x42673335), SkBits2Float(0x42ab0000));
3867path.lineTo(SkBits2Float(0x41c0ccd0), SkBits2Float(0x42990000));
3868path.cubicTo(SkBits2Float(0x41b33336), SkBits2Float(0x42a5999a), SkBits2Float(0x41ac0003), SkBits2Float(0x42b2cccd), SkBits2Float(0x41ac0003), SkBits2Float(0x42c00000));
3869path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
3870path.lineTo(SkBits2Float(0x4261999c), SkBits2Float(0x42c00000));
3871path.cubicTo(SkBits2Float(0x4261999c), SkBits2Float(