Lines Matching refs:SkPath
44 SkPath path;
51 SkPath path;
76 static void make_path_crbug364224(SkPath* path) {
100 static void make_path_crbug364224_simplified(SkPath* path) {
109 SkPath path;
121 SkPath path;
133 static void test_draw_AA_path(int width, int height, const SkPath& path) {
143 SkPath path;
152 SkPath path;
167 SkPath path;
180 SkPath path;
204 SkPath path;
218 SkPath path;
231 static void make_path_crbugskia2820(SkPath* path, skiatest::Reporter* reporter) {
245 SkPath path;
254 SkPath path;
262 static void make_path0(SkPath* path) {
273 static void make_path1(SkPath* path) {
277 typedef void (*PathProc)(SkPath*);
296 SkPath path;
315 SkPath path;
363 SkPath a, b;
387 SkPath c(a);
412 SkPath path;
428 SkPath path;
436 SkPath dst;
442 static void build_path_170666(SkPath& path) {
522 static void build_path_simple_170666(SkPath& path) {
531 SkPath path;
542 SkPath smallPath;
545 SkPath largePath;
602 SkPath path;
613 SkPath path;
641 SkPath path;
660 static void build_big_path(SkPath* path, bool reducedCase) {
687 SkPath path;
708 SkPath path;
738 SkPath path;
756 SkPath path;
765 SkPath path;
790 static void add_corner_arc(SkPath* path, const SkRect& rect,
820 static void make_arb_round_rect(SkPath* path, const SkRect& r,
849 SkPath temp;
876 SkPath temp;
925 SkPath path;
950 SkPath path;
973 static void test_poly(skiatest::Reporter* reporter, const SkPath& path,
1021 SkPath path;
1053 static void check_direction(skiatest::Reporter* reporter, const SkPath& path,
1059 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1069 SkPath path;
1154 static void add_rect(SkPath* path, const SkRect& r) {
1170 SkPath path0, path1;
1180 SkPath path;
1188 SkPath fill;
1215 static void check_close(skiatest::Reporter* reporter, const SkPath& path) {
1217 SkPath::Iter iter(path, SkToBool(i));
1220 SkPath::Verb v;
1224 while (SkPath::kDone_Verb != (v = iter.next(pts))) {
1226 case SkPath::kMove_Verb:
1230 case SkPath::kClose_Verb:
1245 SkPath closePt;
1250 SkPath openPt;
1254 SkPath empty;
1259 SkPath rect;
1265 SkPath quad;
1271 SkPath cubic;
1278 SkPath line;
1285 SkPath rect2;
1293 SkPath oval3;
1301 SkPath moves;
1311 static void check_convexity(skiatest::Reporter* reporter, const SkPath& path,
1314 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1320 SkPath tinyConvexPolygon;
1329 SkPath platTriangle;
1347 SkPath pt;
1353 SkPath line;
1360 SkPath triLeft;
1368 SkPath triRight;
1376 SkPath square;
1385 SkPath redundantSquare;
1402 SkPath bowTie;
1419 SkPath spiral;
1431 SkPath dent;
1442 SkPath strokedSin;
1459 SkPath degenerateConcave;
1470 SkPath badFirstVector;
1484 SkPath falseBackEdge;
1500 SkPath doubleback;
1522 static void check_convex_bounds(skiatest::Reporter* reporter, const SkPath& p,
1527 SkPath p2(p);
1531 SkPath other;
1537 static void setFromString(SkPath* path, const char str[]) {
1557 SkPath path;
1602 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1685 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1719 SkPath copy(path); // NOLINT(performance-unnecessary-copy-initialization)
1738 SkPath path;
1788 SkPath path;
2018 SkPath path;
2120 SkPath path;
2159 SkPath path1;
2214 static void check_simple_rect(skiatest::Reporter* reporter, const SkPath& path, bool isClosed,
2237 SkPath path;
2242 SkPath path2 = path;
2315 SkPath path;
2426 SkPath path;
2465 SkPath path1;
2557 SkPath path;
2571 SkPath src, dst;
2581 const SkPath& p) {
2589 SkPath readBack;
2622 SkPath p;
2644 SkPath p2;
2652 SkPath tooShort;
2663 SkPath oval;
2672 SkPath p;
2698 SkPath p1;
2708 SkPath p1; // Leave p1 non-unique (i.e., the empty path)
2725 SkPath p1;
2745 SkPath p1;
2757 SkPath p1;
2767 SkPath p1;
2775 SkPath p1;
2777 SkPath p2;
2793 SkPath p;
2800 const SkPath::Verb* resultVerbs;
2804 static const SkPath::Verb resultVerbs1[] = { SkPath::kMove_Verb };
2805 static const SkPath::Verb resultVerbs2[] = { SkPath::kMove_Verb, SkPath::kMove_Verb };
2806 static const SkPath::Verb resultVerbs3[] = { SkPath::kMove_Verb, SkPath::kClose_Verb };
2807 static const SkPath::Verb resultVerbs4[] = { SkPath::kMove_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb, SkPath::kClose_Verb };
2808 static const SkPath::Verb resultVerbs5[] = { SkPath::kMove_Verb, SkPath::kLine_Verb };
2809 static const SkPath::Verb resultVerbs6[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb, SkPath::kLine_Verb };
2810 static const SkPath::Verb resultVerbs7[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kClose_Verb };
2811 static const SkPath::Verb resultVerbs8[] = {
2812 SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kClose_Verb
2814 static const SkPath::Verb resultVerbs9[] = { SkPath::kMove_Verb, SkPath::kQuad_Verb };
2815 static const SkPath::Verb resultVerbs10[] = { SkPath::kMove_Verb, SkPath::kQuad_Verb, SkPath::kMove_Verb, SkPath::kQuad_Verb };
2816 static const SkPath::Verb resultVerbs11[] = { SkPath::kMove_Verb, SkPath::kQuad_Verb, SkPath::kClose_Verb };
2817 static const SkPath::Verb resultVerbs12[] = {
2818 SkPath::kMove_Verb, SkPath::kQuad_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb, SkPath::kQuad_Verb, SkPath::kClose_Verb
2820 static const SkPath::Verb resultVerbs13[] = { SkPath::kMove_Verb, SkPath::kCubic_Verb };
2821 static const SkPath::Verb resultVerbs14[] = { SkPath::kMove_Verb, SkPath::kCubic_Verb, SkPath::kMove_Verb, SkPath::kCubic_Verb };
2822 static const SkPath::Verb resultVerbs15[] = { SkPath::kMove_Verb, SkPath::kCubic_Verb, SkPath::kClose_Verb };
2823 static const SkPath::Verb resultVerbs16[] = {
2824 SkPath::kMove_Verb, SkPath::kCubic_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb, SkPath::kCubic_Verb, SkPath::kClose_Verb
2864 SkPath fPath;
2868 #define kCurveSegmentMask (SkPath::kQuad_SegmentMask | SkPath::kCubic_SegmentMask)
2871 SkPath p, p2;
2875 REPORTER_ASSERT(reporter, SkPath::kQuad_SegmentMask == p.getSegmentMasks());
2888 REPORTER_ASSERT(reporter, SkPath::kCubic_SegmentMask == p.getSegmentMasks());
2896 SkPath p;
2900 SkPath::Iter noPathIter;
2901 REPORTER_ASSERT(reporter, noPathIter.next(pts) == SkPath::kDone_Verb);
2905 REPORTER_ASSERT(reporter, noPathIter.next(pts) == SkPath::kDone_Verb);
2909 REPORTER_ASSERT(reporter, noPathIter.next(pts) == SkPath::kDone_Verb);
2912 SkPath::Iter iter(p, false);
2913 REPORTER_ASSERT(reporter, iter.next(pts) == SkPath::kDone_Verb);
2917 REPORTER_ASSERT(reporter, iter.next(pts) == SkPath::kDone_Verb);
2925 const SkPath::Verb* resultVerbs;
2929 static const SkPath::Verb resultVerbs1[] = { SkPath::kDone_Verb };
2930 static const SkPath::Verb resultVerbs2[] = {
2931 SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb, SkPath::kClose_Verb, SkPath::kDone_Verb
2933 static const SkPath::Verb resultVerbs3[] = {
2934 SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb, SkPath::kClose_Verb, SkPath::kDone_Verb
2965 } while (gIterTests[i].resultVerbs[j++] != SkPath::kDone_Verb);
2987 // this checks to see if the NaN logic is executed in SkPath::autoClose(), but does not
2996 REPORTER_ASSERT(reporter, SkPath::kClose_Verb == iter.next(pts));
3003 REPORTER_ASSERT(reporter, SkPath::kQuad_Verb == iter.next(pts));
3009 REPORTER_ASSERT(reporter, SkPath::kConic_Verb == iter.next(pts));
3015 REPORTER_ASSERT(reporter, SkPath::kCubic_Verb == iter.next(pts));
3020 REPORTER_ASSERT(reporter, SkPath::kCubic_Verb == iter.next(pts));
3032 REPORTER_ASSERT(reporter, SkPath::kMove_Verb == iter.next(pts));
3033 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == iter.next(pts));
3035 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == iter.next(pts));
3036 REPORTER_ASSERT(reporter, SkPath::kConic_Verb == iter.next(pts));
3041 SkPath path;
3165 nextVerb = static_cast<SkPathVerb>((rand.nextU() >> 16) % SkPath::kDone_Verb);
3292 const SkPath& path,
3302 SkPath tmpPath;
3310 const SkPath& path,
3312 SkPath tmp;
3328 const SkPath& path,
3330 SkPath tmp;
3348 const SkPath& path,
3351 SkPath tmp;
3368 const SkPath& path,
3370 SkPath tmp;
3385 const SkPath& path,
3387 SkPath tmp;
3404 const SkPath& path,
3406 SkPath tmp;
3419 SkPath path;
3459 SkPath path;
3460 SkPath circle;
3461 SkPath rect;
3462 SkPath empty;
3499 SkPath path;
3527 SkPath path;
3538 SkPath tmp;
3587 static void test_empty(skiatest::Reporter* reporter, const SkPath& p) {
3588 SkPath empty;
3601 static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path,
3611 static void test_rrect_convexity_is_unknown(skiatest::Reporter* reporter, SkPath* path,
3622 SkPath p;
3688 SkPath p;
3698 SkPath cwOval;
3703 SkPath ccwOval;
3744 const SkPath& path) {
3750 SkPath recreatedPath;
3761 SkPath path;
3763 // SkPath's interfaces for inserting and extracting ovals only allow contours
3774 SkPath path;
3813 static void check_done(skiatest::Reporter* reporter, SkPath* p, SkPathPriv::RangeIter* iter) {
3817 static void check_done_and_reset(skiatest::Reporter* reporter, SkPath* p,
3823 static void check_path_is_move_and_reset(skiatest::Reporter* reporter, SkPath* p,
3830 static void check_path_is_line_and_reset(skiatest::Reporter* reporter, SkPath* p,
3838 static void check_path_is_line(skiatest::Reporter* reporter, SkPath* p,
3846 static void check_path_is_line_pair_and_reset(skiatest::Reporter* reporter, SkPath* p,
3855 static void check_path_is_quad_and_reset(skiatest::Reporter* reporter, SkPath* p,
3871 SkPath p;
3899 SkPath p;
3952 p.arcTo(216, 108, 0, SkPath::ArcSize::kLarge_ArcSize, SkPathDirection::kCW, 216, 0);
3953 p.arcTo(270, 135, 0, SkPath::ArcSize::kLarge_ArcSize, SkPathDirection::kCCW, 216, 216);
3963 SkPath p, q;
3981 SkPath p, q;
3990 p.addPath(q, extend ? SkPath::kExtend_AddPathMode : SkPath::kAppend_AddPathMode);
3994 REPORTER_ASSERT(reporter, verbs[0] == SkPath::kMove_Verb);
3995 REPORTER_ASSERT(reporter, verbs[1] == SkPath::kLine_Verb);
3996 REPORTER_ASSERT(reporter, verbs[2] == (extend ? SkPath::kLine_Verb : SkPath::kMove_Verb));
3997 REPORTER_ASSERT(reporter, verbs[3] == SkPath::kLine_Verb);
4001 SkPath p, q;
4008 p.addPath(q, SkPath::kExtend_AddPathMode);
4012 REPORTER_ASSERT(reporter, verbs[0] == SkPath::kMove_Verb);
4013 REPORTER_ASSERT(reporter, verbs[1] == SkPath::kLine_Verb);
4014 REPORTER_ASSERT(reporter, verbs[2] == SkPath::kLine_Verb);
4015 REPORTER_ASSERT(reporter, verbs[3] == SkPath::kClose_Verb);
4016 REPORTER_ASSERT(reporter, verbs[4] == SkPath::kMove_Verb);
4017 REPORTER_ASSERT(reporter, verbs[5] == SkPath::kLine_Verb);
4018 REPORTER_ASSERT(reporter, verbs[6] == SkPath::kLine_Verb);
4026 static void test_addEmptyPath(skiatest::Reporter* reporter, SkPath::AddPathMode mode) {
4027 SkPath p, q, r;
4043 SkPath p;
4053 SkPath p;
4067 SkPath p;
4239 ed.growForRepeatedVerb(SkPath::kMove_Verb, kRepeatCnt);
4244 REPORTER_ASSERT(reporter, SkPath::kMove_Verb == pathRef->atVerb(i));
4250 ed.growForRepeatedVerb(SkPath::kLine_Verb, kRepeatCnt);
4253 REPORTER_ASSERT(reporter, SkPath::kLine_SegmentMask == pathRef->getSegmentMasks());
4255 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == pathRef->atVerb(i));
4261 ed.growForRepeatedVerb(SkPath::kQuad_Verb, kRepeatCnt);
4264 REPORTER_ASSERT(reporter, SkPath::kQuad_SegmentMask == pathRef->getSegmentMasks());
4266 REPORTER_ASSERT(reporter, SkPath::kQuad_Verb == pathRef->atVerb(i));
4273 ed.growForRepeatedVerb(SkPath::kConic_Verb, kRepeatCnt, &weights);
4277 REPORTER_ASSERT(reporter, SkPath::kConic_SegmentMask == pathRef->getSegmentMasks());
4280 REPORTER_ASSERT(reporter, SkPath::kConic_Verb == pathRef->atVerb(i));
4286 ed.growForRepeatedVerb(SkPath::kCubic_Verb, kRepeatCnt);
4289 REPORTER_ASSERT(reporter, SkPath::kCubic_SegmentMask == pathRef->getSegmentMasks());
4291 REPORTER_ASSERT(reporter, SkPath::kCubic_Verb == pathRef->atVerb(i));
4299 SkPath a;
4300 SkPath b;
4319 static void compare_dump(skiatest::Reporter* reporter, const SkPath& path, bool dumpAsHex,
4333 SkPath p;
4393 static size_t GetFreeSpace(const SkPath& path) {
4398 SkPath p, q;
4416 SkPath p;
4450 SkPath q;
4462 SkPath q;
4473 SkPath path;
4484 SkPath path;
4504 SkPath path;
4523 SkPath path;
4533 SkPath path;
4545 constexpr SkPath::Verb kMove = SkPath::kMove_Verb;
4546 constexpr SkPath::Verb kLine = SkPath::kLine_Verb;
4547 constexpr SkPath::Verb kClose = SkPath::kClose_Verb;
4548 SkPath::Verb verbs[] = {kMove, kLine, kLine, kLine, kLine, kLine, kLine, kLine, kClose,
4569 SkPath path;
4582 SkPath path;
4593 SkPath path;
4756 SkPath p1, p2, out;
4800 SkPath path;
4834 SkPath p, empty;
4840 // this triggers a code path in SkPath::operator= which is otherwise unexercised
4841 SkPath& self = p;
4844 // this triggers a code path in SkPath::swap which is otherwise unexercised
4853 p.getSegmentMasks() & (kCurveSegmentMask | SkPath::kConic_SegmentMask));
4869 REPORTER_ASSERT(reporter, SkPath::kLine_SegmentMask == p.getSegmentMasks());
4884 REPORTER_ASSERT(reporter, SkPath::kMove_Verb == verbs[0]);
4885 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[1]);
4886 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[2]);
4887 REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[3]);
4888 REPORTER_ASSERT(reporter, SkPath::kClose_Verb == verbs[4]);
4972 test_addEmptyPath(reporter, SkPath::kExtend_AddPathMode);
4973 test_addEmptyPath(reporter, SkPath::kAppend_AddPathMode);
4991 SkPath path;
5006 static void rand_path(SkPath* path, SkRandom& rand, SkPath::Verb verb, int n) {
5009 case SkPath::kLine_Verb:
5012 case SkPath::kQuad_Verb:
5016 case SkPath::kConic_Verb:
5020 case SkPath::kCubic_Verb:
5035 const SkPath::Verb verbs[] = {
5036 SkPath::kLine_Verb, SkPath::kQuad_Verb, SkPath::kConic_Verb, SkPath::kCubic_Verb,
5040 for (SkPath::Verb verb : verbs) {
5041 SkPath path;
5078 SkPath path;
5093 SkPath readBack;
5103 SkPath readBack;
5110 SkPath path;
5124 SkPath aPath;
5128 SkPath scalePath = aPath;
5135 SkPath scalePath = aPath;
5195 SkPath path;
5212 auto makePath = [](const SkPoint* points, size_t count, bool close) -> SkPath {
5213 SkPath path;
5222 auto makePath2 = [](const SkPoint* points, const SkPath::Verb* verbs, size_t count) -> SkPath {
5223 SkPath path;
5226 case SkPath::kMove_Verb:
5229 case SkPath::kLine_Verb:
5232 case SkPath::kClose_Verb:
5244 SkPath path = makePath(points, SK_ARRAY_COUNT(points), false);
5260 SkPath::Verb verbs11[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5261 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb };
5268 SkPath::Verb verbs14[] = { SkPath::kMove_Verb, SkPath::kMove_Verb, SkPath::kMove_Verb,
5269 SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5270 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kClose_Verb,
5271 SkPath::kLine_Verb, SkPath::kClose_Verb };
5277 SkPath::Verb verbs15[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5278 SkPath::kLine_Verb, SkPath::kMove_Verb };
5289 SkPath::Verb verbs19[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5290 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5291 SkPath::kLine_Verb, SkPath::kClose_Verb, SkPath::kMove_Verb,
5292 SkPath::kLine_Verb, SkPath::kLine_Verb };
5298 SkPath::Verb verbs23[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb,
5299 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5300 SkPath::kLine_Verb, SkPath::kClose_Verb };
5308 SkPath::Verb verbs29[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5309 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb,
5310 SkPath::kClose_Verb };
5315 SkPath::Verb verbs31[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5316 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb,
5317 SkPath::kClose_Verb };
5324 SkPath::Verb verbs36[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5325 SkPath::kLine_Verb, SkPath::kMove_Verb, SkPath::kLine_Verb };
5330 SkPath::Verb verbs39[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5331 SkPath::kLine_Verb };
5336 SkPath::Verb verbsAA[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5337 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5338 SkPath::kLine_Verb, SkPath::kClose_Verb };
5346 SkPath::Verb verbs41[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5347 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb,
5348 SkPath::kClose_Verb };
5355 SkPath::Verb verbs53[] = { SkPath::kMove_Verb, SkPath::kLine_Verb, SkPath::kLine_Verb,
5356 SkPath::kLine_Verb, SkPath::kLine_Verb, SkPath::kMove_Verb,
5357 SkPath::kClose_Verb };
5373 // reserve allocation strategy is for SkPath, therefore we can't know when an append operation
5375 // an ASAN error w/o the fix to SkPath::addPath().
5378 SkPath path;
5393 SkPath path;
5430 static void add_verbs(SkPath* path, int count) {
5447 SkPath unique_path, shared_path;
5451 const SkPath copy = shared_path;
5495 // There was a time where SkPath::setLastPoint() didn't invalidate cached path bounds.
5496 SkPath p;
5510 SkPath path;
5515 SkPath shallowPath = path;
5541 static bool conditional_convex(const SkPath& path, bool is_convex) {
5548 void survive(SkPath* path, const Xforms& x, bool isAxisAligned, skiatest::Reporter* reporter,
5554 SkPath path2;
5602 SkPath path;
5604 survive(&path, x, true, r, [](const SkPath& p) { return p.isRect(nullptr); });
5608 survive(&path, x, true, r, [](const SkPath& p) { return p.isOval(nullptr); });
5612 survive(&path, x, true, r, [](const SkPath& p) { return p.isRRect(nullptr); });
5618 survive(&path, x, false, r, [](const SkPath& p) { return true; });
5624 // set it to path's value inside SkPath::transform()
5633 SkPath copyPath;
5634 SkFont().getPaths(glyphs, len, [](const SkPath* src, const SkMatrix& mx, void* ctx) {
5636 ((SkPath*)ctx)->addPath(*src, mx);
5641 SkPath path;
5649 const std::initializer_list<SkPath::Verb>& in,
5650 const std::initializer_list<SkPath::Verb>& expected) {
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;
5672 const SkPath& path, const std::initializer_list<SkPoint>& list) {
5674 SkPath::RawIter iter(path);
5678 case SkPath::kDone_Verb:
5681 case SkPath::kMove_Verb:
5685 case SkPath::kLine_Verb:
5689 case SkPath::kClose_Verb: break;
5696 SkPath path;
5744 * SkPath allows the caller to "skip" calling moveTo for contours. If lineTo (or a curve) is
5763 auto test_before_after_lineto = [reporter](SkPath& path,
5779 SkPath path1;
5780 SkPath path2;
5797 auto M = SkPath::kMove_Verb;
5798 auto L = SkPath::kLine_Verb;
5799 auto C = SkPath::kClose_Verb;
5819 SkPath p1, p2;
5826 SkPath path = SkPathBuilder().moveTo(0,0).lineTo(1, 0)
5831 SkPath path2;
5840 // Test both an empty and non-empty rect passed to SkPath::addRect
5846 SkPath path;
5876 SkPath path;
5884 SkPath pathWithExtraMoveTo;