tests/PathTest.cpp - Issue 65493004: increase coverage of SkPath.cpp, remove unused code

Unified Diff: tests/PathTest.cpp

Issue 65493004: increase coverage of SkPath.cpp, remove unused code (Closed) Base URL: https://skia.googlecode.com/svn/trunk

Patch Set: remove dead code Created 7 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: tests/PathTest.cpp

diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp

index 2dbf5c695e99039d9ef9d05619011afa9d0a7549..c1aa47be6391fcda57627ef8a6b499e055d77089 100644

--- a/tests/PathTest.cpp

+++ b/tests/PathTest.cpp

@@ -23,11 +23,11 @@

static void make_path0(SkPath* path) {

// from * https://code.google.com/p/skia/issues/detail?id=1706

- path->moveTo(146.939f, 1012.84f);

- path->lineTo(181.747f, 1009.18f);

- path->lineTo(182.165f, 1013.16f);

- path->lineTo(147.357f, 1016.82f);

- path->lineTo(146.939f, 1012.84f);

+ path->moveTo(SkFloatToScalar(146.939f), SkFloatToScalar(1012.84f));

reed1 2013/11/13 18:37:52 are these macros required?

caryclark 2013/11/13 18:52:37 Only if one day, we wanted to allow optionally SkS

reed1 2013/11/13 18:58:58 Good question. It began life when scalars could be

+ path->lineTo(SkFloatToScalar(181.747f), SkFloatToScalar(1009.18f));

+ path->lineTo(SkFloatToScalar(182.165f), SkFloatToScalar(1013.16f));

+ path->lineTo(SkFloatToScalar(147.357f), SkFloatToScalar(1016.82f));

+ path->lineTo(SkFloatToScalar(146.939f), SkFloatToScalar(1012.84f));

path->close();

}

@@ -143,7 +143,10 @@ static void test_android_specific_behavior(skiatest::Reporter* reporter) {

assign = original;

REPORTER_ASSERT(reporter, assign.getGenerationID() != assignID);

REPORTER_ASSERT(reporter, assign.getSourcePath() == original.getSourcePath());

+ assignID = assign.getGenerationID();

+ assign = assign;

reed1 2013/11/13 18:37:52 this looks odd enough, perhaps we could add a comm

caryclark 2013/11/13 18:52:37 I'll add a comment. I wouldn't be surprised if I

reed1 2013/11/13 18:58:58 It definitely is. I'm just noting that we don't *t

+ REPORTER_ASSERT(reporter, assign.getGenerationID() == assignID);

// Test rewind. Change generation ID, don't touch source path.

copyID = copy.getGenerationID();

copy.rewind();

@@ -222,10 +225,10 @@ static void test_gen_id(skiatest::Reporter* reporter) {

// This used to assert in the debug build, as the edges did not all line-up.

static void test_bad_cubic_crbug234190() {

SkPath path;

- path.moveTo(13.8509f, 3.16858f);

- path.cubicTo(-2.35893e+08f, -4.21044e+08f,

- -2.38991e+08f, -4.26573e+08f,

- -2.41016e+08f, -4.30188e+08f);

+ path.moveTo(SkFloatToScalar(13.8509f), SkFloatToScalar(3.16858f));

+ path.cubicTo(SkFloatToScalar(-2.35893e+08f), SkFloatToScalar(-4.21044e+08f),

+ SkFloatToScalar(-2.38991e+08f), SkFloatToScalar(-4.26573e+08f),

+ SkFloatToScalar(-2.41016e+08f), SkFloatToScalar(-4.30188e+08f));

SkPaint paint;

paint.setAntiAlias(true);

@@ -235,10 +238,10 @@ static void test_bad_cubic_crbug234190() {

static void test_bad_cubic_crbug229478() {

const SkPoint pts[] = {

- { 4595.91064f, -11596.9873f },

- { 4597.2168f, -11595.9414f },

- { 4598.52344f, -11594.8955f },

- { 4599.83008f, -11593.8496f },

+ { SkFloatToScalar(4595.91064f), SkFloatToScalar(-11596.9873f) },

+ { SkFloatToScalar(4597.2168f), SkFloatToScalar(-11595.9414f) },

+ { SkFloatToScalar(4598.52344f), SkFloatToScalar(-11594.8955f) },

+ { SkFloatToScalar(4599.83008f), SkFloatToScalar(-11593.8496f) },

};

SkPath path;

@@ -256,88 +259,88 @@ static void test_bad_cubic_crbug229478() {

}

static void build_path_170666(SkPath& path) {

- path.moveTo(17.9459f, 21.6344f);

- path.lineTo(139.545f, -47.8105f);

- path.lineTo(131.07f, -47.3888f);

- path.lineTo(122.586f, -46.9532f);

- path.lineTo(18076.6f, 31390.9f);

- path.lineTo(18085.1f, 31390.5f);

- path.lineTo(18076.6f, 31390.9f);

- path.lineTo(17955, 31460.3f);

- path.lineTo(17963.5f, 31459.9f);

- path.lineTo(17971.9f, 31459.5f);

- path.lineTo(17.9551f, 21.6205f);

- path.lineTo(9.47091f, 22.0561f);

- path.lineTo(17.9459f, 21.6344f);

- path.close();path.moveTo(0.995934f, 22.4779f);

- path.lineTo(0.986725f, 22.4918f);

- path.lineTo(17955, 31460.4f);

- path.lineTo(17971.9f, 31459.5f);

- path.lineTo(18093.6f, 31390.1f);

- path.lineTo(18093.6f, 31390);

- path.lineTo(139.555f, -47.8244f);

- path.lineTo(122.595f, -46.9671f);

- path.lineTo(0.995934f, 22.4779f);

+ path.moveTo(SkFloatToScalar(17.9459f), SkFloatToScalar(21.6344f));

+ path.lineTo(SkFloatToScalar(139.545f), SkFloatToScalar(-47.8105f));

+ path.lineTo(SkFloatToScalar(131.07f), SkFloatToScalar(-47.3888f));

+ path.lineTo(SkFloatToScalar(122.586f), SkFloatToScalar(-46.9532f));

+ path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));

+ path.lineTo(SkFloatToScalar(18085.1f), SkFloatToScalar(31390.5f));

+ path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));

+ path.lineTo(17955, SkFloatToScalar(31460.3f));

+ path.lineTo(SkFloatToScalar(17963.5f), SkFloatToScalar(31459.9f));

+ path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));

+ path.lineTo(SkFloatToScalar(17.9551f), SkFloatToScalar(21.6205f));

