From 78d58d1084f0390c1c0f9123ac6e48efcd226f39 Mon Sep 17 00:00:00 2001 From: bsalomon Date: Fri, 27 May 2016 09:17:04 -0700 Subject: Make SkPath::isOval() and SkPath::isRRect return the orientation and starting index. These are tracked in SkPathRef. Unit tests are updated to test that the returned values are correct. GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2012233002 Review-Url: https://codereview.chromium.org/2012233002 --- tests/RRectInPathTest.cpp | 518 +++++++++++++++++++++++++++------------------- 1 file changed, 301 insertions(+), 217 deletions(-) (limited to 'tests/RRectInPathTest.cpp') diff --git a/tests/RRectInPathTest.cpp b/tests/RRectInPathTest.cpp index c6b1d9c15e..5b7d17d9ce 100644 --- a/tests/RRectInPathTest.cpp +++ b/tests/RRectInPathTest.cpp @@ -8,24 +8,40 @@ #include "SkMatrix.h" #include "SkPath.h" #include "SkPathRef.h" -#include "SkPathOps.h" #include "SkRRect.h" #include "Test.h" -static SkRRect path_contains_rrect(skiatest::Reporter* reporter, const SkPath& path) { +static SkRRect path_contains_rrect(skiatest::Reporter* reporter, const SkPath& path, + SkPath::Direction* dir, unsigned* start) { SkRRect out; - REPORTER_ASSERT(reporter, path.isRRect(&out)); - SkPath path2, xorBoth; - path2.addRRect(out); - if (path == path2) { - return out; + REPORTER_ASSERT(reporter, path.isRRect(&out, dir, start)); + SkPath recreatedPath; + recreatedPath.addRRect(out, *dir, *start); + REPORTER_ASSERT(reporter, path == recreatedPath); + // Test that rotations/mirrors of the rrect path are still rrect paths and the returned + // parameters for the transformed paths are correct. + static const SkMatrix kMatrices[] = { + SkMatrix::MakeScale(1, 1), + SkMatrix::MakeScale(-1, 1), + SkMatrix::MakeScale(1, -1), + SkMatrix::MakeScale(-1, -1), + }; + for (auto& m : kMatrices) { + SkPath xformed; + path.transform(m, &xformed); + SkRRect xrr = SkRRect::MakeRect(SkRect::MakeEmpty()); + SkPath::Direction xd = SkPath::kCCW_Direction; + unsigned xs = ~0U; + REPORTER_ASSERT(reporter, xformed.isRRect(&xrr, &xd, &xs)); + recreatedPath.reset(); + recreatedPath.addRRect(xrr, xd, xs); + REPORTER_ASSERT(reporter, recreatedPath == xformed); } - Op(path, path2, SkPathOp::kXOR_SkPathOp, &xorBoth); - REPORTER_ASSERT(reporter, xorBoth.isEmpty()); return out; } -static SkRRect inner_path_contains_rrect(skiatest::Reporter* reporter, const SkRRect& in) { +static SkRRect inner_path_contains_rrect(skiatest::Reporter* reporter, const SkRRect& in, + SkPath::Direction dir, unsigned start) { switch (in.getType()) { case SkRRect::kEmpty_Type: case SkRRect::kRect_Type: @@ -35,157 +51,192 @@ static SkRRect inner_path_contains_rrect(skiatest::Reporter* reporter, const SkR break; } SkPath path; - path.addRRect(in); - return path_contains_rrect(reporter, path); + path.addRRect(in, dir, start); + SkPath::Direction outDir; + unsigned outStart; + SkRRect rrect = path_contains_rrect(reporter, path, &outDir, &outStart); + REPORTER_ASSERT(reporter, outDir == dir && outStart == start); + return rrect; } -static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRRect& in) { - SkRRect out = inner_path_contains_rrect(reporter, in); +static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRRect& in, + SkPath::Direction dir, unsigned start) { + SkRRect out = inner_path_contains_rrect(reporter, in, dir, start); if (in != out) { SkDebugf(""); } REPORTER_ASSERT(reporter, in == out); } -static void path_contains_rrect_nocheck(skiatest::Reporter* reporter, const SkRRect& in) { - SkRRect out = inner_path_contains_rrect(reporter, in); +static void path_contains_rrect_nocheck(skiatest::Reporter* reporter, const SkRRect& in, + SkPath::Direction dir, unsigned start) { + SkRRect out = inner_path_contains_rrect(reporter, in, dir, start); if (in == out) { SkDebugf(""); } } static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRect& r, - SkVector v[4]) { + SkVector v[4], SkPath::Direction dir, unsigned start) { SkRRect rrect; rrect.setRectRadii(r, v); - path_contains_rrect_check(reporter, rrect); + path_contains_rrect_check(reporter, rrect, dir, start); } class ForceIsRRect_Private { public: - ForceIsRRect_Private(SkPath* path) { - path->fPathRef->setIsRRect(true); + ForceIsRRect_Private(SkPath* path, SkPath::Direction dir, unsigned start) { + path->fPathRef->setIsRRect(true, dir == SkPath::kCCW_Direction, start); } }; -static void force_path_contains_rrect(skiatest::Reporter* reporter, SkPath& path) { - ForceIsRRect_Private force_rrect(&path); - path_contains_rrect(reporter, path); +static void force_path_contains_rrect(skiatest::Reporter* reporter, SkPath& path, + SkPath::Direction dir, unsigned start) { + ForceIsRRect_Private force_rrect(&path, dir, start); + SkPath::Direction outDir; + unsigned outStart; + path_contains_rrect(reporter, path, &outDir, &outStart); + REPORTER_ASSERT(reporter, outDir == dir && outStart == start); } static void test_undetected_paths(skiatest::Reporter* reporter) { + // We use a dummy path to get the exact conic weight used by SkPath for a circular arc. This + // allows our local, hand-crafted, artisanal round rect paths below to exactly match the + // factory made corporate paths produced by SkPath. + SkPath dummyPath; + dummyPath.addCircle(0, 0, 10); + SkPath::RawIter iter(dummyPath); + SkPoint dummyPts[4]; + SkPath::Verb v = iter.next(dummyPts); + REPORTER_ASSERT(reporter, SkPath::kMove_Verb == v); + v = iter.next(dummyPts); + REPORTER_ASSERT(reporter, SkPath::kConic_Verb == v); + const SkScalar weight = iter.conicWeight(); + SkPath path; path.moveTo(0, 62.5f); path.lineTo(0, 3.5f); - path.conicTo(0, 0, 3.5f, 0, 0.70710677f); + path.conicTo(0, 0, 3.5f, 0, weight); path.lineTo(196.5f, 0); - path.conicTo(200, 0, 200, 3.5f, 0.70710677f); + path.conicTo(200, 0, 200, 3.5f, weight); path.lineTo(200, 62.5f); - path.conicTo(200, 66, 196.5f, 66, 0.70710677f); + path.conicTo(200, 66, 196.5f, 66, weight); path.lineTo(3.5f, 66); - path.conicTo(0, 66, 0, 62.5, 0.70710677f); + path.conicTo(0, 66, 0, 62.5, weight); path.close(); - force_path_contains_rrect(reporter, path); + force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6); path.reset(); path.moveTo(0, 81.5f); path.lineTo(0, 3.5f); - path.conicTo(0, 0, 3.5f, 0, 0.70710677f); + path.conicTo(0, 0, 3.5f, 0, weight); path.lineTo(149.5, 0); - path.conicTo(153, 0, 153, 3.5f, 0.70710677f); + path.conicTo(153, 0, 153, 3.5f, weight); path.lineTo(153, 81.5f); - path.conicTo(153, 85, 149.5f, 85, 0.70710677f); + path.conicTo(153, 85, 149.5f, 85, weight); path.lineTo(3.5f, 85); - path.conicTo(0, 85, 0, 81.5f, 0.70710677f); + path.conicTo(0, 85, 0, 81.5f, weight); path.close(); - force_path_contains_rrect(reporter, path); + force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6); path.reset(); path.moveTo(14, 1189); path.lineTo(14, 21); - path.conicTo(14, 14, 21, 14, 0.70710677f); + path.conicTo(14, 14, 21, 14, weight); path.lineTo(1363, 14); - path.conicTo(1370, 14, 1370, 21, 0.70710677f); + path.conicTo(1370, 14, 1370, 21, weight); path.lineTo(1370, 1189); - path.conicTo(1370, 1196, 1363, 1196, 0.70710677f); + path.conicTo(1370, 1196, 1363, 1196, weight); path.lineTo(21, 1196); - path.conicTo(14, 1196, 14, 1189, 0.70710677f); + path.conicTo(14, 1196, 14, 1189, weight); path.close(); - force_path_contains_rrect(reporter, path); + force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6); path.reset(); path.moveTo(14, 1743); path.lineTo(14, 21); - path.conicTo(14, 14, 21, 14, 0.70710677f); + path.conicTo(14, 14, 21, 14, weight); path.lineTo(1363, 14); - path.conicTo(1370, 14, 1370, 21, 0.70710677f); + path.conicTo(1370, 14, 1370, 21, weight); path.lineTo(1370, 1743); - path.conicTo(1370, 1750, 1363, 1750, 0.70710677f); + path.conicTo(1370, 1750, 1363, 1750, weight); path.lineTo(21, 1750); - path.conicTo(14, 1750, 14, 1743, 0.70710677f); + path.conicTo(14, 1750, 14, 1743, weight); path.close(); - force_path_contains_rrect(reporter, path); + force_path_contains_rrect(reporter, path, SkPath::kCW_Direction, 6); } static const SkScalar kWidth = 100.0f; static const SkScalar kHeight = 100.0f; static void test_tricky_radii(skiatest::Reporter* reporter) { - { - // crbug.com/458522 - SkRRect rr; - const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; - const SkScalar rad = 12814; - const SkVector vec[] = { { rad, rad }, { 0, rad }, { rad, rad }, { 0, rad } }; - rr.setRectRadii(bounds, vec); - path_contains_rrect_check(reporter, rr); - } - - { - // crbug.com//463920 - SkRect r = SkRect::MakeLTRB(0, 0, 1009, 33554432.0); - SkVector radii[4] = { - { 13.0f, 8.0f }, { 170.0f, 2.0 }, { 256.0f, 33554432.0 }, { 110.0f, 5.0f } - }; - SkRRect rr; - rr.setRectRadii(r, radii); - path_contains_rrect_nocheck(reporter, rr); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + { + // crbug.com/458522 + SkRRect rr; + const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; + const SkScalar rad = 12814; + const SkVector vec[] = { { rad, rad }, { 0, rad }, { rad, rad }, { 0, rad } }; + rr.setRectRadii(bounds, vec); + path_contains_rrect_check(reporter, rr, dir, start); + } + + { + // crbug.com//463920 + SkRect r = SkRect::MakeLTRB(0, 0, 1009, 33554432.0); + SkVector radii[4] = { + { 13.0f, 8.0f }, { 170.0f, 2.0 }, { 256.0f, 33554432.0 }, { 110.0f, 5.0f } + }; + SkRRect rr; + rr.setRectRadii(r, radii); + path_contains_rrect_nocheck(reporter, rr, dir, start); + } + } } } static void test_empty_crbug_458524(skiatest::Reporter* reporter) { - SkRRect rr; - const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; - const SkScalar rad = 40; - rr.setRectXY(bounds, rad, rad); - path_contains_rrect_check(reporter, rr); - - SkRRect other; - SkMatrix matrix; - matrix.setScale(0, 1); - rr.transform(matrix, &other); - path_contains_rrect_check(reporter, rr); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + SkRRect rr; + const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; + const SkScalar rad = 40; + rr.setRectXY(bounds, rad, rad); + path_contains_rrect_check(reporter, rr, dir, start); + + SkRRect other; + SkMatrix matrix; + matrix.setScale(0, 1); + rr.transform(matrix, &other); + path_contains_rrect_check(reporter, rr, dir, start); + } + } } static void test_inset(skiatest::Reporter* reporter) { - SkRRect rr, rr2; - SkRect r = { 0, 0, 100, 100 }; - - rr.setRect(r); - rr.inset(-20, -20, &rr2); - path_contains_rrect_check(reporter, rr); - - rr.inset(20, 20, &rr2); - path_contains_rrect_check(reporter, rr); - - rr.inset(r.width()/2, r.height()/2, &rr2); - path_contains_rrect_check(reporter, rr); - - rr.setRectXY(r, 20, 20); - rr.inset(19, 19, &rr2); - path_contains_rrect_check(reporter, rr); - rr.inset(20, 20, &rr2); - path_contains_rrect_check(reporter, rr); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + SkRRect rr, rr2; + SkRect r = { 0, 0, 100, 100 }; + + rr.setRect(r); + rr.inset(-20, -20, &rr2); + path_contains_rrect_check(reporter, rr, dir, start); + + rr.inset(20, 20, &rr2); + path_contains_rrect_check(reporter, rr, dir, start); + + rr.inset(r.width()/2, r.height()/2, &rr2); + path_contains_rrect_check(reporter, rr, dir, start); + + rr.setRectXY(r, 20, 20); + rr.inset(19, 19, &rr2); + path_contains_rrect_check(reporter, rr, dir, start); + rr.inset(20, 20, &rr2); + path_contains_rrect_check(reporter, rr, dir, start); + } + } } @@ -193,152 +244,177 @@ static void test_9patch_rrect(skiatest::Reporter* reporter, const SkRect& rect, SkScalar l, SkScalar t, SkScalar r, SkScalar b, bool checkRadii) { - SkRRect rr; - rr.setNinePatch(rect, l, t, r, b); - if (checkRadii) { - path_contains_rrect_check(reporter, rr); - } else { - path_contains_rrect_nocheck(reporter, rr); - } - - SkRRect rr2; // construct the same RR using the most general set function - SkVector radii[4] = { { l, t }, { r, t }, { r, b }, { l, b } }; - rr2.setRectRadii(rect, radii); - if (checkRadii) { - path_contains_rrect_check(reporter, rr); - } else { - path_contains_rrect_nocheck(reporter, rr); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + SkRRect rr; + rr.setNinePatch(rect, l, t, r, b); + if (checkRadii) { + path_contains_rrect_check(reporter, rr, dir, start); + } else { + path_contains_rrect_nocheck(reporter, rr, dir, start); + } + + SkRRect rr2; // construct the same RR using the most general set function + SkVector radii[4] = { { l, t }, { r, t }, { r, b }, { l, b } }; + rr2.setRectRadii(rect, radii); + if (checkRadii) { + path_contains_rrect_check(reporter, rr, dir, start); + } else { + path_contains_rrect_nocheck(reporter, rr, dir, start); + } + } } } // Test out the basic API entry points static void test_round_rect_basic(skiatest::Reporter* reporter) { - - //---- - SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); - - SkRRect rr1; - rr1.setRect(rect); - path_contains_rrect_check(reporter, rr1); - - SkRRect rr1_2; // construct the same RR using the most general set function - SkVector rr1_2_radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; - rr1_2.setRectRadii(rect, rr1_2_radii); - path_contains_rrect_check(reporter, rr1_2); - SkRRect rr1_3; // construct the same RR using the nine patch set function - rr1_3.setNinePatch(rect, 0, 0, 0, 0); - path_contains_rrect_check(reporter, rr1_2); - - //---- - SkPoint halfPoint = { SkScalarHalf(kWidth), SkScalarHalf(kHeight) }; - SkRRect rr2; - rr2.setOval(rect); - path_contains_rrect_check(reporter, rr2); - - SkRRect rr2_2; // construct the same RR using the most general set function - SkVector rr2_2_radii[4] = { { halfPoint.fX, halfPoint.fY }, { halfPoint.fX, halfPoint.fY }, - { halfPoint.fX, halfPoint.fY }, { halfPoint.fX, halfPoint.fY } }; - rr2_2.setRectRadii(rect, rr2_2_radii); - path_contains_rrect_check(reporter, rr2_2); - SkRRect rr2_3; // construct the same RR using the nine patch set function - rr2_3.setNinePatch(rect, halfPoint.fX, halfPoint.fY, halfPoint.fX, halfPoint.fY); - path_contains_rrect_check(reporter, rr2_3); - - //---- - SkPoint p = { 5, 5 }; - SkRRect rr3; - rr3.setRectXY(rect, p.fX, p.fY); - path_contains_rrect_check(reporter, rr3); - - SkRRect rr3_2; // construct the same RR using the most general set function - SkVector rr3_2_radii[4] = { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 } }; - rr3_2.setRectRadii(rect, rr3_2_radii); - path_contains_rrect_check(reporter, rr3_2); - SkRRect rr3_3; // construct the same RR using the nine patch set function - rr3_3.setNinePatch(rect, 5, 5, 5, 5); - path_contains_rrect_check(reporter, rr3_3); - - //---- - test_9patch_rrect(reporter, rect, 10, 9, 8, 7, true); - - { - // Test out the rrect from skia:3466 - SkRect rect2 = SkRect::MakeLTRB(0.358211994f, 0.755430222f, 0.872866154f, 0.806214333f); - - test_9patch_rrect(reporter, - rect2, - 0.926942348f, 0.642850280f, 0.529063463f, 0.587844372f, - false); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + //---- + SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); + + SkRRect rr1; + rr1.setRect(rect); + path_contains_rrect_check(reporter, rr1, dir, start); + + SkRRect rr1_2; // construct the same RR using the most general set function + SkVector rr1_2_radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; + rr1_2.setRectRadii(rect, rr1_2_radii); + path_contains_rrect_check(reporter, rr1_2, dir, start); + SkRRect rr1_3; // construct the same RR using the nine patch set function + rr1_3.setNinePatch(rect, 0, 0, 0, 0); + path_contains_rrect_check(reporter, rr1_2, dir, start); + + //---- + SkPoint halfPoint = { SkScalarHalf(kWidth), SkScalarHalf(kHeight) }; + SkRRect rr2; + rr2.setOval(rect); + path_contains_rrect_check(reporter, rr2, dir, start); + + SkRRect rr2_2; // construct the same RR using the most general set function + SkVector rr2_2_radii[4] = { { halfPoint.fX, halfPoint.fY }, + { halfPoint.fX, halfPoint.fY }, + { halfPoint.fX, halfPoint.fY }, + { halfPoint.fX, halfPoint.fY } }; + rr2_2.setRectRadii(rect, rr2_2_radii); + path_contains_rrect_check(reporter, rr2_2, dir, start); + SkRRect rr2_3; // construct the same RR using the nine patch set function + rr2_3.setNinePatch(rect, halfPoint.fX, halfPoint.fY, halfPoint.fX, halfPoint.fY); + path_contains_rrect_check(reporter, rr2_3, dir, start); + + //---- + SkPoint p = { 5, 5 }; + SkRRect rr3; + rr3.setRectXY(rect, p.fX, p.fY); + path_contains_rrect_check(reporter, rr3, dir, start); + + SkRRect rr3_2; // construct the same RR using the most general set function + SkVector rr3_2_radii[4] = { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 } }; + rr3_2.setRectRadii(rect, rr3_2_radii); + path_contains_rrect_check(reporter, rr3_2, dir, start); + SkRRect rr3_3; // construct the same RR using the nine patch set function + rr3_3.setNinePatch(rect, 5, 5, 5, 5); + path_contains_rrect_check(reporter, rr3_3, dir, start); + + //---- + test_9patch_rrect(reporter, rect, 10, 9, 8, 7, true); + + { + // Test out the rrect from skia:3466 + SkRect rect2 = SkRect::MakeLTRB(0.358211994f, 0.755430222f, 0.872866154f, + 0.806214333f); + + test_9patch_rrect(reporter, + rect2, + 0.926942348f, 0.642850280f, 0.529063463f, 0.587844372f, + false); + } + + //---- + SkPoint radii2[4] = { { 0, 0 }, { 0, 0 }, { 50, 50 }, { 20, 50 } }; + + SkRRect rr5; + rr5.setRectRadii(rect, radii2); + path_contains_rrect_check(reporter, rr5, dir, start); + } } - - //---- - SkPoint radii2[4] = { { 0, 0 }, { 0, 0 }, { 50, 50 }, { 20, 50 } }; - - SkRRect rr5; - rr5.setRectRadii(rect, radii2); - path_contains_rrect_check(reporter, rr5); } // Test out the cases when the RR degenerates to a rect static void test_round_rect_rects(skiatest::Reporter* reporter) { + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + //---- + SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); + SkRRect rr1; + rr1.setRectXY(rect, 0, 0); - //---- - SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); - SkRRect rr1; - rr1.setRectXY(rect, 0, 0); + path_contains_rrect_check(reporter, rr1, dir, start); - path_contains_rrect_check(reporter, rr1); + //---- + SkPoint radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; - //---- - SkPoint radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; + SkRRect rr2; + rr2.setRectRadii(rect, radii); - SkRRect rr2; - rr2.setRectRadii(rect, radii); + path_contains_rrect_check(reporter, rr2, dir, start); - path_contains_rrect_check(reporter, rr2); + //---- + SkPoint radii2[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; - //---- - SkPoint radii2[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; - - SkRRect rr3; - rr3.setRectRadii(rect, radii2); - path_contains_rrect_check(reporter, rr3); + SkRRect rr3; + rr3.setRectRadii(rect, radii2); + path_contains_rrect_check(reporter, rr3, dir, start); + } + } } // Test out the cases when the RR degenerates to an oval static void test_round_rect_ovals(skiatest::Reporter* reporter) { - //---- - SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); - SkRRect rr1; - rr1.setRectXY(rect, SkScalarHalf(kWidth), SkScalarHalf(kHeight)); - - path_contains_rrect_check(reporter, rr1); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + //---- + SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); + SkRRect rr1; + rr1.setRectXY(rect, SkScalarHalf(kWidth), SkScalarHalf(kHeight)); + + path_contains_rrect_check(reporter, rr1, dir, start); + } + } } // Test out the non-degenerate RR cases static void test_round_rect_general(skiatest::Reporter* reporter) { - //---- - SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); - SkRRect rr1; - rr1.setRectXY(rect, 20, 20); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + //---- + SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); + SkRRect rr1; + rr1.setRectXY(rect, 20, 20); - path_contains_rrect_check(reporter, rr1); + path_contains_rrect_check(reporter, rr1, dir, start); - //---- - SkPoint radii[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; + //---- + SkPoint radii[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; - SkRRect rr2; - rr2.setRectRadii(rect, radii); + SkRRect rr2; + rr2.setRectRadii(rect, radii); - path_contains_rrect_check(reporter, rr2); + path_contains_rrect_check(reporter, rr2, dir, start); + } + } } static void test_round_rect_iffy_parameters(skiatest::Reporter* reporter) { - SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); - SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } }; - SkRRect rr1; - rr1.setRectRadii(rect, radii); - path_contains_rrect_nocheck(reporter, rr1); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); + SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } }; + SkRRect rr1; + rr1.setRectRadii(rect, radii); + path_contains_rrect_nocheck(reporter, rr1, dir, start); + } + } } static void set_radii(SkVector radii[4], int index, float rad) { @@ -356,21 +432,29 @@ static void test_skbug_3239(skiatest::Reporter* reporter) { const SkRect rectx = SkRect::MakeLTRB(min, min, max, big); const SkRect recty = SkRect::MakeLTRB(min, min, big, max); - SkVector radii[4]; - for (int i = 0; i < 4; ++i) { - set_radii(radii, i, rad); - path_contains_rrect_check(reporter, rectx, radii); - path_contains_rrect_check(reporter, recty, radii); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + SkVector radii[4]; + for (int i = 0; i < 4; ++i) { + set_radii(radii, i, rad); + path_contains_rrect_check(reporter, rectx, radii, dir, start); + path_contains_rrect_check(reporter, recty, radii, dir, start); + } + } } } static void test_mix(skiatest::Reporter* reporter) { - // Test out mixed degenerate and non-degenerate geometry with Conics - const SkVector radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 100, 100 } }; - SkRect r = SkRect::MakeWH(100, 100); - SkRRect rr; - rr.setRectRadii(r, radii); - path_contains_rrect_check(reporter, rr); + for (auto dir : {SkPath::kCW_Direction, SkPath::kCCW_Direction}) { + for (int start = 0; start < 8; ++start) { + // Test out mixed degenerate and non-degenerate geometry with Conics + const SkVector radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 100, 100 } }; + SkRect r = SkRect::MakeWH(100, 100); + SkRRect rr; + rr.setRectRadii(r, radii); + path_contains_rrect_check(reporter, rr, dir, start); + } + } } DEF_TEST(RoundRectInPath, reporter) { -- cgit v1.2.3