xref: /third_party/skia/tests/GrStyledShapeTest.cpp

548     void testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const;
704 void TestCase::testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const {
706     REPORTER_ASSERT(reporter, fBaseKey.count());
708         REPORTER_ASSERT(reporter, fBaseKey != fAppliedPEKey);
709         REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedPEKey.count()));
710         REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
711         REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedFullKey.count()));
713             REPORTER_ASSERT(reporter, fAppliedPEKey != fAppliedFullKey);
714             REPORTER_ASSERT(reporter, SkToBool(fAppliedFullKey.count()));
717         REPORTER_ASSERT(reporter, fBaseKey == fAppliedPEKey);
721         REPORTER_ASSERT(reporter, a == b);
723             REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
725             REPORTER_ASSERT(reporter, fBaseKey == fAppliedFullKey);
777 static void test_basic(skiatest::Reporter* reporter, const Geo& geo) {
783     TestCase fillCase(geo, fill, reporter);
787     fillCase.testExpectations(reporter, expectations);
789     make_TestCase(geo, fill, reporter)
790         ->compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
797     TestCase stroke2RoundBevelCase(geo, stroke2RoundBevel, reporter);
801     stroke2RoundBevelCase.testExpectations(reporter, expectations);
802     make_TestCase(geo, stroke2RoundBevel, reporter)
803         ->compare(reporter, stroke2RoundBevelCase, TestCase::kAllSame_ComparisonExpecation);
807     TestCase stroke2RoundBevelDashCase(geo, stroke2RoundBevelDash, reporter);
811     stroke2RoundBevelDashCase.testExpectations(reporter, expectations);
812     make_TestCase(geo, stroke2RoundBevelDash, reporter)
813         ->compare(reporter, stroke2RoundBevelDashCase, TestCase::kAllSame_ComparisonExpecation);
816         fillCase.compare(reporter, stroke2RoundBevelCase,
818         fillCase.compare(reporter, stroke2RoundBevelDashCase,
821         fillCase.compare(reporter, stroke2RoundBevelCase,
823         fillCase.compare(reporter, stroke2RoundBevelDashCase,
827         stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
830         stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
837     TestCase stroke2RoundBevelAndFillCase(geo, stroke2RoundBevelAndFill, reporter);
841     stroke2RoundBevelAndFillCase.testExpectations(reporter, expectations);
842     make_TestCase(geo, stroke2RoundBevelAndFill, reporter)->compare(
843             reporter, stroke2RoundBevelAndFillCase, TestCase::kAllSame_ComparisonExpecation);
847     TestCase stroke2RoundBevelAndFillDashCase(geo, stroke2RoundBevelAndFillDash, reporter);
851     stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations);
852     make_TestCase(geo, stroke2RoundBevelAndFillDash, reporter)->compare(
853         reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation);
854     stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelAndFillCase,
860     TestCase hairlineCase(geo, hairline, reporter);
864         hairlineCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation);
866         hairlineCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
868     REPORTER_ASSERT(reporter, hairlineCase.baseShape().style().isSimpleHairline());
869     REPORTER_ASSERT(reporter, hairlineCase.appliedFullStyleShape().style().isSimpleHairline());
870     REPORTER_ASSERT(reporter, hairlineCase.appliedPathEffectShape().style().isSimpleHairline());
874 static void test_scale(skiatest::Reporter* reporter, const Geo& geo) {
881     TestCase fillCase1(geo, fill, reporter, kS1);
882     TestCase fillCase2(geo, fill, reporter, kS2);
884     fillCase1.compare(reporter, fillCase2, TestCase::kAllSame_ComparisonExpecation);
889     TestCase hairlineCase1(geo, hairline, reporter, kS1);
890     TestCase hairlineCase2(geo, hairline, reporter, kS2);
892     hairlineCase1.compare(reporter, hairlineCase2, TestCase::kAllSame_ComparisonExpecation);
897     TestCase strokeCase1(geo, stroke, reporter, kS1);
898     TestCase strokeCase2(geo, stroke, reporter, kS2);
901         REPORTER_ASSERT(reporter, !strokeCase1.baseShape().style().applies());
902         strokeCase1.compare(reporter, strokeCase2, TestCase::kAllSame_ComparisonExpecation);
904         strokeCase1.compare(reporter, strokeCase2, TestCase::kSameUpToStroke_ComparisonExpecation);
909     TestCase strokeDashCase1(geo, strokeDash, reporter, kS1);
910     TestCase strokeDashCase2(geo, strokeDash, reporter, kS2);
912     strokeDashCase1.compare(reporter, strokeDashCase2,
918     TestCase strokeAndFillCase1(geo, strokeAndFill, reporter, kS1);
919     TestCase strokeAndFillCase2(geo, strokeAndFill, reporter, kS2);
923     TestCase strokeAndFillDashCase1(geo, strokeAndFillDash, reporter, kS1);
924     TestCase strokeAndFillDashCase2(geo, strokeAndFillDash, reporter, kS2);
929         REPORTER_ASSERT(reporter, !strokeAndFillCase1.baseShape().style().applies());
930         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
932         strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2,
935         strokeAndFillCase1.compare(reporter, strokeAndFillCase2,
938     strokeAndFillDashCase1.compare(reporter, strokeAndFillCase1,
940     strokeAndFillDashCase2.compare(reporter, strokeAndFillCase2,
945 static void test_stroke_param_impl(skiatest::Reporter* reporter, const Geo& geo,
960     TestCase strokeACase(geo, strokeA, reporter);
961     TestCase strokeBCase(geo, strokeB, reporter);
966             strokeACase.compare(reporter, strokeBCase,
969             strokeACase.compare(reporter, strokeBCase,
973         strokeACase.compare(reporter, strokeBCase, TestCase::kAllSame_ComparisonExpecation);
980     TestCase strokeAndFillACase(geo, strokeAndFillA, reporter);
981     TestCase strokeAndFillBCase(geo, strokeAndFillB, reporter);
987             strokeAndFillACase.compare(reporter, strokeAndFillBCase,
990             strokeAndFillACase.compare(reporter, strokeAndFillBCase,
994         strokeAndFillACase.compare(reporter, strokeAndFillBCase,
1002     TestCase fillACase(geo, fillA, reporter);
1003     TestCase fillBCase(geo, fillB, reporter);
1004     fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);
1011     TestCase dashACase(geo, dashA, reporter);
1012     TestCase dashBCase(geo, dashB, reporter);
1014         dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
1016         dashACase.compare(reporter, dashBCase, TestCase::kAllSame_ComparisonExpecation);
1021 static void test_stroke_param(skiatest::Reporter* reporter, const Geo& geo,
1023     test_stroke_param_impl(reporter, geo, setter, a, b, true, true);
1026 static void test_stroke_cap(skiatest::Reporter* reporter, const Geo& geo) {
1036         reporter,
1048 static void test_stroke_join(skiatest::Reporter* reporter, const Geo& geo) {
1059             reporter,
1066 static void test_miter_limit(skiatest::Reporter* reporter, const Geo& geo) {
1086         reporter,
1096         reporter,
1104 static void test_dash_fill(skiatest::Reporter* reporter, const Geo& geo) {
1110         TestCase dashFillCase(geo, dashFill, reporter);
1112         TestCase fillCase(geo, SkPaint(), reporter);
1113         dashFillCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
1117 void test_null_dash(skiatest::Reporter* reporter, const Geo& geo) {
1131     TestCase fillCase(geo, fill, reporter);
1132     TestCase strokeCase(geo, stroke, reporter);
1133     TestCase dashCase(geo, dash, reporter);
1134     TestCase nullDashCase(geo, nullDash, reporter);
1137     nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation);
1141         nullDashCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation);
1143         nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation);
1147         nullDashCase.compare(reporter, dashCase, TestCase::kAllDifferent_ComparisonExpecation);
1149         nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation);
1153 void test_path_effect_makes_rrect(skiatest::Reporter* reporter, const Geo& geo) {
1189     TestCase fillGeoCase(geo, fill, reporter);
1193     TestCase geoPECase(geo, pe, reporter);
1199     TestCase geoPEStrokeCase(geo, peStroke, reporter);
1204         fillGeoCase.compare(reporter, geoPECase, TestCase::kAllDifferent_ComparisonExpecation);
1205         fillGeoCase.compare(reporter, geoPEStrokeCase,
1208         fillGeoCase.compare(reporter, geoPECase, TestCase::kSameUpToPE_ComparisonExpecation);
1209         fillGeoCase.compare(reporter, geoPEStrokeCase, TestCase::kSameUpToPE_ComparisonExpecation);
1211     geoPECase.compare(reporter, geoPEStrokeCase,
1214     TestCase rrectFillCase(reporter, RRectPathEffect::RRect(), fill);
1217     TestCase rrectStrokeCase(reporter, RRectPathEffect::RRect(), stroke);
1222     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectShape().asRRect(&rrect, nullptr, nullptr,
1224     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
1225     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == rrectFillCase.baseKey());
1227     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().asRRect(&rrect, nullptr, nullptr,
1229     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
1230     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleKey() == rrectFillCase.baseKey());
1233     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().asRRect(&rrect, nullptr,
1235     REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect());
1236     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == rrectFillCase.baseKey());
1238     REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().asRRect(&rrect, nullptr,
1240     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() ==
1244 void test_unknown_path_effect(skiatest::Reporter* reporter, const Geo& geo) {
1282     TestCase geoPEStrokeCase(geo, peStroke, reporter);
1287     geoPEStrokeCase.testExpectations(reporter, expectations);
1290 void test_make_hairline_path_effect(skiatest::Reporter* reporter, const Geo& geo) {
1319     TestCase peCase(geo, pe, reporter);
1330         REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1331         REPORTER_ASSERT(reporter, paths_fill_same(a, c));
1338         REPORTER_ASSERT(reporter, a == b);
1339         REPORTER_ASSERT(reporter, a == c);
1341         REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1342         REPORTER_ASSERT(reporter, paths_fill_same(a, c));
1343         REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty());
1344         REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty());
1346     REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline());
1347     REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline());
1350 void test_volatile_path(skiatest::Reporter* reporter, const Geo& geo) {
1358     TestCase volatileCase(reporter, vPath, dashAndStroke);
1362         REPORTER_ASSERT(reporter, SkToBool(volatileCase.baseKey().count()));
1364         TestCase nonVolatileCase(reporter, geo.path(), dashAndStroke);
1365         volatileCase.compare(reporter, nonVolatileCase, TestCase::kAllSame_ComparisonExpecation);
1368         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.baseKey().count()));
1369         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectKey().count()));
1370         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedFullStyleKey().count()));
1371         REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectThenStrokeKey().count()));
1375 void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const Geo& geo) {
1410     REPORTER_ASSERT(reporter, emptyShape.isEmpty());
1416     REPORTER_ASSERT(reporter, invertedEmptyShape.isEmpty());
1418     REPORTER_ASSERT(reporter, invertedEmptyKey != emptyKey);
1422     TestCase geoPECase(geo, pe, reporter);
1423     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleKey() == emptyKey);
1424     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == emptyKey);
1425     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectThenStrokeKey() == emptyKey);
1426     REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectShape().isEmpty());
1427     REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().isEmpty());
1428     REPORTER_ASSERT(reporter, !geoPECase.appliedPathEffectShape().inverseFilled());
1429     REPORTER_ASSERT(reporter, !geoPECase.appliedFullStyleShape().inverseFilled());
1435     TestCase geoPEStrokeCase(geo, peStroke, reporter);
1436     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == emptyKey);
1437     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == emptyKey);
1438     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectThenStrokeKey() == emptyKey);
1439     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().isEmpty());
1440     REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleShape().isEmpty());
1441     REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedPathEffectShape().inverseFilled());
1442     REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().inverseFilled());
1445     TestCase geoPEInvertCase(geo, pe, reporter);
1446     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleKey() == invertedEmptyKey);
1447     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectKey() == invertedEmptyKey);
1448     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectThenStrokeKey() == invertedEmptyKey);
1449     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectShape().isEmpty());
1450     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleShape().isEmpty());
1451     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectShape().inverseFilled());
1452     REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleShape().inverseFilled());
1455     TestCase geoPEInvertStrokeCase(geo, peStroke, reporter);
1456     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleKey() == invertedEmptyKey);
1457     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectKey() == invertedEmptyKey);
1458     REPORTER_ASSERT(reporter,
1460     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectShape().isEmpty());
1461     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleShape().isEmpty());
1462     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectShape().inverseFilled());
1463     REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleShape().inverseFilled());
1466 void test_path_effect_fails(skiatest::Reporter* reporter, const Geo& geo) {
1487     TestCase fillCase(geo, fill, reporter);
1491     TestCase peCase(geo, pe, reporter);
1496     TestCase strokeCase(geo, stroke, reporter);
1500     TestCase peStrokeCase(geo, peStroke, reporter);
1513     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1517     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1521     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1525     REPORTER_ASSERT(reporter, paths_fill_same(a, b));
1528 DEF_TEST(GrStyledShape_empty_shape, reporter) {
1533     TestCase fillEmptyCase(reporter, emptyPath, fill);
1534     REPORTER_ASSERT(reporter, fillEmptyCase.baseShape().isEmpty());
1535     REPORTER_ASSERT(reporter, fillEmptyCase.appliedPathEffectShape().isEmpty());
1536     REPORTER_ASSERT(reporter, fillEmptyCase.appliedFullStyleShape().isEmpty());
1537     REPORTER_ASSERT(reporter, !fillEmptyCase.baseShape().inverseFilled());
1538     REPORTER_ASSERT(reporter, !fillEmptyCase.appliedPathEffectShape().inverseFilled());
1539     REPORTER_ASSERT(reporter, !fillEmptyCase.appliedFullStyleShape().inverseFilled());
1540     TestCase fillInvertedEmptyCase(reporter, invertedEmptyPath, fill);
1541     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.baseShape().isEmpty());
1542     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedPathEffectShape().isEmpty());
1543     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedFullStyleShape().isEmpty());
1544     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.baseShape().inverseFilled());
1545     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedPathEffectShape().inverseFilled());
1546     REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedFullStyleShape().inverseFilled());
1549     REPORTER_ASSERT(reporter, emptyKey.count());
1551     REPORTER_ASSERT(reporter, inverseEmptyKey.count());
1556     fillEmptyCase.testExpectations(reporter, expectations);
1557     fillInvertedEmptyCase.testExpectations(reporter, expectations);
1565     TestCase strokeEmptyCase(reporter, emptyPath, stroke);
1566     strokeEmptyCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation);
1567     TestCase strokeInvertedEmptyCase(reporter, invertedEmptyPath, stroke);
1568     strokeInvertedEmptyCase.compare(reporter, fillInvertedEmptyCase,
1576     TestCase dashAndStrokeEmptyCase(reporter, emptyPath, dashAndStroke);
1577     dashAndStrokeEmptyCase.compare(reporter, fillEmptyCase,
1579     TestCase dashAndStrokeInvertexEmptyCase(reporter, invertedEmptyPath, dashAndStroke);
1581     dashAndStrokeInvertexEmptyCase.compare(reporter, fillEmptyCase,
1588     REPORTER_ASSERT(reporter, emptyRRect.getType() == SkRRect::kEmpty_Type);
1590     TestCase fillEmptyRRectCase(reporter, emptyRRect, fill);
1591     fillEmptyRRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation);
1593     TestCase strokeEmptyRRectCase(reporter, emptyRRect, stroke);
1594     strokeEmptyRRectCase.compare(reporter, strokeEmptyCase,
1597     TestCase dashAndStrokeEmptyRRectCase(reporter, emptyRRect, dashAndStroke);
1598     dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase,
1604     TestCase fillInvertedEmptyRRectCase(reporter, emptyRRect, kDir, kStart, true, GrStyle(fill));
1605     fillInvertedEmptyRRectCase.compare(reporter, fillInvertedEmptyCase,
1608     TestCase strokeInvertedEmptyRRectCase(reporter, emptyRRect, kDir, kStart, true,
1610     strokeInvertedEmptyRRectCase.compare(reporter, strokeInvertedEmptyCase,
1613     TestCase dashAndStrokeEmptyInvertedRRectCase(reporter, emptyRRect, kDir, kStart, true,
1615     dashAndStrokeEmptyInvertedRRectCase.compare(reporter, fillEmptyCase,
1620     TestCase fillEmptyRectCase(reporter, emptyRect, fill);
1621     fillEmptyRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation);
1623     TestCase dashAndStrokeEmptyRectCase(reporter, emptyRect, dashAndStroke);
1624     dashAndStrokeEmptyRectCase.compare(reporter, fillEmptyCase,
1627     TestCase dashAndStrokeEmptyInvertedRectCase(reporter, SkRRect::MakeRect(emptyRect), kDir,
1630     dashAndStrokeEmptyInvertedRectCase.compare(reporter, fillEmptyCase,
2143 DEF_TEST(GrStyledShape, reporter) {
2165         test_rrect(reporter, rr);
2228         test_basic(reporter, *geos[i]);
2229         test_scale(reporter, *geos[i]);
2230         test_dash_fill(reporter, *geos[i]);
2231         test_null_dash(reporter, *geos[i]);
2234                 reporter, *geos[i],
2237         test_stroke_join(reporter, *geos[i]);
2238         test_stroke_cap(reporter, *geos[i]);
2239         test_miter_limit(reporter, *geos[i]);
2240         test_path_effect_makes_rrect(reporter, *geos[i]);
2241         test_unknown_path_effect(reporter, *geos[i]);
2242         test_path_effect_makes_empty_shape(reporter, *geos[i]);
2243         test_path_effect_fails(reporter, *geos[i]);
2244         test_make_hairline_path_effect(reporter, *geos[i]);
2245         test_volatile_path(reporter, *geos[i]);
2251         TestCase fillPathCase(reporter, rrgeo.path(), fillPaint);
2253         REPORTER_ASSERT(reporter, rrgeo.isNonPath(fillPaint) ==
2257             TestCase fillPathCase2(reporter, rrgeo.path(), fillPaint);
2258             REPORTER_ASSERT(reporter, rrect == rrgeo.rrect());
2259             TestCase fillRRectCase(reporter, rrect, fillPaint);
2260             fillPathCase2.compare(reporter, fillRRectCase,
2266         TestCase strokePathCase(reporter, rrgeo.path(), strokePaint);
2268             REPORTER_ASSERT(reporter, strokePathCase.baseShape().asRRect(&rrect, nullptr, nullptr,
2270             REPORTER_ASSERT(reporter, rrect == rrgeo.rrect());
2271             TestCase strokeRRectCase(reporter, rrect, strokePaint);
2272             strokePathCase.compare(reporter, strokeRRectCase,
2278     test_volatile_path(reporter, PathGeo(SkPath(), PathGeo::Invert::kNo));
2281 DEF_TEST(GrStyledShape_arcs, reporter) {
2306                                                  reporter);
2307         TestCase emptyPath(reporter, SkPath(), style);
2308         emptyArc.compare(reporter, emptyPath, TestCase::kAllSame_ComparisonExpecation);
2314         TestCase arc1CW(GrStyledShape::MakeArc(kOval1, 0, 90.f, false, style), reporter);
2315         TestCase arc1CCW(GrStyledShape::MakeArc(kOval1, 90.f, -90.f, false, style), reporter);
2317         TestCase arc1CWWithCenter(GrStyledShape::MakeArc(kOval1, 0, 90.f, true, style), reporter);
2319                                    reporter);
2321         TestCase arc2CW(GrStyledShape::MakeArc(kOval2, 0, 90.f, false, style), reporter);
2322         TestCase arc2CWWithCenter(GrStyledShape::MakeArc(kOval2, 0, 90.f, true, style), reporter);
2327         arc1CW.compare(reporter, arc1CCW, reversedExepectations);
2328         arc1CWWithCenter.compare(reporter, arc1CCWWithCenter, reversedExepectations);
2329         arc1CW.compare(reporter, arc2CW, TestCase::kAllDifferent_ComparisonExpecation);
2330         arc1CW.compare(reporter, arc1CWWithCenter, TestCase::kAllDifferent_ComparisonExpecation);
2331         arc1CWWithCenter.compare(reporter, arc2CWWithCenter,
2335         TestCase arc3A(GrStyledShape::MakeArc(kOval1, 224.f, 73.f, false, style), reporter);
2336         TestCase arc3B(GrStyledShape::MakeArc(kOval1, 224.f - 360.f, 73.f, false, style), reporter);
2337         arc3A.compare(reporter, arc3B, TestCase::kAllDifferent_ComparisonExpecation);
2341         TestCase ovalArc(GrStyledShape::MakeArc(kOval1, 150.f, -790.f, false, style), reporter);
2342         TestCase oval(GrStyledShape(SkRRect::MakeOval(kOval1)), reporter);
2348         ovalArc.compare(reporter, oval, ovalExpectations);
2353                                    reporter);
2356         ovalArcWithCenter.compare(reporter, oval, ovalExpectations);

Indexes created Thu Nov 07 10:32:03 CST 2024