+ path.lineTo(SkFloatToScalar(9.47091f), SkFloatToScalar(22.0561f));

+ path.lineTo(SkFloatToScalar(17.9459f), SkFloatToScalar(21.6344f));

+ path.close();path.moveTo(SkFloatToScalar(0.995934f), SkFloatToScalar(22.4779f));

+ path.lineTo(SkFloatToScalar(0.986725f), SkFloatToScalar(22.4918f));

+ path.lineTo(17955, SkFloatToScalar(31460.4f));

+ path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));

+ path.lineTo(SkFloatToScalar(18093.6f), SkFloatToScalar(31390.1f));

+ path.lineTo(SkFloatToScalar(18093.6f), 31390);

+ path.lineTo(SkFloatToScalar(139.555f), SkFloatToScalar(-47.8244f));

+ path.lineTo(SkFloatToScalar(122.595f), SkFloatToScalar(-46.9671f));

+ path.lineTo(SkFloatToScalar(0.995934f), SkFloatToScalar(22.4779f));

path.close();

- path.moveTo(5.43941f, 25.5223f);

- path.lineTo(798267, -28871.1f);

- path.lineTo(3.12512e+06f, -113102);

- path.cubicTo(5.16324e+06f, -186882, 8.15247e+06f, -295092, 1.1957e+07f, -432813);

- path.cubicTo(1.95659e+07f, -708257, 3.04359e+07f, -1.10175e+06f, 4.34798e+07f, -1.57394e+06f);

- path.cubicTo(6.95677e+07f, -2.51831e+06f, 1.04352e+08f, -3.77748e+06f, 1.39135e+08f, -5.03666e+06f);

- path.cubicTo(1.73919e+08f, -6.29583e+06f, 2.08703e+08f, -7.555e+06f, 2.34791e+08f, -8.49938e+06f);

- path.cubicTo(2.47835e+08f, -8.97157e+06f, 2.58705e+08f, -9.36506e+06f, 2.66314e+08f, -9.6405e+06f);

- path.cubicTo(2.70118e+08f, -9.77823e+06f, 2.73108e+08f, -9.88644e+06f, 2.75146e+08f, -9.96022e+06f);

- path.cubicTo(2.76165e+08f, -9.99711e+06f, 2.76946e+08f, -1.00254e+07f, 2.77473e+08f, -1.00444e+07f);

- path.lineTo(2.78271e+08f, -1.00733e+07f);

- path.cubicTo(2.78271e+08f, -1.00733e+07f, 2.08703e+08f, -7.555e+06f, 135.238f, 23.3517f);

- path.cubicTo(131.191f, 23.4981f, 125.995f, 23.7976f, 123.631f, 24.0206f);

- path.cubicTo(121.267f, 24.2436f, 122.631f, 24.3056f, 126.677f, 24.1591f);

- path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);

- path.lineTo(2.77473e+08f, -1.00444e+07f);

- path.cubicTo(2.76946e+08f, -1.00254e+07f, 2.76165e+08f, -9.99711e+06f, 2.75146e+08f, -9.96022e+06f);

- path.cubicTo(2.73108e+08f, -9.88644e+06f, 2.70118e+08f, -9.77823e+06f, 2.66314e+08f, -9.6405e+06f);

- path.cubicTo(2.58705e+08f, -9.36506e+06f, 2.47835e+08f, -8.97157e+06f, 2.34791e+08f, -8.49938e+06f);

- path.cubicTo(2.08703e+08f, -7.555e+06f, 1.73919e+08f, -6.29583e+06f, 1.39135e+08f, -5.03666e+06f);

- path.cubicTo(1.04352e+08f, -3.77749e+06f, 6.95677e+07f, -2.51831e+06f, 4.34798e+07f, -1.57394e+06f);

- path.cubicTo(3.04359e+07f, -1.10175e+06f, 1.95659e+07f, -708258, 1.1957e+07f, -432814);

- path.cubicTo(8.15248e+06f, -295092, 5.16324e+06f, -186883, 3.12513e+06f, -113103);

+ path.moveTo(SkFloatToScalar(5.43941f), SkFloatToScalar(25.5223f));

+ path.lineTo(798267, SkFloatToScalar(-28871.1f));

+ path.lineTo(SkFloatToScalar(3.12512e+06f), -113102);

+ path.cubicTo(SkFloatToScalar(5.16324e+06f), -186882, SkFloatToScalar(8.15247e+06f), -295092, SkFloatToScalar(1.1957e+07f), -432813);

+ path.cubicTo(SkFloatToScalar(1.95659e+07f), -708257, SkFloatToScalar(3.04359e+07f), SkFloatToScalar(-1.10175e+06f), SkFloatToScalar(4.34798e+07f), SkFloatToScalar(-1.57394e+06f));

+ path.cubicTo(SkFloatToScalar(6.95677e+07f), SkFloatToScalar(-2.51831e+06f), SkFloatToScalar(1.04352e+08f), SkFloatToScalar(-3.77748e+06f), SkFloatToScalar(1.39135e+08f), SkFloatToScalar(-5.03666e+06f));

+ path.cubicTo(SkFloatToScalar(1.73919e+08f), SkFloatToScalar(-6.29583e+06f), SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(2.34791e+08f), SkFloatToScalar(-8.49938e+06f));

+ path.cubicTo(SkFloatToScalar(2.47835e+08f), SkFloatToScalar(-8.97157e+06f), SkFloatToScalar(2.58705e+08f), SkFloatToScalar(-9.36506e+06f), SkFloatToScalar(2.66314e+08f), SkFloatToScalar(-9.6405e+06f));

+ path.cubicTo(SkFloatToScalar(2.70118e+08f), SkFloatToScalar(-9.77823e+06f), SkFloatToScalar(2.73108e+08f), SkFloatToScalar(-9.88644e+06f), SkFloatToScalar(2.75146e+08f), SkFloatToScalar(-9.96022e+06f));

+ path.cubicTo(SkFloatToScalar(2.76165e+08f), SkFloatToScalar(-9.99711e+06f), SkFloatToScalar(2.76946e+08f), SkFloatToScalar(-1.00254e+07f), SkFloatToScalar(2.77473e+08f), SkFloatToScalar(-1.00444e+07f));

+ path.lineTo(SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));

+ path.cubicTo(SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f), SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(135.238f), SkFloatToScalar(23.3517f));

+ path.cubicTo(SkFloatToScalar(131.191f), SkFloatToScalar(23.4981f), SkFloatToScalar(125.995f), SkFloatToScalar(23.7976f), SkFloatToScalar(123.631f), SkFloatToScalar(24.0206f));

