PathOpsOpTest.cpp revision fa2aeee27af27f2934ee52a9732148f66481fb03 
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
9#define TEST(name) { name, #name }
10
11static void cubicOp1d(skiatest::Reporter* reporter) {
12    SkPath path, pathB;
13    path.setFillType(SkPath::kWinding_FillType);
14    path.moveTo(0,1);
15    path.cubicTo(0,2, 1,0, 1,0);
16    path.close();
17    pathB.setFillType(SkPath::kWinding_FillType);
18    pathB.moveTo(0,1);
19    pathB.cubicTo(0,1, 1,0, 2,0);
20    pathB.close();
21    testPathOp(reporter, path, pathB, kDifference_PathOp);
22}
23
24static void cubicOp2d(skiatest::Reporter* reporter) {
25    SkPath path, pathB;
26    path.setFillType(SkPath::kWinding_FillType);
27    path.moveTo(0,2);
28    path.cubicTo(0,1, 1,0, 1,0);
29    path.close();
30    pathB.setFillType(SkPath::kWinding_FillType);
31    pathB.moveTo(0,1);
32    pathB.cubicTo(0,1, 2,0, 1,0);
33    pathB.close();
34    testPathOp(reporter, path, pathB, kDifference_PathOp);
35}
36
37static void cubicOp3d(skiatest::Reporter* reporter) {
38    SkPath path, pathB;
39    path.setFillType(SkPath::kWinding_FillType);
40    path.moveTo(0,1);
41    path.cubicTo(2,3, 1,0, 1,0);
42    path.close();
43    pathB.setFillType(SkPath::kWinding_FillType);
44    pathB.moveTo(0,1);
45    pathB.cubicTo(0,1, 1,0, 3,2);
46    pathB.close();
47    testPathOp(reporter, path, pathB, kDifference_PathOp);
48}
49
50static void cubicOp5d(skiatest::Reporter* reporter) {
51    SkPath path, pathB;
52    path.setFillType(SkPath::kWinding_FillType);
53    path.moveTo(0,1);
54    path.cubicTo(0,2, 1,0, 2,0);
55    path.close();
56    pathB.setFillType(SkPath::kWinding_FillType);
57    pathB.moveTo(0,1);
58    pathB.cubicTo(0,2, 1,0, 2,0);
59    pathB.close();
60    testPathOp(reporter, path, pathB, kDifference_PathOp);
61}
62
63static void cubicOp6d(skiatest::Reporter* reporter) {
64    SkPath path, pathB;
65    path.setFillType(SkPath::kWinding_FillType);
66    path.moveTo(0,1);
67    path.cubicTo(0,6, 1,0, 3,0);
68    path.close();
69    pathB.setFillType(SkPath::kWinding_FillType);
70    pathB.moveTo(0,1);
71    pathB.cubicTo(0,3, 1,0, 6,0);
72    pathB.close();
73    testPathOp(reporter, path, pathB, kDifference_PathOp);
74}
75
76static void cubicOp7d(skiatest::Reporter* reporter) {
77    SkPath path, pathB;
78    path.setFillType(SkPath::kWinding_FillType);
79    path.moveTo(0,1);
80    path.cubicTo(3,4, 1,0, 3,0);
81    path.close();
82    pathB.setFillType(SkPath::kWinding_FillType);
83    pathB.moveTo(0,1);
84    pathB.cubicTo(0,3, 1,0, 4,3);
85    pathB.close();
86    testPathOp(reporter, path, pathB, kDifference_PathOp);
87}
88
89static void cubicOp8d(skiatest::Reporter* reporter) {
90    SkPath path, pathB;
91    path.setFillType(SkPath::kWinding_FillType);
92    path.moveTo(0,1);
93    path.cubicTo(0,5, 1,0, 4,0);
94    path.close();
95    pathB.setFillType(SkPath::kWinding_FillType);
96    pathB.moveTo(0,1);
97    pathB.cubicTo(0,4, 1,0, 5,0);
98    pathB.close();
99    testPathOp(reporter, path, pathB, kDifference_PathOp);
100}
101
102static void cubicOp9d(skiatest::Reporter* reporter) {
103    SkPath path, pathB;
104    path.setFillType(SkPath::kWinding_FillType);
105    path.moveTo(0,1);
106    path.cubicTo(1,6, 1,0, 2,1);
107    path.close();
108    pathB.setFillType(SkPath::kWinding_FillType);
109    pathB.moveTo(0,1);
110    pathB.cubicTo(1,2, 1,0, 6,1);
111    pathB.close();
112    testPathOp(reporter, path, pathB, kDifference_PathOp);
113}
114
115static void quadOp9d(skiatest::Reporter* reporter) {
116    SkPath path, pathB;
117    path.setFillType(SkPath::kWinding_FillType);
118    path.moveTo(0,1);
119    path.quadTo(1,6, 1.5f,1);
120    path.quadTo(1.5f,0.5f, 2,1);
121    path.close();
122    pathB.setFillType(SkPath::kWinding_FillType);
123    pathB.moveTo(0,1);
124    pathB.quadTo(1,2, 1.4f,1);
125    pathB.quadTo(3,0.4f, 6,1);
126    pathB.close();
127    testPathOp(reporter, path, pathB, kDifference_PathOp);
128}
129
130static void lineOp9d(skiatest::Reporter* reporter) {
131    SkPath path, pathB;
132    path.setFillType(SkPath::kWinding_FillType);
133    path.moveTo(0,1);
134    path.lineTo(1,6);
135    path.lineTo(1.5f,1);
136    path.lineTo(1.8f,0.8f);
137    path.lineTo(2,1);
138    path.close();
139    pathB.setFillType(SkPath::kWinding_FillType);
140    pathB.moveTo(0,1);
141    pathB.lineTo(1,2);
142    pathB.lineTo(1.4f,1);
143    pathB.lineTo(3,0.4f);
144    pathB.lineTo(6,1);
145    pathB.close();
146    testPathOp(reporter, path, pathB, kDifference_PathOp);
147}
148
149static void cubicOp1i(skiatest::Reporter* reporter) {
150    SkPath path, pathB;
151    path.setFillType(SkPath::kWinding_FillType);
152    path.moveTo(0,1);
153    path.cubicTo(1,2, 1,0, 2,1);
154    path.close();
155    pathB.setFillType(SkPath::kWinding_FillType);
156    pathB.moveTo(0,1);
157    pathB.cubicTo(1,2, 1,0, 2,1);
158    pathB.close();
159    testPathOp(reporter, path, pathB, kIntersect_PathOp);
160}
161
162static void cubicOp10d(skiatest::Reporter* reporter) {
163    SkPath path, pathB;
164    path.setFillType(SkPath::kWinding_FillType);
165    path.moveTo(0,1);
166    path.cubicTo(1,3, 1,0, 4,1);
167    path.close();
168    pathB.setFillType(SkPath::kWinding_FillType);
169    pathB.moveTo(0,1);
170    pathB.cubicTo(1,4, 1,0, 3,1);
171    pathB.close();
172    testPathOp(reporter, path, pathB, kDifference_PathOp);
173}
174
175static void cubicOp11d(skiatest::Reporter* reporter) {
176    SkPath path, pathB;
177    path.setFillType(SkPath::kWinding_FillType);
178    path.moveTo(0,1);
179    path.cubicTo(3,4, 1,0, 5,1);
180    path.close();
181    pathB.setFillType(SkPath::kWinding_FillType);
182    pathB.moveTo(0,1);
183    pathB.cubicTo(1,5, 1,0, 4,3);
184    pathB.close();
185    testPathOp(reporter, path, pathB, kDifference_PathOp);
186}
187
188static void cubicOp12d(skiatest::Reporter* reporter) {
189    SkPath path, pathB;
190    path.setFillType(SkPath::kWinding_FillType);
191    path.moveTo(0,1);
192    path.cubicTo(1,6, 1,0, 1,0);
193    path.close();
194    pathB.setFillType(SkPath::kWinding_FillType);
195    pathB.moveTo(0,1);
196    pathB.cubicTo(0,1, 1,0, 6,1);
197    pathB.close();
198    testPathOp(reporter, path, pathB, kDifference_PathOp);
199}
200
201static void cubicOp13d(skiatest::Reporter* reporter) {
202    SkPath path, pathB;
203    path.setFillType(SkPath::kWinding_FillType);
204    path.moveTo(0,1);
205    path.cubicTo(4,5, 1,0, 5,3);
206    path.close();
207    pathB.setFillType(SkPath::kWinding_FillType);
208    pathB.moveTo(0,1);
209    pathB.cubicTo(3,5, 1,0, 5,4);
210    pathB.close();
211    testPathOp(reporter, path, pathB, kDifference_PathOp);
212}
213
214static void cubicOp14d(skiatest::Reporter* reporter) {
215    SkPath path, pathB;
216    path.setFillType(SkPath::kWinding_FillType);
217    path.moveTo(0,1);
218    path.cubicTo(0,2, 2,0, 2,1);
219    path.close();
220    pathB.setFillType(SkPath::kWinding_FillType);
221    pathB.moveTo(0,2);
222    pathB.cubicTo(1,2, 1,0, 2,0);
223    pathB.close();
224    testPathOp(reporter, path, pathB, kDifference_PathOp);
225}
226
227static void cubicOp15d(skiatest::Reporter* reporter) {
228    SkPath path, pathB;
229    path.setFillType(SkPath::kWinding_FillType);
230    path.moveTo(0,1);
231    path.cubicTo(3,6, 2,0, 2,1);
232    path.close();
233    pathB.setFillType(SkPath::kWinding_FillType);
234    pathB.moveTo(0,2);
235    pathB.cubicTo(1,2, 1,0, 6,3);
236    pathB.close();
237    testPathOp(reporter, path, pathB, kDifference_PathOp);
238}
239
240static void cubicOp16d(skiatest::Reporter* reporter) {
241    SkPath path, pathB;
242    path.setFillType(SkPath::kWinding_FillType);
243    path.moveTo(0,2);
244    path.cubicTo(0,1, 3,0, 1,0);
245    path.close();
246    pathB.setFillType(SkPath::kWinding_FillType);
247    pathB.moveTo(0,3);
248    pathB.cubicTo(0,1, 2,0, 1,0);
249    pathB.close();
250    testPathOp(reporter, path, pathB, kDifference_PathOp);
251}
252
253static void cubicOp17d(skiatest::Reporter* reporter) {
254    SkPath path, pathB;
255    path.setFillType(SkPath::kWinding_FillType);
256    path.moveTo(0,2);
257    path.cubicTo(0,2, 4,0, 2,1);
258    path.close();
259    pathB.setFillType(SkPath::kWinding_FillType);
260    pathB.moveTo(0,4);
261    pathB.cubicTo(1,2, 2,0, 2,0);
262    pathB.close();
263    testPathOp(reporter, path, pathB, kDifference_PathOp);
264}
265
266static void cubicOp18d(skiatest::Reporter* reporter) {
267    SkPath path, pathB;
268    path.setFillType(SkPath::kWinding_FillType);
269    path.moveTo(0,1);
270    path.cubicTo(3,5, 2,0, 2,1);
271    path.close();
272    pathB.setFillType(SkPath::kWinding_FillType);
273    pathB.moveTo(0,2);
274    pathB.cubicTo(1,2, 1,0, 5,3);
275    pathB.close();
276    testPathOp(reporter, path, pathB, kDifference_PathOp);
277}
278
279static void cubicOp19i(skiatest::Reporter* reporter) {
280    SkPath path, pathB;
281    path.setFillType(SkPath::kWinding_FillType);
282    path.moveTo(0,2);
283    path.cubicTo(0,1, 2,1, 6,2);
284    path.close();
285    pathB.setFillType(SkPath::kWinding_FillType);
286    pathB.moveTo(1,2);
287    pathB.cubicTo(2,6, 2,0, 1,0);
288    pathB.close();
289    testPathOp(reporter, path, pathB, kIntersect_PathOp);
290}
291
292static void cubicOp20d(skiatest::Reporter* reporter) {
293    SkPath path, pathB;
294    path.setFillType(SkPath::kWinding_FillType);
295    path.moveTo(0,1);
296    path.cubicTo(0,1, 6,0, 2,1);
297    path.close();
298    pathB.setFillType(SkPath::kWinding_FillType);
299    pathB.moveTo(0,6);
300    pathB.cubicTo(1,2, 1,0, 1,0);
301    pathB.close();
302    testPathOp(reporter, path, pathB, kDifference_PathOp);
303}
304
305static void cubicOp21d(skiatest::Reporter* reporter) {
306    SkPath path, pathB;
307    path.setFillType(SkPath::kWinding_FillType);
308    path.moveTo(0,1);
309    path.cubicTo(0,1, 2,1, 6,5);
310    path.close();
311    pathB.setFillType(SkPath::kWinding_FillType);
312    pathB.moveTo(1,2);
313    pathB.cubicTo(5,6, 1,0, 1,0);
314    pathB.close();
315    testPathOp(reporter, path, pathB, kDifference_PathOp);
316}
317
318static void cubicOp22d(skiatest::Reporter* reporter) {
319    SkPath path, pathB;
320    path.setFillType(SkPath::kWinding_FillType);
321    path.moveTo(0,1);
322    path.cubicTo(2,3, 3,0, 2,1);
323    path.close();
324    pathB.setFillType(SkPath::kWinding_FillType);
325    pathB.moveTo(0,3);
326    pathB.cubicTo(1,2, 1,0, 3,2);
327    pathB.close();
328    testPathOp(reporter, path, pathB, kDifference_PathOp);
329}
330
331static void cubicOp23d(skiatest::Reporter* reporter) {
332    SkPath path, pathB;
333    path.setFillType(SkPath::kWinding_FillType);
334    path.moveTo(0,1);
335    path.cubicTo(1,2, 4,0, 2,1);
336    path.close();
337    pathB.setFillType(SkPath::kWinding_FillType);
338    pathB.moveTo(0,4);
339    pathB.cubicTo(1,2, 1,0, 2,1);
340    pathB.close();
341    testPathOp(reporter, path, pathB, kDifference_PathOp);
342}
343
344static void cubicOp24d(skiatest::Reporter* reporter) {
345    SkPath path, pathB;
346    path.setFillType(SkPath::kWinding_FillType);
347    path.moveTo(0,1);
348    path.cubicTo(1,2, 2,0, 3,2);
349    path.close();
350    pathB.setFillType(SkPath::kWinding_FillType);
351    pathB.moveTo(0,2);
352    pathB.cubicTo(2,3, 1,0, 2,1);
353    pathB.close();
354    testPathOp(reporter, path, pathB, kDifference_PathOp);
355}
356
357static void testIntersect1(skiatest::Reporter* reporter) {
358    SkPath one, two;
359    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
360    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
361    testPathOp(reporter, one, two, kIntersect_PathOp);
362}
363
364static void testUnion1(skiatest::Reporter* reporter) {
365    SkPath one, two;
366    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
367    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
368    testPathOp(reporter, one, two, kUnion_PathOp);
369}
370
371static void testDiff1(skiatest::Reporter* reporter) {
372    SkPath one, two;
373    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
374    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
375    testPathOp(reporter, one, two, kDifference_PathOp);
376}
377
378static void testXor1(skiatest::Reporter* reporter) {
379    SkPath one, two;
380    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
381    two.addRect(3, 3, 9, 9, SkPath::kCW_Direction);
382    testPathOp(reporter, one, two, kXOR_PathOp);
383}
384
385static void testIntersect2(skiatest::Reporter* reporter) {
386    SkPath one, two;
387    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
388    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
389    testPathOp(reporter, one, two, kIntersect_PathOp);
390}
391
392static void testUnion2(skiatest::Reporter* reporter) {
393    SkPath one, two;
394    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
395    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
396    testPathOp(reporter, one, two, kUnion_PathOp);
397}
398
399static void testDiff2(skiatest::Reporter* reporter) {
400    SkPath one, two;
401    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
402    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
403    testPathOp(reporter, one, two, kDifference_PathOp);
404}
405
406static void testXor2(skiatest::Reporter* reporter) {
407    SkPath one, two;
408    one.addRect(0, 0, 6, 6, SkPath::kCW_Direction);
409    two.addRect(0, 3, 9, 9, SkPath::kCW_Direction);
410    testPathOp(reporter, one, two, kXOR_PathOp);
411}
412
413static void testOp1d(skiatest::Reporter* reporter) {
414    SkPath path, pathB;
415    path.setFillType(SkPath::kWinding_FillType);
416    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
417    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
418    pathB.setFillType(SkPath::kWinding_FillType);
419    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
420    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
421    testPathOp(reporter, path, pathB, kDifference_PathOp);
422}
423
424static void testOp2d(skiatest::Reporter* reporter) {
425    SkPath path, pathB;
426    path.setFillType(SkPath::kWinding_FillType);
427    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
428    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
429    pathB.setFillType(SkPath::kEvenOdd_FillType);
430    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
431    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
432    testPathOp(reporter, path, pathB, kDifference_PathOp);
433}
434
435static void testOp3d(skiatest::Reporter* reporter) {
436    SkPath path, pathB;
437    path.setFillType(SkPath::kWinding_FillType);
438    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
439    path.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
440    pathB.setFillType(SkPath::kWinding_FillType);
441    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
442    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
443    testPathOp(reporter, path, pathB, kDifference_PathOp);
444}
445
446static void testOp1u(skiatest::Reporter* reporter) {
447    SkPath path, pathB;
448    path.setFillType(SkPath::kWinding_FillType);
449    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
450    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
451    pathB.setFillType(SkPath::kWinding_FillType);
452    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
453    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
454    testPathOp(reporter, path, pathB, kUnion_PathOp);
455}
456
457static void testOp4d(skiatest::Reporter* reporter) {
458    SkPath path, pathB;
459    path.setFillType(SkPath::kWinding_FillType);
460    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
461    path.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
462    pathB.setFillType(SkPath::kWinding_FillType);
463    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
464    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
465    testPathOp(reporter, path, pathB, kDifference_PathOp);
466}
467
468static void testOp5d(skiatest::Reporter* reporter) {
469    SkPath path, pathB;
470    path.setFillType(SkPath::kEvenOdd_FillType);
471    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
472    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
473    pathB.setFillType(SkPath::kEvenOdd_FillType);
474    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
475    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
476    testPathOp(reporter, path, pathB, kDifference_PathOp);
477}
478
479static void testOp6d(skiatest::Reporter* reporter) {
480    SkPath path, pathB;
481    path.setFillType(SkPath::kEvenOdd_FillType);
482    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
483    path.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
484    pathB.setFillType(SkPath::kWinding_FillType);
485    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
486    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
487    testPathOp(reporter, path, pathB, kDifference_PathOp);
488}
489
490static void testOp7d(skiatest::Reporter* reporter) {
491    SkPath path, pathB;
492    path.setFillType(SkPath::kEvenOdd_FillType);
493    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
494    path.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
495    pathB.setFillType(SkPath::kEvenOdd_FillType);
496    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
497    pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction);
498    testPathOp(reporter, path, pathB, kDifference_PathOp);
499}
500
501static void testOp2u(skiatest::Reporter* reporter) {
502    SkPath path, pathB;
503    path.setFillType(SkPath::kEvenOdd_FillType);
504    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
505    path.addRect(0, 0, 2, 2, SkPath::kCW_Direction);
506    pathB.setFillType(SkPath::kWinding_FillType);
507    pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction);
508    pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction);
509    testPathOp(reporter, path, pathB, kUnion_PathOp);
510}
511
512static void testOp8d(skiatest::Reporter* reporter) {
513    SkPath path, pathB;
514    path.addRect(0, 0, 640, 480);
515    pathB.moveTo(577330, 1971.72f);
516    pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
517    pathB.close();
518    testPathOp(reporter, path, pathB, kDifference_PathOp);
519}
520static void cubicOp25i(skiatest::Reporter* reporter) {
521    SkPath path, pathB;
522    path.setFillType(SkPath::kWinding_FillType);
523    path.moveTo(0,1);
524    path.cubicTo(2,4, 5,0, 3,2);
525    path.close();
526    pathB.setFillType(SkPath::kWinding_FillType);
527    pathB.moveTo(0,5);
528    pathB.cubicTo(2,3, 1,0, 4,2);
529    pathB.close();
530    testPathOp(reporter, path, pathB, kIntersect_PathOp);
531}
532
533static void cubicOp26d(skiatest::Reporter* reporter) {
534    SkPath path, pathB;
535    path.setFillType(SkPath::kWinding_FillType);
536    path.moveTo(0,1);
537    path.cubicTo(3,4, 4,0, 3,2);
538    path.close();
539    pathB.setFillType(SkPath::kWinding_FillType);
540    pathB.moveTo(0,4);
541    pathB.cubicTo(2,3, 1,0, 4,3);
542    pathB.close();
543    testPathOp(reporter, path, pathB, kDifference_PathOp);
544}
545
546static void cubicOp27d(skiatest::Reporter* reporter) {
547    SkPath path, pathB;
548    path.setFillType(SkPath::kWinding_FillType);
549    path.moveTo(0,1);
550    path.cubicTo(3,6, 1,0, 5,2);
551    path.close();
552    pathB.setFillType(SkPath::kWinding_FillType);
553    pathB.moveTo(0,1);
554    pathB.cubicTo(2,5, 1,0, 6,3);
555    pathB.close();
556    testPathOp(reporter, path, pathB, kDifference_PathOp);
557}
558
559static void cubicOp28u(skiatest::Reporter* reporter) {
560    SkPath path, pathB;
561    path.setFillType(SkPath::kWinding_FillType);
562    path.moveTo(0,1);
563    path.cubicTo(1,4, 6,0, 3,2);
564    path.close();
565    pathB.setFillType(SkPath::kWinding_FillType);
566    pathB.moveTo(0,6);
567    pathB.cubicTo(2,3, 1,0, 4,1);
568    pathB.close();
569    testPathOp(reporter, path, pathB, kUnion_PathOp);
570}
571
572static void cubicOp29d(skiatest::Reporter* reporter) {
573    SkPath path, pathB;
574    path.setFillType(SkPath::kWinding_FillType);
575    path.moveTo(0,1);
576    path.cubicTo(2,5, 6,0, 4,2);
577    path.close();
578    pathB.setFillType(SkPath::kWinding_FillType);
579    pathB.moveTo(0,6);
580    pathB.cubicTo(2,4, 1,0, 5,2);
581    pathB.close();
582    testPathOp(reporter, path, pathB, kDifference_PathOp);
583}
584
585static void cubicOp30d(skiatest::Reporter* reporter) {
586    SkPath path, pathB;
587    path.setFillType(SkPath::kWinding_FillType);
588    path.moveTo(0,1);
589    path.cubicTo(2,5, 6,0, 5,3);
590    path.close();
591    pathB.setFillType(SkPath::kWinding_FillType);
592    pathB.moveTo(0,6);
593    pathB.cubicTo(3,5, 1,0, 5,2);
594    pathB.close();
595    testPathOp(reporter, path, pathB, kDifference_PathOp);
596}
597
598static void cubicOp31d(skiatest::Reporter* reporter) {
599    SkPath path, pathB;
600    path.setFillType(SkPath::kWinding_FillType);
601    path.moveTo(0,2);
602    path.cubicTo(0,3, 2,1, 4,0);
603    path.close();
604    pathB.setFillType(SkPath::kWinding_FillType);
605    pathB.moveTo(1,2);
606    pathB.cubicTo(0,4, 2,0, 3,0);
607    pathB.close();
608    testPathOp(reporter, path, pathB, kDifference_PathOp);
609}
610
611static void cubicOp31u(skiatest::Reporter* reporter) {
612    SkPath path, pathB;
613    path.setFillType(SkPath::kWinding_FillType);
614    path.moveTo(0,2);
615    path.cubicTo(0,3, 2,1, 4,0);
616    path.close();
617    pathB.setFillType(SkPath::kWinding_FillType);
618    pathB.moveTo(1,2);
619    pathB.cubicTo(0,4, 2,0, 3,0);
620    pathB.close();
621    testPathOp(reporter, path, pathB, kUnion_PathOp);
622}
623
624static void cubicOp31x(skiatest::Reporter* reporter) {
625    SkPath path, pathB;
626    path.setFillType(SkPath::kWinding_FillType);
627    path.moveTo(0,2);
628    path.cubicTo(0,3, 2,1, 4,0);
629    path.close();
630    pathB.setFillType(SkPath::kWinding_FillType);
631    pathB.moveTo(1,2);
632    pathB.cubicTo(0,4, 2,0, 3,0);
633    pathB.close();
634    testPathOp(reporter, path, pathB, kXOR_PathOp);
635}
636
637static void cubicOp32d(skiatest::Reporter* reporter) {
638    SkPath path, pathB;
639    path.setFillType(SkPath::kWinding_FillType);
640    path.moveTo(0,1);
641    path.cubicTo(1,2, 6,0, 3,1);
642    path.close();
643    pathB.setFillType(SkPath::kWinding_FillType);
644    pathB.moveTo(0,6);
645    pathB.cubicTo(1,3, 1,0, 2,1);
646    pathB.close();
647    testPathOp(reporter, path, pathB, kDifference_PathOp);
648}
649
650static void cubicOp33i(skiatest::Reporter* reporter) {
651    SkPath path, pathB;
652    path.setFillType(SkPath::kWinding_FillType);
653    path.moveTo(0,1);
654    path.cubicTo(1,2, 6,0, 3,1);
655    path.close();
656    pathB.setFillType(SkPath::kWinding_FillType);
657    pathB.moveTo(0,6);
658    pathB.cubicTo(1,3, 1,0, 2,1);
659    pathB.close();
660    testPathOp(reporter, path, pathB, kIntersect_PathOp);
661}
662
663static void cubicOp34d(skiatest::Reporter* reporter) {
664    SkPath path, pathB;
665    path.setFillType(SkPath::kWinding_FillType);
666    path.moveTo(0,1);
667    path.cubicTo(3,5, 2,1, 3,1);
668    path.close();
669    pathB.setFillType(SkPath::kWinding_FillType);
670    pathB.moveTo(1,2);
671    pathB.cubicTo(1,3, 1,0, 5,3);
672    pathB.close();
673    testPathOp(reporter, path, pathB, kDifference_PathOp);
674}
675
676static void cubicOp35d(skiatest::Reporter* reporter) {
677    SkPath path, pathB;
678    path.setFillType(SkPath::kWinding_FillType);
679    path.moveTo(0,1);
680    path.cubicTo(1,5, 2,1, 4,0);
681    path.close();
682    pathB.setFillType(SkPath::kWinding_FillType);
683    pathB.moveTo(1,2);
684    pathB.cubicTo(0,4, 1,0, 5,1);
685    pathB.close();
686    testPathOp(reporter, path, pathB, kDifference_PathOp);
687}
688
689static void cubicOp36u(skiatest::Reporter* reporter) {
690    SkPath path, pathB;
691    path.setFillType(SkPath::kWinding_FillType);
692    path.moveTo(0,1);
693    path.cubicTo(1,6, 2,0, 5,1);
694    path.close();
695    pathB.setFillType(SkPath::kWinding_FillType);
696    pathB.moveTo(0,2);
697    pathB.cubicTo(1,5, 1,0, 6,1);
698    pathB.close();
699    testPathOp(reporter, path, pathB, kUnion_PathOp);
700}
701
702static void cubicOp37d(skiatest::Reporter* reporter) {
703    SkPath path, pathB;
704    path.setFillType(SkPath::kWinding_FillType);
705    path.moveTo(0,1);
706    path.cubicTo(2,6, 6,1, 4,3);
707    path.close();
708    pathB.setFillType(SkPath::kWinding_FillType);
709    pathB.moveTo(1,6);
710    pathB.cubicTo(3,4, 1,0, 6,2);
711    pathB.close();
712    testPathOp(reporter, path, pathB, kDifference_PathOp);
713}
714
715#if 1
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) {
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);
732}
733#endif
734
735static void cubicOp39d(skiatest::Reporter* reporter) {
736    SkPath path, pathB;
737    path.setFillType(SkPath::kWinding_FillType);
738    path.moveTo(0,1);
739    path.cubicTo(2,3, 5,1, 4,3);
740    path.close();
741    pathB.setFillType(SkPath::kWinding_FillType);
742    pathB.moveTo(1,5);
743    pathB.cubicTo(3,4, 1,0, 3,2);
744    pathB.close();
745    testPathOp(reporter, path, pathB, kDifference_PathOp);
746}
747
748static void cubicOp40d(skiatest::Reporter* reporter) {
749    SkPath path, pathB;
750    path.setFillType(SkPath::kWinding_FillType);
751    path.moveTo(0,1);
752    path.cubicTo(1,5, 3,2, 4,2);
753    path.close();
754    pathB.setFillType(SkPath::kWinding_FillType);
755    pathB.moveTo(2,3);
756    pathB.cubicTo(2,4, 1,0, 5,1);
757    pathB.close();
758    testPathOp(reporter, path, pathB, kDifference_PathOp);
759}
760
761static void cubicOp41i(skiatest::Reporter* reporter) {
762    SkPath path, pathB;
763    path.setFillType(SkPath::kWinding_FillType);
764    path.moveTo(0,1);
765    path.cubicTo(2,6, 4,3, 6,4);
766    path.close();
767    pathB.setFillType(SkPath::kWinding_FillType);
768    pathB.moveTo(3,4);
769    pathB.cubicTo(4,6, 1,0, 6,2);
770    pathB.close();
771    testPathOp(reporter, path, pathB, kIntersect_PathOp);
772}
773
774static void cubicOp42d(skiatest::Reporter* reporter) {
775    SkPath path, pathB;
776    path.setFillType(SkPath::kWinding_FillType);
777    path.moveTo(0,1);
778    path.cubicTo(1,2, 6,5, 5,4);
779    path.close();
780    pathB.setFillType(SkPath::kWinding_FillType);
781    pathB.moveTo(5,6);
782    pathB.cubicTo(4,5, 1,0, 2,1);
783    pathB.close();
784    testPathOp(reporter, path, pathB, kDifference_PathOp);
785}
786
787static void cubicOp43d(skiatest::Reporter* reporter) {
788    SkPath path, pathB;
789    path.setFillType(SkPath::kWinding_FillType);
790    path.moveTo(0,2);
791    path.cubicTo(1,2, 4,0, 3,1);
792    path.close();
793    pathB.setFillType(SkPath::kWinding_FillType);
794    pathB.moveTo(0,4);
795    pathB.cubicTo(1,3, 2,0, 2,1);
796    pathB.close();
797    testPathOp(reporter, path, pathB, kDifference_PathOp);
798}
799
800static void cubicOp44d(skiatest::Reporter* reporter) {
801    SkPath path, pathB;
802    path.setFillType(SkPath::kWinding_FillType);
803    path.moveTo(0,2);
804    path.cubicTo(3,6, 4,0, 3,2);
805    path.close();
806    pathB.setFillType(SkPath::kWinding_FillType);
807    pathB.moveTo(0,4);
808    pathB.cubicTo(2,3, 2,0, 6,3);
809    pathB.close();
810    testPathOp(reporter, path, pathB, kDifference_PathOp);
811}
812
813static void cubicOp45d(skiatest::Reporter* reporter) {
814    SkPath path, pathB;
815    path.setFillType(SkPath::kWinding_FillType);
816    path.moveTo(0,2);
817    path.cubicTo(2,4, 4,0, 3,2);
818    path.close();
819    pathB.setFillType(SkPath::kWinding_FillType);
820    pathB.moveTo(0,4);
821    pathB.cubicTo(2,3, 2,0, 4,2);
822    pathB.close();
823    testPathOp(reporter, path, pathB, kDifference_PathOp);
824}
825
826static void cubicOp46d(skiatest::Reporter* reporter) {
827    SkPath path, pathB;
828    path.setFillType(SkPath::kWinding_FillType);
829    path.moveTo(0,2);
830    path.cubicTo(3,5, 5,0, 4,2);
831    path.close();
832    pathB.setFillType(SkPath::kWinding_FillType);
833    pathB.moveTo(0,5);
834    pathB.cubicTo(2,4, 2,0, 5,3);
835    pathB.close();
836    testPathOp(reporter, path, pathB, kDifference_PathOp);
837}
838
839static void cubicOp47d(skiatest::Reporter* reporter) {
840    SkPath path, pathB;
841    path.setFillType(SkPath::kWinding_FillType);
842    path.moveTo(0,1);
843    path.cubicTo(1,6, 6,2, 5,4);
844    path.close();
845    pathB.setFillType(SkPath::kWinding_FillType);
846    pathB.moveTo(2,6);
847    pathB.cubicTo(4,5, 1,0, 6,1);
848    pathB.close();
849    testPathOp(reporter, path, pathB, kDifference_PathOp);
850}
851
852static void cubicOp48d(skiatest::Reporter* reporter) {
853    SkPath path, pathB;
854    path.setFillType(SkPath::kWinding_FillType);
855    path.moveTo(0,2);
856    path.cubicTo(2,3, 5,1, 3,2);
857    path.close();
858    pathB.setFillType(SkPath::kWinding_FillType);
859    pathB.moveTo(1,5);
860    pathB.cubicTo(2,3, 2,0, 3,2);
861    pathB.close();
862    testPathOp(reporter, path, pathB, kDifference_PathOp);
863}
864
865static void cubicOp49d(skiatest::Reporter* reporter) {
866    SkPath path, pathB;
867    path.setFillType(SkPath::kWinding_FillType);
868    path.moveTo(0,2);
869    path.cubicTo(1,5, 3,2, 4,1);
870    path.close();
871    pathB.setFillType(SkPath::kWinding_FillType);
872    pathB.moveTo(2,3);
873    pathB.cubicTo(1,4, 2,0, 5,1);
874    pathB.close();
875    testPathOp(reporter, path, pathB, kDifference_PathOp);
876}
877
878static void cubicOp50d(skiatest::Reporter* reporter) {
879    SkPath path, pathB;
880    path.setFillType(SkPath::kWinding_FillType);
881    path.moveTo(0,3);
882    path.cubicTo(1,6, 5,0, 5,1);
883    path.close();
884    pathB.setFillType(SkPath::kWinding_FillType);
885    pathB.moveTo(0,5);
886    pathB.cubicTo(1,5, 3,0, 6,1);
887    pathB.close();
888    testPathOp(reporter, path, pathB, kDifference_PathOp);
889}
890
891static void cubicOp51d(skiatest::Reporter* reporter) {
892    SkPath path, pathB;
893    path.setFillType(SkPath::kWinding_FillType);
894    path.moveTo(0,3);
895    path.cubicTo(1,2, 4,1, 6,0);
896    path.close();
897    pathB.setFillType(SkPath::kWinding_FillType);
898    pathB.moveTo(1,4);
899    pathB.cubicTo(0,6, 3,0, 2,1);
900    pathB.close();
901    testPathOp(reporter, path, pathB, kDifference_PathOp);
902}
903
904static void cubicOp52d(skiatest::Reporter* reporter) {
905    SkPath path, pathB;
906    path.setFillType(SkPath::kWinding_FillType);
907    path.moveTo(0,2);
908    path.cubicTo(1,2, 5,4, 4,3);
909    path.close();
910    pathB.setFillType(SkPath::kWinding_FillType);
911    pathB.moveTo(4,5);
912    pathB.cubicTo(3,4, 2,0, 2,1);
913    pathB.close();
914    testPathOp(reporter, path, pathB, kDifference_PathOp);
915}
916
917static void cubicOp53d(skiatest::Reporter* reporter) {
918    SkPath path, pathB;
919    path.setFillType(SkPath::kWinding_FillType);
920    path.moveTo(0,3);
921    path.cubicTo(1,2, 5,3, 2,1);
922    path.close();
923    pathB.setFillType(SkPath::kWinding_FillType);
924    pathB.moveTo(3,5);
925    pathB.cubicTo(1,2, 3,0, 2,1);
926    pathB.close();
927    testPathOp(reporter, path, pathB, kDifference_PathOp);
928}
929
930static void cubicOp54d(skiatest::Reporter* reporter) {
931    SkPath path, pathB;
932    path.setFillType(SkPath::kWinding_FillType);
933    path.moveTo(0,4);
934    path.cubicTo(1,3, 5,4, 4,2);
935    path.close();
936    pathB.setFillType(SkPath::kWinding_FillType);
937    pathB.moveTo(4,5);
938    pathB.cubicTo(2,4, 4,0, 3,1);
939    pathB.close();
940    testPathOp(reporter, path, pathB, kDifference_PathOp);
941}
942
943static void cubicOp55d(skiatest::Reporter* reporter) {
944    SkPath path, pathB;
945    path.setFillType(SkPath::kWinding_FillType);
946    path.moveTo(0,5);
947    path.cubicTo(1,3, 3,2, 5,0);
948    path.close();
949    pathB.setFillType(SkPath::kWinding_FillType);
950    pathB.moveTo(2,3);
951    pathB.cubicTo(0,5, 5,0, 3,1);
952    pathB.close();
953    testPathOp(reporter, path, pathB, kDifference_PathOp);
954}
955
956static void cubicOp56d(skiatest::Reporter* reporter) {
957    SkPath path, pathB;
958    path.setFillType(SkPath::kWinding_FillType);
959    path.moveTo(0,1);
960    path.cubicTo(2,6, 5,0, 2,1);
961    path.close();
962    pathB.setFillType(SkPath::kWinding_FillType);
963    pathB.moveTo(0,5);
964    pathB.cubicTo(1,2, 1,0, 6,2);
965    pathB.close();
966    testPathOp(reporter, path, pathB, kDifference_PathOp);
967}
968
969static void cubicOp57d(skiatest::Reporter* reporter) {
970    SkPath path, pathB;
971    path.setFillType(SkPath::kWinding_FillType);
972    path.moveTo(0,5);
973    path.cubicTo(0,5, 5,4, 6,4);
974    path.close();
975    pathB.setFillType(SkPath::kWinding_FillType);
976    pathB.moveTo(4,5);
977    pathB.cubicTo(4,6, 5,0, 5,0);
978    pathB.close();
979    testPathOp(reporter, path, pathB, kDifference_PathOp);
980}
981
982static void cubicOp58d(skiatest::Reporter* reporter) {
983    SkPath path, pathB;
984    path.setFillType(SkPath::kWinding_FillType);
985    path.moveTo(0,5);
986    path.cubicTo(3,4, 6,5, 5,3);
987    path.close();
988    pathB.setFillType(SkPath::kWinding_FillType);
989    pathB.moveTo(5,6);
990    pathB.cubicTo(3,5, 5,0, 4,3);
991    pathB.close();
992    testPathOp(reporter, path, pathB, kDifference_PathOp);
993}
994
995static void cubicOp59d(skiatest::Reporter* reporter) {
996    SkPath path, pathB;
997    path.setFillType(SkPath::kWinding_FillType);
998    path.moveTo(0,1);
999    path.cubicTo(5,6, 4,0, 4,1);
1000    path.close();
1001    pathB.setFillType(SkPath::kWinding_FillType);
1002    pathB.moveTo(0,4);
1003    pathB.cubicTo(1,4, 1,0, 6,5);
1004    pathB.close();
1005    testPathOp(reporter, path, pathB, kDifference_PathOp);
1006}
1007
1008static void cubicOp60d(skiatest::Reporter* reporter) {
1009    SkPath path, pathB;
1010    path.setFillType(SkPath::kWinding_FillType);
1011    path.moveTo(0,2);
1012    path.cubicTo(4,6, 6,0, 5,2);
1013    path.close();
1014    pathB.setFillType(SkPath::kWinding_FillType);
1015    pathB.moveTo(0,6);
1016    pathB.cubicTo(2,5, 2,0, 6,4);
1017    pathB.close();
1018    testPathOp(reporter, path, pathB, kDifference_PathOp);
1019}
1020
1021static void cubicOp61d(skiatest::Reporter* reporter) {
1022    SkPath path, pathB;
1023    path.setFillType(SkPath::kWinding_FillType);
1024    path.moveTo(1,2);
1025    path.cubicTo(0,5, 3,2, 6,1);
1026    path.close();
1027    pathB.setFillType(SkPath::kWinding_FillType);
1028    pathB.moveTo(2,3);
1029    pathB.cubicTo(1,6, 2,1, 5,0);
1030    pathB.close();
1031    testPathOp(reporter, path, pathB, kDifference_PathOp);
1032}
1033
1034static void cubicOp62d(skiatest::Reporter* reporter) {
1035    SkPath path, pathB;
1036    path.setFillType(SkPath::kWinding_FillType);
1037    path.moveTo(1,3);
1038    path.cubicTo(5,6, 5,3, 5,4);
1039    path.close();
1040    pathB.setFillType(SkPath::kWinding_FillType);
1041    pathB.moveTo(3,5);
1042    pathB.cubicTo(4,5, 3,1, 6,5);
1043    pathB.close();
1044    testPathOp(reporter, path, pathB, kDifference_PathOp);
1045}
1046
1047static void cubicOp63d(skiatest::Reporter* reporter) {
1048    SkPath path, pathB;
1049    path.setFillType(SkPath::kWinding_FillType);
1050    path.moveTo(2,3);
1051    path.cubicTo(0,4, 3,2, 5,3);
1052    path.close();
1053    pathB.setFillType(SkPath::kWinding_FillType);
1054    pathB.moveTo(2,3);
1055    pathB.cubicTo(3,5, 3,2, 4,0);
1056    pathB.close();
1057    testPathOp(reporter, path, pathB, kDifference_PathOp);
1058}
1059
1060static void cubicOp64d(skiatest::Reporter* reporter) {
1061    SkPath path, pathB;
1062    path.moveTo(0,1);
1063    path.cubicTo(0,1, 1,0, 3,0);
1064    path.lineTo(0,1);
1065    path.close();
1066    pathB.moveTo(0,1);
1067    pathB.cubicTo(0,3, 1,0, 1,0);
1068    pathB.lineTo(0,1);
1069    pathB.close();
1070    testPathOp(reporter, path, pathB, kDifference_PathOp);
1071}
1072
1073static void cubicOp65d(skiatest::Reporter* reporter) {
1074    SkPath path, pathB;
1075    path.moveTo(0,1);
1076    path.cubicTo(1,5, 1,0, 1,0);
1077    path.lineTo(0,1);
1078    path.close();
1079    pathB.moveTo(0,1);
1080    pathB.cubicTo(0,1, 1,0, 5,1);
1081    pathB.lineTo(0,1);
1082    pathB.close();
1083    testPathOp(reporter, path, pathB, kDifference_PathOp);
1084}
1085
1086static void rectOp1d(skiatest::Reporter* reporter) {
1087    SkPath path, pathB;
1088    path.moveTo(0,1);
1089    path.cubicTo(0,1, 1,0, 3,0);
1090    path.lineTo(0,1);
1091    path.close();
1092    pathB.moveTo(0,1);
1093    pathB.cubicTo(0,3, 1,0, 1,0);
1094    pathB.lineTo(0,1);
1095    pathB.close();
1096    testPathOp(reporter, path, pathB, kDifference_PathOp);
1097}
1098
1099static void cubicOp66u(skiatest::Reporter* reporter) {
1100    SkPath path, pathB;
1101    path.setFillType(SkPath::kWinding_FillType);
1102    path.moveTo(0,1);
1103    path.cubicTo(2,6, 4,2, 5,3);
1104    path.close();
1105    pathB.setFillType(SkPath::kWinding_FillType);
1106    pathB.moveTo(2,4);
1107    pathB.cubicTo(3,5, 1,0, 6,2);
1108    pathB.close();
1109    testPathOp(reporter, path, pathB, kUnion_PathOp);
1110}
1111
1112static void cubicOp67u(skiatest::Reporter* reporter) {
1113    SkPath path, pathB;
1114    path.moveTo(3,5);
1115    path.cubicTo(1,6, 5,0, 3,1);
1116    path.lineTo(3,5);
1117    path.close();
1118    pathB.moveTo(0,5);
1119    pathB.cubicTo(1,3, 5,3, 6,1);
1120    pathB.lineTo(0,5);
1121    pathB.close();
1122    testPathOp(reporter, path, pathB, kUnion_PathOp);
1123}
1124
1125static void cubicOp68u(skiatest::Reporter* reporter) {
1126    SkPath path, pathB;
1127    path.moveTo(0,5);
1128    path.cubicTo(4,5, 4,1, 5,0);
1129    path.close();
1130    pathB.moveTo(1,4);
1131    pathB.cubicTo(0,5, 5,0, 5,4);
1132    pathB.close();
1133    testPathOp(reporter, path, pathB, kUnion_PathOp);
1134}
1135
1136static void cubicOp69d(skiatest::Reporter* reporter) {
1137    SkPath path, pathB;
1138    path.moveTo(1,3);
1139    path.cubicTo(0,1, 3,1, 2,0);
1140    path.close();
1141    pathB.moveTo(1,3);
1142    pathB.cubicTo(0,2, 3,1, 1,0);
1143    pathB.close();
1144    testPathOp(reporter, path, pathB, kDifference_PathOp);
1145}
1146
1147SkPathOp ops[] = {
1148    kUnion_PathOp,
1149    kXOR_PathOp,
1150    kReverseDifference_PathOp,
1151    kXOR_PathOp,
1152    kReverseDifference_PathOp,
1153};
1154
1155static void rRect1(skiatest::Reporter* reporter) {
1156    SkScalar xA = SkFloatToScalar(0.65f);
1157    SkScalar xB = SkFloatToScalar(10.65f);
1158    SkScalar xC = SkFloatToScalar(20.65f);
1159    SkScalar xD = SkFloatToScalar(30.65f);
1160    SkScalar xE = SkFloatToScalar(40.65f);
1161    SkScalar xF = SkFloatToScalar(50.65f);
1162
1163    SkScalar yA = SkFloatToScalar(0.65f);
1164    SkScalar yB = SkFloatToScalar(10.65f);
1165    SkScalar yC = SkFloatToScalar(20.65f);
1166    SkScalar yD = SkFloatToScalar(30.65f);
1167    SkScalar yE = SkFloatToScalar(40.65f);
1168    SkScalar yF = SkFloatToScalar(50.65f);
1169    SkPath paths[5];
1170    SkRect rects[5];
1171    rects[0].set(xB, yB, xE, yE);
1172    paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5));  // red
1173    rects[1].set(xA, yA, xD, yD);
1174    paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5));  // green
1175    rects[2].set(xC, yA, xF, yD);
1176    paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5));  // blue
1177    rects[3].set(xA, yC, xD, yF);
1178    paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5));  // yellow
1179    rects[4].set(xC, yC, xF, yF);
1180    paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5));  // cyan
1181    SkPath path;
1182    path.setFillType(SkPath::kInverseEvenOdd_FillType);
1183    for (int index = 0; index < 5; ++index) {
1184        testPathOp(reporter, path, paths[index], ops[index]);
1185        Op(path, paths[index], ops[index], &path);
1186    }
1187}
1188
1189static void skp1(skiatest::Reporter* reporter) {
1190    SkPath path;
1191    path.setFillType(SkPath::kEvenOdd_FillType);
1192    path.moveTo(189,7);
1193    path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4);
1194    path.lineTo(243,4);
1195    path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7);
1196    path.lineTo(246,21);
1197    path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24);
1198    path.lineTo(192,24);
1199    path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21);
1200    path.lineTo(189,7);
1201    path.close();
1202    path.moveTo(191,8);
1203    path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6);
1204    path.lineTo(242,6);
1205    path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8);
1206    path.lineTo(244,20);
1207    path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22);
1208    path.lineTo(193,22);
1209    path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20);
1210    path.lineTo(191,8);
1211    path.close();
1212    SkPath pathB;
1213    pathB.setFillType(SkPath::kWinding_FillType);
1214    pathB.moveTo(189,4);
1215    pathB.lineTo(199,14);
1216    pathB.lineTo(236,14);
1217    pathB.lineTo(246,4);
1218    pathB.lineTo(189,4);
1219    pathB.close();
1220    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1221}
1222
1223static void skp2(skiatest::Reporter* reporter) {
1224    SkPath path;
1225    path.setFillType(SkPath::kEvenOdd_FillType);
1226    path.moveTo(253.000000f, 11757.0000f);
1227    path.lineTo(253.000000f, 222.000000f);
1228    path.lineTo(823.000000f, 222.000000f);
1229    path.lineTo(823.000000f, 11757.0000f);
1230    path.lineTo(253.000000f, 11757.0000f);
1231    path.close();
1232    SkPath pathB;
1233    pathB.setFillType(SkPath::kWinding_FillType);
1234    pathB.moveTo(258.000000f, 1028.00000f);
1235    pathB.lineTo(258.000000f, 1027.00000f);
1236    pathB.lineTo(823.000000f, 1027.00000f);
1237    pathB.lineTo(823.000000f, 1028.00000f);
1238    pathB.lineTo(258.000000f, 1028.00000f);
1239    pathB.close();
1240    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1241}
1242
1243static void skp3(skiatest::Reporter* reporter) {
1244    SkPath path;
1245    path.setFillType(SkPath::kEvenOdd_FillType);
1246    path.moveTo(717.000000f, 507.000000f);
1247    path.lineTo(717.000000f, 425.000000f);
1248    path.lineTo(973.000000f, 425.000000f);
1249    path.lineTo(973.000000f, 507.000000f);
1250    path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f);
1251    path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f);
1252    path.lineTo(720.000000f, 510.000000f);
1253    path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f);
1254    path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f);
1255    path.close();
1256    path.moveTo(719.000000f, 426.000000f);
1257    path.lineTo(971.000000f, 426.000000f);
1258    path.lineTo(971.000000f, 506.000000f);
1259    path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f);
1260    path.lineTo(721.000000f, 508.000000f);
1261    path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f);
1262    path.lineTo(719.000000f, 426.000000f);
1263    path.close();
1264    SkPath pathB;
1265    pathB.setFillType(SkPath::kWinding_FillType);
1266    pathB.moveTo(717.000000f, 510.000000f);
1267    pathB.lineTo(760.000000f, 467.000000f);
1268    pathB.lineTo(930.000000f, 467.000000f);
1269    pathB.lineTo(973.000000f, 510.000000f);
1270    pathB.lineTo(717.000000f, 510.000000f);
1271    pathB.close();
1272    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1273}
1274
1275static void skp4(skiatest::Reporter* reporter) {
1276    SkPath path;
1277    path.setFillType(SkPath::kEvenOdd_FillType);
1278    path.moveTo(230.756805f, 591.756775f);
1279    path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f);
1280    path.lineTo(300.000000f, 590.000000f);
1281    path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f);
1282    path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f);
1283    path.lineTo(306.000000f, 617.000000f);
1284    path.lineTo(229.000000f, 617.000000f);
1285    path.lineTo(229.000000f, 596.000000f);
1286    path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f);
1287    path.close();
1288    path.moveTo(231.000000f, 597.000000f);
1289    path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f);
1290    path.lineTo(299.000000f, 592.000000f);
1291    path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f);
1292    path.lineTo(304.000000f, 616.000000f);
1293    path.lineTo(231.000000f, 616.000000f);
1294    path.lineTo(231.000000f, 597.000000f);
1295    path.close();
1296    SkPath pathB;
1297    pathB.setFillType(SkPath::kWinding_FillType);
1298    pathB.moveTo(306.000000f, 590.000000f);
1299    pathB.lineTo(292.000000f, 604.000000f);
1300    pathB.lineTo(305.000000f, 617.000000f);
1301    pathB.lineTo(306.000000f, 617.000000f);
1302    pathB.lineTo(306.000000f, 590.000000f);
1303    pathB.close();
1304    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1305}
1306
1307static void skp5(skiatest::Reporter* reporter) {
1308    SkPath path;
1309    path.setFillType(SkPath::kEvenOdd_FillType);
1310    path.moveTo(18.0000000f, 226.000000f);
1311    path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f);
1312    path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f);
1313    path.lineTo(10.0000000f, 253.000000f);
1314    path.lineTo(1247.00000f, 253.000000f);
1315    path.lineTo(1247.00000f, 234.000000f);
1316    path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f);
1317    path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f);
1318    path.lineTo(18.0000000f, 226.000000f);
1319    path.close();
1320    SkPath pathB;
1321    pathB.setFillType(SkPath::kInverseWinding_FillType);
1322    pathB.moveTo(18.0000000f, 226.000000f);
1323    pathB.lineTo(1239.00000f, 226.000000f);
1324    pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f);
1325    pathB.lineTo(1247.00000f, 252.000000f);
1326    pathB.lineTo(10.0000000f, 252.000000f);
1327    pathB.lineTo(10.0000000f, 234.000000f);
1328    pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f);
1329    pathB.close();
1330    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1331}
1332
1333static void cubicOp70d(skiatest::Reporter* reporter) {
1334    SkPath path, pathB;
1335    path.setFillType(SkPath::kWinding_FillType);
1336    path.moveTo(0,1);
1337    path.cubicTo(0,5, 4,0, 5,0);
1338    path.close();
1339    pathB.setFillType(SkPath::kWinding_FillType);
1340    pathB.moveTo(0,4);
1341    pathB.cubicTo(0,5, 1,0, 5,0);
1342    pathB.close();
1343    testPathOp(reporter, path, pathB, kDifference_PathOp);
1344}
1345
1346static void cubicOp71d(skiatest::Reporter* reporter) {
1347    SkPath path, pathB;
1348    path.setFillType(SkPath::kWinding_FillType);
1349    path.moveTo(0,1);
1350    path.cubicTo(0,5, 4,1, 6,4);
1351    path.close();
1352    pathB.setFillType(SkPath::kWinding_FillType);
1353    pathB.moveTo(1,4);
1354    pathB.cubicTo(4,6, 1,0, 5,0);
1355    pathB.close();
1356    testPathOp(reporter, path, pathB, kDifference_PathOp);
1357}
1358
1359static void cubicOp72i(skiatest::Reporter* reporter) {
1360    SkPath path, pathB;
1361    path.setFillType(SkPath::kWinding_FillType);
1362    path.moveTo(0,1);
1363    path.cubicTo(0,5, 5,2, 5,4);
1364    path.close();
1365    pathB.setFillType(SkPath::kWinding_FillType);
1366    pathB.moveTo(2,5);
1367    pathB.cubicTo(4,5, 1,0, 5,0);
1368    pathB.close();
1369    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1370}
1371
1372static void cubicOp73d(skiatest::Reporter* reporter) {
1373    SkPath path, pathB;
1374    path.setFillType(SkPath::kWinding_FillType);
1375    path.moveTo(0,1);
1376    path.cubicTo(3,4, 4,0, 6,4);
1377    path.lineTo(0,1);
1378    path.close();
1379    pathB.setFillType(SkPath::kWinding_FillType);
1380    pathB.moveTo(0,4);
1381    pathB.cubicTo(4,6, 1,0, 4,3);
1382    pathB.lineTo(0,4);
1383    pathB.close();
1384    testPathOp(reporter, path, pathB, kDifference_PathOp);
1385}
1386
1387static void cubicOp74d(skiatest::Reporter* reporter) {
1388    SkPath path, pathB;
1389    path.setFillType(SkPath::kWinding_FillType);
1390    path.moveTo(0,1);
1391    path.cubicTo(1,5, 5,1, 5,1);
1392    path.lineTo(0,1);
1393    path.close();
1394    pathB.setFillType(SkPath::kWinding_FillType);
1395    pathB.moveTo(1,5);
1396    pathB.cubicTo(1,5, 1,0, 5,1);
1397    pathB.lineTo(1,5);
1398    pathB.close();
1399    testPathOp(reporter, path, pathB, kDifference_PathOp);
1400}
1401
1402static void cubicOp75d(skiatest::Reporter* reporter) {
1403    SkPath path, pathB;
1404    path.setFillType(SkPath::kWinding_FillType);
1405    path.moveTo(0,1);
1406    path.cubicTo(0,4, 5,1, 6,4);
1407    path.lineTo(0,1);
1408    path.close();
1409    pathB.setFillType(SkPath::kWinding_FillType);
1410    pathB.moveTo(1,5);
1411    pathB.cubicTo(4,6, 1,0, 4,0);
1412    pathB.lineTo(1,5);
1413    pathB.close();
1414    testPathOp(reporter, path, pathB, kDifference_PathOp);
1415}
1416
1417static void cubicOp76u(skiatest::Reporter* reporter) {
1418    SkPath path, pathB;
1419    path.setFillType(SkPath::kWinding_FillType);
1420    path.moveTo(0,1);
1421    path.cubicTo(0,2, 2,0, 5,3);
1422    path.close();
1423    pathB.setFillType(SkPath::kWinding_FillType);
1424    pathB.moveTo(0,2);
1425    pathB.cubicTo(3,5, 1,0, 2,0);
1426    pathB.close();
1427    testPathOp(reporter, path, pathB, kUnion_PathOp);
1428}
1429
1430static void cubicOp77i(skiatest::Reporter* reporter) {
1431    SkPath path, pathB;
1432    path.setFillType(SkPath::kEvenOdd_FillType);
1433    path.moveTo(0,1);
1434    path.cubicTo(1,3, 2,0, 3,2);
1435    path.lineTo(0,1);
1436    path.close();
1437    pathB.setFillType(SkPath::kEvenOdd_FillType);
1438    pathB.moveTo(0,2);
1439    pathB.cubicTo(2,3, 1,0, 3,1);
1440    pathB.lineTo(0,2);
1441    pathB.close();
1442    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1443}
1444
1445static void cubicOp78u(skiatest::Reporter* reporter) {
1446    SkPath path, pathB;
1447    path.setFillType(SkPath::kEvenOdd_FillType);
1448    path.moveTo(1,6);
1449    path.cubicTo(1,6, 5,0, 6,1);
1450    path.lineTo(1,6);
1451    path.close();
1452    pathB.setFillType(SkPath::kEvenOdd_FillType);
1453    pathB.moveTo(0,5);
1454    pathB.cubicTo(1,6, 6,1, 6,1);
1455    pathB.lineTo(0,5);
1456    pathB.close();
1457    testPathOp(reporter, path, pathB, kUnion_PathOp);
1458}
1459
1460static void cubicOp79u(skiatest::Reporter* reporter) {
1461    SkPath path, pathB;
1462    path.setFillType(SkPath::kWinding_FillType);
1463    path.moveTo(0,1);
1464    path.cubicTo(1,3, 1,0, 6,4);
1465    path.close();
1466    pathB.setFillType(SkPath::kWinding_FillType);
1467    pathB.moveTo(0,1);
1468    pathB.cubicTo(4,6, 1,0, 3,1);
1469    pathB.close();
1470    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1471}
1472
1473static void cubicOp80i(skiatest::Reporter* reporter) {
1474    SkPath path, pathB;
1475    path.setFillType(SkPath::kWinding_FillType);
1476    path.moveTo(0,1);
1477    path.cubicTo(2,3, 2,1, 4,3);
1478    path.lineTo(0,1);
1479    path.close();
1480    pathB.setFillType(SkPath::kWinding_FillType);
1481    pathB.moveTo(1,2);
1482    pathB.cubicTo(3,4, 1,0, 3,2);
1483    pathB.lineTo(1,2);
1484    pathB.close();
1485    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1486}
1487
1488static void cubicOp81d(skiatest::Reporter* reporter) {
1489    SkPath path, pathB;
1490    path.setFillType(SkPath::kWinding_FillType);
1491    path.moveTo(0,1);
1492    path.cubicTo(4,6, 4,3, 5,4);
1493    path.close();
1494    pathB.setFillType(SkPath::kWinding_FillType);
1495    pathB.moveTo(3,4);
1496    pathB.cubicTo(4,5, 1,0, 6,4);
1497    pathB.close();
1498    testPathOp(reporter, path, pathB, kDifference_PathOp);
1499}
1500
1501static void cubicOp82i(skiatest::Reporter* reporter) {
1502    SkPath path, pathB;
1503    path.setFillType(SkPath::kEvenOdd_FillType);
1504    path.moveTo(0,1);
1505    path.cubicTo(2,3, 5,2, 3,0);
1506    path.lineTo(0,1);
1507    path.close();
1508    pathB.setFillType(SkPath::kWinding_FillType);
1509    pathB.moveTo(2,5);
1510    pathB.cubicTo(0,3, 1,0, 3,2);
1511    pathB.lineTo(2,5);
1512    pathB.close();
1513    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1514}
1515
1516static void cubicOp83i(skiatest::Reporter* reporter) {
1517    SkPath path, pathB;
1518    path.setFillType(SkPath::kWinding_FillType);
1519    path.moveTo(0,1);
1520    path.cubicTo(0,3, 2,1, 4,1);
1521    path.lineTo(0,1);
1522    path.close();
1523    pathB.setFillType(SkPath::kWinding_FillType);
1524    pathB.moveTo(1,2);
1525    pathB.cubicTo(1,4, 1,0, 3,0);
1526    pathB.lineTo(1,2);
1527    pathB.close();
1528    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1529}
1530
1531static void cubicOp84d(skiatest::Reporter* reporter) {
1532    SkPath path, pathB;
1533    path.setFillType(SkPath::kWinding_FillType);
1534    path.moveTo(0,4);
1535    path.cubicTo(2,3, 6,3, 3,2);
1536    path.close();
1537    pathB.setFillType(SkPath::kWinding_FillType);
1538    pathB.moveTo(3,6);
1539    pathB.cubicTo(2,3, 4,0, 3,2);
1540    pathB.close();
1541    testPathOp(reporter, path, pathB, kDifference_PathOp);
1542}
1543
1544static void skpClip1(skiatest::Reporter* reporter) {
1545    SkPath path;
1546    path.setFillType(SkPath::kEvenOdd_FillType);
1547    path.moveTo(1126.17114f, 877.171204f);
1548    path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f);
1549    path.lineTo(1243.00000f, 876.000000f);
1550    path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f);
1551    path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f);
1552    path.lineTo(1247.00000f, 907.000000f);
1553    path.lineTo(1246.00000f, 907.000000f);
1554    path.lineTo(1246.00000f, 880.000000f);
1555    path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f);
1556    path.lineTo(1129.00000f, 877.000000f);
1557    path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f);
1558    path.lineTo(1126.00000f, 907.000000f);
1559    path.lineTo(1125.00000f, 907.000000f);
1560    path.lineTo(1125.00000f, 880.000000f);
1561    path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f);
1562    path.close();
1563    SkPath pathB;
1564    pathB.setFillType(SkPath::kWinding_FillType);
1565    pathB.moveTo(1247.00000f, 876.000000f);
1566    pathB.lineTo(1231.00000f, 892.000000f);
1567    pathB.lineTo(1246.00000f, 907.000000f);
1568    pathB.lineTo(1247.00000f, 907.000000f);
1569    pathB.lineTo(1247.00000f, 876.000000f);
1570    pathB.close();
1571    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1572}
1573
1574static void skpClip2(skiatest::Reporter* reporter) {
1575    SkPath path;
1576    path.setFillType(SkPath::kEvenOdd_FillType);
1577    path.moveTo(134.000000f, 11414.0000f);
1578    path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f);
1579    path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f);
1580    path.lineTo(806.000000f, 11419.0000f);
1581    path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f);
1582    path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f);
1583    path.lineTo(134.000000f, 11414.0000f);
1584    path.close();
1585    SkPath pathB;
1586    pathB.setFillType(SkPath::kInverseWinding_FillType);
1587    pathB.moveTo(132.000000f, 11415.0000f);
1588    pathB.lineTo(806.000000f, 11415.0000f);
1589    pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f);
1590    pathB.lineTo(808.000000f, 11417.0000f);
1591    pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f);
1592    pathB.lineTo(132.000000f, 11419.0000f);
1593    pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f);
1594    pathB.lineTo(130.000000f, 11416.0000f);
1595    pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f);
1596    pathB.close();
1597    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1598}
1599
1600static void skp96prezzi1(skiatest::Reporter* reporter) {
1601    SkPath path;
1602    path.setFillType(SkPath::kEvenOdd_FillType);
1603    path.moveTo(157.464005f, 670.463989f);
1604    path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f);
1605    path.lineTo(248.000000f, 669.000000f);
1606    path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f);
1607    path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f);
1608    path.lineTo(253.000000f, 706.000000f);
1609    path.lineTo(251.000000f, 706.000000f);
1610    path.lineTo(251.000000f, 675.000000f);
1611    path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f);
1612    path.lineTo(162.000000f, 671.000000f);
1613    path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f);
1614    path.lineTo(158.000000f, 706.000000f);
1615    path.lineTo(156.000000f, 706.000000f);
1616    path.lineTo(156.000000f, 674.000000f);
1617    path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f);
1618    path.close();
1619    SkPath pathB;
1620    pathB.setFillType(SkPath::kWinding_FillType);
1621    pathB.moveTo(156.000000f, 669.000000f);
1622    pathB.lineTo(178.500000f, 691.500000f);
1623    pathB.lineTo(230.500000f, 691.500000f);
1624    pathB.lineTo(253.000000f, 669.000000f);
1625    pathB.lineTo(156.000000f, 669.000000f);
1626    pathB.close();
1627    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1628}
1629
1630static void skpancestry_com1(skiatest::Reporter* reporter) {
1631    SkPath path;
1632    path.setFillType(SkPath::kEvenOdd_FillType);
1633    path.moveTo(161.000000f, 925.000000f);
1634    path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f);
1635    path.lineTo(158.000000f, 926.000000f);
1636    path.lineTo(1108.00000f, 926.000000f);
1637    path.lineTo(1108.00000f, 925.999634f);
1638    path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f);
1639    path.lineTo(161.000000f, 925.000000f);
1640    path.close();
1641    SkPath pathB;
1642    pathB.setFillType(SkPath::kEvenOdd_FillType);
1643    pathB.moveTo(161.000000f, 926.000000f);
1644    pathB.lineTo(1105.00000f, 926.000000f);
1645    pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f);
1646    pathB.lineTo(1109.00000f, 956.000000f);
1647    pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f);
1648    pathB.lineTo(161.000000f, 960.000000f);
1649    pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f);
1650    pathB.lineTo(157.000000f, 930.000000f);
1651    pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f);
1652    pathB.close();
1653    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1654}
1655
1656static void skpeldorado_com_ua1(skiatest::Reporter* reporter) {
1657    SkPath path;
1658    path.setFillType(SkPath::kEvenOdd_FillType);
1659    path.moveTo(286.695129f, 291.000000f);
1660    path.lineTo(229.304855f, 561.000000f);
1661    path.lineTo(979.304871f, 561.000000f);
1662    path.lineTo(1036.69507f, 291.000000f);
1663    path.lineTo(286.695129f, 291.000000f);
1664    path.close();
1665    SkPath pathB;
1666    pathB.setFillType(SkPath::kWinding_FillType);
1667    pathB.moveTo(1006.69513f, 291.000000f);
1668    pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f);
1669    pathB.lineTo(985.681519f, 531.000000f);
1670    pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f);
1671    pathB.lineTo(259.304871f, 561.000000f);
1672    pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f);
1673    pathB.lineTo(280.318420f, 321.000000f);
1674    pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f);
1675    pathB.lineTo(1006.69513f, 291.000000f);
1676    pathB.close();
1677    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1678}
1679
1680static void skpbyte_com1(skiatest::Reporter* reporter) {
1681    SkPath path;
1682    path.setFillType(SkPath::kEvenOdd_FillType);
1683    path.moveTo(968.000000f, 14.0000000f);
1684    path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f);
1685    path.lineTo(963.000000f, 32.0000000f);
1686    path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f);
1687    path.lineTo(1034.00000f, 37.0000000f);
1688    path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f);
1689    path.lineTo(1039.00000f, 19.0000000f);
1690    path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f);
1691    path.lineTo(968.000000f, 14.0000000f);
1692    path.close();
1693    SkPath pathB;
1694    pathB.setFillType(SkPath::kInverseWinding_FillType);
1695    pathB.moveTo(968.000000f, 14.0000000f);
1696    pathB.lineTo(1034.00000f, 14.0000000f);
1697    pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f);
1698    pathB.lineTo(1039.00000f, 32.0000000f);
1699    pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f);
1700    pathB.lineTo(968.000000f, 36.0000000f);
1701    pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f);
1702    pathB.lineTo(963.000000f, 19.0000000f);
1703    pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f);
1704    pathB.close();
1705    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1706}
1707
1708static void skphealth_com76(skiatest::Reporter* reporter) {
1709    SkPath path;
1710    path.setFillType(SkPath::kEvenOdd_FillType);
1711    path.moveTo(708.099182f, 7.09919119f);
1712    path.lineTo(708.099182f, 7.09920025f);
1713    path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f);
1714    path.lineTo(704.000000f, 33.0000000f);
1715    path.lineTo(705.000000f, 33.0000000f);
1716    path.lineTo(705.000000f, 17.0000000f);
1717    path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f);
1718    path.lineTo(708.099182f, 7.09919119f);
1719    path.close();
1720    SkPath pathB;
1721    pathB.setFillType(SkPath::kWinding_FillType);
1722    pathB.moveTo(704.000000f, 3.00000000f);
1723#if 0
1724    pathB.lineTo(719.500000f, 3.00000000f);
1725    pathB.lineTo(705.000000f, 33.0000000f);
1726    pathB.lineTo(704.000000f, 33.0000000f);
1727    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1728#else
1729    pathB.lineTo(704.000000f, 33.0000000f);
1730    pathB.lineTo(705.000000f, 33.0000000f);
1731    pathB.lineTo(719.500000f, 3.00000000f);
1732    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1733#endif
1734}
1735
1736static void skpahrefs_com88(skiatest::Reporter* reporter) {
1737    SkPath path;
1738    path.setFillType(SkPath::kEvenOdd_FillType);
1739    path.moveTo(1099.82886f, 7.17117119f);
1740    path.lineTo(1099.12134f, 7.87867832f);
1741    path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f);
1742    path.lineTo(1100.00000f, 28.0000000f);
1743    path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f);
1744    path.lineTo(1088.00000f, 31.0000000f);
1745    path.lineTo(1088.00000f, 32.0000000f);
1746    path.lineTo(1097.00000f, 32.0000000f);
1747    path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f);
1748    path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f);
1749    path.lineTo(1101.00000f, 10.0000000f);
1750    path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f);
1751    path.lineTo(1099.82886f, 7.17117119f);
1752    path.close();
1753    SkPath pathB;
1754    pathB.setFillType(SkPath::kWinding_FillType);
1755    pathB.moveTo(1101.00000f, 6.00000000f);
1756    pathB.lineTo(1088.00000f, 6.00000000f);
1757    pathB.lineTo(1088.00000f, 19.0000000f);
1758    pathB.lineTo(1101.00000f, 32.0000000f);
1759    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1760}
1761
1762static void skpahrefs_com29(skiatest::Reporter* reporter) {
1763    SkPath path;
1764    path.setFillType(SkPath::kEvenOdd_FillType);
1765    path.moveTo(1037.17114f, 7.17119980f);
1766    path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f);
1767    path.lineTo(1074.00000f, 6.00000000f);
1768    path.lineTo(1074.00000f, 32.0000000f);
1769    path.lineTo(1040.00000f, 32.0000000f);
1770    path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f);
1771    path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f);
1772    path.lineTo(1036.00000f, 10.0000000f);
1773    path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f);
1774    path.close();
1775    path.moveTo(1037.00000f, 10.0000000f);
1776    path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f);
1777    path.lineTo(1073.00000f, 7.00000000f);
1778    path.lineTo(1073.00000f, 31.0000000f);
1779    path.lineTo(1040.00000f, 31.0000000f);
1780    path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f);
1781    path.lineTo(1037.00000f, 10.0000000f);
1782    path.close();
1783    SkPath pathB;
1784    pathB.setFillType(SkPath::kWinding_FillType);
1785    pathB.moveTo(1036.00000f, 32.0000000f);
1786    pathB.lineTo(1049.00000f, 19.0000000f);
1787    pathB.lineTo(1073.00000f, 31.0000000f);
1788    pathB.lineTo(1074.00000f, 32.0000000f);
1789    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1790}
1791
1792static void cubicOp85d(skiatest::Reporter* reporter) {
1793    SkPath path;
1794    path.setFillType(SkPath::kWinding_FillType);
1795    path.moveTo(0,1);
1796    path.cubicTo(1,6, 1,0, 6,2);
1797    path.close();
1798    SkPath pathB;
1799    pathB.setFillType(SkPath::kWinding_FillType);
1800    pathB.moveTo(0,1);
1801    pathB.cubicTo(2,6, 1,0, 6,1);
1802    pathB.close();
1803    testPathOp(reporter, path, pathB, kDifference_PathOp);
1804}
1805
1806#if 0 // FIXME
1807// this fails because the pair of nearly coincident cubics intersect at the ends
1808// but the line connected to one of the cubics at the same point does not intersect
1809// the other
1810static void skpkkiste_to98(skiatest::Reporter* reporter) {
1811    SkPath path;
1812    path.setFillType(SkPath::kEvenOdd_FillType);
1813    path.moveTo(96, 122);
1814    path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f);
1815    path.lineTo(94.1715698f, 125.17157f);
1816    path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124);
1817    path.lineTo(257, 124);
1818    path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f);
1819    path.lineTo(261.535522f, 123.46447f);
1820    path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122);
1821    path.lineTo(96, 122);
1822    path.close();
1823    SkPath pathB;
1824    pathB.setFillType(SkPath::kWinding_FillType);
1825    pathB.moveTo(258, 122);
1826    pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127);
1827    pathB.lineTo(263, 284);
1828    pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289);
1829    pathB.lineTo(96, 289);
1830    pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284);
1831    pathB.lineTo(91, 127);
1832    pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122);
1833    pathB.lineTo(258, 122);
1834    pathB.close();
1835    testPathOp(reporter, path, pathB, kIntersect_PathOp);
1836}
1837#endif
1838
1839static void (*firstTest)(skiatest::Reporter* ) = 0;
1840
1841static struct TestDesc tests[] = {
1842//    TEST(skpkkiste_to98),
1843    TEST(skpahrefs_com29),
1844    TEST(cubicOp85d),
1845    TEST(skpahrefs_com88),
1846    TEST(skphealth_com76),
1847    TEST(skpancestry_com1),
1848    TEST(skpbyte_com1),
1849    TEST(skpeldorado_com_ua1),
1850    TEST(skp96prezzi1),
1851    TEST(skpClip2),
1852    TEST(skpClip1),
1853    TEST(cubicOp84d),
1854    TEST(cubicOp83i),
1855    TEST(cubicOp82i),
1856    TEST(cubicOp81d),
1857    TEST(cubicOp80i),
1858    TEST(cubicOp79u),
1859    TEST(cubicOp78u),
1860    TEST(cubicOp77i),
1861    TEST(cubicOp76u),
1862    TEST(cubicOp75d),
1863    TEST(cubicOp74d),
1864    TEST(cubicOp73d),
1865    TEST(cubicOp72i),
1866    TEST(cubicOp71d),
1867    TEST(skp5),
1868    TEST(skp4),
1869    TEST(skp3),
1870    TEST(skp2),
1871    TEST(skp1),
1872    TEST(rRect1),
1873    TEST(cubicOp70d),
1874    TEST(cubicOp69d),
1875    TEST(cubicOp68u),
1876    TEST(cubicOp67u),
1877    TEST(cubicOp66u),
1878    TEST(rectOp1d),
1879    TEST(cubicOp65d),
1880    TEST(cubicOp64d),
1881    TEST(cubicOp63d),
1882    TEST(cubicOp62d),
1883    TEST(cubicOp61d),
1884    TEST(cubicOp60d),
1885    TEST(cubicOp59d),
1886    TEST(cubicOp58d),
1887    TEST(cubicOp57d),
1888    TEST(cubicOp56d),
1889    TEST(cubicOp55d),
1890    TEST(cubicOp54d),
1891    TEST(cubicOp53d),
1892    TEST(cubicOp52d),
1893    TEST(cubicOp51d),
1894    TEST(cubicOp50d),
1895    TEST(cubicOp49d),
1896    TEST(cubicOp48d),
1897    TEST(cubicOp47d),
1898    TEST(cubicOp46d),
1899    TEST(cubicOp45d),
1900    TEST(cubicOp44d),
1901    TEST(cubicOp43d),
1902    TEST(cubicOp42d),
1903    TEST(cubicOp41i),
1904    TEST(cubicOp40d),
1905    TEST(cubicOp39d),
1906    TEST(cubicOp38d),
1907    TEST(cubicOp37d),
1908    TEST(cubicOp36u),
1909    TEST(cubicOp35d),
1910    TEST(cubicOp34d),
1911    TEST(cubicOp33i),
1912    TEST(cubicOp32d),
1913    TEST(cubicOp31d),
1914    TEST(cubicOp31x),
1915    TEST(cubicOp31u),
1916    TEST(cubicOp30d),
1917    TEST(cubicOp29d),
1918    TEST(cubicOp28u),
1919    TEST(cubicOp27d),
1920    TEST(cubicOp26d),
1921    TEST(cubicOp25i),
1922    TEST(testOp8d),
1923    TEST(testDiff1),
1924    TEST(testIntersect1),
1925    TEST(testUnion1),
1926    TEST(testXor1),
1927    TEST(testDiff2),
1928    TEST(testIntersect2),
1929    TEST(testUnion2),
1930    TEST(testXor2),
1931    TEST(testOp1d),
1932    TEST(testOp2d),
1933    TEST(testOp3d),
1934    TEST(testOp1u),
1935    TEST(testOp4d),
1936    TEST(testOp5d),
1937    TEST(testOp6d),
1938    TEST(testOp7d),
1939    TEST(testOp2u),
1940
1941    TEST(cubicOp24d),
1942    TEST(cubicOp23d),
1943    TEST(cubicOp22d),
1944    TEST(cubicOp21d),
1945    TEST(cubicOp20d),
1946    TEST(cubicOp19i),
1947    TEST(cubicOp18d),
1948    TEST(cubicOp17d),
1949    TEST(cubicOp16d),
1950    TEST(cubicOp15d),
1951    TEST(cubicOp14d),
1952    TEST(cubicOp13d),
1953    TEST(cubicOp12d),
1954    TEST(cubicOp11d),
1955    TEST(cubicOp10d),
1956    TEST(cubicOp1i),
1957    TEST(cubicOp9d),
1958    TEST(quadOp9d),
1959    TEST(lineOp9d),
1960    TEST(cubicOp8d),
1961    TEST(cubicOp7d),
1962    TEST(cubicOp6d),
1963    TEST(cubicOp5d),
1964    TEST(cubicOp3d),
1965    TEST(cubicOp2d),
1966    TEST(cubicOp1d),
1967};
1968
1969static const size_t testCount = SK_ARRAY_COUNT(tests);
1970
1971static struct TestDesc subTests[] = {
1972    TEST(cubicOp6d),
1973    TEST(cubicOp8d),
1974    TEST(cubicOp70d),
1975    TEST(cubicOp16d),
1976    TEST(skp5),
1977};
1978
1979static const size_t subTestCount = SK_ARRAY_COUNT(subTests);
1980
1981static void (*firstSubTest)(skiatest::Reporter* ) = 0;
1982
1983static bool runSubTestsFirst = false;
1984static bool runReverse = false;
1985static void (*stopTest)(skiatest::Reporter* ) = 0;
1986
1987static void PathOpsOpTest(skiatest::Reporter* reporter) {
1988#ifdef SK_DEBUG
1989    gDebugMaxWindSum = 4;
1990    gDebugMaxWindValue = 4;
1991#endif
1992#if DEBUG_SHOW_TEST_NAME
1993    strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH);
1994#endif
1995    if (runSubTestsFirst) {
1996        RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
1997    }
1998    RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse);
1999    if (!runSubTestsFirst) {
2000        RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse);
2001    }
2002#ifdef SK_DEBUG
2003    gDebugMaxWindSum = SK_MaxS32;
2004    gDebugMaxWindValue = SK_MaxS32;
2005#endif
2006}
2007
2008#include "TestClassDef.h"
2009DEFINE_TESTCLASS_SHORT(PathOpsOpTest)
2010