Lines Matching refs:path
44 SkPath path;
46 path.addRRect(rrect);
47 REPORTER_ASSERT(reporter, bounds == path.getBounds());
51 SkPath path;
52 path.moveTo(20, 20);
53 path.quadTo(20, 50, 80, 50);
54 path.quadTo(20, 50, 20, 80);
55 REPORTER_ASSERT(reporter, !path.isConvex());
76 static void make_path_crbug364224(SkPath* path) {
77 path->reset();
78 path->moveTo(3.747501373f, 2.724499941f);
79 path->lineTo(3.747501373f, 3.75f);
80 path->cubicTo(3.747501373f, 3.88774991f, 3.635501385f, 4.0f, 3.497501373f, 4.0f);
81 path->lineTo(0.7475013733f, 4.0f);
82 path->cubicTo(0.6095013618f, 4.0f, 0.4975013733f, 3.88774991f, 0.4975013733f, 3.75f);
83 path->lineTo(0.4975013733f, 1.0f);
84 path->cubicTo(0.4975013733f, 0.8622499704f, 0.6095013618f, 0.75f, 0.7475013733f,0.75f);
85 path->lineTo(3.497501373f, 0.75f);
86 path->cubicTo(3.50275135f, 0.75f, 3.5070014f, 0.7527500391f, 3.513001442f, 0.753000021f);
87 path->lineTo(3.715001345f, 0.5512499809f);
88 path->cubicTo(3.648251295f, 0.5194999576f, 3.575501442f, 0.4999999702f, 3.497501373f, 0.4999999702f);
89 path->lineTo(0.7475013733f, 0.4999999702f);
90 path->cubicTo(0.4715013802f, 0.4999999702f, 0.2475013733f, 0.7239999771f, 0.2475013733f, 1.0f);
91 path->lineTo(0.2475013733f, 3.75f);
92 path->cubicTo(0.2475013733f, 4.026000023f, 0.4715013504f, 4.25f, 0.7475013733f, 4.25f);
93 path->lineTo(3.497501373f, 4.25f);
94 path->cubicTo(3.773501396f, 4.25f, 3.997501373f, 4.026000023f, 3.997501373f, 3.75f);
95 path->lineTo(3.997501373f, 2.474750042f);
96 path->lineTo(3.747501373f, 2.724499941f);
97 path->close();
100 static void make_path_crbug364224_simplified(SkPath* path) {
101 path->moveTo(3.747501373f, 2.724499941f);
102 path->cubicTo(3.648251295f, 0.5194999576f, 3.575501442f, 0.4999999702f, 3.497501373f, 0.4999999702f);
103 path->close();
109 SkPath path;
110 path.reset();
111 path.moveTo(-540000, -720000);
112 path.lineTo(-9.10000017e-05f, 9.99999996e-13f);
113 path.lineTo(1, 1);
117 SkSurface::MakeRasterN32Premul(10, 10)->getCanvas()->drawPath(path, paint);
121 SkPath path;
126 make_path_crbug364224_simplified(&path);
127 canvas->drawPath(path, paint);
129 make_path_crbug364224(&path);
130 canvas->drawPath(path, paint);
133 static void test_draw_AA_path(int width, int height, const SkPath& path) {
138 canvas->drawPath(path, paint);
143 SkPath path;
144 path.moveTo(SkBits2Float(0x47452a00), SkBits2Float(0x43211d01)); // 50474, 161.113f
145 path.conicTo(SkBits2Float(0x401c0000), SkBits2Float(0x40680000),
148 test_draw_AA_path(250, 250, path);
152 SkPath path;
153 path.moveTo(0, 0);
154 path.conicTo(SkBits2Float(0x002001f2), SkBits2Float(0x4161ffff), // 2.93943e-39f, 14.125f
157 test_draw_AA_path(250, 250, path);
158 path.reset();
159 path.moveTo(0, 0);
160 path.conicTo(SkBits2Float(0x00007ff2), SkBits2Float(0x4169ffff), // 4.58981e-41f, 14.625f
163 test_draw_AA_path(250, 250, path);
167 SkPath path;
168 path.moveTo(0, 0);
169 path.conicTo(SkBits2Float(0x00003939), SkBits2Float(0x42487fff), // 2.05276e-41f, 50.125f
172 test_draw_AA_path(250, 250, path);
180 SkPath path;
181 path.moveTo(SkBits2Float(0x41000000), SkBits2Float(0x431e0000)); // 8, 158
182 path.lineTo(SkBits2Float(0x41000000), SkBits2Float(0x42f00000)); // 8, 120
184 path.conicTo(SkBits2Float(0x41000000), SkBits2Float(0x41000000),
186 path.lineTo(SkBits2Float(0x439a0000), SkBits2Float(0x41000000)); // 308, 8
188 path.conicTo(SkBits2Float(0x439a0000), SkBits2Float(0x41000000),
190 path.lineTo(SkBits2Float(0x439a0000), SkBits2Float(0x431e0000)); // 308, 158
192 path.conicTo(SkBits2Float(0x439a0000), SkBits2Float(0x431e0000),
194 path.lineTo(SkBits2Float(0x41000000), SkBits2Float(0x431e0000)); // 8, 158
196 path.conicTo(SkBits2Float(0x41000000), SkBits2Float(0x431e0000),
198 path.close();
199 canvas->clipPath(path, true);
204 SkPath path;
205 path.moveTo(SkBits2Float(0x43e28000), SkBits2Float(0x43aa8000)); // 453, 341
206 path.lineTo(SkBits2Float(0x43de6000), SkBits2Float(0x43aa8000)); // 444.75f, 341
208 path.cubicTo(SkBits2Float(0x43dc3c29), SkBits2Float(0x43aa8000),
211 path.lineTo(SkBits2Float(0x43da8000), SkBits2Float(0x43b18000)); // 437, 355
212 path.lineTo(SkBits2Float(0x43e28000), SkBits2Float(0x43b18000)); // 453, 355
213 path.lineTo(SkBits2Float(0x43e28000), SkBits2Float(0x43aa8000)); // 453, 341
214 test_draw_AA_path(500, 500, path);
218 SkPath path;
219 path.moveTo(SkBits2Float(0x46313741), SkBits2Float(0x3b00e540)); // 11341.8f, 0.00196679f
220 path.quadTo(SkBits2Float(0x41410041), SkBits2Float(0xc1414141), SkBits2Float(0x41414141),
222 path.lineTo(SkBits2Float(0x46313741), SkBits2Float(0x3b00e540)); // 11341.8f, 0.00196679f
223 path.close();
224 test_draw_AA_path(400, 500, path);
228 * In debug mode, this path was causing an assertion to fail in
231 static void make_path_crbugskia2820(SkPath* path, skiatest::Reporter* reporter) {
238 path->reset();
239 path->moveTo(orig);
240 path->cubicTo(p1, p2, p3);
241 path->close();
245 SkPath path;
246 make_path_crbugskia2820(&path, reporter);
250 stroke.applyToPath(&path, path);
254 SkPath path;
255 path.moveTo(SkBits2Float(0x40303030), SkBits2Float(0x3e303030)); // 2.75294f, 0.172059f
256 path.quadTo(SkBits2Float(0x41d63030), SkBits2Float(0x30303030), SkBits2Float(0x41013030),
258 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
259 test_draw_AA_path(500, 500, path);
262 static void make_path0(SkPath* path) {
265 path->moveTo(146.939f, 1012.84f);
266 path->lineTo(181.747f, 1009.18f);
267 path->lineTo(182.165f, 1013.16f);
268 path->lineTo(147.357f, 1016.82f);
269 path->lineTo(146.939f, 1012.84f);
270 path->close();
273 static void make_path1(SkPath* path) {
274 path->addRect(SkRect::MakeXYWH(10, 10, 10, 1));
281 * construction of the region when the path was INVERSE. That is now fixed,
296 SkPath path;
297 procs[i](&path);
300 rgn.setPath(path, clip);
301 path.toggleInverseFillType();
302 rgn.setPath(path, clip);
315 SkPath path;
319 path.rLineTo(0, 100);
320 path.rLineTo(100, 0);
321 path.close(); // Returns us back to 0,0.
322 path.rLineTo(50, 50); // This should go to 50,50.
324 path.getLastPt(&last);
329 path.rewind();
330 path.rLineTo(0, 100);
331 path.rLineTo(100, 0);
332 path.close();
333 path.rQuadTo(50, 50, 75, 75);
335 path.getLastPt(&last);
340 path.rewind();
341 path.rLineTo(0, 100);
342 path.rLineTo(100, 0);
343 path.close();
344 path.rConicTo(50, 50, 85, 85, 2);
346 path.getLastPt(&last);
351 path.rewind();
352 path.rLineTo(0, 100);
353 path.rLineTo(100, 0);
354 path.close();
355 path.rCubicTo(50, 50, 85, 85, 95, 95);
357 path.getLastPt(&last);
412 SkPath path;
413 path.moveTo(13.8509f, 3.16858f);
414 path.cubicTo(-2.35893e+08f, -4.21044e+08f,
417 test_draw_AA_path(84, 88, path);
428 SkPath path;
429 path.moveTo(pts[0]);
430 path.cubicTo(pts[1], pts[2], pts[3]);
439 paint.getFillPath(path, &dst, nullptr);
442 static void build_path_170666(SkPath& path) {
443 path.moveTo(17.9459f, 21.6344f);
444 path.lineTo(139.545f, -47.8105f);
445 path.lineTo(139.545f, -47.8105f);
446 path.lineTo(131.07f, -47.3888f);
447 path.lineTo(131.07f, -47.3888f);
448 path.lineTo(122.586f, -46.9532f);
449 path.lineTo(122.586f, -46.9532f);
450 path.lineTo(18076.6f, 31390.9f);
451 path.lineTo(18076.6f, 31390.9f);
452 path.lineTo(18085.1f, 31390.5f);
453 path.lineTo(18085.1f, 31390.5f);
454 path.lineTo(18076.6f, 31390.9f);
455 path.lineTo(18076.6f, 31390.9f);
456 path.lineTo(17955, 31460.3f);
457 path.lineTo(17955, 31460.3f);
458 path.lineTo(17963.5f, 31459.9f);
459 path.lineTo(17963.5f, 31459.9f);
460 path.lineTo(17971.9f, 31459.5f);
461 path.lineTo(17971.9f, 31459.5f);
462 path.lineTo(17.9551f, 21.6205f);
463 path.lineTo(17.9551f, 21.6205f);
464 path.lineTo(9.47091f, 22.0561f);
465 path.lineTo(9.47091f, 22.0561f);
466 path.lineTo(17.9459f, 21.6344f);
467 path.lineTo(17.9459f, 21.6344f);
468 path.close();path.moveTo(0.995934f, 22.4779f);
469 path.lineTo(0.986725f, 22.4918f);
470 path.lineTo(0.986725f, 22.4918f);
471 path.lineTo(17955, 31460.4f);
472 path.lineTo(17955, 31460.4f);
473 path.lineTo(17971.9f, 31459.5f);
474 path.lineTo(17971.9f, 31459.5f);
475 path.lineTo(18093.6f, 31390.1f);
476 path.lineTo(18093.6f, 31390.1f);
477 path.lineTo(18093.6f, 31390);
478 path.lineTo(18093.6f, 31390);
479 path.lineTo(139.555f, -47.8244f);
480 path.lineTo(139.555f, -47.8244f);
481 path.lineTo(122.595f, -46.9671f);
482 path.lineTo(122.595f, -46.9671f);
483 path.lineTo(0.995934f, 22.4779f);
484 path.lineTo(0.995934f, 22.4779f);
485 path.close();
486 path.moveTo(5.43941f, 25.5223f);
487 path.lineTo(798267, -28871.1f);
488 path.lineTo(798267, -28871.1f);
489 path.lineTo(3.12512e+06f, -113102);
490 path.lineTo(3.12512e+06f, -113102);
491 path.cubicTo(5.16324e+06f, -186882, 8.15247e+06f, -295092, 1.1957e+07f, -432813);
492 path.cubicTo(1.95659e+07f, -708257, 3.04359e+07f, -1.10175e+06f, 4.34798e+07f, -1.57394e+06f);
493 path.cubicTo(6.95677e+07f, -2.51831e+06f, 1.04352e+08f, -3.77748e+06f, 1.39135e+08f, -5.03666e+06f);
494 path.cubicTo(1.73919e+08f, -6.29583e+06f, 2.08703e+08f, -7.555e+06f, 2.34791e+08f, -8.49938e+06f);
495 path.cubicTo(2.47835e+08f, -8.97157e+06f, 2.58705e+08f, -9.36506e+06f, 2.66314e+08f, -9.6405e+06f);
496 path.cubicTo(2.70118e+08f, -9.77823e+06f, 2.73108e+08f, -9.88644e+06f, 2.75146e+08f, -9.96022e+06f);
497 path.cubicTo(2.76165e+08f, -9.99711e+06f, 2.76946e+08f, -1.00254e+07f, 2.77473e+08f, -1.00444e+07f);
498 path.lineTo(2.78271e+08f, -1.00733e+07f);
499 path.lineTo(2.78271e+08f, -1.00733e+07f);
500 path.cubicTo(2.78271e+08f, -1.00733e+07f, 2.08703e+08f, -7.555e+06f, 135.238f, 23.3517f);
501 path.cubicTo(131.191f, 23.4981f, 125.995f, 23.7976f, 123.631f, 24.0206f);
502 path.cubicTo(121.267f, 24.2436f, 122.631f, 24.3056f, 126.677f, 24.1591f);
503 path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);
504 path.lineTo(2.77473e+08f, -1.00444e+07f);
505 path.lineTo(2.77473e+08f, -1.00444e+07f);
506 path.cubicTo(2.76946e+08f, -1.00254e+07f, 2.76165e+08f, -9.99711e+06f, 2.75146e+08f, -9.96022e+06f);
507 path.cubicTo(2.73108e+08f, -9.88644e+06f, 2.70118e+08f, -9.77823e+06f, 2.66314e+08f, -9.6405e+06f);
508 path.cubicTo(2.58705e+08f, -9.36506e+06f, 2.47835e+08f, -8.97157e+06f, 2.34791e+08f, -8.49938e+06f);
509 path.cubicTo(2.08703e+08f, -7.555e+06f, 1.73919e+08f, -6.29583e+06f, 1.39135e+08f, -5.03666e+06f);
510 path.cubicTo(1.04352e+08f, -3.77749e+06f, 6.95677e+07f, -2.51831e+06f, 4.34798e+07f, -1.57394e+06f);
511 path.cubicTo(3.04359e+07f, -1.10175e+06f, 1.95659e+07f, -708258, 1.1957e+07f, -432814);
512 path.cubicTo(8.15248e+06f, -295092, 5.16324e+06f, -186883, 3.12513e+06f, -113103);
513 path.lineTo(798284, -28872);
514 path.lineTo(798284, -28872);
515 path.lineTo(22.4044f, 24.6677f);
516 path.lineTo(22.4044f, 24.6677f);
517 path.cubicTo(22.5186f, 24.5432f, 18.8134f, 24.6337f, 14.1287f, 24.8697f);
518 path.cubicTo(9.4439f, 25.1057f, 5.55359f, 25.3978f, 5.43941f, 25.5223f);
519 path.close();
522 static void build_path_simple_170666(SkPath& path) {
523 path.moveTo(126.677f, 24.1591f);
524 path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);
531 SkPath path;
532 build_path_simple_170666(path);
533 test_draw_AA_path(1000, 1000, path);
535 build_path_170666(path);
536 test_draw_AA_path(1000, 1000, path);
602 SkPath path;
603 path.conicTo(-6.62478e-08f, 4.13885e-08f, -6.36935e-08f, 3.97927e-08f, 0.729058f);
604 path.quadTo(2.28206e-09f, -1.42572e-09f, 3.91919e-09f, -2.44852e-09f);
605 path.cubicTo(-16752.2f, -26792.9f, -21.4673f, 10.9347f, -8.57322f, -7.22739f);
609 path.contains(-1.84817e-08f, 1.15465e-08f);
613 SkPath path;
614 path.lineTo(0, 0);
615 path.addRect(SkRect::MakeWH(50, 100));
616 REPORTER_ASSERT(reporter, path.isRect(nullptr));
618 path.reset();
619 path.lineTo(FLT_EPSILON, FLT_EPSILON);
620 path.addRect(SkRect::MakeWH(50, 100));
621 REPORTER_ASSERT(reporter, !path.isRect(nullptr));
623 path.reset();
624 path.quadTo(0, 0, 0, 0);
625 path.addRect(SkRect::MakeWH(50, 100));
626 REPORTER_ASSERT(reporter, !path.isRect(nullptr));
628 path.reset();
629 path.conicTo(0, 0, 0, 0, 0.5f);
630 path.addRect(SkRect::MakeWH(50, 100));
631 REPORTER_ASSERT(reporter, !path.isRect(nullptr));
633 path.reset();
634 path.cubicTo(0, 0, 0, 0, 0, 0);
635 path.addRect(SkRect::MakeWH(50, 100));
636 REPORTER_ASSERT(reporter, !path.isRect(nullptr));
641 SkPath path;
643 path.addRect(SkRect::MakeWH(50, 100));
644 REPORTER_ASSERT(reporter, path.isFinite());
646 path.moveTo(0, 0);
647 path.lineTo(SK_ScalarInfinity, 42);
648 REPORTER_ASSERT(reporter, !path.isFinite());
650 path.addRect(SkRect::MakeWH(50, 100));
651 REPORTER_ASSERT(reporter, !path.isFinite());
653 path.reset();
654 REPORTER_ASSERT(reporter, path.isFinite());
656 path.addRect(SkRect::MakeWH(50, 100));
657 REPORTER_ASSERT(reporter, path.isFinite());
660 static void build_big_path(SkPath* path, bool reducedCase) {
662 path->moveTo(577330, 1971.72f);
663 path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
665 path->moveTo(60.1631f, 7.70567f);
666 path->quadTo(60.1631f, 7.70567f, 0.99474f, 0.901199f);
667 path->lineTo(577379, 1977.77f);
668 path->quadTo(577364, 1979.57f, 577325, 1980.26f);
669 path->quadTo(577286, 1980.95f, 577245, 1980.13f);
670 path->quadTo(577205, 1979.3f, 577187, 1977.45f);
671 path->quadTo(577168, 1975.6f, 577183, 1973.8f);
672 path->quadTo(577198, 1972, 577238, 1971.31f);
673 path->quadTo(577277, 1970.62f, 577317, 1971.45f);
674 path->quadTo(577330, 1971.72f, 577341, 1972.11f);
675 path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
676 path->moveTo(306.718f, -32.912f);
677 path->cubicTo(30.531f, 10.0005f, 1502.47f, 13.2804f, 84.3088f, 9.99601f);
684 // This path used to assert, because our cubic-chopping code incorrectly
687 SkPath path;
689 build_big_path(&path, SkToBool(doReducedCase));
694 surface->getCanvas()->drawPath(path, paint);
701 ERRORF(reporter, "path.getBounds() returned [%g %g %g %g], but expected [%g %g %g %g]",
708 SkPath path;
712 REPORTER_ASSERT(reporter, SkRect::MakeLTRB(0, 0, 0, 0) == path.getBounds());
714 path.moveTo(-5, -8);
715 REPORTER_ASSERT(reporter, SkRect::MakeLTRB(-5, -8, -5, -8) == path.getBounds());
717 path.addRect(SkRect::MakeLTRB(1, 2, 3, 4));
718 REPORTER_ASSERT(reporter, SkRect::MakeLTRB(-5, -8, 3, 4) == path.getBounds());
720 path.moveTo(1, 2);
721 REPORTER_ASSERT(reporter, SkRect::MakeLTRB(-5, -8, 3, 4) == path.getBounds());
723 dump_if_ne(reporter, SkRect::MakeLTRB(0, 0, 0, 0), path.getBounds());
725 path.moveTo(-5, -8); // should set the bounds
726 dump_if_ne(reporter, SkRect::MakeLTRB(-5, -8, -5, -8), path.getBounds());
728 path.addRect(SkRect::MakeLTRB(1, 2, 3, 4)); // should extend the bounds
729 dump_if_ne(reporter, SkRect::MakeLTRB(-5, -8, 3, 4), path.getBounds());
731 path.moveTo(1, 2); // don't expect this to have changed the bounds
732 dump_if_ne(reporter, SkRect::MakeLTRB(-5, -8, 3, 4), path.getBounds());
738 SkPath path;
739 path.moveTo(0, 0);
740 path.conicTo(3.58732e-43f, 2.72084f, 3.00392f, 3.00392f, 8.46e+37f);
741 test_draw_AA_path(100, 100, path);
756 SkPath path;
757 path.moveTo(pts[0]);
758 path.cubicTo(pts[1], pts[2], pts[3]);
759 test_draw_AA_path(19, 130, path);
765 SkPath path;
766 path.quadTo(157, 366, 286, 208);
767 path.arcTo(37, 442, 315, 163, 957494590897113.0f);
772 // Be sure that path::transform correctly updates isFinite and the bounds
776 while (path.isFinite()) {
777 REPORTER_ASSERT(reporter, path.getBounds().isFinite());
778 REPORTER_ASSERT(reporter, !path.getBounds().isEmpty());
779 path.transform(matrix);
781 REPORTER_ASSERT(reporter, path.getBounds().isEmpty());
784 path.transform(matrix);
786 REPORTER_ASSERT(reporter, !path.isFinite());
787 REPORTER_ASSERT(reporter, path.getBounds().isEmpty());
790 static void add_corner_arc(SkPath* path, const SkRect& rect,
817 path->arcTo(arcRect, SkIntToScalar(startAngle), SkIntToScalar(90), false);
820 static void make_arb_round_rect(SkPath* path, const SkRect& r,
823 add_corner_arc(path, r, xCorner, yCorner, 270);
824 add_corner_arc(path, r, xCorner, yCorner, 0);
825 add_corner_arc(path, r, xCorner, yCorner, 90);
826 add_corner_arc(path, r, xCorner, yCorner, 180);
827 path->close();
858 // quads prevent the path from being converted to a rect
925 SkPath path;
926 REPORTER_ASSERT(reporter, path.isFinite());
928 path.reset();
929 REPORTER_ASSERT(reporter, path.isFinite());
931 path.reset();
932 path.moveTo(SK_Scalar1, 0);
933 REPORTER_ASSERT(reporter, path.isFinite());
935 path.reset();
936 path.moveTo(inf, negInf);
937 REPORTER_ASSERT(reporter, !path.isFinite());
939 path.reset();
940 path.moveTo(nan, 0);
941 REPORTER_ASSERT(reporter, !path.isFinite());
950 SkPath path;
951 REPORTER_ASSERT(reporter, !path.isLastContourClosed());
952 path.moveTo(0, 0);
953 REPORTER_ASSERT(reporter, !path.isLastContourClosed());
954 path.close();
955 REPORTER_ASSERT(reporter, path.isLastContourClosed());
956 path.lineTo(100, 100);
957 REPORTER_ASSERT(reporter, !path.isLastContourClosed());
958 path.moveTo(200, 200);
959 REPORTER_ASSERT(reporter, !path.isLastContourClosed());
960 path.close();
961 REPORTER_ASSERT(reporter, path.isLastContourClosed());
962 path.moveTo(0, 0);
963 REPORTER_ASSERT(reporter, !path.isLastContourClosed());
973 static void test_poly(skiatest::Reporter* reporter, const SkPath& path,
977 for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
1021 SkPath path;
1022 path.addPoly(pts, SkToInt(count), SkToBool(doClose));
1023 test_poly(reporter, path, pts, SkToBool(doClose));
1053 static void check_direction(skiatest::Reporter* reporter, const SkPath& path,
1058 // We make a copy so that we don't cache the result on the passed in path.
1059 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1069 SkPath path;
1071 SkPathPriv::ComputeFirstDirection(path) == SkPathFirstDirection::kUnknown);
1082 path.reset();
1083 bool valid = SkParsePath::FromSVGString(gDegen[i], &path);
1086 SkPathPriv::ComputeFirstDirection(path) == SkPathFirstDirection::kUnknown);
1099 path.reset();
1100 bool valid = SkParsePath::FromSVGString(gCW[i], &path);
1102 check_direction(reporter, path, SkPathFirstDirection::kCW);
1115 path.reset();
1116 bool valid = SkParsePath::FromSVGString(gCCW[i], &path);
1118 check_direction(reporter, path, SkPathFirstDirection::kCCW);
1123 path.reset();
1124 path.addCircle(0, 0, SkIntToScalar(2), SkPathDirection::kCW);
1125 path.addCircle(0, 0, SkIntToScalar(1), SkPathDirection::kCCW);
1126 check_direction(reporter, path, SkPathFirstDirection::kCW);
1128 path.reset();
1129 path.addCircle(0, 0, SkIntToScalar(1), SkPathDirection::kCW);
1130 path.addCircle(0, 0, SkIntToScalar(2), SkPathDirection::kCCW);
1131 check_direction(reporter, path, SkPathFirstDirection::kCCW);
1134 path.reset();
1136 path.moveTo(SkBits2Float(0x501c7652), SkBits2Float(0x501c7652));
1137 path.lineTo(110 * SK_Scalar1, -10 * SK_Scalar1);
1138 path.lineTo(-10 * SK_Scalar1, 60 * SK_Scalar1);
1139 check_direction(reporter, path, SkPathFirstDirection::kCCW);
1141 path.reset();
1142 path.conicTo(20, 0, 20, 20, 0.5f);
1143 path.close();
1144 check_direction(reporter, path, SkPathFirstDirection::kCW);
1146 path.reset();
1147 path.lineTo(1, 1e7f);
1148 path.lineTo(1e7f, 2e7f);
1149 path.close();
1150 REPORTER_ASSERT(reporter, path.isConvex());
1151 check_direction(reporter, path, SkPathFirstDirection::kCCW);
1154 static void add_rect(SkPath* path, const SkRect& r) {
1155 path->moveTo(r.fLeft, r.fTop);
1156 path->lineTo(r.fRight, r.fTop);
1157 path->lineTo(r.fRight, r.fBottom);
1158 path->lineTo(r.fLeft, r.fBottom);
1159 path->close();
1180 SkPath path;
1181 path.moveTo(pts[0]);
1182 path.cubicTo(pts[1], pts[2], pts[3]);
1189 paint.getFillPath(path, &fill);
1215 static void check_close(skiatest::Reporter* reporter, const SkPath& path) {
1217 SkPath::Iter iter(path, SkToBool(i));
1311 static void check_convexity(skiatest::Reporter* reporter, const SkPath& path,
1313 // We make a copy so that we don't cache the result on the passed in path.
1314 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1537 static void setFromString(SkPath* path, const char str[]) {
1548 path->moveTo(x, y);
1551 path->lineTo(x, y);
1557 SkPath path;
1559 check_convexity(reporter, path, true);
1560 path.addCircle(0, 0, SkIntToScalar(10));
1561 check_convexity(reporter, path, true);
1562 path.addCircle(0, 0, SkIntToScalar(10)); // 2nd circle
1563 check_convexity(reporter, path, false);
1565 path.reset();
1566 path.addRect(0, 0, SkIntToScalar(10), SkIntToScalar(10), SkPathDirection::kCCW);
1567 check_convexity(reporter, path, true);
1568 REPORTER_ASSERT(reporter, SkPathPriv::ComputeFirstDirection(path) == SkPathFirstDirection::kCCW);
1570 path.reset();
1571 path.addRect(0, 0, SkIntToScalar(10), SkIntToScalar(10), SkPathDirection::kCW);
1572 check_convexity(reporter, path, true);
1573 REPORTER_ASSERT(reporter, SkPathPriv::ComputeFirstDirection(path) == SkPathFirstDirection::kCW);
1575 path.reset();
1576 path.quadTo(100, 100, 50, 50); // This from GM:convexpaths
1577 check_convexity(reporter, path, true);
1595 path.reset();
1596 setFromString(&path, gRec[i].fPathStr);
1597 check_convexity(reporter, path, gRec[i].fExpectedIsConvex);
1598 check_direction(reporter, path, gRec[i].fExpectedDirection);
1601 // We make a copy so that we don't cache the result on the passed in path.
1602 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1610 REPORTER_ASSERT(reporter, gRec[i].fExpectedIsConvex == path.isConvex());
1611 check_direction(reporter, path, gRec[i].fExpectedDirection);
1643 path.reset();
1645 case 0: path.lineTo(nonFinitePts[i]); break;
1646 case 1: path.quadTo(nonFinitePts[i], nonFinitePts[i]); break;
1647 case 2: path.quadTo(nonFinitePts[i], axisAlignedPts[f]); break;
1648 case 3: path.quadTo(axisAlignedPts[f], nonFinitePts[i]); break;
1649 case 4: path.cubicTo(nonFinitePts[i], axisAlignedPts[f], axisAlignedPts[f]); break;
1650 case 5: path.cubicTo(axisAlignedPts[f], nonFinitePts[i], axisAlignedPts[f]); break;
1651 case 6: path.cubicTo(axisAlignedPts[f], axisAlignedPts[f], nonFinitePts[i]); break;
1652 case 7: path.cubicTo(nonFinitePts[i], nonFinitePts[i], axisAlignedPts[f]); break;
1653 case 8: path.cubicTo(nonFinitePts[i], axisAlignedPts[f], nonFinitePts[i]); break;
1654 case 9: path.cubicTo(axisAlignedPts[f], nonFinitePts[i], nonFinitePts[i]); break;
1655 case 10: path.cubicTo(nonFinitePts[i], nonFinitePts[i], nonFinitePts[i]); break;
1656 case 11: path.cubicTo(nonFinitePts[i], axisAlignedPts[f], axisAlignedPts[g]); break;
1657 case 12: path.moveTo(nonFinitePts[i]); break;
1660 SkPathPriv::GetConvexityOrUnknown(path) == SkPathConvexity::kUnknown);
1666 path.reset();
1669 case 0: path.moveTo(axisAlignedPts[f]); break;
1670 case 1: path.lineTo(axisAlignedPts[f]); break;
1671 case 2: path.quadTo(axisAlignedPts[f], axisAlignedPts[f]); break;
1672 case 3: path.quadTo(axisAlignedPts[f], axisAlignedPts[g]); break;
1673 case 4: path.quadTo(axisAlignedPts[g], axisAlignedPts[f]); break;
1674 case 5: path.cubicTo(axisAlignedPts[f], axisAlignedPts[f], axisAlignedPts[f]); break;
1675 case 6: path.cubicTo(axisAlignedPts[f], axisAlignedPts[f], axisAlignedPts[g]); break;
1676 case 7: path.cubicTo(axisAlignedPts[f], axisAlignedPts[g], axisAlignedPts[f]); break;
1677 case 8: path.cubicTo(axisAlignedPts[f], axisAlignedPts[g], axisAlignedPts[g]); break;
1678 case 9: path.cubicTo(axisAlignedPts[g], axisAlignedPts[f], axisAlignedPts[f]); break;
1679 case 10: path.cubicTo(axisAlignedPts[g], axisAlignedPts[f], axisAlignedPts[g]); break;
1682 check_convexity(reporter, path, true);
1684 // We make a copy so that we don't cache the result on the passed in path.
1685 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1700 path.reset();
1703 case 0: path.moveTo(diagonalPts[f]); break;
1704 case 1: path.lineTo(diagonalPts[f]); break;
1705 case 2: path.quadTo(diagonalPts[f], diagonalPts[f]); break;
1706 case 3: path.quadTo(axisAlignedPts[f], diagonalPts[g]); break;
1707 case 4: path.quadTo(diagonalPts[g], axisAlignedPts[f]); break;
1708 case 5: path.cubicTo(diagonalPts[f], diagonalPts[f], diagonalPts[f]); break;
1709 case 6: path.cubicTo(diagonalPts[f], diagonalPts[f], axisAlignedPts[g]); break;
1710 case 7: path.cubicTo(diagonalPts[f], axisAlignedPts[g], diagonalPts[f]); break;
1711 case 8: path.cubicTo(axisAlignedPts[f], diagonalPts[g], diagonalPts[g]); break;
1712 case 9: path.cubicTo(diagonalPts[g], diagonalPts[f], axisAlignedPts[f]); break;
1713 case 10: path.cubicTo(diagonalPts[g], axisAlignedPts[f], diagonalPts[g]); break;
1716 check_convexity(reporter, path, true);
1718 // We make a copy so that we don't cache the result on the passed in path.
1719 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1725 path.reset();
1726 path.moveTo(SkBits2Float(0xbe9171db), SkBits2Float(0xbd7eeb5d)); // -0.284072f, -0.0622362f
1727 path.lineTo(SkBits2Float(0xbe9171db), SkBits2Float(0xbd7eea38)); // -0.284072f, -0.0622351f
1728 path.lineTo(SkBits2Float(0xbe9171a0), SkBits2Float(0xbd7ee5a7)); // -0.28407f, -0.0622307f
1729 path.lineTo(SkBits2Float(0xbe917147), SkBits2Float(0xbd7ed886)); // -0.284067f, -0.0622182f
1730 path.lineTo(SkBits2Float(0xbe917378), SkBits2Float(0xbd7ee1a9)); // -0.284084f, -0.0622269f
1731 path.lineTo(SkBits2Float(0xbe9171db), SkBits2Float(0xbd7eeb5d)); // -0.284072f, -0.0622362f
1732 path.close();
1733 check_convexity(reporter, path, false);
1738 SkPath path;
1742 REPORTER_ASSERT(reporter, !path.isLine(nullptr));
1747 REPORTER_ASSERT(reporter, !path.isLine(pts));
1756 path.moveTo(moveX, moveY);
1757 REPORTER_ASSERT(reporter, !path.isLine(nullptr));
1758 REPORTER_ASSERT(reporter, !path.isLine(pts));
1767 path.lineTo(lineX, lineY);
1768 REPORTER_ASSERT(reporter, path.isLine(nullptr));
1772 REPORTER_ASSERT(reporter, path.isLine(pts));
1776 path.lineTo(0, 0); // too many points/verbs
1777 REPORTER_ASSERT(reporter, !path.isLine(nullptr));
1778 REPORTER_ASSERT(reporter, !path.isLine(pts));
1782 path.reset();
1783 path.quadTo(1, 1, 2, 2);
1784 REPORTER_ASSERT(reporter, !path.isLine(nullptr));
1788 SkPath path;
1890 path.reset();
1891 path.addRect(kBaseRect, dir);
1893 path.conservativelyContainsRect(qRect));
1895 path.reset();
1896 path.addCircle(kCircleC.fX, kCircleC.fY, circleR, dir);
1898 path.conservativelyContainsRect(qRect));
1900 path.reset();
1901 path.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1], dir);
1903 path.conservativelyContainsRect(qRect));
1905 path.reset();
1906 path.moveTo(kBaseRect.fLeft + kRRRadii[0], kBaseRect.fTop);
1907 path.cubicTo(kBaseRect.fLeft + kRRRadii[0] / 2, kBaseRect.fTop,
1910 path.lineTo(kBaseRect.fLeft, kBaseRect.fBottom);
1911 path.lineTo(kBaseRect.fRight, kBaseRect.fBottom);
1912 path.lineTo(kBaseRect.fRight, kBaseRect.fTop);
1913 path.close();
1915 path.conservativelyContainsRect(qRect));
1919 path.reset();
1920 path.moveTo(0, 0);
1921 path.lineTo(SkIntToScalar(50), 0.05f);
1922 path.lineTo(SkIntToScalar(100), 0);
1923 path.lineTo(SkIntToScalar(100), SkIntToScalar(100));
1924 path.lineTo(0, SkIntToScalar(100));
1925 path.close();
1926 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(qRect));
1931 path.reset();
1932 path.moveTo(0, 0);
1933 path.lineTo(SkIntToScalar(100), 0);
1934 path.lineTo(0, SkIntToScalar(100));
1937 REPORTER_ASSERT(reporter, path.conservativelyContainsRect(SkRect::MakeXYWH(SkIntToScalar(50), 0,
1941 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(
1947 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeXYWH(SkIntToScalar(-10),
1953 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeXYWH(SkIntToScalar(10),
1960 path.moveTo(SkIntToScalar(100), SkIntToScalar(100));
1961 REPORTER_ASSERT(reporter, path.conservativelyContainsRect(SkRect::MakeXYWH(SkIntToScalar(50), 0,
1965 // Same as above path and first test but with an extra moveTo.
1966 path.reset();
1967 path.moveTo(100, 100);
1968 path.moveTo(0, 0);
1969 path.lineTo(SkIntToScalar(100), 0);
1970 path.lineTo(0, SkIntToScalar(100));
1971 // Convexity logic treats a path as filled and closed, so that multiple (non-trailing) moveTos
1973 REPORTER_ASSERT(reporter, path.conservativelyContainsRect(
1978 // Same as above path and first test but with the extra moveTo making a degenerate sub-path
1979 // following the non-empty sub-path. Verifies that this does not trigger assertions.
1980 path.reset();
1981 path.moveTo(0, 0);
1982 path.lineTo(SkIntToScalar(100), 0);
1983 path.lineTo(0, SkIntToScalar(100));
1984 path.moveTo(100, 100);
1986 REPORTER_ASSERT(reporter, path.conservativelyContainsRect(SkRect::MakeXYWH(SkIntToScalar(50), 0,
1992 path.reset();
1993 path.moveTo(0, 0);
1994 path.lineTo(SkIntToScalar(100), 0);
1995 path.lineTo(0, SkIntToScalar(100));
1996 path.moveTo(0, SkIntToScalar(200));
1997 path.lineTo(SkIntToScalar(100), SkIntToScalar(200));
1998 path.lineTo(0, SkIntToScalar(300));
2000 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(
2005 path.reset();
2006 path.lineTo(100, 100);
2007 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeXYWH(0, 0, 1, 1)));
2009 // An empty path should not contain any rectangle. It's questionable whether an empty path
2012 path.reset();
2013 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeWH(1,1)));
2014 REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeWH(0,0)));
2018 SkPath path;
2021 path.moveTo(0, 0); path.lineTo(1, 0); path.lineTo(1, 1); path.lineTo(0, 1);
2022 path.close();
2024 REPORTER_ASSERT(reporter, path.isRect(nullptr, &isClosed, nullptr));
2120 SkPath path;
2121 path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
2123 path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
2126 path.close();
2128 REPORTER_ASSERT(reporter, tests[testIndex].fIsRect == path.isRect(nullptr));
2136 SkPathFirstDirection cheapDirection = SkPathPriv::ComputeFirstDirection(path);
2138 REPORTER_ASSERT(reporter, path.isRect(&computed, &isClosed, &direction));
2149 REPORTER_ASSERT(reporter, !path.isRect(&computed, &isClosed, &direction));
2214 static void check_simple_rect(skiatest::Reporter* reporter, const SkPath& path, bool isClosed,
2220 REPORTER_ASSERT(reporter, SkPathPriv::IsSimpleRect(path, false, &r, &d, &s) == isClosed);
2221 REPORTER_ASSERT(reporter, SkPathPriv::IsSimpleRect(path, true, &r, &d, &s));
2237 SkPath path;
2238 path.addRect(testRect, dir, start);
2239 check_simple_rect(reporter, path, true, testRect, dir, start);
2240 path.close();
2241 check_simple_rect(reporter, path, true, testRect, dir, start);
2242 SkPath path2 = path;
2246 path2 = path;
2250 path2 = path;
2254 // Make the path by hand, manually closing it.
2257 for (auto [v, verbPts, w] : SkPathPriv::Iterate(path)) {
2296 // An inverted rect makes a rect path, but changes the winding dir and start point.
2315 SkPath path;
2316 path.moveTo(1, 1);
2317 path.lineTo(1, 2);
2318 path.lineTo(1, 1);
2319 path.lineTo(0, 1);
2323 path.close();
2324 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, false, &rect, &dir, &start));
2325 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, true, &rect, &dir, &start));
2327 path.reset();
2328 path.moveTo(1, 1);
2329 path.lineTo(2, 1);
2330 path.lineTo(1, 1);
2331 path.lineTo(1, 0);
2332 path.close();
2333 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, false, &rect, &dir, &start));
2334 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, true, &rect, &dir, &start));
2336 path.reset();
2337 path.moveTo(1, 0);
2338 path.lineTo(3, 0);
2339 path.lineTo(2, 1);
2340 path.lineTo(0, 1);
2341 path.close();
2342 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, false, &rect, &dir, &start));
2343 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, true, &rect, &dir, &start));
2345 path.reset();
2346 path.moveTo(0, 1);
2347 path.lineTo(0, 3);
2348 path.lineTo(1, 2);
2349 path.lineTo(1, 0);
2350 path.close();
2351 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, false, &rect, &dir, &start));
2352 REPORTER_ASSERT(reporter, !SkPathPriv::IsSimpleRect(path, true, &rect, &dir, &start));
2392 bool fIsNestedRect; // nests with path.addRect(-1, -1, 2, 2);
2426 SkPath path;
2428 path.addRect(-1, -1, 2, 2, SkPathDirection::kCW);
2430 path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
2432 path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
2435 path.close();
2438 path.addRect(-1, -1, 2, 2, SkPathDirection::kCCW);
2441 tests[testIndex].fIsNestedRect == SkPathPriv::IsNestedFillRects(path, nullptr));
2456 REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(path, computed, computedDirs));
2557 SkPath path;
2558 path.moveTo(0, 0);
2559 path.lineTo(10, 0);
2560 path.lineTo(10, 10);
2561 path.lineTo(0, 10);
2562 path.lineTo(0, 0);
2563 path.moveTo(1, 1);
2564 path.lineTo(9, 1);
2565 path.lineTo(9, 9);
2566 path.lineTo(1, 9);
2567 path.lineTo(1, 1);
2568 REPORTER_ASSERT(reporter, SkPathPriv::IsNestedFillRects(path, nullptr));
2637 // create a buffer that should be much larger than the path so we don't
2708 SkPath p1; // Leave p1 non-unique (i.e., the empty path)
2758 p1.moveTo(SkPoint::Make(0, 0)); // Make p1 unique (i.e., not empty path)
2768 p1.moveTo(SkPoint::Make(0, 0)); // Make p1 unique (i.e., not empty path)
2899 // Test an iterator with no path
2903 // Test that setting an empty path works
2907 // Test that close path makes no difference for an empty path
2911 // Test an iterator with an initial empty path
2915 // Test that close path makes no difference
3041 SkPath path;
3043 // Test an iterator with an initial empty path
3044 SkPathPriv::Iterate iterate(path);
3047 // Test that a move-only path returns the move.
3048 path.moveTo(SK_Scalar1, 0);
3049 iterate = SkPathPriv::Iterate(path);
3060 path.moveTo(SK_Scalar1*2, SK_Scalar1);
3061 path.moveTo(SK_Scalar1*3, SK_Scalar1*2);
3062 iterate = SkPathPriv::Iterate(path);
3085 path.reset();
3086 path.close();
3087 iterate = SkPathPriv::Iterate(path);
3091 path.reset();
3092 path.close(); // Not stored, no purpose
3093 path.moveTo(SK_Scalar1, 0);
3094 path.close();
3095 path.close(); // Not stored, no purpose
3096 path.moveTo(SK_Scalar1*2, SK_Scalar1);
3097 path.close();
3098 path.moveTo(SK_Scalar1*3, SK_Scalar1*2);
3099 path.moveTo(SK_Scalar1*4, SK_Scalar1*3);
3100 path.close();
3101 iterate = SkPathPriv::Iterate(path);
3156 path.reset();
3170 path.moveTo(expectedPts[numPoints]);
3183 path.lineTo(expectedPts[numPoints]);
3195 path.quadTo(expectedPts[numPoints], expectedPts[numPoints + 1]);
3207 path.conicTo(expectedPts[numPoints], expectedPts[numPoints + 1],
3221 path.cubicTo(expectedPts[numPoints], expectedPts[numPoints + 1],
3227 path.close();
3244 for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
3292 const SkPath& path,
3296 REPORTER_ASSERT(reporter, path.isOval(&rect) == expectedCircle);
3299 if (SkPathPriv::IsOval(path, &rect, &isOvalDir, &isOvalStart)) {
3304 REPORTER_ASSERT(reporter, path == tmpPath);
3306 REPORTER_ASSERT(reporter, SkPathPriv::ComputeFirstDirection(path) == expectedDir);
3310 const SkPath& path,
3316 path.transform(m, &tmp);
3328 const SkPath& path,
3335 path.transform(m, &tmp);
3343 path.transform(m, &tmp);
3348 const SkPath& path,
3354 path.transform(m, &tmp);
3368 const SkPath& path,
3374 path.transform(m, &tmp);
3385 const SkPath& path,
3391 path.transform(m, &tmp);
3404 const SkPath& path,
3411 path.transform(m, &tmp);
3419 SkPath path;
3422 path.addCircle(0, 0, SkIntToScalar(20), inDir);
3424 check_for_circle(reporter, path, true, dir);
3425 test_circle_rotate(reporter, path, dir);
3426 test_circle_translate(reporter, path, dir);
3427 test_circle_skew(reporter, path, dir);
3428 test_circle_mirror_x(reporter, path, dir);
3429 test_circle_mirror_y(reporter, path, dir);
3430 test_circle_mirror_xy(reporter, path, dir);
3433 path.reset();
3434 path.addCircle(SkIntToScalar(10), SkIntToScalar(10),
3437 check_for_circle(reporter, path, true, dir);
3438 test_circle_rotate(reporter, path, dir);
3439 test_circle_translate(reporter, path, dir);
3440 test_circle_skew(reporter, path, dir);
3441 test_circle_mirror_x(reporter, path, dir);
3442 test_circle_mirror_y(reporter, path, dir);
3443 test_circle_mirror_xy(reporter, path, dir);
3447 path.reset();
3448 path.addOval(SkRect::MakeXYWH(20, 10, 5, 5), inDir, start);
3449 test_circle_rotate(reporter, path, dir);
3450 test_circle_translate(reporter, path, dir);
3451 test_circle_skew(reporter, path, dir);
3452 test_circle_mirror_x(reporter, path, dir);
3453 test_circle_mirror_y(reporter, path, dir);
3454 test_circle_mirror_xy(reporter, path, dir);
3459 SkPath path;
3474 // Although all the path concatenation related operations leave
3475 // the path a circle, most mark it as a non-circle for simplicity
3478 path = empty;
3479 path.addPath(circle, translate);
3480 check_for_circle(reporter, path, false, SkPathPriv::AsFirstDirection(kCircleDir));
3483 path = circle;
3484 path.addPath(empty, translate);
3486 check_for_circle(reporter, path, true, SkPathPriv::AsFirstDirection(kCircleDir));
3489 path = circle;
3490 path.reverseAddPath(rect);
3491 check_for_circle(reporter, path, false, SkPathPriv::AsFirstDirection(kCircleDirOpposite));
3499 SkPath path;
3500 path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
3501 path.addCircle(0, 0, SkIntToScalar(20), SkPathDirection::kCW);
3502 check_for_circle(reporter, path, false, SkPathFirstDirection::kCW);
3505 path.reset();
3506 path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
3507 path.lineTo(0, 0);
3508 check_for_circle(reporter, path, false, SkPathFirstDirection::kCW);
3511 path.reset();
3512 path.addCircle(0, 0, SkIntToScalar(10), SkPathDirection::kCW);
3513 path.setLastPt(SkIntToScalar(5), SkIntToScalar(5));
3514 check_for_circle(reporter, path, false, SkPathFirstDirection::kCW);
3519 path.reset();
3520 path.addCircle(0, 0, -1, SkPathDirection::kCW);
3521 REPORTER_ASSERT(reporter, path.isEmpty());
3527 SkPath path;
3532 path.addOval(rect);
3535 REPORTER_ASSERT(reporter, path.isOval(nullptr));
3539 path.transform(m, &tmp);
3549 path.transform(m, &tmp);
3553 // since empty path being transformed.
3554 path.reset();
3557 path.transform(m, &tmp);
3560 // empty path is not an oval
3572 path.reset();
3573 path.moveTo(0, 0);
3574 path.addOval(rect);
3575 REPORTER_ASSERT(reporter, path.isOval(nullptr));
3577 // copy path
3578 path.reset();
3581 path = tmp;
3582 REPORTER_ASSERT(reporter, SkPathPriv::IsOval(path, nullptr, &dir, &start));
3601 static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path,
3603 REPORTER_ASSERT(reporter, path->isConvex());
3605 SkPathPriv::ComputeFirstDirection(*path) == SkPathPriv::AsFirstDirection(dir));
3606 SkPathPriv::ForceComputeConvexity(*path);
3607 REPORTER_ASSERT(reporter, path->isConvex());
3608 path->reset();
3611 static void test_rrect_convexity_is_unknown(skiatest::Reporter* reporter, SkPath* path,
3613 REPORTER_ASSERT(reporter, path->isConvex());
3615 SkPathPriv::ComputeFirstDirection(*path) == SkPathPriv::AsFirstDirection(dir));
3616 SkPathPriv::ForceComputeConvexity(*path);
3617 REPORTER_ASSERT(reporter, !path->isConvex());
3618 path->reset();
3673 // the path isn't "empty" in that it should have verbs and points.
3744 const SkPath& path) {
3748 bool isOval = SkPathPriv::IsOval(path, &r, &d, &s);
3752 REPORTER_ASSERT(reporter, path == recreatedPath);
3761 SkPath path;
3762 path.addArc(oval, start, sweep);
3766 check_oval_arc(reporter, start, sweep, path);
3768 REPORTER_ASSERT(reporter, !path.isOval(nullptr));
3774 SkPath path;
3775 path.addArc(oval, start + delta, sweep);
3776 check_oval_arc(reporter, start, sweep, path);
4319 static void compare_dump(skiatest::Reporter* reporter, const SkPath& path, bool dumpAsHex,
4322 path.dump(&wStream, dumpAsHex);
4334 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kWinding);\n");
4337 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kWinding);\n"
4338 "path.moveTo(1, 2);\n"
4339 "path.lineTo(3, 4);\n");
4344 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kEvenOdd);\n"
4345 "path.moveTo(1, 2);\n"
4346 "path.quadTo(3, 4, 5, 6);\n");
4351 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kInverseWinding);\n"
4352 "path.moveTo(1, 2);\n"
4353 "path.conicTo(3, 4, 5, 6, 0.5f);\n");
4358 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kInverseEvenOdd);\n"
4359 "path.moveTo(1, 2);\n"
4360 "path.cubicTo(3, 4, 5, 6, 7, 8);\n");
4366 "path.setFillType(SkPathFillType::kWinding);\n"
4367 "path.moveTo(SkBits2Float(0x3f800000), SkBits2Float(0x40000000)); // 1, 2\n"
4368 "path.lineTo(SkBits2Float(0x40400000), SkBits2Float(0x40800000)); // 3, 4\n");
4372 compare_dump(reporter, p, false, "path.setFillType(SkPathFillType::kWinding);\n"
4373 "path.moveTo(1, 2);\n"
4374 "path.lineTo(3, 4);\n");
4393 static size_t GetFreeSpace(const SkPath& path) {
4394 return PathRefTest_Private::GetFreeSpace(*path.fPathRef);
4473 SkPath path;
4474 path.moveTo(0, 0);
4475 path.cubicTo(SkBits2Float(0xcdcdcd00), SkBits2Float(0xcdcdcdcd),
4479 path.lineTo(0, 0);
4480 test_draw_AA_path(100, 100, path);
4484 SkPath path;
4485 path.moveTo(SkBits2Float(0x4109999a), SkBits2Float(0x411c0000)); // 8.6f, 9.75f
4486 path.lineTo(SkBits2Float(0x410a6666), SkBits2Float(0x411c0000)); // 8.65f, 9.75f
4487 path.lineTo(SkBits2Float(0x410a6666), SkBits2Float(0x411e6666)); // 8.65f, 9.9f
4488 path.lineTo(SkBits2Float(0x4109999a), SkBits2Float(0x411e6666)); // 8.6f, 9.9f
4489 path.lineTo(SkBits2Float(0x4109999a), SkBits2Float(0x411c0000)); // 8.6f, 9.75f
4490 path.close();
4495 surface->getCanvas()->clipPath(path, true);
4504 SkPath path;
4505 path.moveTo(SkBits2Float(0x4325e666), SkBits2Float(0x42a1999a)); // 165.9f, 80.8f
4506 path.lineTo(SkBits2Float(0x4325e666), SkBits2Float(0x42a2999a)); // 165.9f, 81.3f
4507 path.lineTo(SkBits2Float(0x4325b333), SkBits2Float(0x42a2999a)); // 165.7f, 81.3f
4508 path.lineTo(SkBits2Float(0x4325b333), SkBits2Float(0x42a16666)); // 165.7f, 80.7f
4509 path.lineTo(SkBits2Float(0x4325b333), SkBits2Float(0x429f6666)); // 165.7f, 79.7f
4511 path.cubicTo(SkBits2Float(0x4325b333), SkBits2Float(0x429f6666), SkBits2Float(0x4325cccc),
4514 path.cubicTo(SkBits2Float(0x4325cccc), SkBits2Float(0x429f6666), SkBits2Float(0x4325cccc),
4516 path.lineTo(SkBits2Float(0x4325e666), SkBits2Float(0x42a1999a)); // 165.9f, 80.8f
4517 path.close();
4518 canvas->clipPath(path, true);
4523 SkPath path;
4524 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
4525 path.lineTo(SkBits2Float(0xd5394437), SkBits2Float(0x37373737)); // -1.2731e+13f, 1.09205e-05f
4526 path.lineTo(SkBits2Float(0x37373737), SkBits2Float(0x37373737)); // 1.09205e-05f, 1.09205e-05f
4527 path.lineTo(SkBits2Float(0x37373745), SkBits2Float(0x0001b800)); // 1.09205e-05f, 1.57842e-40f
4528 path.close();
4529 test_draw_AA_path(100, 100, path);
4533 SkPath path;
4554 path.moveTo(points[pointIndex++]);
4557 path.lineTo(points[pointIndex++]);
4561 path.close();
4565 test_draw_AA_path(250, 125, path);
4569 SkPath path;
4570 path.setFillType(SkPathFillType::kWinding);
4571 path.moveTo(SkBits2Float(0x4388c000), SkBits2Float(0x43947c08)); // 273.5f, 296.969f
4572 path.lineTo(SkBits2Float(0x4386c000), SkBits2Float(0x43947c08)); // 269.5f, 296.969f
4574 path.cubicTo(SkBits2Float(0x4386a604), SkBits2Float(0x43921604),
4577 path.close();
4578 test_draw_AA_path(500, 500, path);
4582 SkPath path;
4583 path.moveTo(10, 10);
4584 path.cubicTo(10, 20, 10, 30, 30, 30);
4585 path.lineTo(50, 20);
4586 path.lineTo(50, 10);
4587 path.close();
4588 test_draw_AA_path(100, 100, path);
4593 SkPath path;
4594 path.setFillType(SkPathFillType::kWinding);
4595 path.moveTo(SkBits2Float(0x7f07a5af), SkBits2Float(0xff07ff1d)); // 1.80306e+38f, -1.8077e+38f
4596 path.lineTo(SkBits2Float(0x7edf4b2d), SkBits2Float(0xfedffe0a)); // 1.48404e+38f, -1.48868e+38f
4597 path.lineTo(SkBits2Float(0x7edf4585), SkBits2Float(0xfee003b2)); // 1.48389e+38f, -1.48883e+38f
4598 path.lineTo(SkBits2Float(0x7ef348e9), SkBits2Float(0xfef403c6)); // 1.6169e+38f, -1.62176e+38f
4599 path.lineTo(SkBits2Float(0x7ef74c4e), SkBits2Float(0xfef803cb)); // 1.64358e+38f, -1.64834e+38f
4600 path.conicTo(SkBits2Float(0x7ef74f23), SkBits2Float(0xfef8069e), SkBits2Float(0x7ef751f6), SkBits2Float(0xfef803c9), SkBits2Float(0x3f3504f3)); // 1.64365e+38f, -1.64841e+38f, 1.64372e+38f, -1.64834e+38f, 0.707107f
4601 path.conicTo(SkBits2Float(0x7ef754c8), SkBits2Float(0xfef800f5), SkBits2Float(0x7ef751f5), SkBits2Float(0xfef7fe22), SkBits2Float(0x3f353472)); // 1.6438e+38f, -1.64827e+38f, 1.64372e+38f, -1.64819e+38f, 0.707832f
4602 path.lineTo(SkBits2Float(0x7edb57a9), SkBits2Float(0xfedbfe06)); // 1.45778e+38f, -1.4621e+38f
4603 path.lineTo(SkBits2Float(0x7e875976), SkBits2Float(0xfe87fdb3)); // 8.99551e+37f, -9.03815e+37f
4604 path.lineTo(SkBits2Float(0x7ded5c2b), SkBits2Float(0xfdeff59e)); // 3.94382e+37f, -3.98701e+37f
4605 path.lineTo(SkBits2Float(0x7d7a78a7), SkBits2Float(0xfd7fda0f)); // 2.08083e+37f, -2.12553e+37f
4606 path.lineTo(SkBits2Float(0x7d7a6403), SkBits2Float(0xfd7fe461)); // 2.08016e+37f, -2.12587e+37f
4607 path.conicTo(SkBits2Float(0x7d7a4764), SkBits2Float(0xfd7ff2b0), SkBits2Float(0x7d7a55b4), SkBits2Float(0xfd8007a8), SkBits2Float(0x3f3504f3)); // 2.07924e+37f, -2.12633e+37f, 2.0797e+37f, -2.12726e+37f, 0.707107f
4608 path.conicTo(SkBits2Float(0x7d7a5803), SkBits2Float(0xfd8009f7), SkBits2Float(0x7d7a5ba9), SkBits2Float(0xfd800bcc), SkBits2Float(0x3f7cba66)); // 2.07977e+37f, -2.12741e+37f, 2.07989e+37f, -2.12753e+37f, 0.987219f
4609 path.lineTo(SkBits2Float(0x7d8d2067), SkBits2Float(0xfd900bdb)); // 2.34487e+37f, -2.39338e+37f
4610 path.lineTo(SkBits2Float(0x7ddd137a), SkBits2Float(0xfde00c2d)); // 3.67326e+37f, -3.72263e+37f
4611 path.lineTo(SkBits2Float(0x7ddd2a1b), SkBits2Float(0xfddff58e)); // 3.67473e+37f, -3.72116e+37f
4612 path.lineTo(SkBits2Float(0x7c694ae5), SkBits2Float(0xfc7fa67c)); // 4.8453e+36f, -5.30965e+36f
4613 path.lineTo(SkBits2Float(0xfc164a8b), SkBits2Float(0x7c005af5)); // -3.12143e+36f, 2.66584e+36f
4614 path.lineTo(SkBits2Float(0xfc8ae983), SkBits2Float(0x7c802da7)); // -5.77019e+36f, 5.32432e+36f
4615 path.lineTo(SkBits2Float(0xfc8b16d9), SkBits2Float(0x7c80007b)); // -5.77754e+36f, 5.31699e+36f
4616 path.lineTo(SkBits2Float(0xfc8b029c), SkBits2Float(0x7c7f8788)); // -5.77426e+36f, 5.30714e+36f
4617 path.lineTo(SkBits2Float(0xfc8b0290), SkBits2Float(0x7c7f8790)); // -5.77425e+36f, 5.30714e+36f
4618 path.lineTo(SkBits2Float(0xfc8b16cd), SkBits2Float(0x7c80007f)); // -5.77753e+36f, 5.31699e+36f
4619 path.lineTo(SkBits2Float(0xfc8b4409), SkBits2Float(0x7c7fa672)); // -5.78487e+36f, 5.30965e+36f
4620 path.lineTo(SkBits2Float(0x7d7aa2ba), SkBits2Float(0xfd800bd1)); // 2.0822e+37f, -2.12753e+37f
4621 path.lineTo(SkBits2Float(0x7e8757ee), SkBits2Float(0xfe88035b)); // 8.99512e+37f, -9.03962e+37f
4622 path.lineTo(SkBits2Float(0x7ef7552d), SkBits2Float(0xfef803ca)); // 1.64381e+38f, -1.64834e+38f
4623 path.lineTo(SkBits2Float(0x7f0fa653), SkBits2Float(0xff1001f9)); // 1.90943e+38f, -1.91419e+38f
4624 path.lineTo(SkBits2Float(0x7f0fa926), SkBits2Float(0xff0fff24)); // 1.90958e+38f, -1.91404e+38f
4625 path.lineTo(SkBits2Float(0x7f0da75c), SkBits2Float(0xff0dff22)); // 1.8829e+38f, -1.88746e+38f
4626 path.lineTo(SkBits2Float(0x7f07a5af), SkBits2Float(0xff07ff1d)); // 1.80306e+38f, -1.8077e+38f
4627 path.close();
4628 path.moveTo(SkBits2Float(0x7f07a2db), SkBits2Float(0xff0801f1)); // 1.80291e+38f, -1.80785e+38f
4629 path.lineTo(SkBits2Float(0x7f0da48a), SkBits2Float(0xff0e01f8)); // 1.88275e+38f, -1.88761e+38f
4630 path.lineTo(SkBits2Float(0x7f0fa654), SkBits2Float(0xff1001fa)); // 1.90943e+38f, -1.91419e+38f
4631 path.lineTo(SkBits2Float(0x7f0fa7bd), SkBits2Float(0xff10008f)); // 1.90951e+38f, -1.91412e+38f
4632 path.lineTo(SkBits2Float(0x7f0fa927), SkBits2Float(0xff0fff25)); // 1.90958e+38f, -1.91404e+38f
4633 path.lineTo(SkBits2Float(0x7ef75ad5), SkBits2Float(0xfef7fe22)); // 1.64395e+38f, -1.64819e+38f
4634 path.lineTo(SkBits2Float(0x7e875d96), SkBits2Float(0xfe87fdb3)); // 8.99659e+37f, -9.03815e+37f
4635 path.lineTo(SkBits2Float(0x7d7acff6), SkBits2Float(0xfd7fea5b)); // 2.08367e+37f, -2.12606e+37f
4636 path.lineTo(SkBits2Float(0xfc8b0588), SkBits2Float(0x7c8049b7)); // -5.77473e+36f, 5.32887e+36f
4637 path.lineTo(SkBits2Float(0xfc8b2b16), SkBits2Float(0x7c803d32)); // -5.78083e+36f, 5.32684e+36f
4638 path.conicTo(SkBits2Float(0xfc8b395c), SkBits2Float(0x7c803870), SkBits2Float(0xfc8b4405), SkBits2Float(0x7c802dd1), SkBits2Float(0x3f79349d)); // -5.78314e+36f, 5.32607e+36f, -5.78487e+36f, 5.32435e+36f, 0.973459f
4639 path.conicTo(SkBits2Float(0xfc8b715b), SkBits2Float(0x7c8000a5), SkBits2Float(0xfc8b442f), SkBits2Float(0x7c7fa69e), SkBits2Float(0x3f3504f3)); // -5.79223e+36f, 5.31702e+36f, -5.7849e+36f, 5.30966e+36f, 0.707107f
4640 path.lineTo(SkBits2Float(0xfc16ffaa), SkBits2Float(0x7bff4c12)); // -3.13612e+36f, 2.65116e+36f
4641 path.lineTo(SkBits2Float(0x7c6895e0), SkBits2Float(0xfc802dc0)); // 4.83061e+36f, -5.32434e+36f
4642 path.lineTo(SkBits2Float(0x7ddd137b), SkBits2Float(0xfde00c2e)); // 3.67326e+37f, -3.72263e+37f
4643 path.lineTo(SkBits2Float(0x7ddd1ecb), SkBits2Float(0xfde000de)); // 3.67399e+37f, -3.72189e+37f
4644 path.lineTo(SkBits2Float(0x7ddd2a1c), SkBits2Float(0xfddff58f)); // 3.67473e+37f, -3.72116e+37f
4645 path.lineTo(SkBits2Float(0x7d8d3711), SkBits2Float(0xfd8ff543)); // 2.34634e+37f, -2.39191e+37f
4646 path.lineTo(SkBits2Float(0x7d7a88fe), SkBits2Float(0xfd7fea69)); // 2.08136e+37f, -2.12606e+37f
4647 path.lineTo(SkBits2Float(0x7d7a7254), SkBits2Float(0xfd800080)); // 2.08063e+37f, -2.1268e+37f
4648 path.lineTo(SkBits2Float(0x7d7a80a4), SkBits2Float(0xfd800ed0)); // 2.08109e+37f, -2.12773e+37f
4649 path.lineTo(SkBits2Float(0x7d7a80a8), SkBits2Float(0xfd800ecf)); // 2.08109e+37f, -2.12773e+37f
4650 path.lineTo(SkBits2Float(0x7d7a7258), SkBits2Float(0xfd80007f)); // 2.08063e+37f, -2.1268e+37f
4651 path.lineTo(SkBits2Float(0x7d7a5bb9), SkBits2Float(0xfd800bd0)); // 2.0799e+37f, -2.12753e+37f
4652 path.lineTo(SkBits2Float(0x7ded458b), SkBits2Float(0xfdf00c3e)); // 3.94235e+37f, -3.98848e+37f
4653 path.lineTo(SkBits2Float(0x7e8753ce), SkBits2Float(0xfe88035b)); // 8.99405e+37f, -9.03962e+37f
4654 path.lineTo(SkBits2Float(0x7edb5201), SkBits2Float(0xfedc03ae)); // 1.45763e+38f, -1.46225e+38f
4655 path.lineTo(SkBits2Float(0x7ef74c4d), SkBits2Float(0xfef803ca)); // 1.64358e+38f, -1.64834e+38f
4656 path.lineTo(SkBits2Float(0x7ef74f21), SkBits2Float(0xfef800f6)); // 1.64365e+38f, -1.64827e+38f
4657 path.lineTo(SkBits2Float(0x7ef751f4), SkBits2Float(0xfef7fe21)); // 1.64372e+38f, -1.64819e+38f
4658 path.lineTo(SkBits2Float(0x7ef34e91), SkBits2Float(0xfef3fe1e)); // 1.61705e+38f, -1.62161e+38f
4659 path.lineTo(SkBits2Float(0x7edf4b2d), SkBits2Float(0xfedffe0a)); // 1.48404e+38f, -1.48868e+38f
4660 path.lineTo(SkBits2Float(0x7edf4859), SkBits2Float(0xfee000de)); // 1.48397e+38f, -1.48876e+38f
4661 path.lineTo(SkBits2Float(0x7edf4585), SkBits2Float(0xfee003b2)); // 1.48389e+38f, -1.48883e+38f
4662 path.lineTo(SkBits2Float(0x7f07a2db), SkBits2Float(0xff0801f1)); // 1.80291e+38f, -1.80785e+38f
4663 path.close();
4664 path.moveTo(SkBits2Float(0xfab120db), SkBits2Float(0x77b50b4f)); // -4.59851e+35f, 7.34402e+33f
4665 path.lineTo(SkBits2Float(0xfd6597e5), SkBits2Float(0x7d60177f)); // -1.90739e+37f, 1.86168e+37f
4666 path.lineTo(SkBits2Float(0xfde2cea1), SkBits2Float(0x7de00c2e)); // -3.76848e+37f, 3.72263e+37f
4667 path.lineTo(SkBits2Float(0xfe316511), SkBits2Float(0x7e300657)); // -5.89495e+37f, 5.84943e+37f
4668 path.lineTo(SkBits2Float(0xfe415da1), SkBits2Float(0x7e400666)); // -6.42568e+37f, 6.38112e+37f
4669 path.lineTo(SkBits2Float(0xfe41634a), SkBits2Float(0x7e4000be)); // -6.42641e+37f, 6.38039e+37f
4670 path.lineTo(SkBits2Float(0xfe41634a), SkBits2Float(0x7e3ff8be)); // -6.42641e+37f, 6.37935e+37f
4671 path.lineTo(SkBits2Float(0xfe416349), SkBits2Float(0x7e3ff8be)); // -6.42641e+37f, 6.37935e+37f
4672 path.lineTo(SkBits2Float(0xfe415f69), SkBits2Float(0x7e3ff8be)); // -6.42591e+37f, 6.37935e+37f
4673 path.lineTo(SkBits2Float(0xfe415bc9), SkBits2Float(0x7e3ff8be)); // -6.42544e+37f, 6.37935e+37f
4674 path.lineTo(SkBits2Float(0xfe415bc9), SkBits2Float(0x7e4000be)); // -6.42544e+37f, 6.38039e+37f
4675 path.lineTo(SkBits2Float(0xfe416171), SkBits2Float(0x7e3ffb16)); // -6.42617e+37f, 6.37966e+37f
4676 path.lineTo(SkBits2Float(0xfe016131), SkBits2Float(0x7dfff5ae)); // -4.29938e+37f, 4.25286e+37f
4677 path.lineTo(SkBits2Float(0xfe0155e2), SkBits2Float(0x7e000628)); // -4.29791e+37f, 4.25433e+37f
4678 path.lineTo(SkBits2Float(0xfe0958ea), SkBits2Float(0x7e080630)); // -4.56415e+37f, 4.52018e+37f
4679 path.lineTo(SkBits2Float(0xfe115c92), SkBits2Float(0x7e100638)); // -4.83047e+37f, 4.78603e+37f
4680 path.conicTo(SkBits2Float(0xfe11623c), SkBits2Float(0x7e100bdf), SkBits2Float(0xfe1167e2), SkBits2Float(0x7e100636), SkBits2Float(0x3f3504f3)); // -4.8312e+37f, 4.78676e+37f, -4.83194e+37f, 4.78603e+37f, 0.707107f
4681 path.conicTo(SkBits2Float(0xfe116d87), SkBits2Float(0x7e10008e), SkBits2Float(0xfe1167e2), SkBits2Float(0x7e0ffae8), SkBits2Float(0x3f35240a)); // -4.83267e+37f, 4.78529e+37f, -4.83194e+37f, 4.78456e+37f, 0.707581f
4682 path.lineTo(SkBits2Float(0xfe016b92), SkBits2Float(0x7dfff5af)); // -4.30072e+37f, 4.25286e+37f
4683 path.lineTo(SkBits2Float(0xfdc2d963), SkBits2Float(0x7dbff56e)); // -3.23749e+37f, 3.18946e+37f
4684 path.lineTo(SkBits2Float(0xfd65ae25), SkBits2Float(0x7d5fea3d)); // -1.90811e+37f, 1.86021e+37f
4685 path.lineTo(SkBits2Float(0xfab448de), SkBits2Float(0xf7b50a19)); // -4.68046e+35f, -7.34383e+33f
4686 path.lineTo(SkBits2Float(0xfab174d9), SkBits2Float(0x43480000)); // -4.60703e+35f, 200
4687 path.lineTo(SkBits2Float(0xfab174d9), SkBits2Float(0x7800007f)); // -4.60703e+35f, 1.03848e+34f
4688 path.lineTo(SkBits2Float(0xfab3f4db), SkBits2Float(0x7800007f)); // -4.67194e+35f, 1.03848e+34f
4689 path.lineTo(SkBits2Float(0xfab3f4db), SkBits2Float(0x43480000)); // -4.67194e+35f, 200
4690 path.lineTo(SkBits2Float(0xfab120db), SkBits2Float(0x77b50b4f)); // -4.59851e+35f, 7.34402e+33f
4691 path.close();
4692 path.moveTo(SkBits2Float(0xfab59cf2), SkBits2Float(0xf800007e)); // -4.71494e+35f, -1.03847e+34f
4693 path.lineTo(SkBits2Float(0xfaa7cc52), SkBits2Float(0xf800007f)); // -4.35629e+35f, -1.03848e+34f
4694 path.lineTo(SkBits2Float(0xfd6580e5), SkBits2Float(0x7d60177f)); // -1.90664e+37f, 1.86168e+37f
4695 path.lineTo(SkBits2Float(0xfdc2c2c1), SkBits2Float(0x7dc00c0f)); // -3.23602e+37f, 3.19093e+37f
4696 path.lineTo(SkBits2Float(0xfe016040), SkBits2Float(0x7e000626)); // -4.29925e+37f, 4.25433e+37f
4697 path.lineTo(SkBits2Float(0xfe115c90), SkBits2Float(0x7e100636)); // -4.83047e+37f, 4.78603e+37f
4698 path.lineTo(SkBits2Float(0xfe116239), SkBits2Float(0x7e10008f)); // -4.8312e+37f, 4.78529e+37f
4699 path.lineTo(SkBits2Float(0xfe1167e0), SkBits2Float(0x7e0ffae6)); // -4.83194e+37f, 4.78456e+37f
4700 path.lineTo(SkBits2Float(0xfe096438), SkBits2Float(0x7e07fade)); // -4.56562e+37f, 4.51871e+37f
4701 path.lineTo(SkBits2Float(0xfe016130), SkBits2Float(0x7dfff5ac)); // -4.29938e+37f, 4.25286e+37f
4702 path.lineTo(SkBits2Float(0xfe015b89), SkBits2Float(0x7e00007f)); // -4.29864e+37f, 4.25359e+37f
4703 path.lineTo(SkBits2Float(0xfe0155e1), SkBits2Float(0x7e000627)); // -4.29791e+37f, 4.25433e+37f
4704 path.lineTo(SkBits2Float(0xfe415879), SkBits2Float(0x7e4008bf)); // -6.42501e+37f, 6.38143e+37f
4705 path.lineTo(SkBits2Float(0xfe415f69), SkBits2Float(0x7e4008bf)); // -6.42591e+37f, 6.38143e+37f
4706 path.lineTo(SkBits2Float(0xfe416349), SkBits2Float(0x7e4008bf)); // -6.42641e+37f, 6.38143e+37f
4707 path.lineTo(SkBits2Float(0xfe41634a), SkBits2Float(0x7e4008bf)); // -6.42641e+37f, 6.38143e+37f
4708 path.conicTo(SkBits2Float(0xfe416699), SkBits2Float(0x7e4008bf), SkBits2Float(0xfe4168f1), SkBits2Float(0x7e400668), SkBits2Float(0x3f6c8ed9)); // -6.42684e+37f, 6.38143e+37f, -6.42715e+37f, 6.38113e+37f, 0.924055f
4709 path.conicTo(SkBits2Float(0xfe416e9a), SkBits2Float(0x7e4000c2), SkBits2Float(0xfe4168f3), SkBits2Float(0x7e3ffb17), SkBits2Float(0x3f3504f3)); // -6.42788e+37f, 6.38039e+37f, -6.42715e+37f, 6.37966e+37f, 0.707107f
4710 path.lineTo(SkBits2Float(0xfe317061), SkBits2Float(0x7e2ffb07)); // -5.89642e+37f, 5.84796e+37f
4711 path.lineTo(SkBits2Float(0xfde2e542), SkBits2Float(0x7ddff58e)); // -3.76995e+37f, 3.72116e+37f
4712 path.lineTo(SkBits2Float(0xfd65c525), SkBits2Float(0x7d5fea3d)); // -1.90886e+37f, 1.86021e+37f
4713 path.lineTo(SkBits2Float(0xfab6c8db), SkBits2Float(0xf7b50b4f)); // -4.74536e+35f, -7.34402e+33f
4714 path.lineTo(SkBits2Float(0xfab59cf2), SkBits2Float(0xf800007e)); // -4.71494e+35f, -1.03847e+34f
4715 path.close();
4716 path.moveTo(SkBits2Float(0xfab3f4db), SkBits2Float(0x43480000)); // -4.67194e+35f, 200
4717 path.lineTo(SkBits2Float(0xfab174d9), SkBits2Float(0x43480000)); // -4.60703e+35f, 200
4718 path.quadTo(SkBits2Float(0xfd0593a5), SkBits2Float(0x7d00007f), SkBits2Float(0xfd659785), SkBits2Float(0x7d6000de)); // -1.10971e+37f, 1.0634e+37f, -1.90737e+37f, 1.86095e+37f
4719 path.quadTo(SkBits2Float(0xfda2cdf2), SkBits2Float(0x7da0009f), SkBits2Float(0xfdc2ce12), SkBits2Float(0x7dc000be)); // -2.70505e+37f, 2.6585e+37f, -3.23675e+37f, 3.1902e+37f
4720 path.quadTo(SkBits2Float(0xfde2ce31), SkBits2Float(0x7de000de), SkBits2Float(0xfe0165e9), SkBits2Float(0x7e00007f)); // -3.76845e+37f, 3.72189e+37f, -4.29999e+37f, 4.25359e+37f
4721 path.quadTo(SkBits2Float(0xfe1164b9), SkBits2Float(0x7e10008f), SkBits2Float(0xfe116239), SkBits2Float(0x7e10008f)); // -4.83153e+37f, 4.78529e+37f, -4.8312e+37f, 4.78529e+37f
4722 path.quadTo(SkBits2Float(0xfe116039), SkBits2Float(0x7e10008f), SkBits2Float(0xfe095e91), SkBits2Float(0x7e080087)); // -4.83094e+37f, 4.78529e+37f, -4.56488e+37f, 4.51944e+37f
4723 path.quadTo(SkBits2Float(0xfe015d09), SkBits2Float(0x7e00007f), SkBits2Float(0xfe015b89), SkBits2Float(0x7e00007f)); // -4.29884e+37f, 4.25359e+37f, -4.29864e+37f, 4.25359e+37f
4724 path.lineTo(SkBits2Float(0xfe415bc9), SkBits2Float(0x7e4000be)); // -6.42544e+37f, 6.38039e+37f
4725 path.quadTo(SkBits2Float(0xfe415da9), SkBits2Float(0x7e4000be), SkBits2Float(0xfe415f69), SkBits2Float(0x7e4000be)); // -6.42568e+37f, 6.38039e+37f, -6.42591e+37f, 6.38039e+37f
4726 path.quadTo(SkBits2Float(0xfe416149), SkBits2Float(0x7e4000be), SkBits2Float(0xfe416349), SkBits2Float(0x7e4000be)); // -6.42615e+37f, 6.38039e+37f, -6.42641e+37f, 6.38039e+37f
4727 path.quadTo(SkBits2Float(0xfe416849), SkBits2Float(0x7e4000be), SkBits2Float(0xfe316ab9), SkBits2Float(0x7e3000af)); // -6.42706e+37f, 6.38039e+37f, -5.89569e+37f, 5.84869e+37f
4728 path.quadTo(SkBits2Float(0xfe216d29), SkBits2Float(0x7e20009f), SkBits2Float(0xfde2d9f2), SkBits2Float(0x7de000de)); // -5.36431e+37f, 5.31699e+37f, -3.76921e+37f, 3.72189e+37f
4729 path.quadTo(SkBits2Float(0xfda2d9b2), SkBits2Float(0x7da0009f), SkBits2Float(0xfd65ae85), SkBits2Float(0x7d6000de)); // -2.70582e+37f, 2.6585e+37f, -1.90812e+37f, 1.86095e+37f
4730 path.quadTo(SkBits2Float(0xfd05a9a6), SkBits2Float(0x7d00007f), SkBits2Float(0xfab3f4db), SkBits2Float(0x43480000)); // -1.11043e+37f, 1.0634e+37f, -4.67194e+35f, 200
4731 path.close();
4732 path.moveTo(SkBits2Float(0x7f07a445), SkBits2Float(0xff080087)); // 1.80299e+38f, -1.80778e+38f
4733 path.quadTo(SkBits2Float(0x7f0ba519), SkBits2Float(0xff0c008b), SkBits2Float(0x7f0da5f3), SkBits2Float(0xff0e008d)); // 1.8562e+38f, -1.86095e+38f, 1.88283e+38f, -1.88753e+38f
4734 path.quadTo(SkBits2Float(0x7f0fa6d5), SkBits2Float(0xff10008f), SkBits2Float(0x7f0fa7bd), SkBits2Float(0xff10008f)); // 1.90946e+38f, -1.91412e+38f, 1.90951e+38f, -1.91412e+38f
4735 path.quadTo(SkBits2Float(0x7f0faa7d), SkBits2Float(0xff10008f), SkBits2Float(0x7ef75801), SkBits2Float(0xfef800f6)); // 1.90965e+38f, -1.91412e+38f, 1.64388e+38f, -1.64827e+38f
4736 path.quadTo(SkBits2Float(0x7ecf5b09), SkBits2Float(0xfed000ce), SkBits2Float(0x7e875ac2), SkBits2Float(0xfe880087)); // 1.37811e+38f, -1.38242e+38f, 8.99585e+37f, -9.03889e+37f
4737 path.quadTo(SkBits2Float(0x7e0eb505), SkBits2Float(0xfe10008f), SkBits2Float(0x7d7ab958), SkBits2Float(0xfd80007f)); // 4.74226e+37f, -4.78529e+37f, 2.08293e+37f, -2.1268e+37f
4738 path.quadTo(SkBits2Float(0xfc8ac1cd), SkBits2Float(0x7c80007f), SkBits2Float(0xfc8b16cd), SkBits2Float(0x7c80007f)); // -5.76374e+36f, 5.31699e+36f, -5.77753e+36f, 5.31699e+36f
4739 path.quadTo(SkBits2Float(0xfc8b36cd), SkBits2Float(0x7c80007f), SkBits2Float(0xfc16a51a), SkBits2Float(0x7c00007f)); // -5.78273e+36f, 5.31699e+36f, -3.12877e+36f, 2.6585e+36f
4740 path.quadTo(SkBits2Float(0xfab6e4de), SkBits2Float(0x43480000), SkBits2Float(0x7c68f062), SkBits2Float(0xfc80007f)); // -4.7482e+35f, 200, 4.83795e+36f, -5.31699e+36f
4741 path.lineTo(SkBits2Float(0x7ddd1ecb), SkBits2Float(0xfde000de)); // 3.67399e+37f, -3.72189e+37f
4742 path.quadTo(SkBits2Float(0x7d9d254b), SkBits2Float(0xfda0009f), SkBits2Float(0x7d8d2bbc), SkBits2Float(0xfd90008f)); // 2.61103e+37f, -2.6585e+37f, 2.3456e+37f, -2.39265e+37f
4743 path.quadTo(SkBits2Float(0x7d7a64d8), SkBits2Float(0xfd80007f), SkBits2Float(0x7d7a7258), SkBits2Float(0xfd80007f)); // 2.08019e+37f, -2.1268e+37f, 2.08063e+37f, -2.1268e+37f
4744 path.quadTo(SkBits2Float(0x7d7a9058), SkBits2Float(0xfd80007f), SkBits2Float(0x7ded50db), SkBits2Float(0xfdf000ee)); // 2.0816e+37f, -2.1268e+37f, 3.94309e+37f, -3.98774e+37f
4745 path.quadTo(SkBits2Float(0x7e2eace5), SkBits2Float(0xfe3000af), SkBits2Float(0x7e8756a2), SkBits2Float(0xfe880087)); // 5.80458e+37f, -5.84869e+37f, 8.99478e+37f, -9.03889e+37f
4746 path.quadTo(SkBits2Float(0x7ebf56d9), SkBits2Float(0xfec000be), SkBits2Float(0x7edb54d5), SkBits2Float(0xfedc00da)); // 1.27167e+38f, -1.27608e+38f, 1.45771e+38f, -1.46217e+38f
4747 path.quadTo(SkBits2Float(0x7ef752e1), SkBits2Float(0xfef800f6), SkBits2Float(0x7ef74f21), SkBits2Float(0xfef800f6)); // 1.64375e+38f, -1.64827e+38f, 1.64365e+38f, -1.64827e+38f
4748 path.quadTo(SkBits2Float(0x7ef74d71), SkBits2Float(0xfef800f6), SkBits2Float(0x7ef34bbd), SkBits2Float(0xfef400f2)); // 1.64361e+38f, -1.64827e+38f, 1.61698e+38f, -1.62168e+38f
4749 path.quadTo(SkBits2Float(0x7eef4a19), SkBits2Float(0xfef000ee), SkBits2Float(0x7edf4859), SkBits2Float(0xfee000de)); // 1.59035e+38f, -1.5951e+38f, 1.48397e+38f, -1.48876e+38f
4750 path.lineTo(SkBits2Float(0x7f07a445), SkBits2Float(0xff080087)); // 1.80299e+38f, -1.80778e+38f
4751 path.close();
4752 SkSurface::MakeRasterN32Premul(250, 250, nullptr)->getCanvas()->drawPath(path, paint);
4800 SkPath path;
4801 path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000)); // 0, 0
4802 path.moveTo(SkBits2Float(0x44000000), SkBits2Float(0x373938b8)); // 512, 1.10401e-05f
4803 path.cubicTo(SkBits2Float(0x00000001), SkBits2Float(0xdf000052), SkBits2Float(0x00000100), SkBits2Float(0x00000000), SkBits2Float(0x00000100), SkBits2Float(0x00000000)); // 1.4013e-45f, -9.22346e+18f, 3.58732e-43f, 0, 3.58732e-43f, 0
4804 path.moveTo(0, 512);
4807 SkSurface::MakeRasterN32Premul(255, 255, nullptr)->getCanvas()->drawPath(path, SkPaint());
4840 // this triggers a code path in SkPath::operator= which is otherwise unexercised
4844 // this triggers a code path in SkPath::swap which is otherwise unexercised
4908 // path has a trailing moveTo. Please see crbug.com\445368)
4991 SkPath path;
4993 path.moveTo(SkBits2Float(0x44000000), SkBits2Float(0x373938b8)); // 512, 1.10401e-05f
4995 path.cubicTo(SkBits2Float(0x00000001), SkBits2Float(0xdf000052),
4998 path.moveTo(0, 0);
5001 path.conservativelyContainsRect({ -211747, 12.1115f, -197893, 25.0321f });
5006 static void rand_path(SkPath* path, SkRandom& rand, SkPath::Verb verb, int n) {
5010 path->lineTo(rand.nextF()*100, rand.nextF()*100);
5013 path->quadTo(rand.nextF()*100, rand.nextF()*100,
5017 path->conicTo(rand.nextF()*100, rand.nextF()*100,
5021 path->cubicTo(rand.nextF()*100, rand.nextF()*100,
5041 SkPath path;
5042 rand_path(&path, rand, verb, n);
5043 SkRect bounds = path.getBounds();
5044 SkRect tight = path.computeTightBounds();
5048 TightBounds(path, &tight2);
5078 SkPath path;
5083 for (size_t i = 0; i < numMoves; ++i) path.moveTo(1, 2);
5084 for (size_t i = 0; i < numConics; ++i) path.conicTo(1, 2, 3, 4, 5);
5085 REPORTER_ASSERT(reporter, path.countPoints() == numPoints);
5086 REPORTER_ASSERT(reporter, path.countVerbs() == numVerbs);
5088 // Verify that path serializes/deserializes properly.
5089 sk_sp<SkData> data = path.serialize();
5094 REPORTER_ASSERT(reporter, readBack != path);
5097 REPORTER_ASSERT(reporter, readBack == path);
5110 SkPath path;
5111 path.moveTo(SK_ScalarInfinity, SK_ScalarInfinity);
5112 SkPathPriv::Iterate iterate(path);
5195 SkPath path;
5196 path.moveTo(p0);
5197 path.lineTo(p1);
5198 path.setFillType(ft);
5200 canvas->clipPath(path, aa);
5201 REPORTER_ASSERT(reporter, canvas->isClipEmpty() == !path.isInverseFillType());
5213 SkPath path;
5215 index < 2 ? path.moveTo(points[index]) : path.lineTo(points[index]);
5218 path.close();
5220 return path;
5223 SkPath path;
5227 path.moveTo(*points++);
5230 path.lineTo(*points++);
5233 path.close();
5239 return path;
5244 SkPath path = makePath(points, SK_ARRAY_COUNT(points), false);
5245 REPORTER_ASSERT(reporter, path.isRect(&rect));
5251 path = makePath(points3, SK_ARRAY_COUNT(points3), true);
5252 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5255 path = makePath(points9, SK_ARRAY_COUNT(points9), true);
5256 REPORTER_ASSERT(reporter, path.isRect(&rect));
5263 path = makePath2(points11, verbs11, SK_ARRAY_COUNT(verbs11));
5264 REPORTER_ASSERT(reporter, path.isRect(&rect));
5274 path = makePath2(points14, verbs14, SK_ARRAY_COUNT(verbs14));
5275 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5280 path = makePath2(points15, verbs15, SK_ARRAY_COUNT(verbs15));
5281 REPORTER_ASSERT(reporter, path.isRect(&rect));
5286 path = makePath(points17, SK_ARRAY_COUNT(points17), true);
5287 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5295 path = makePath2(points19, verbs19, SK_ARRAY_COUNT(verbs19));
5296 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5303 path = makePath2(points23, verbs23, SK_ARRAY_COUNT(verbs23));
5304 REPORTER_ASSERT(reporter, path.isRect(&rect));
5312 path = makePath2(points29, verbs29, SK_ARRAY_COUNT(verbs29));
5313 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5319 path = makePath2(points31, verbs31, SK_ARRAY_COUNT(verbs31));
5320 REPORTER_ASSERT(reporter, path.isRect(&rect));
5327 path = makePath2(points36, verbs36, SK_ARRAY_COUNT(verbs36));
5328 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5333 path = makePath2(points39, verbs39, SK_ARRAY_COUNT(verbs39));
5334 REPORTER_ASSERT(reporter, !path.isRect(&rect));
5341 path = makePath2(pointsAA, verbsAA, SK_ARRAY_COUNT(verbsAA));
5342 REPORTER_ASSERT(reporter, path.isRect(&rect));
5350 path = makePath2(points41, verbs41, SK_ARRAY_COUNT(verbs41));
5351 REPORTER_ASSERT(reporter, path.isRect(&rect));
5359 path = makePath2(points53, verbs53, SK_ARRAY_COUNT(verbs53));
5360 REPORTER_ASSERT(reporter, path.isRect(&rect));
5367 // The possible problem is that during path.add() we may have to grow the dst buffers as
5378 SkPath path;
5381 path.moveTo(1, 2).lineTo(3, 4).cubicTo(1,2,3,4,5,6).conicTo(1,2,3,4,5);
5383 path.addPath(path, 1, 2);
5384 path.addPath(path, 3, 4);
5393 SkPath path;
5394 path.addPoly(pts, 3, false);
5395 canvas->drawPath(path, SkPaint());
5430 static void add_verbs(SkPath* path, int count) {
5431 path->moveTo(0, 0);
5434 case 0: path->lineTo(10, 20); break;
5435 case 1: path->quadTo(5, 6, 7, 8); break;
5436 case 2: path->conicTo(1, 2, 3, 4, 0.5f); break;
5437 case 3: path->cubicTo(2, 4, 6, 8, 10, 12); break;
5495 // There was a time where SkPath::setLastPoint() didn't invalidate cached path bounds.
5510 SkPath path;
5512 path.conicTo({0, 0}, {1, 1}, SK_FloatNegativeInfinity);
5514 // <== use a copy path object to force SkPathRef::copy() and SkPathRef::resetToSize()
5515 SkPath shallowPath = path;
5541 static bool conditional_convex(const SkPath& path, bool is_convex) {
5542 SkPathConvexity c = SkPathPriv::GetConvexityOrUnknown(path);
5548 void survive(SkPath* path, const Xforms& x, bool isAxisAligned, skiatest::Reporter* reporter,
5550 REPORTER_ASSERT(reporter, isa_proc(*path));
5552 REPORTER_ASSERT(reporter, path->isConvex());
5556 // a path's isa and convexity should survive assignment
5557 path2 = *path;
5561 // a path's isa and convexity should identity transform
5562 path->transform(x.fIM, &path2);
5563 path->transform(x.fIM);
5566 REPORTER_ASSERT(reporter, isa_proc(*path));
5567 REPORTER_ASSERT(reporter, SkPathPriv::GetConvexityOrUnknown(*path) == SkPathConvexity::kConvex);
5569 // a path's isa should survive translation, convexity depends on axis alignment
5570 path->transform(x.fTM, &path2);
5571 path->transform(x.fTM);
5573 REPORTER_ASSERT(reporter, isa_proc(*path));
5575 REPORTER_ASSERT(reporter, conditional_convex(*path, isAxisAligned));
5577 // a path's isa should survive scaling, convexity depends on axis alignment
5578 path->transform(x.fSM, &path2);
5579 path->transform(x.fSM);
5581 REPORTER_ASSERT(reporter, isa_proc(*path));
5583 REPORTER_ASSERT(reporter, conditional_convex(*path, isAxisAligned));
5588 path->transform(x.fRM, &path2);
5589 path->transform(x.fRM);
5591 REPORTER_ASSERT(reporter, SkPathPriv::GetConvexityOrUnknown(*path) != SkPathConvexity::kConvex);
5595 REPORTER_ASSERT(reporter, !isa_proc(*path));
5602 SkPath path;
5603 path.addRect({10, 10, 40, 50});
5604 survive(&path, x, true, r, [](const SkPath& p) { return p.isRect(nullptr); });
5606 path.reset();
5607 path.addOval({10, 10, 40, 50});
5608 survive(&path, x, true, r, [](const SkPath& p) { return p.isOval(nullptr); });
5610 path.reset();
5611 path.addRRect(SkRRect::MakeRectXY({10, 10, 40, 50}, 5, 5));
5612 survive(&path, x, true, r, [](const SkPath& p) { return p.isRRect(nullptr); });
5615 path.reset();
5616 path.moveTo(0, 0).lineTo(100, 0).lineTo(70, 100).lineTo(30, 100);
5617 REPORTER_ASSERT(r, path.isConvex());
5618 survive(&path, x, false, r, [](const SkPath& p) { return true; });
5622 // Make sure that copyPath is safe after the call to path.offset().
5624 // set it to path's value inside SkPath::transform()
5641 SkPath path;
5642 path.addRoundRect({10, 10, 110, 110}, radii);
5643 path.offset(0, 5, &(copyPath)); // <== change buffer copyPath.fPathRef->fPoints but not reset copyPath.fLastMoveToIndex lead to out of bound
5651 SkPath path;
5655 case SkPath::kMove_Verb: path.moveTo(x++, y++); break;
5656 case SkPath::kLine_Verb: path.lineTo(x++, y++); break;
5657 case SkPath::kClose_Verb: path.close(); break;
5662 SkPathEdgeIter iter(path);
5672 const SkPath& path, const std::initializer_list<SkPoint>& list) {
5674 SkPath::RawIter iter(path);
5696 SkPath path;
5707 path.reset();
5708 path.addRect(r, dir, i);
5716 assert_points(reporter, path, {
5721 path.lineTo(7,8);
5722 assert_points(reporter, path, {
5730 // the "first" point in the path when we handle the trailing lineTo
5731 path.reset();
5732 path.moveTo(7, 8);
5733 path.addRect(r, SkPathDirection::kCW, 2);
5734 path.lineTo(5, 6);
5736 assert_points(reporter, path, {
5745 * called on an empty path, a 'moveTo(0,0)' will automatically be injected. If the path is
5750 * path.moveTo(...) <-- needed to show the bug
5751 * path.moveTo....close()
5752 * // at this point, the path's verbs are: M M ... C
5754 * path.lineTo(...)
5755 * // after lineTo, the path's verbs are: M M ... C M L
5759 * Given a path, and the expected last-point and last-move-to in it,
5763 auto test_before_after_lineto = [reporter](SkPath& path,
5766 SkPoint p = path.getPoint(path.countPoints() - 1);
5770 path.lineTo(newLineTo);
5772 p = path.getPoint(path.countPoints() - 2);
5775 p = path.getPoint(path.countPoints() - 1);
5817 // When we add a path to another path, we need to sniff out in case the argument ended
5826 SkPath path = SkPathBuilder().moveTo(0,0).lineTo(1, 0)
5830 REPORTER_ASSERT(r, path.isConvex());
5833 path.transform(SkMatrix::Scale(scale, scale), &path2);
5846 SkPath path;
5847 // Convexity and contains functions treat the path as a simple fill, so consecutive
5850 path.moveTo(i, i);
5852 path.addRect(rect);
5854 REPORTER_ASSERT(r, (numExtraMoveTos + 1) == SkPathPriv::LeadingMoveToCount(path));
5856 // addRect should mark the path as known convex automatically (i.e. it wasn't set
5858 SkPathConvexity origConvexity = SkPathPriv::GetConvexityOrUnknown(path);
5862 SkPathPriv::ForceComputeConvexity(path);
5863 REPORTER_ASSERT(r, path.isConvex());
5866 REPORTER_ASSERT(r, path.conservativelyContainsRect(query));
5874 // and the BySign convexity pass would not evaluate the entire path, effectively only using the
5876 SkPath path;
5877 path.setFillType(SkPathFillType::kWinding);
5878 path.moveTo(3.25f, 115.5f);
5879 path.conicTo(9.98099e+17f, 2.83874e+15f, 1.75098e-30f, 1.75097e-30f, 1.05385e+18f);
5880 path.conicTo(9.96938e+17f, 6.3804e+19f, 9.96934e+17f, 1.75096e-30f, 1.75096e-30f);
5881 path.quadTo(1.28886e+10f, 9.9647e+17f, 9.98101e+17f, 2.61006e+15f);
5882 REPORTER_ASSERT(r, !path.isConvex());
5887 pathWithExtraMoveTo.addPath(path);