+ path.cubicTo(SkFloatToScalar(121.267f), SkFloatToScalar(24.2436f), SkFloatToScalar(122.631f), SkFloatToScalar(24.3056f), SkFloatToScalar(126.677f), SkFloatToScalar(24.1591f));

+ path.cubicTo(SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));

+ path.lineTo(SkFloatToScalar(2.77473e+08f), SkFloatToScalar(-1.00444e+07f));

+ path.cubicTo(SkFloatToScalar(2.76946e+08f), SkFloatToScalar(-1.00254e+07f), SkFloatToScalar(2.76165e+08f), SkFloatToScalar(-9.99711e+06f), SkFloatToScalar(2.75146e+08f), SkFloatToScalar(-9.96022e+06f));

+ path.cubicTo(SkFloatToScalar(2.73108e+08f), SkFloatToScalar(-9.88644e+06f), SkFloatToScalar(2.70118e+08f), SkFloatToScalar(-9.77823e+06f), SkFloatToScalar(2.66314e+08f), SkFloatToScalar(-9.6405e+06f));

+ path.cubicTo(SkFloatToScalar(2.58705e+08f), SkFloatToScalar(-9.36506e+06f), SkFloatToScalar(2.47835e+08f), SkFloatToScalar(-8.97157e+06f), SkFloatToScalar(2.34791e+08f), SkFloatToScalar(-8.49938e+06f));

+ path.cubicTo(SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(1.73919e+08f), SkFloatToScalar(-6.29583e+06f), SkFloatToScalar(1.39135e+08f), SkFloatToScalar(-5.03666e+06f));

+ path.cubicTo(SkFloatToScalar(1.04352e+08f), SkFloatToScalar(-3.77749e+06f), SkFloatToScalar(6.95677e+07f), SkFloatToScalar(-2.51831e+06f), SkFloatToScalar(4.34798e+07f), SkFloatToScalar(-1.57394e+06f));

+ path.cubicTo(SkFloatToScalar(3.04359e+07f), SkFloatToScalar(-1.10175e+06f), SkFloatToScalar(1.95659e+07f), -708258, SkFloatToScalar(1.1957e+07f), -432814);

+ path.cubicTo(SkFloatToScalar(8.15248e+06f), -295092, SkFloatToScalar(5.16324e+06f), -186883, SkFloatToScalar(3.12513e+06f), -113103);

path.lineTo(798284, -28872);

- path.lineTo(22.4044f, 24.6677f);

- path.cubicTo(22.5186f, 24.5432f, 18.8134f, 24.6337f, 14.1287f, 24.8697f);

- path.cubicTo(9.4439f, 25.1057f, 5.55359f, 25.3978f, 5.43941f, 25.5223f);

+ path.lineTo(SkFloatToScalar(22.4044f), SkFloatToScalar(24.6677f));

+ path.cubicTo(SkFloatToScalar(22.5186f), SkFloatToScalar(24.5432f), SkFloatToScalar(18.8134f), SkFloatToScalar(24.6337f), SkFloatToScalar(14.1287f), SkFloatToScalar(24.8697f));

+ path.cubicTo(SkFloatToScalar(9.4439f), SkFloatToScalar(25.1057f), SkFloatToScalar(5.55359f), SkFloatToScalar(25.3978f), SkFloatToScalar(5.43941f), SkFloatToScalar(25.5223f));

path.close();

}

static void build_path_simple_170666(SkPath& path) {

- path.moveTo(126.677f, 24.1591f);

- path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);

+ path.moveTo(SkFloatToScalar(126.677f), SkFloatToScalar(24.1591f));

}

// This used to assert in the SK_DEBUG build, as the clip step would fail with

@@ -380,22 +383,22 @@ static void test_addrect_isfinite(skiatest::Reporter* reporter) {

static void build_big_path(SkPath* path, bool reducedCase) {

if (reducedCase) {

- path->moveTo(577330, 1971.72f);

- path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);

+ path->moveTo(577330, SkFloatToScalar(1971.72f));

+ path->cubicTo(SkFloatToScalar(10.7082f), SkFloatToScalar(-116.596f), SkFloatToScalar(262.057f), SkFloatToScalar(45.6468f), SkFloatToScalar(294.694f), SkFloatToScalar(1.96237f));

} else {

- path->moveTo(60.1631f, 7.70567f);

- path->quadTo(60.1631f, 7.70567f, 0.99474f, 0.901199f);

- path->lineTo(577379, 1977.77f);

- path->quadTo(577364, 1979.57f, 577325, 1980.26f);

- path->quadTo(577286, 1980.95f, 577245, 1980.13f);

- path->quadTo(577205, 1979.3f, 577187, 1977.45f);

- path->quadTo(577168, 1975.6f, 577183, 1973.8f);

- path->quadTo(577198, 1972, 577238, 1971.31f);

- path->quadTo(577277, 1970.62f, 577317, 1971.45f);

- path->quadTo(577330, 1971.72f, 577341, 1972.11f);

- path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);

- path->moveTo(306.718f, -32.912f);

- path->cubicTo(30.531f, 10.0005f, 1502.47f, 13.2804f, 84.3088f, 9.99601f);

+ path->moveTo(SkFloatToScalar(60.1631f), SkFloatToScalar(7.70567f));

+ path->quadTo(SkFloatToScalar(60.1631f), SkFloatToScalar(7.70567f), SkFloatToScalar(0.99474f), SkFloatToScalar(0.901199f));

+ path->lineTo(577379, SkFloatToScalar(1977.77f));

+ path->quadTo(577364, SkFloatToScalar(1979.57f), 577325, SkFloatToScalar(1980.26f));

+ path->quadTo(577286, SkFloatToScalar(1980.95f), 577245, SkFloatToScalar(1980.13f));

+ path->quadTo(577205, SkFloatToScalar(1979.3f), 577187, SkFloatToScalar(1977.45f));

+ path->quadTo(577168, SkFloatToScalar(1975.6f), 577183, SkFloatToScalar(1973.8f));

+ path->quadTo(577198, 1972, 577238, SkFloatToScalar(1971.31f));

+ path->quadTo(577277, SkFloatToScalar(1970.62f), 577317, SkFloatToScalar(1971.45f));

+ path->quadTo(577330, SkFloatToScalar(1971.72f), 577341, SkFloatToScalar(1972.11f));

+ path->cubicTo(SkFloatToScalar(10.7082f), SkFloatToScalar(-116.596f), SkFloatToScalar(262.057f), SkFloatToScalar(45.6468f), SkFloatToScalar(294.694f), SkFloatToScalar(1.96237f));

+ path->moveTo(SkFloatToScalar(306.718f), SkFloatToScalar(-32.912f));

+ path->cubicTo(SkFloatToScalar(30.531f), SkFloatToScalar(10.0005f), SkFloatToScalar(1502.47f), SkFloatToScalar(13.2804f), SkFloatToScalar(84.3088f), SkFloatToScalar(9.99601f));

}

