Stop banning stroke-and-fill for GrStyle and add tests

tests/GrShapeTest.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <initializer_list>
 #include <functional>
 #include "Test.h"
@@ skipping 233 matching lines @@
     TestCase(geo, stroke2RoundBevelDash, reporter).compare(reporter, stroke2RoundBevelDashCase,
                                                            TestCase::kAllSame_ComparisonExpecation);
 
     fillCase.compare(reporter, stroke2RoundBevelCase,
                      TestCase::kSameUpToStroke_ComparisonExpecation);
     fillCase.compare(reporter, stroke2RoundBevelDashCase,
                      TestCase::kSameUpToPE_ComparisonExpecation);
     stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
                                   TestCase::kSameUpToPE_ComparisonExpecation);
 
+    // Stroke and fill cases
+    SkPaint stroke2RoundBevelAndFill = stroke2RoundBevel;
+    stroke2RoundBevelAndFill.setStyle(SkPaint::kStrokeAndFill_Style);
+    TestCase stroke2RoundBevelAndFillCase(geo, stroke2RoundBevelAndFill, reporter);
+    expectations.fPEHasValidKey = true;
+    expectations.fPEHasEffect = false;
+    expectations.fStrokeApplies = true;
+    stroke2RoundBevelAndFillCase.testExpectations(reporter, expectations);
+    TestCase(geo, stroke2RoundBevelAndFill, reporter).compare(reporter,
+            stroke2RoundBevelAndFillCase, TestCase::kAllSame_ComparisonExpecation);
+
+    SkPaint stroke2RoundBevelAndFillDash = stroke2RoundBevelDash;
+    stroke2RoundBevelAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style);
+    TestCase stroke2RoundBevelAndFillDashCase(geo, stroke2RoundBevelAndFillDash, reporter);
+    expectations.fPEHasValidKey = true;
+    expectations.fPEHasEffect = true;
+    expectations.fStrokeApplies = true;
+    stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations);
+    TestCase(geo, stroke2RoundBevelAndFillDash, reporter).compare(
+        reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation);
+
+    stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelCase,
+                                         TestCase::kSameUpToStroke_ComparisonExpecation);
+    stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelDashCase,
+                                             TestCase::kSameUpToStroke_ComparisonExpecation);
+    stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelAndFillDashCase,
+                                         TestCase::kSameUpToPE_ComparisonExpecation);
+
     SkPaint hairline;
     hairline.setStyle(SkPaint::kStroke_Style);
     hairline.setStrokeWidth(0.f);
     TestCase hairlineCase(geo, hairline, reporter);
     // Since hairline style doesn't change the SkPath data, it is keyed identically to fill.
     hairlineCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
     REPORTER_ASSERT(reporter, hairlineCase.baseShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, hairlineCase.appliedFullStyleShape().style().isSimpleHairline());
     REPORTER_ASSERT(reporter, hairlineCase.appliedPathEffectShape().style().isSimpleHairline());
 }
@@ skipping 15 matching lines @@
     setter(&strokeB, b);
 
     TestCase strokeACase(geo, strokeA, reporter);
     TestCase strokeBCase(geo, strokeB, reporter);
     if (paramAffectsStroke) {
         strokeACase.compare(reporter, strokeBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
     } else {
         strokeACase.compare(reporter, strokeBCase, TestCase::kAllSame_ComparisonExpecation);
     }
 
+    SkPaint strokeAndFillA = strokeA;
+    SkPaint strokeAndFillB = strokeB;
+    strokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style);
+    strokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style);
+    TestCase strokeAndFillACase(geo, strokeAndFillA, reporter);
+    TestCase strokeAndFillBCase(geo, strokeAndFillB, reporter);
+    if (paramAffectsStroke) {
+        strokeAndFillACase.compare(reporter, strokeAndFillBCase,
+                                   TestCase::kSameUpToStroke_ComparisonExpecation);
+    } else {
+        strokeAndFillACase.compare(reporter, strokeAndFillBCase,
+                                   TestCase::kAllSame_ComparisonExpecation);
+    }
+
     // Make sure stroking params don't affect fill style.
     SkPaint fillA = strokeA, fillB = strokeB;
     fillA.setStyle(SkPaint::kFill_Style);
     fillB.setStyle(SkPaint::kFill_Style);
     TestCase fillACase(geo, fillA, reporter);
     TestCase fillBCase(geo, fillB, reporter);
     fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);
 
     // Make sure just applying the dash but not stroke gives the same key for both stroking
     // variations.
     SkPaint dashA = strokeA, dashB = strokeB;
     dashA.setPathEffect(make_dash());
     dashB.setPathEffect(make_dash());
     TestCase dashACase(geo, dashA, reporter);
     TestCase dashBCase(geo, dashB, reporter);
     if (paramAffectsDashAndStroke) {
         dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
     } else {
         dashACase.compare(reporter, dashBCase, TestCase::kAllSame_ComparisonExpecation);
     }
+
+    SkPaint dashStrokeAndFillA = dashA, dashStrokeAndFillB = dashB;
+    dashStrokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style);
+    dashStrokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style);
+    TestCase dashStrokeAndFillACase(geo, dashStrokeAndFillA, reporter);
+    TestCase dashStrokeAndFillBCase(geo, dashStrokeAndFillB, reporter);
+    if (paramAffectsDashAndStroke) {
+        dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase,
+                                       TestCase::kSameUpToStroke_ComparisonExpecation);
+    } else {
+        dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase,
+                                       TestCase::kAllSame_ComparisonExpecation);
+    }
 }
 
 template <typename GEO, typename T>
 static void test_stroke_param(skiatest::Reporter* reporter, const GEO& geo,
                               std::function<void(SkPaint*, T)> setter, T a, T b) {
     test_stroke_param_impl(reporter, geo, setter, a, b, true, true);
 };
 
 template <typename GEO>
 static void test_stroke_cap(skiatest::Reporter* reporter, const GEO& geo) {
@@ skipping 472 matching lines @@
         }
     }
 
     // Test a volatile empty path.
     test_volatile_path(reporter, SkPath(), true);
 
     test_empty_shape(reporter);
 }
 
 #endif