@@ -446,7 +449,7 @@ static void test_tricky_cubic() {

static void test_isfinite_after_transform(skiatest::Reporter* reporter) {

SkPath path;

path.quadTo(157, 366, 286, 208);

- path.arcTo(37, 442, 315, 163, 957494590897113.0f);

+ path.arcTo(37, 442, 315, 163, SkFloatToScalar(957494590897113.0f));

SkMatrix matrix;

matrix.setScale(1000*1000, 1000*1000);

@@ -811,6 +814,18 @@ static void test_direction(skiatest::Reporter* reporter) {

path.lineTo(-10 * SK_Scalar1, 60 * SK_Scalar1);

check_direction(reporter, path, SkPath::kCCW_Direction);

#endif

+ path.reset();

+ path.conicTo(20, 0, 20, 20, SkFloatToScalar(0.5f));

+ path.close();

+ check_direction(reporter, path, SkPath::kCW_Direction);

+ path.reset();

+ path.lineTo(1, SkFloatToScalar(1e7f));

+ path.lineTo(SkFloatToScalar(1e7f), SkFloatToScalar(2e7f));

+ path.close();

+ REPORTER_ASSERT(reporter, SkPath::kConvex_Convexity == path.getConvexity());

+ check_direction(reporter, path, SkPath::kCCW_Direction);

}

static void add_rect(SkPath* path, const SkRect& r) {

@@ -856,19 +871,19 @@ static void stroke_cubic(const SkPoint pts[4]) {

// but that was fixed with the introduction of SkPoint::CanNormalize

static void stroke_tiny_cubic() {

SkPoint p0[] = {

- { 372.0f, 92.0f },

+ { SkFloatToScalar(372.0f), SkFloatToScalar(92.0f) },

};

stroke_cubic(p0);

SkPoint p1[] = {

- { 372.0f, 92.0f },

- { 372.0007f, 92.000755f },

- { 371.99927f, 92.003922f },

- { 371.99826f, 92.003899f },

+ { SkFloatToScalar(372.0f), SkFloatToScalar(92.0f) },

+ { SkFloatToScalar(372.0007f), SkFloatToScalar(92.000755f) },

+ { SkFloatToScalar(371.99927f), SkFloatToScalar(92.003922f) },

+ { SkFloatToScalar(371.99826f), SkFloatToScalar(92.003899f) },

};

stroke_cubic(p1);

@@ -1146,6 +1161,18 @@ static void test_convexity(skiatest::Reporter* reporter) {

setFromString(&path, gRec[i].fPathStr);

check_convexity(reporter, path, gRec[i].fExpectedConvexity);

check_direction(reporter, path, gRec[i].fExpectedDirection);

+ // check after setting the initial convex and direction

+ if (kDontCheckDir != gRec[i].fExpectedDirection) {

+ SkPath copy(path);

+ SkPath::Direction dir;

+ bool foundDir = copy.cheapComputeDirection(&dir);

+ REPORTER_ASSERT(reporter, (gRec[i].fExpectedDirection == SkPath::kUnknown_Direction)

+ ^ foundDir);

+ REPORTER_ASSERT(reporter, !foundDir || gRec[i].fExpectedDirection == dir);

+ check_convexity(reporter, copy, gRec[i].fExpectedConvexity);

+ }

+ REPORTER_ASSERT(reporter, gRec[i].fExpectedConvexity == path.getConvexity());

+ check_direction(reporter, path, gRec[i].fExpectedDirection);

}

@@ -1166,7 +1193,7 @@ static void test_isLine(skiatest::Reporter* reporter) {

const SkScalar moveX = SkIntToScalar(1);

const SkScalar moveY = SkIntToScalar(2);

- SkASSERT(value != moveX && value != moveY);

+ REPORTER_ASSERT(reporter, value != moveX && value != moveY);

path.moveTo(moveX, moveY);

REPORTER_ASSERT(reporter, !path.isLine(NULL));

@@ -1177,7 +1204,7 @@ static void test_isLine(skiatest::Reporter* reporter) {

const SkScalar lineX = SkIntToScalar(2);

const SkScalar lineY = SkIntToScalar(2);

- SkASSERT(value != lineX && value != lineY);

+ REPORTER_ASSERT(reporter, value != lineX && value != lineY);

path.lineTo(lineX, lineY);

REPORTER_ASSERT(reporter, path.isLine(NULL));

@@ -1214,74 +1241,75 @@ static void test_conservativelyContains(skiatest::Reporter* reporter) {

bool fInRect;

bool fInCircle;

bool fInRR;

+ bool fInCubicRR;

} kQueries[] = {

- {kBaseRect, true, true, false},

+ {kBaseRect, true, true, false, false},

// rect well inside of kBaseRect

{SkRect::MakeLTRB(kBaseRect.fLeft + SkFloatToScalar(0.25f)*kBaseRect.width(),

kBaseRect.fTop + SkFloatToScalar(0.25f)*kBaseRect.height(),

kBaseRect.fRight - SkFloatToScalar(0.25f)*kBaseRect.width(),

kBaseRect.fBottom - SkFloatToScalar(0.25f)*kBaseRect.height()),

- true, true, true},

+ true, true, true, true},

// rects with edges off by one from kBaseRect's edges

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,

kBaseRect.width(), kBaseRect.height() + 1),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,

kBaseRect.width() + 1, kBaseRect.height()),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,

kBaseRect.width() + 1, kBaseRect.height() + 1),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft - 1, kBaseRect.fTop,

kBaseRect.width(), kBaseRect.height()),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop - 1,

kBaseRect.width(), kBaseRect.height()),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft - 1, kBaseRect.fTop,

kBaseRect.width() + 2, kBaseRect.height()),

- false, true, false},

+ false, true, false, false},

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop - 1,

kBaseRect.width() + 2, kBaseRect.height()),

- false, true, false},

+ false, true, false, false},

// zero-w/h rects at each corner of kBaseRect

- {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop, 0, 0), true, true, false},

- {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fTop, 0, 0), true, true, false},

- {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fBottom, 0, 0), true, true, false},

- {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fBottom, 0, 0), true, true, false},

+ {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop, 0, 0), true, true, false, false},

+ {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fTop, 0, 0), true, true, false, true},

+ {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fBottom, 0, 0), true, true, false, true},

+ {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fBottom, 0, 0), true, true, false, true},

// far away rect

{SkRect::MakeXYWH(10 * kBaseRect.fRight, 10 * kBaseRect.fBottom,

SkIntToScalar(10), SkIntToScalar(10)),

- false, false, false},

+ false, false, false, false},

// very large rect containing kBaseRect

{SkRect::MakeXYWH(kBaseRect.fLeft - 5 * kBaseRect.width(),

kBaseRect.fTop - 5 * kBaseRect.height(),

11 * kBaseRect.width(), 11 * kBaseRect.height()),

- false, false, false},

+ false, false, false, false},

// skinny rect that spans same y-range as kBaseRect

{SkRect::MakeXYWH(kBaseRect.centerX(), kBaseRect.fTop,

SkIntToScalar(1), kBaseRect.height()),

- true, true, true},

+ true, true, true, true},

// short rect that spans same x-range as kBaseRect

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.centerY(), kBaseRect.width(), SkScalar(1)),

- true, true, true},

+ true, true, true, true},

// skinny rect that spans slightly larger y-range than kBaseRect

{SkRect::MakeXYWH(kBaseRect.centerX(), kBaseRect.fTop,

SkIntToScalar(1), kBaseRect.height() + 1),

- false, true, false},

+ false, true, false, false},

// short rect that spans slightly larger x-range than kBaseRect

{SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.centerY(),

kBaseRect.width() + 1, SkScalar(1)),

- false, true, false},

+ false, true, false, false},

};

for (int inv = 0; inv < 4; ++inv) {

@@ -1309,6 +1337,19 @@ static void test_conservativelyContains(skiatest::Reporter* reporter) {

path.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1], dir);

REPORTER_ASSERT(reporter, kQueries[q].fInRR ==

path.conservativelyContainsRect(qRect));

+ path.reset();

+ path.moveTo(kBaseRect.fLeft + kRRRadii[0], kBaseRect.fTop);

+ path.cubicTo(kBaseRect.fLeft + kRRRadii[0] / 2, kBaseRect.fTop,

+ kBaseRect.fLeft, kBaseRect.fTop + kRRRadii[1] / 2,

+ kBaseRect.fLeft, kBaseRect.fTop + kRRRadii[1]);

+ path.lineTo(kBaseRect.fLeft, kBaseRect.fBottom);

+ path.lineTo(kBaseRect.fRight, kBaseRect.fBottom);

+ path.lineTo(kBaseRect.fRight, kBaseRect.fTop);

+ path.close();

+ REPORTER_ASSERT(reporter, kQueries[q].fInCubicRR ==

+ path.conservativelyContainsRect(qRect));

}

// Slightly non-convex shape, shouldn't contain any rects.

path.reset();

@@ -1398,8 +1439,8 @@ static void test_isRect(skiatest::Reporter* reporter) {

SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};

SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};

SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};

- SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}};

- SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}};

+ SkPoint ra[] = {{0, 0}, {0, SkFloatToScalar(.5f)}, {0, 1}, {SkFloatToScalar(.5f), 1}, {1, 1}, {1, SkFloatToScalar(.5f)}, {1, 0}, {SkFloatToScalar(.5f), 0}};

+ SkPoint rb[] = {{0, 0}, {SkFloatToScalar(.5f), 0}, {1, 0}, {1, SkFloatToScalar(.5f)}, {1, 1}, {SkFloatToScalar(.5f), 1}, {0, 1}, {0, SkFloatToScalar(.5f)}};

SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}};

SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}};

SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}};

@@ -1516,7 +1557,7 @@ static void test_isRect(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.moveTo(1, .5f);

+ path1.moveTo(1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1537,7 +1578,7 @@ static void test_isRect(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.quadTo(1, .5f, 1, .5f);

+ path1.quadTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1549,7 +1590,7 @@ static void test_isRect(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.cubicTo(1, .5f, 1, .5f, 1, .5f);

+ path1.cubicTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1568,8 +1609,8 @@ static void test_isNestedRects(skiatest::Reporter* reporter) {

SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};

SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};

SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};

- SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}}; // CCW

- SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}}; // CW

+ SkPoint ra[] = {{0, 0}, {0, SkFloatToScalar(.5f)}, {0, 1}, {SkFloatToScalar(.5f), 1}, {1, 1}, {1, SkFloatToScalar(.5f)}, {1, 0}, {SkFloatToScalar(.5f), 0}}; // CCW

+ SkPoint rb[] = {{0, 0}, {SkFloatToScalar(.5f), 0}, {1, 0}, {1, SkFloatToScalar(.5f)}, {1, 1}, {SkFloatToScalar(.5f), 1}, {0, 1}, {0, SkFloatToScalar(.5f)}}; // CW

SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}; // CW

SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}}; // CCW

SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW

@@ -1687,7 +1728,7 @@ static void test_isNestedRects(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.moveTo(1, .5f);

+ path1.moveTo(1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1720,7 +1761,7 @@ static void test_isNestedRects(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.quadTo(1, .5f, 1, .5f);

+ path1.quadTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1738,7 +1779,7 @@ static void test_isNestedRects(skiatest::Reporter* reporter) {

path1.moveTo(r1[0].fX, r1[0].fY);

for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {

if (index == 2) {

- path1.cubicTo(1, .5f, 1, .5f, 1, .5f);

+ path1.cubicTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));

}

path1.lineTo(r1[index].fX, r1[index].fY);

}

@@ -1836,17 +1877,25 @@ static void test_flattening(skiatest::Reporter* reporter) {

static void test_transform(skiatest::Reporter* reporter) {

SkPath p, p1;

+#define CONIC_PERSPECTIVE_BUG_FIXED 0

static const SkPoint pts[] = {

- { 0, 0 },

- { SkIntToScalar(10), SkIntToScalar(10) },

- { SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },

- { 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }

+ { 0, 0 }, // move

+ { SkIntToScalar(10), SkIntToScalar(10) }, // line

+ { SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 }, // quad

+ { 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }, // cubic

+#if CONIC_PERSPECTIVE_BUG_FIXED

+ { 0, 0 }, { SkIntToScalar(20), SkIntToScalar(10) }, // conic

+#endif

};

+ const int kPtCount = SK_ARRAY_COUNT(pts);

p.moveTo(pts[0]);

p.lineTo(pts[1]);

p.quadTo(pts[2], pts[3]);

p.cubicTo(pts[4], pts[5], pts[6]);

+#if CONIC_PERSPECTIVE_BUG_FIXED

+ p.conicTo(pts[4], pts[5], SkFloatToScalar(0.5f));

+#endif

+ p.close();

SkMatrix matrix;

matrix.reset();

p.transform(matrix, &p1);

@@ -1854,13 +1903,36 @@ static void test_transform(skiatest::Reporter* reporter) {

matrix.setScale(SK_Scalar1 * 2, SK_Scalar1 * 3);

p.transform(matrix, &p1);

- SkPoint pts1[7];

- int count = p1.getPoints(pts1, 7);

- REPORTER_ASSERT(reporter, 7 == count);

+ SkPoint pts1[kPtCount];

+ int count = p1.getPoints(pts1, kPtCount);

+ REPORTER_ASSERT(reporter, kPtCount == count);

for (int i = 0; i < count; ++i) {

SkPoint newPt = SkPoint::Make(pts[i].fX * 2, pts[i].fY * 3);

REPORTER_ASSERT(reporter, newPt == pts1[i]);

}

+ matrix.reset();

+ matrix.setPerspX(SkScalarToPersp(4));

+ p.transform(matrix, &p1);

+ REPORTER_ASSERT(reporter, matrix.invert(&matrix));

+ p1.transform(matrix, NULL);

+ SkRect pBounds = p.getBounds();

+ SkRect p1Bounds = p1.getBounds();

+ REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fLeft, p1Bounds.fLeft));

+ REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fTop, p1Bounds.fTop));

+ REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fRight, p1Bounds.fRight));

+ REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fBottom, p1Bounds.fBottom));

+ matrix.reset();

+ p.reset();

+ p.addCircle(0, 0, 1, SkPath::kCW_Direction);

+ p.transform(matrix, &p1);

+ REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kCW_Direction));

+ matrix.setScaleX(-1);

+ p.transform(matrix, &p1);

+ REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kCCW_Direction));

+ matrix.setAll(1, 1, 0, 1, 1, 0, 0, 0, 1);

+ p.transform(matrix, &p1);

+ REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kUnknown_Direction));

}

static void test_zero_length_paths(skiatest::Reporter* reporter) {

@@ -2064,6 +2136,54 @@ static void test_iter(skiatest::Reporter* reporter) {

REPORTER_ASSERT(reporter, j == (int)gIterTests[i].numResultVerbs);

}

+ p.reset();

+ iter.setPath(p, false);

+ REPORTER_ASSERT(reporter, !iter.isClosedContour());

+ p.lineTo(1, 1);

+ p.close();

+ iter.setPath(p, false);

+ REPORTER_ASSERT(reporter, iter.isClosedContour());

+ p.reset();

+ iter.setPath(p, true);

+ REPORTER_ASSERT(reporter, !iter.isClosedContour());

+ p.lineTo(1, 1);

+ iter.setPath(p, true);

+ REPORTER_ASSERT(reporter, iter.isClosedContour());

+ p.moveTo(0, 0);

+ p.lineTo(2, 2);

+ iter.setPath(p, false);

+ REPORTER_ASSERT(reporter, !iter.isClosedContour());

+ // this checks to see if the NaN logic is executed in SkPath::autoClose(), but does not

+ // check to see if the result is correct.

+ for (int setNaN = 0; setNaN < 4; ++setNaN) {

+ p.reset();

+ p.moveTo(setNaN == 0 ? SK_ScalarNaN : 0, setNaN == 1 ? SK_ScalarNaN : 0);

+ p.lineTo(setNaN == 2 ? SK_ScalarNaN : 1, setNaN == 3 ? SK_ScalarNaN : 1);

+ iter.setPath(p, true);

+ iter.next(pts, false);

+ REPORTER_ASSERT(reporter, SkPath::kClose_Verb == iter.next(pts, false));

+ }

+ p.reset();

+ p.quadTo(0, 0, 0, 0);

+ iter.setPath(p, false);

+ iter.next(pts, false);

+ REPORTER_ASSERT(reporter, SkPath::kQuad_Verb == iter.next(pts, false));

+ iter.setPath(p, false);

+ iter.next(pts, false);

+ REPORTER_ASSERT(reporter, SkPath::kDone_Verb == iter.next(pts, true));

+ p.reset();

+ p.cubicTo(0, 0, 0, 0, 0, 0);

+ iter.setPath(p, false);

+ iter.next(pts, false);

+ REPORTER_ASSERT(reporter, SkPath::kCubic_Verb == iter.next(pts, false));

+ iter.setPath(p, false);

+ iter.next(pts, false);

+ REPORTER_ASSERT(reporter, SkPath::kDone_Verb == iter.next(pts, true));

// The GM degeneratesegments.cpp test is more extensive

}

@@ -2323,7 +2443,7 @@ static void test_circle_skew(skiatest::Reporter* reporter,

if (SkPath::kCCW_Direction == dir) {

dir = SkPath::kCW_Direction;

} else {

- SkASSERT(SkPath::kCW_Direction == dir);

+ REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);

dir = SkPath::kCCW_Direction;

}

check_for_circle(reporter, tmp, false, dir);

@@ -2381,7 +2501,7 @@ static void test_circle_mirror_x(skiatest::Reporter* reporter,

if (SkPath::kCW_Direction == dir) {

dir = SkPath::kCCW_Direction;

} else {

- SkASSERT(SkPath::kCCW_Direction == dir);

+ REPORTER_ASSERT(reporter, SkPath::kCCW_Direction == dir);

dir = SkPath::kCW_Direction;

}

@@ -2400,7 +2520,7 @@ static void test_circle_mirror_y(skiatest::Reporter* reporter,

if (SkPath::kCW_Direction == dir) {

dir = SkPath::kCCW_Direction;

} else {

- SkASSERT(SkPath::kCCW_Direction == dir);

+ REPORTER_ASSERT(reporter, SkPath::kCCW_Direction == dir);

dir = SkPath::kCW_Direction;

}

@@ -2573,8 +2693,10 @@ static void test_empty(skiatest::Reporter* reporter, const SkPath& p) {

REPORTER_ASSERT(reporter, !(p != empty));

}

-static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path) {

+static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path,

+ SkPath::Direction dir) {

REPORTER_ASSERT(reporter, path->isConvex());

+ REPORTER_ASSERT(reporter, path->cheapIsDirection(dir));

path->setConvexity(SkPath::kUnknown_Convexity);

REPORTER_ASSERT(reporter, path->isConvex());

path->reset();

@@ -2587,19 +2709,275 @@ static void test_rrect(skiatest::Reporter* reporter) {

SkRect r = {10, 20, 30, 40};

rr.setRectRadii(r, radii);

p.addRRect(rr);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

p.addRRect(rr, SkPath::kCCW_Direction);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);

p.addRoundRect(r, &radii[0].fX);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

p.addRoundRect(r, &radii[0].fX, SkPath::kCCW_Direction);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);

p.addRoundRect(r, radii[1].fX, radii[1].fY);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

p.addRoundRect(r, radii[1].fX, radii[1].fY, SkPath::kCCW_Direction);

- test_rrect_is_convex(reporter, &p);

+ test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);

+ for (size_t i = 0; i < SK_ARRAY_COUNT(radii); ++i) {

+ SkVector save = radii[i];

+ radii[i].set(0, 0);

+ rr.setRectRadii(r, radii);

+ p.addRRect(rr);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+ radii[i] = save;

+ }

+ p.addRoundRect(r, 0, 0);

+ SkRect returnedRect;

+ REPORTER_ASSERT(reporter, p.isRect(&returnedRect));

+ REPORTER_ASSERT(reporter, returnedRect == r);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+ SkVector zeroRadii[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};

+ rr.setRectRadii(r, zeroRadii);

+ p.addRRect(rr);

+ bool closed;

+ SkPath::Direction dir;

+ REPORTER_ASSERT(reporter, p.isRect(&closed, &dir));

+ REPORTER_ASSERT(reporter, closed);

+ REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+ p.addRRect(rr, SkPath::kCW_Direction);

+ REPORTER_ASSERT(reporter, !p.isConvex());

+ p.reset();

+ p.addRRect(rr, SkPath::kCCW_Direction);

+ REPORTER_ASSERT(reporter, !p.isConvex());

+ p.reset();

+ SkRect emptyR = {10, 20, 10, 30};

+ rr.setRectRadii(emptyR, radii);

+ p.addRRect(rr);

+ REPORTER_ASSERT(reporter, p.isEmpty());

+ SkRect largeR = {0, 0, SK_ScalarMax, SK_ScalarMax};

+ rr.setRectRadii(largeR, radii);

+ p.addRRect(rr);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+ SkRect infR = {0, 0, SK_ScalarMax, SK_ScalarInfinity};

+ rr.setRectRadii(infR, radii);

+ p.addRRect(rr);

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+ SkRect tinyR = {0, 0, SkFloatToScalar(1e-9), SkFloatToScalar(1e-9)};

+ p.addRoundRect(tinyR, SkFloatToScalar(5e-11), SkFloatToScalar(5e-11));

+ test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);

+static void test_arc(skiatest::Reporter* reporter) {

+ SkPath p;

+ SkRect emptyOval = {10, 20, 30, 20};

+ REPORTER_ASSERT(reporter, emptyOval.isEmpty());

+ p.addArc(emptyOval, 1, 2);

+ REPORTER_ASSERT(reporter, p.isEmpty());

+ p.reset();

+ SkRect oval = {10, 20, 30, 40};

+ p.addArc(oval, 1, 0);

+ REPORTER_ASSERT(reporter, p.isEmpty());

+ p.reset();

+ SkPath cwOval;

+ cwOval.addOval(oval);

+ p.addArc(oval, 1, 360);

+ REPORTER_ASSERT(reporter, p == cwOval);

+ p.reset();

+ SkPath ccwOval;

+ ccwOval.addOval(oval, SkPath::kCCW_Direction);

+ p.addArc(oval, 1, -360);

+ REPORTER_ASSERT(reporter, p == ccwOval);

+ p.reset();

+ p.addArc(oval, 1, 180);

+ REPORTER_ASSERT(reporter, p.isConvex());

+ REPORTER_ASSERT(reporter, p.cheapIsDirection(SkPath::kCW_Direction));

+ p.setConvexity(SkPath::kUnknown_Convexity);

+ REPORTER_ASSERT(reporter, p.isConvex());

+static void check_move(skiatest::Reporter* reporter, SkPath::RawIter* iter,

+ SkScalar x0, SkScalar y0) {

+ SkPoint pts[4];

+ SkPath::Verb v = iter->next(pts);

+ REPORTER_ASSERT(reporter, v == SkPath::kMove_Verb);

+ REPORTER_ASSERT(reporter, pts[0].fX == x0);

+ REPORTER_ASSERT(reporter, pts[0].fY == y0);

+static void check_line(skiatest::Reporter* reporter, SkPath::RawIter* iter,

+ SkScalar x1, SkScalar y1) {

+ SkPoint pts[4];

+ SkPath::Verb v = iter->next(pts);

+ REPORTER_ASSERT(reporter, v == SkPath::kLine_Verb);

+ REPORTER_ASSERT(reporter, pts[1].fX == x1);

+ REPORTER_ASSERT(reporter, pts[1].fY == y1);

+static void check_quad(skiatest::Reporter* reporter, SkPath::RawIter* iter,

+ SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {

+ SkPoint pts[4];

+ SkPath::Verb v = iter->next(pts);

+ REPORTER_ASSERT(reporter, v == SkPath::kQuad_Verb);

+ REPORTER_ASSERT(reporter, pts[1].fX == x1);

+ REPORTER_ASSERT(reporter, pts[1].fY == y1);

+ REPORTER_ASSERT(reporter, pts[2].fX == x2);

+ REPORTER_ASSERT(reporter, pts[2].fY == y2);

+static void check_done(skiatest::Reporter* reporter, SkPath* p, SkPath::RawIter* iter) {

+ SkPoint pts[4];

+ SkPath::Verb v = iter->next(pts);

+ REPORTER_ASSERT(reporter, v == SkPath::kDone_Verb);

+static void check_done_and_reset(skiatest::Reporter* reporter, SkPath* p, SkPath::RawIter* iter) {

+ check_done(reporter, p, iter);

+ p->reset();

}

+static void check_path_is_move_and_reset(skiatest::Reporter* reporter, SkPath* p,

+ SkScalar x0, SkScalar y0) {

+ SkPath::RawIter iter(*p);

+ check_move(reporter, &iter, x0, y0);

+ check_done_and_reset(reporter, p, &iter);

+static void check_path_is_line_and_reset(skiatest::Reporter* reporter, SkPath* p,

+ SkScalar x1, SkScalar y1) {

+ SkPath::RawIter iter(*p);

+ check_move(reporter, &iter, 0, 0);

+ check_line(reporter, &iter, x1, y1);

+ check_done_and_reset(reporter, p, &iter);

+static void check_path_is_line(skiatest::Reporter* reporter, SkPath* p,

+ SkScalar x1, SkScalar y1) {

+ SkPath::RawIter iter(*p);

+ check_move(reporter, &iter, 0, 0);

+ check_line(reporter, &iter, x1, y1);

+ check_done(reporter, p, &iter);

+static void check_path_is_line_pair_and_reset(skiatest::Reporter* reporter, SkPath* p,

+ SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {

+ SkPath::RawIter iter(*p);

+ check_move(reporter, &iter, 0, 0);

+ check_line(reporter, &iter, x1, y1);

+ check_line(reporter, &iter, x2, y2);

+ check_done_and_reset(reporter, p, &iter);

+static void check_path_is_quad_and_reset(skiatest::Reporter* reporter, SkPath* p,

+ SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {

+ SkPath::RawIter iter(*p);

+ check_move(reporter, &iter, 0, 0);

+ check_quad(reporter, &iter, x1, y1, x2, y2);

+ check_done_and_reset(reporter, p, &iter);

+static void test_arcTo(skiatest::Reporter* reporter) {

+ SkPath p;

+ p.arcTo(0, 0, 1, 2, 1);

+ check_path_is_line_and_reset(reporter, &p, 0, 0);

+ p.arcTo(1, 2, 1, 2, 1);

+ check_path_is_line_and_reset(reporter, &p, 1, 2);

+ p.arcTo(1, 2, 3, 4, 0);

+ check_path_is_line_and_reset(reporter, &p, 1, 2);

+ p.arcTo(1, 2, 0, 0, 1);

+ check_path_is_line_and_reset(reporter, &p, 1, 2);

+ p.arcTo(1, 0, 1, 1, 1);

+ SkPoint pt;

+ REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt.fX == 1 && pt.fY == 1);

+ p.reset();

+ p.arcTo(1, 0, 1, -1, 1);

+ REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt.fX == 1 && pt.fY == -1);

+ p.reset();

+ SkRect oval = {1, 2, 3, 4};

+ p.arcTo(oval, 0, 0, true);

+ check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());

+ p.arcTo(oval, 0, 0, false);

+ check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());

+ p.arcTo(oval, 360, 0, true);

+ check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());

+ p.arcTo(oval, 360, 0, false);

+ check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());

+ for (float sweep = 359, delta = 0.5f; sweep != (float) (sweep + delta); ) {

+ p.arcTo(oval, 0, SkFloatToScalar(sweep), false);

+ REPORTER_ASSERT(reporter, p.getBounds() == oval);

+ sweep += delta;

+ delta /= 2;

+ }

+ for (float sweep = 361, delta = 0.5f; sweep != (float) (sweep - delta);) {

+ p.arcTo(oval, 0, SkFloatToScalar(sweep), false);

+ REPORTER_ASSERT(reporter, p.getBounds() == oval);

+ sweep -= delta;

+ delta /= 2;

+ }

+static void test_addPath(skiatest::Reporter* reporter) {

+ SkPath p, q;

+ p.lineTo(1, 2);

+ q.moveTo(4, 4);

+ q.lineTo(7, 8);

+ q.conicTo(8, 7, 6, 5, SkFloatToScalar(0.5f));

+ q.quadTo(6, 7, 8, 6);

+ q.cubicTo(5, 6, 7, 8, 7, 5);

+ q.close();

+ p.addPath(q, -4, -4);

+ SkRect expected = {0, 0, 4, 4};

+ REPORTER_ASSERT(reporter, p.getBounds() == expected);

+ p.reset();

+ p.reverseAddPath(q);

+ SkRect reverseExpected = {4, 4, 8, 8};

+ REPORTER_ASSERT(reporter, p.getBounds() == reverseExpected);

+static void test_conicTo_special_case(skiatest::Reporter* reporter) {

+ SkPath p;

+ p.conicTo(1, 2, 3, 4, -1);

+ check_path_is_line_and_reset(reporter, &p, 3, 4);

+ p.conicTo(1, 2, 3, 4, SK_ScalarInfinity);

+ check_path_is_line_pair_and_reset(reporter, &p, 1, 2, 3, 4);

+ p.conicTo(1, 2, 3, 4, 1);

+ check_path_is_quad_and_reset(reporter, &p, 1, 2, 3, 4);

+static void test_get_point(skiatest::Reporter* reporter) {

+ SkPath p;

+ SkPoint pt = p.getPoint(0);

+ REPORTER_ASSERT(reporter, pt == SkPoint::Make(0, 0));

+ REPORTER_ASSERT(reporter, !p.getLastPt(NULL));

+ REPORTER_ASSERT(reporter, !p.getLastPt(&pt) && pt == SkPoint::Make(0, 0));

+ p.setLastPt(10, 10);

+ pt = p.getPoint(0);

+ REPORTER_ASSERT(reporter, pt == SkPoint::Make(10, 10));

+ REPORTER_ASSERT(reporter, p.getLastPt(NULL));

+ p.rMoveTo(10, 10);

+ REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt == SkPoint::Make(20, 20));

+class PathTest_Private {

+public:

+ static void TestPathTo(skiatest::Reporter* reporter) {

+ SkPath p, q;

+ p.lineTo(4, 4);

+ p.reversePathTo(q);

+ check_path_is_line(reporter, &p, 4, 4);

+ q.moveTo(-4, -4);

+ p.reversePathTo(q);

+ check_path_is_line(reporter, &p, 4, 4);

+ q.lineTo(7, 8);

+ q.conicTo(8, 7, 6, 5, SkFloatToScalar(0.5f));

+ q.quadTo(6, 7, 8, 6);

+ q.cubicTo(5, 6, 7, 8, 7, 5);

+ q.close();

+ p.reversePathTo(q);

+ SkRect reverseExpected = {-4, -4, 8, 8};

+ REPORTER_ASSERT(reporter, p.getBounds() == reverseExpected);

+ }

+};

static void TestPath(skiatest::Reporter* reporter) {

SkTSize<SkScalar>::Make(3,4);

@@ -2702,6 +3080,12 @@ static void TestPath(skiatest::Reporter* reporter) {

test_path_close_issue1474(reporter);

test_path_to_region(reporter);

test_rrect(reporter);

+ test_arc(reporter);

+ test_arcTo(reporter);

+ test_addPath(reporter);

+ test_conicTo_special_case(reporter);

+ test_get_point(reporter);

+ PathTest_Private::TestPathTo(reporter);

}

#include "TestClassDef.h"

« include/core/SkPath.h ('K') | « src/core/SkPathRef.cpp ('k') | no next file » | no next file with comments »