flutter::testing::CanvasCompareTester Class Reference

Public Types
enum class	DirectoryStatus {   kExisted ,   kCreated ,   kFailed }

Static Public Member Functions
static void	EnableSaveImagesOnFailures ()
static void	PrintFailureImageFileNames ()
static void	RenderAll (const std::unique_ptr< DlSurfaceProvider > &provider, const TestParameters &params, const BoundsTolerance &tolerance=DefaultTolerance)
static void	RenderWithSaveRestore (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)
static void	RenderWithAttributes (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)
static void	RenderWithStrokes (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance_in)
static void	RenderWithTransforms (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance)
static void	RenderWithClips (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &diff_tolerance)
static DirectoryStatus	CheckDir (const std::string &dir)
static void	SetupFailureImageDirectory ()
static void	save_to_png (const RenderResult &result, const std::string &op_desc, const std::string &reason)
static void	RenderWith (const TestParameters &testP, const RenderEnvironment &env, const BoundsTolerance &tolerance_in, const CaseParameters &caseP)
static bool	fuzzyCompare (uint32_t pixel_a, uint32_t pixel_b, int fudge)
static int	groupOpacityFudgeFactor (const RenderEnvironment &env)
static void	checkGroupOpacity (const RenderEnvironment &env, const sk_sp< DisplayList > &display_list, const RenderResult &ref_result, const std::string &info, DlColor bg)
static bool	checkPixels (const RenderResult &ref_result, const DlRect ref_bounds, const std::string &info, const DlColor bg=DlColor::kTransparent())
static int	countModifiedTransparentPixels (const RenderResult &ref_result, const RenderResult &test_result)
static bool	quickCompareToReference (const RenderResult &ref_result, const RenderResult &test_result, bool should_match, const std::string &info)
static void	compareToReference (const RenderResult &test_result, const RenderResult &ref_result, const std::string &info, const DlRect *bounds, const BoundsTolerance *tolerance, const DlColor bg, bool fuzzyCompares=false, uint32_t width=kTestWidth, uint32_t height=kTestHeight, bool printMismatches=false)
static void	showBoundsOverflow (const std::string &info, DlIRect &bounds, const BoundsTolerance *tolerance, int pixLeft, int pixTop, int pixRight, int pixBottom)

Static Public Attributes
static BoundsTolerance	DefaultTolerance

Detailed Description

Definition at line 908 of file dl_rendering_unittests.cc.

Member Enumeration Documentation

DirectoryStatus

enum class flutter::testing::CanvasCompareTester::DirectoryStatus

strong

Enumerator
kExisted
kCreated
kFailed

Definition at line 1804 of file dl_rendering_unittests.cc.

                             {
    kExisted,
    kCreated,
    kFailed,
  };

Member Function Documentation

CheckDir()

static DirectoryStatus flutter::testing::CanvasCompareTester::CheckDir ( const std::string &  dir )

inlinestatic

Definition at line 1810 of file dl_rendering_unittests.cc.

                                                        {
    fml::UniqueFD ret =
        fml::OpenDirectory(dir.c_str(), false, fml::FilePermission::kRead);
    if (ret.is_valid()) {
      return DirectoryStatus::kExisted;
    }
    ret =
        fml::OpenDirectory(dir.c_str(), true, fml::FilePermission::kReadWrite);
    if (ret.is_valid()) {
      return DirectoryStatus::kCreated;
    }
    FML_LOG(ERROR) << "Could not create directory (" << dir
                   << ") for impeller failure images" << ", ret = " << ret.get()
                   << ", errno = " << errno;
    return DirectoryStatus::kFailed;
  }

References FML_LOG, fml::UniqueObject< T, Traits >::get(), fml::UniqueObject< T, Traits >::is_valid(), kCreated, kExisted, kFailed, fml::kRead, fml::kReadWrite, and fml::OpenDirectory().

Referenced by SetupFailureImageDirectory().

checkGroupOpacity()

static void flutter::testing::CanvasCompareTester::checkGroupOpacity ( const RenderEnvironment &  env, const sk_sp< DisplayList > &  display_list, const RenderResult &  ref_result, const std::string &  info, DlColor  bg  )

inlinestatic

Definition at line 2004 of file dl_rendering_unittests.cc.

                                            {
    DlScalar opacity = 128.0 / 255.0;
 
    if (opacity > 0) {
      return;
    }
    DisplayListJobRenderer opacity_job(display_list);
    RenderJobInfo opacity_info = {
        .bg = bg,
        .opacity = opacity,
    };
    RenderResult group_opacity_result =
        env.GetResult(opacity_info, opacity_job);
 
    ASSERT_EQ(group_opacity_result.pixel_data->width(), kTestWidth) << info;
    ASSERT_EQ(group_opacity_result.pixel_data->height(), kTestHeight) << info;
 
    ASSERT_EQ(ref_result.pixel_data->width(), kTestWidth) << info;
    ASSERT_EQ(ref_result.pixel_data->height(), kTestHeight) << info;
 
    int pixels_touched = 0;
    int pixels_different = 0;
    int max_diff = 0;
    // We need to allow some slight differences per component due to the
    // fact that rearranging discrete calculations can compound round off
    // errors. Off-by-2 is enough for 8 bit components, but for the 565
    // tests we allow at least 9 which is the maximum distance between
    // samples when converted to 8 bits. (You might think it would be a
    // max step of 8 converting 5 bits to 8 bits, but it is really
    // converting 31 steps to 255 steps with an average step size of
    // 8.23 - 24 of the steps are by 8, but 7 of them are by 9.)
    int fudge = groupOpacityFudgeFactor(env);
    for (uint32_t y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result.pixel_data->addr32(0, y);
      const uint32_t* test_row = group_opacity_result.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < kTestWidth; x++) {
        uint32_t ref_pixel = ref_row[x];
        uint32_t test_pixel = test_row[x];
        if (ref_pixel != bg.argb() || test_pixel != bg.argb()) {
          pixels_touched++;
          for (int i = 0; i < 32; i += 8) {
            int ref_comp = (ref_pixel >> i) & 0xff;
            int bg_comp = (bg.argb() >> i) & 0xff;
            DlScalar faded_comp = bg_comp + (ref_comp - bg_comp) * opacity;
            int test_comp = (test_pixel >> i) & 0xff;
            if (std::abs(faded_comp - test_comp) > fudge) {
              int diff = std::abs(faded_comp - test_comp);
              if (max_diff < diff) {
                max_diff = diff;
              }
              pixels_different++;
              break;
            }
          }
        }
      }
    }
    ASSERT_GT(pixels_touched, 20) << info;
    if (pixels_different > 1) {
      FML_LOG(ERROR) << "max diff == " << max_diff << " for " << info;
    }
    ASSERT_LE(pixels_different, 1) << info;
  }

References flutter::DlColor::argb(), flutter::testing::RenderJobInfo::bg, FML_LOG, flutter::testing::RenderEnvironment::GetResult(), groupOpacityFudgeFactor(), i, flutter::testing::kTestHeight, flutter::testing::kTestWidth, flutter::testing::RenderResult::pixel_data, x, and y.

Referenced by RenderWith().

checkPixels()

static bool flutter::testing::CanvasCompareTester::checkPixels ( const RenderResult &  ref_result, const DlRect  ref_bounds, const std::string &  info, const DlColor  bg = DlColor::kTransparent()  )

inlinestatic

Definition at line 2072 of file dl_rendering_unittests.cc.

                                                                    {
    uint32_t untouched = PremultipliedArgb(bg);
    int pixels_touched = 0;
    int pixels_oob = 0;
    DlIRect i_bounds = DlIRect::RoundOut(ref_bounds);
    EXPECT_EQ(ref_result.pixel_data->width(), kTestWidth) << info;
    EXPECT_EQ(ref_result.pixel_data->height(), kTestWidth) << info;
    for (uint32_t y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < kTestWidth; x++) {
        if (ref_row[x] != untouched) {
          pixels_touched++;
          if (!i_bounds.Contains(DlIPoint(x, y))) {
            pixels_oob++;
          }
        }
      }
    }
    EXPECT_EQ(pixels_oob, 0) << info;
    EXPECT_GT(pixels_touched, 0) << info;
    return pixels_oob == 0 && pixels_touched > 0;
  }

References impeller::TRect< T >::Contains(), flutter::testing::kTestHeight, flutter::testing::kTestWidth, flutter::testing::RenderResult::pixel_data, impeller::TRect< T >::RoundOut(), x, and y.

Referenced by RenderWith().

compareToReference()

static void flutter::testing::CanvasCompareTester::compareToReference ( const RenderResult &  test_result, const RenderResult &  ref_result, const std::string &  info, const DlRect *  bounds, const BoundsTolerance *  tolerance, const DlColor  bg, bool  fuzzyCompares = false, uint32_t  width = kTestWidth, uint32_t  height = kTestHeight, bool  printMismatches = false  )

inlinestatic

Definition at line 2145 of file dl_rendering_unittests.cc.

                                                               {
    uint32_t untouched = PremultipliedArgb(bg);
    ASSERT_EQ(test_result.pixel_data->width(), width) << info;
    ASSERT_EQ(test_result.pixel_data->height(), height) << info;
    DlIRect i_bounds =
        bounds ? DlIRect::RoundOut(*bounds) : DlIRect::MakeWH(width, height);
 
    int pixels_different = 0;
    int pixels_oob = 0;
    uint32_t min_x = width;
    uint32_t min_y = height;
    uint32_t max_x = 0;
    uint32_t max_y = 0;
    for (uint32_t y = 0; y < height; y++) {
      const uint32_t* ref_row = ref_result.pixel_data->addr32(0, y);
      const uint32_t* test_row = test_result.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < width; x++) {
        if (bounds && test_row[x] != untouched) {
          if (min_x > x) {
            min_x = x;
          }
          if (min_y > y) {
            min_y = y;
          }
          if (max_x <= x) {
            max_x = x + 1;
          }
          if (max_y <= y) {
            max_y = y + 1;
          }
          if (!i_bounds.Contains(DlIPoint(x, y))) {
            pixels_oob++;
          }
        }
        bool match = fuzzyCompares ? fuzzyCompare(test_row[x], ref_row[x], 1)
                                   : test_row[x] == ref_row[x];
        if (!match) {
          if (printMismatches && pixels_different < 5) {
            FML_LOG(ERROR) << "pix[" << x << ", " << y
                           << "] mismatch: " << std::hex << test_row[x]
                           << "(test) != (ref)" << ref_row[x] << std::dec;
          }
          pixels_different++;
        }
      }
    }
    if (pixels_oob > 0) {
      FML_LOG(ERROR) << "pix bounds["
                     << DlIRect::MakeLTRB(min_x, min_y, max_x, max_y)  //
                     << "]";
      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
    } else if (bounds) {
      showBoundsOverflow(info, i_bounds, tolerance, min_x, min_y, max_x, max_y);
    }
    ASSERT_EQ(pixels_oob, 0) << info;
    ASSERT_EQ(pixels_different, 0) << info;
  }

References impeller::TRect< T >::Contains(), FML_LOG, fuzzyCompare(), height, impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::MakeWH(), flutter::testing::RenderResult::pixel_data, impeller::TRect< T >::RoundOut(), showBoundsOverflow(), width, x, and y.

Referenced by flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

countModifiedTransparentPixels()

static int flutter::testing::CanvasCompareTester::countModifiedTransparentPixels ( const RenderResult &  ref_result, const RenderResult &  test_result  )

inlinestatic

Definition at line 2098 of file dl_rendering_unittests.cc.

                                                                             {
    int count = 0;
    for (uint32_t y = 0; y < kTestHeight; y++) {
      const uint32_t* ref_row = ref_result.pixel_data->addr32(0, y);
      const uint32_t* test_row = test_result.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < kTestWidth; x++) {
        if (ref_row[x] != test_row[x]) {
          if (ref_row[x] == 0) {
            count++;
          }
        }
      }
    }
    return count;
  }

References flutter::testing::kTestHeight, flutter::testing::kTestWidth, flutter::testing::RenderResult::pixel_data, x, and y.

Referenced by flutter::testing::TEST_F(), and flutter::testing::TEST_F().

EnableSaveImagesOnFailures()

static void flutter::testing::CanvasCompareTester::EnableSaveImagesOnFailures ( )

inlinestatic

Definition at line 915 of file dl_rendering_unittests.cc.

{ save_failure_images_ = true; }

Referenced by flutter::testing::DisplayListRendering::SetUpTestSuite().

fuzzyCompare()

static bool flutter::testing::CanvasCompareTester::fuzzyCompare ( uint32_t  pixel_a, uint32_t  pixel_b, int  fudge  )

inlinestatic

Definition at line 1981 of file dl_rendering_unittests.cc.

                                                                          {
    for (int i = 0; i < 32; i += 8) {
      int comp_a = (pixel_a >> i) & 0xff;
      int comp_b = (pixel_b >> i) & 0xff;
      if (std::abs(comp_a - comp_b) > fudge) {
        return false;
      }
    }
    return true;
  }

References i.

Referenced by compareToReference().

groupOpacityFudgeFactor()

static int flutter::testing::CanvasCompareTester::groupOpacityFudgeFactor ( const RenderEnvironment &  env )

inlinestatic

Definition at line 1992 of file dl_rendering_unittests.cc.

                                                                   {
    if (env.GetPixelFormat() == PixelFormat::k565) {
      return 9;
    }
    if (env.GetProvider()->GetBackendType() == BackendType::kSkiaOpenGL) {
      // OpenGL gets a little fuzzy at times. Still, "within 5" (aka +/-4)
      // for byte samples is not bad, though the other backends give +/-1
      return 5;
    }
    return 2;
  }

References flutter::testing::DlSurfaceProvider::GetBackendType(), flutter::testing::RenderEnvironment::GetPixelFormat(), and flutter::testing::RenderEnvironment::GetProvider().

Referenced by checkGroupOpacity().

PrintFailureImageFileNames()

static void flutter::testing::CanvasCompareTester::PrintFailureImageFileNames ( )

inlinestatic

Definition at line 917 of file dl_rendering_unittests.cc.

                                           {
    if (failure_image_filenames_.empty()) {
      return;
    }
    FML_LOG(INFO);
    FML_LOG(INFO) << failure_image_filenames_.size() << " images saved in "
                  << failure_image_directory_;
    for (const std::string& filename : failure_image_filenames_) {
      FML_LOG(INFO) << "  " << filename;
    }
    FML_LOG(INFO);
  }

References FML_LOG.

Referenced by flutter::testing::DisplayListRendering::TearDownTestSuite().

quickCompareToReference()

static bool flutter::testing::CanvasCompareTester::quickCompareToReference ( const RenderResult &  ref_result, const RenderResult &  test_result, bool  should_match, const std::string &  info  )

inlinestatic

Definition at line 2115 of file dl_rendering_unittests.cc.

                                                             {
    uint32_t w = test_result.pixel_data->width();
    uint32_t h = test_result.pixel_data->height();
    EXPECT_EQ(w, ref_result.pixel_data->width()) << info;
    EXPECT_EQ(h, ref_result.pixel_data->height()) << info;
    int pixels_different = 0;
    for (uint32_t y = 0; y < h; y++) {
      const uint32_t* ref_row = ref_result.pixel_data->addr32(0, y);
      const uint32_t* test_row = test_result.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < w; x++) {
        if (ref_row[x] != test_row[x]) {
          if (should_match && pixels_different < 5) {
            FML_LOG(ERROR) << std::hex << ref_row[x] << " != " << test_row[x];
          }
          pixels_different++;
        }
      }
    }
    if (should_match) {
      EXPECT_EQ(pixels_different, 0) << info;
      return pixels_different == 0;
    } else {
      EXPECT_NE(pixels_different, 0) << info;
      return pixels_different != 0;
    }
  }

References FML_LOG, flutter::h, flutter::testing::RenderResult::pixel_data, x, and y.

Referenced by RenderWith(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

RenderAll()

static void flutter::testing::CanvasCompareTester::RenderAll ( const std::unique_ptr< DlSurfaceProvider > &  provider, const TestParameters &  params, const BoundsTolerance &  tolerance = DefaultTolerance  )

inlinestatic

Definition at line 932 of file dl_rendering_unittests.cc.

                                                                             {
    RenderEnvironment env = RenderEnvironment::MakeN32(provider.get());
    env.InitializeReference(kEmptyDlSetup, params.dl_renderer());
 
    RenderWithTransforms(params, env, tolerance);
    RenderWithClips(params, env, tolerance);
    RenderWithSaveRestore(params, env, tolerance);
    // Only test attributes if the canvas version uses the paint object
    if (params.uses_paint()) {
      RenderWithAttributes(params, env, tolerance);
    }
  }

References flutter::testing::RenderEnvironment::InitializeReference(), flutter::testing::kEmptyDlSetup, flutter::testing::RenderEnvironment::MakeN32(), params, RenderWithAttributes(), RenderWithClips(), RenderWithSaveRestore(), and RenderWithTransforms().

Referenced by flutter::testing::DisplayListRendering::RenderAll().

RenderWith()

static void flutter::testing::CanvasCompareTester::RenderWith ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  tolerance_in, const CaseParameters &  caseP  )

inlinestatic

Run a suite of tests on the indicated parameters to determine if the output matches various expectations, including:

• The rendering does not exceed the bounds computed by the DisplayList into which the operation was recorded.
• If the parameters indicate an attribute (color, filter, stroke) or and environmental condition (clip, transform, save layer) which should affect the rendering, that it does affect the rendering, and conversely that it does not if it should not.

testP - The parameters of the basic rendering operation being tested such as DrawRect, DrawPath, DrawText, etc. env - The parameters of the test environment for this suite of tests such as the Surface Provider that determines which backend is being used. tolerance_in - A first approximation of how tight the bounds might be for the indicated test and case parameters. Some issues that might require a higher bounds tolerance would include the fact that text glyphs do not consume most of their measured bounds, or that antialiasing is enabled which allows pixels outside the theoretical bounds of the operation's geometry to be rendered. caseP - The parameters under which the test is being rendered, which includes information such as transform, clip, and attributes.

Definition at line 1900 of file dl_rendering_unittests.cc.

                                                      {
    std::string test_name =
        ::testing::UnitTest::GetInstance()->current_test_info()->name();
    const std::string info =
        env.GetBackendName() + ": " + test_name + " (" + caseP.info() + ")";
    const DlColor bg = caseP.bg();
    RenderJobInfo base_info = {
        .bg = bg,
    };
 
    // This is the basic rendering of the specified job. We combine the
    // rendering from the test, with the attribute and environment mutations
    // from the case
    DlJobRenderer dl_job(caseP.dl_setup(),     //
                         testP.dl_renderer(),  //
                         caseP.dl_restore());
    RenderResult dl_result = env.GetResult(base_info, dl_job);
 
    ASSERT_EQ(dl_result.pixel_data->width(), kTestWidth) << info;
    ASSERT_EQ(dl_result.pixel_data->height(), kTestHeight) << info;
 
    // We construct a display list from the rendering operations which will
    // estimate the bounds we expect from the operation, among other properties.
    const sk_sp<DisplayList> display_list =
        dl_job.MakeDisplayList(env, base_info);
 
    // We now test the result of rendering the operations to verify that:
    // - it did render something (pixels touched > 0)
    // - no pixels were rendered outside the computed bounds (pixels_oob == 0)
    DlRect dl_bounds = display_list->GetBounds();
    bool success = checkPixels(dl_result, dl_bounds,
                               info + " (DisplayList reference)", bg);
 
    // Now we test if the operation should have rendered something different
    // compared to the default reference rendering that has no attributes
    // applied. Some operations ignore some attributes and so we need to
    // examine the test case properties to see if the rendering should or
    // should not match the default reference rendering.
    //
    // quickCompareToReference does both jobs (matches or does not match)
    // and we provide it with a boolean indicating if we expect the two
    // results to match and a string that prints out the expectation that
    // was violated.
    if (testP.should_match(env, caseP, dl_job.GetSetupPaint(), dl_job)) {
      success = quickCompareToReference(
                    env.GetReferenceResult(), dl_result, true,
                    info + " (attribute should not have effect)") &&
                success;
    } else {
      success = quickCompareToReference(
                    env.GetReferenceResult(), dl_result, false,
                    info + " (attribute should affect rendering)") &&
                success;
    }
 
    if (save_failure_images_ && !success) {
      FML_LOG(ERROR) << "Rendering issue encountered for: " << *display_list;
      save_to_png(dl_result, info + " (Test Result)", "output saved in");
      save_to_png(env.GetReferenceResult(), info + " (Test Reference)",
                  "compare to reference without attributes");
    }
 
    // We now determine if the display list is compatible with distributing
    // a group opacity to its individual rendering operations. If the
    // display list believes that can be done, we double check by asking
    // the canvas to render the display list with a group opacity value
    // and then see if the results really match a faded version of the
    // original rendering results.
    //
    // If the display list does not promise that it can apply group opacity
    // then we do not verify that condition, we allow it the freedom to
    // answer "false" conservatively.
    if (display_list->can_apply_group_opacity()) {
      checkGroupOpacity(env, display_list, dl_result,
                        info + " with Group Opacity", bg);
    }
  }

References flutter::testing::RenderJobInfo::bg, flutter::testing::CaseParameters::bg(), checkGroupOpacity(), checkPixels(), flutter::testing::TestParameters::dl_renderer(), flutter::testing::CaseParameters::dl_restore(), flutter::testing::CaseParameters::dl_setup(), FML_LOG, flutter::testing::RenderEnvironment::GetBackendName(), flutter::testing::RenderEnvironment::GetReferenceResult(), flutter::testing::RenderEnvironment::GetResult(), flutter::testing::DlJobRenderer::GetSetupPaint(), flutter::testing::CaseParameters::info(), flutter::testing::kTestHeight, flutter::testing::kTestWidth, flutter::testing::DlJobRenderer::MakeDisplayList(), flutter::testing::RenderResult::pixel_data, quickCompareToReference(), save_to_png(), and flutter::testing::TestParameters::should_match().

Referenced by RenderWithAttributes(), RenderWithClips(), RenderWithSaveRestore(), RenderWithStrokes(), RenderWithTransforms(), and flutter::testing::TEST_F().

RenderWithAttributes()

static void flutter::testing::CanvasCompareTester::RenderWithAttributes ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  tolerance  )

inlinestatic

Definition at line 1171 of file dl_rendering_unittests.cc.

                                                                     {
    RenderWith(testP, env, tolerance, CaseParameters("Defaults Test"));
 
    {
      // CPU renderer with default line width of 0 does not show antialiasing
      // for stroked primitives, so we make a new reference with a non-trivial
      // stroke width to demonstrate the differences
      RenderEnvironment aa_env = RenderEnvironment::MakeN32(env.GetProvider());
      // Tweak the bounds tolerance for the displacement of 1/10 of a pixel
      const BoundsTolerance aa_tolerance = tolerance.addBoundsPadding(1, 1);
      auto dl_aa_setup = [=](DlSetupContext ctx, bool is_aa) -> void {
        ctx.canvas->Translate(0.1, 0.1);
        ctx.paint.setAntiAlias(is_aa);
        ctx.paint.setStrokeWidth(5.0);
      };
      aa_env.InitializeReference(
          [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, false); },
          testP.dl_renderer());
 
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(
          testP, aa_env, aa_tolerance,
          CaseParameters(
              "AntiAlias == True",
              [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, true); }));
      RenderWith(
          testP, aa_env, aa_tolerance,
          CaseParameters(
              "AntiAlias == False",
              [=](const DlSetupContext& ctx) { dl_aa_setup(ctx, false); }));
      // clang-format on
    }
 
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Color == Blue",
            [=](const DlSetupContext& ctx) {
              ctx.paint.setColor(DlColor::kBlue());
            }));
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Color == Green",
            [=](const DlSetupContext& ctx) {
              ctx.paint.setColor(DlColor::kGreen());
            }));
    // clang-format on
 
    RenderWithStrokes(testP, env, tolerance);
 
    {
      // half opaque cyan
      DlColor blendable_color = DlColor::kCyan().withAlpha(0x7f);
      DlColor bg = DlColor::kWhite();
 
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(testP, env, tolerance,
                 CaseParameters(
                     "Blend == SrcIn",
                     [=](const DlSetupContext& ctx) {
                       ctx.paint.setBlendMode(DlBlendMode::kSrcIn);
                       ctx.paint.setColor(blendable_color);
                     })
                     .with_bg(bg));
      RenderWith(testP, env, tolerance,
                 CaseParameters(
                     "Blend == DstIn",
                     [=](const DlSetupContext& ctx) {
                       ctx.paint.setBlendMode(DlBlendMode::kDstIn);
                       ctx.paint.setColor(blendable_color);
                     })
                     .with_bg(bg));
      // clang-format on
    }
 
    {
      // Being able to see a blur requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment blur_env =
          RenderEnvironment::MakeN32(env.GetProvider());
      DlSetup dl_blur_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.env.GetTestImage()));
        ctx.paint.setStrokeWidth(5.0);
      };
      blur_env.InitializeReference(dl_blur_setup, testP.dl_renderer());
 
      DlBlurImageFilter dl_filter_decal_5(5.0, 5.0, DlTileMode::kDecal);
      BoundsTolerance blur_5_tolerance = tolerance.addBoundsPadding(4, 4);
      {
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, blur_env, blur_5_tolerance,
                   CaseParameters(
                       "ImageFilter == Decal Blur 5",
                       [=](const DlSetupContext& ctx) {
                         dl_blur_setup(ctx);
                         ctx.paint.setImageFilter(&dl_filter_decal_5);
                       }));
        // clang-format on
      }
      DlBlurImageFilter dl_filter_clamp_5(5.0, 5.0, DlTileMode::kClamp);
      {
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, blur_env, blur_5_tolerance,
                   CaseParameters(
                       "ImageFilter == Clamp Blur 5",
                       [=](const DlSetupContext& ctx) {
                         dl_blur_setup(ctx);
                         ctx.paint.setImageFilter(&dl_filter_clamp_5);
                       }));
        // clang-format on
      }
    }
 
    {
      // Being able to see a dilate requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment dilate_env =
          RenderEnvironment::MakeN32(env.GetProvider());
      DlSetup dl_dilate_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.env.GetTestImage()));
        ctx.paint.setStrokeWidth(5.0);
      };
      dilate_env.InitializeReference(dl_dilate_setup, testP.dl_renderer());
 
      DlDilateImageFilter dl_dilate_filter_5(5.0, 5.0);
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(testP, dilate_env, tolerance,
                 CaseParameters(
                     "ImageFilter == Dilate 5",
                     [=](const DlSetupContext& ctx) {
                       dl_dilate_setup(ctx);
                       ctx.paint.setImageFilter(&dl_dilate_filter_5);
                     }));
      // clang-format on
    }
 
    {
      // Being able to see an erode requires some non-default attributes,
      // like a non-trivial stroke width and a shader rather than a color
      // (for drawPaint) so we create a new environment for these tests.
      RenderEnvironment erode_env =
          RenderEnvironment::MakeN32(env.GetProvider());
      DlSetup dl_erode_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setColorSource(MakeColorSource(ctx.env.GetTestImage()));
        ctx.paint.setStrokeWidth(6.0);
      };
      erode_env.InitializeReference(dl_erode_setup, testP.dl_renderer());
 
      // do not erode too much, because some tests assert there are enough
      // pixels that are changed.
      DlErodeImageFilter dl_erode_filter_1(1.0, 1.0);
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(testP, erode_env, tolerance,
                 CaseParameters(
                     "ImageFilter == Erode 1",
                     [=](const DlSetupContext& ctx) {
                       dl_erode_setup(ctx);
                       ctx.paint.setImageFilter(&dl_erode_filter_1);
                     }));
      // clang-format on
    }
 
    {
      // clang-format off
      constexpr float rotate_color_matrix[20] = {
          0, 1, 0, 0, 0,
          0, 0, 1, 0, 0,
          1, 0, 0, 0, 0,
          0, 0, 0, 1, 0,
      };
      // clang-format on
      std::shared_ptr<const DlColorFilter> dl_color_filter =
          DlColorFilter::MakeMatrix(rotate_color_matrix);
      {
        DlColor bg = DlColor::kWhite();
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "ColorFilter == RotateRGB",
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColor(DlColor::kYellow());
                         ctx.paint.setColorFilter(dl_color_filter);
                       })
                       .with_bg(bg));
        // clang-format on
      }
      {
        DlColor bg = DlColor::kWhite();
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "ColorFilter == Invert",
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColor(DlColor::kYellow());
                         ctx.paint.setInvertColors(true);
                       })
                       .with_bg(bg));
        // clang-format on
      }
    }
 
    {
      const DlBlurMaskFilter dl_mask_filter(DlBlurStyle::kNormal, 5.0);
      BoundsTolerance blur_5_tolerance = tolerance.addBoundsPadding(4, 4);
      {
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, env, blur_5_tolerance,
                   CaseParameters(
                       "MaskFilter == Blur 5",
                       [=](const DlSetupContext& ctx) {
                         // Stroked primitives need some non-trivial stroke
                         // width to be blurred
                         ctx.paint.setStrokeWidth(5.0);
                         ctx.paint.setMaskFilter(&dl_mask_filter);
                       }));
        // clang-format on
      }
    }
 
    {
      DlPoint dl_end_points[] = {
          kRenderBounds.GetLeftTop(),
          kRenderBounds.GetRightBottom(),
      };
      DlColor dl_colors[] = {
          DlColor::kGreen(),
          DlColor::kYellow().withAlpha(0x7f),
          DlColor::kBlue(),
      };
      float stops[] = {
          0.0,
          0.5,
          1.0,
      };
      std::shared_ptr<DlColorSource> dl_gradient =
          DlColorSource::MakeLinear(dl_end_points[0], dl_end_points[1], 3,
                                    dl_colors, stops, DlTileMode::kMirror);
      {
        // clang-format off
        // The following section gets re-formatted on every commit even if it
        // doesn't change.
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "LinearGradient GYB",
                       [=](const DlSetupContext& ctx) {
                         ctx.paint.setColorSource(dl_gradient);
                       }));
        // clang-format on
      }
    }
  }

References flutter::testing::BoundsTolerance::addBoundsPadding(), flutter::testing::DlSetupContext::canvas, flutter::testing::TestParameters::dl_renderer(), flutter::testing::DlSetupContext::env, impeller::TRect< T >::GetLeftTop(), flutter::testing::RenderEnvironment::GetProvider(), impeller::TRect< T >::GetRightBottom(), flutter::testing::RenderEnvironment::GetTestImage(), flutter::testing::RenderEnvironment::InitializeReference(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kCyan(), flutter::kDecal, flutter::DlColor::kGreen(), flutter::kMirror, flutter::kNormal, flutter::testing::kRenderBounds, flutter::DlColor::kWhite(), flutter::DlColor::kYellow(), flutter::testing::MakeColorSource(), flutter::DlColorSource::MakeLinear(), flutter::DlColorFilter::MakeMatrix(), flutter::testing::RenderEnvironment::MakeN32(), flutter::testing::DlSetupContext::paint, RenderWith(), RenderWithStrokes(), flutter::DlPaint::setAntiAlias(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setImageFilter(), flutter::DlPaint::setInvertColors(), flutter::DlPaint::setMaskFilter(), flutter::DlPaint::setStrokeWidth(), flutter::DlCanvas::Translate(), and flutter::DlColor::withAlpha().

Referenced by RenderAll().

RenderWithClips()

static void flutter::testing::CanvasCompareTester::RenderWithClips ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  diff_tolerance  )

inlinestatic

Definition at line 1681 of file dl_rendering_unittests.cc.

                                                                     {
    // We used to use an inset of 15.5 pixels here, but since Skia's rounding
    // behavior at the center of pixels does not match between HW and SW, we
    // ended up with some clips including different pixels between the two
    // destinations and this interacted poorly with the carefully chosen
    // geometry in some of the tests which was designed to have just the
    // right features fully filling the clips based on the SW rounding. By
    // moving to a 15.4 inset, the edge of the clip is never on the "rounding
    // edge" of a pixel.
    DlRect r_clip = kRenderBounds.Expand(-15.4, -15.4);
    BoundsTolerance intersect_tolerance = diff_tolerance.clip(r_clip);
    intersect_tolerance = intersect_tolerance.addPostClipPadding(1, 1);
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipRect inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipRect inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipRect Diff, inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRect(r_clip, DlClipOp::kDifference, false);
                   })
                   .with_diff_clip());
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipOval",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipOval",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipOval Diff",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipOval(r_clip, DlClipOp::kDifference, false);
                   })
                   .with_diff_clip());
    // clang-format on
 
    // This test RR clip used to use very small radii, but due to
    // optimizations in the HW rrect rasterization, this caused small
    // bulges in the corners of the RRect which were interpreted as
    // "clip overruns" by the clip OOB pixel testing code. Using less
    // abusively small radii fixes the problem.
    DlRoundRect rr_clip = DlRoundRect::MakeRectXY(r_clip, 9, 9);
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipRRect with radius of 9",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
                                               false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipRRect with radius of 9",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
                                               true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipRRect Diff, with radius of 9",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kDifference,
                                               false);
                   })
                   .with_diff_clip());
    // clang-format on
 
    DlPathBuilder path_builder;
    path_builder.SetFillType(DlPathFillType::kOdd);
    path_builder.AddRect(r_clip);
    path_builder.AddCircle(DlPoint(kRenderCenterX, kRenderCenterY), 1.0f);
    DlPath path_clip = path_builder.TakePath();
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "Hard ClipPath inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
                                          false);
                   }));
    RenderWith(testP, env, intersect_tolerance,
               CaseParameters(
                   "AntiAlias ClipPath inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
                                          true);
                   }));
    RenderWith(testP, env, diff_tolerance,
               CaseParameters(
                   "Hard ClipPath Diff, inset by 15.4",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->ClipPath(path_clip, DlClipOp::kDifference,
                                          false);
                   })
                   .with_diff_clip());
    // clang-format off
  }

References flutter::DlPathBuilder::AddCircle(), flutter::testing::BoundsTolerance::addPostClipPadding(), flutter::DlPathBuilder::AddRect(), flutter::testing::DlSetupContext::canvas, flutter::testing::BoundsTolerance::clip(), flutter::DlCanvas::ClipOval(), flutter::DlCanvas::ClipPath(), flutter::DlCanvas::ClipRect(), flutter::DlCanvas::ClipRoundRect(), impeller::TRect< T >::Expand(), flutter::kDifference, flutter::kIntersect, flutter::testing::kRenderBounds, flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, impeller::RoundRect::MakeRectXY(), RenderWith(), flutter::DlPathBuilder::SetFillType(), and flutter::DlPathBuilder::TakePath().

Referenced by RenderAll().

RenderWithSaveRestore()

static void flutter::testing::CanvasCompareTester::RenderWithSaveRestore ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  tolerance  )

inlinestatic

Definition at line 947 of file dl_rendering_unittests.cc.

                                                                      {
    DlRect clip =
        DlRect::MakeXYWH(kRenderCenterX - 1, kRenderCenterY - 1, 2, 2);
    DlRect rect = DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 10, 10);
    DlColor alpha_layer_color = DlColor::kCyan().withAlpha(0x7f);
    DlRenderer dl_safe_restore = [=](const DlRenderContext& ctx) {
      // Draw another primitive to disable peephole optimizations
      // As the rendering op rejection in the DisplayList Builder
      // gets smarter and smarter, this operation has had to get
      // sneakier and sneakier about specifying an operation that
      // won't practically show up in the output, but technically
      // can't be culled.
      ctx.canvas->DrawRect(
          DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 0.0001, 0.0001),
          DlPaint());
      ctx.canvas->Restore();
    };
    DlRenderer dl_opt_restore = [=](const DlRenderContext& ctx) {
      // Just a simple restore to allow peephole optimizations to occur
      ctx.canvas->Restore();
    };
    DlRect layer_bounds = kRenderBounds.Expand(-15, -15);
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "With prior save/clip/restore",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->Save();
                     ctx.canvas->ClipRect(clip, DlClipOp::kIntersect, false);
                     DlPaint p2;
                     ctx.canvas->DrawRect(rect, p2);
                     p2.setBlendMode(DlBlendMode::kClear);
                     ctx.canvas->DrawRect(rect, p2);
                     ctx.canvas->Restore();
                   }));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer no paint, no bounds",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->SaveLayer(std::nullopt, nullptr);
                   })
                   .with_restore(dl_safe_restore, false));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer no paint, with bounds",
                   [=](const DlSetupContext& ctx) {
                     ctx.canvas->SaveLayer(layer_bounds, nullptr);
                   })
                   .with_restore(dl_safe_restore, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with alpha, no bounds",
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                   })
                   .with_restore(dl_safe_restore, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with peephole alpha, no bounds",
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                   })
                   .with_restore(dl_opt_restore, true, true));
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "saveLayer with alpha and bounds",
                   [=](const DlSetupContext& ctx) {
                     DlPaint save_p;
                     save_p.setColor(alpha_layer_color);
                     ctx.canvas->SaveLayer(layer_bounds, &save_p);
                   })
                   .with_restore(dl_safe_restore, true));
    // clang-format on
    {
      // Being able to see a backdrop blur requires a non-default background
      // so we create a new environment for these tests that has a checkerboard
      // background that can be blurred by the backdrop filter. We also want
      // to avoid the rendered primitive from obscuring the blurred background
      // so we set an alpha value which works for all primitives except for
      // drawColor which can override the alpha with its color, but it now uses
      // a non-opaque color to avoid that problem.
      RenderEnvironment backdrop_env =
          RenderEnvironment::MakeN32(env.GetProvider());
      DlSetup dl_backdrop_setup = [=](const DlSetupContext& ctx) {
        DlPaint setup_p;
        setup_p.setColorSource(MakeColorSource(ctx.env.GetTestImage()));
        ctx.canvas->DrawPaint(setup_p);
      };
      DlSetup dl_content_setup = [=](const DlSetupContext& ctx) {
        ctx.paint.setAlpha(ctx.paint.getAlpha() / 2);
      };
      backdrop_env.InitializeReference(dl_backdrop_setup, testP.dl_renderer());
 
      DlBlurImageFilter dl_backdrop(5, 5, DlTileMode::kDecal);
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(
          testP, backdrop_env, tolerance,
          CaseParameters(
              "saveLayer with backdrop",
              [=](const DlSetupContext& ctx) {
                dl_backdrop_setup(ctx);
                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
                dl_content_setup(ctx);
              })
              .with_restore(dl_safe_restore, true));
      RenderWith(testP, backdrop_env, tolerance,
                 CaseParameters(
                     "saveLayer with bounds and backdrop",
                     [=](const DlSetupContext& ctx) {
                       dl_backdrop_setup(ctx);
                       ctx.canvas->SaveLayer(layer_bounds, nullptr,
                                             &dl_backdrop);
                       dl_content_setup(ctx);
                     })
                     .with_restore(dl_safe_restore, true));
      RenderWith(
          testP, backdrop_env, tolerance,
          CaseParameters(
              "clipped saveLayer with backdrop",
              [=](const DlSetupContext& ctx) {
                dl_backdrop_setup(ctx);
                ctx.canvas->ClipRect(layer_bounds);
                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
                dl_content_setup(ctx);
              })
              .with_restore(dl_safe_restore, true));
      // clang-format on
    }
 
    {
      // clang-format off
      constexpr float rotate_alpha_color_matrix[20] = {
          0, 1, 0,  0 , 0,
          0, 0, 1,  0 , 0,
          1, 0, 0,  0 , 0,
          0, 0, 0, 0.5, 0,
      };
      // clang-format on
      std::shared_ptr<const DlColorFilter> dl_alpha_rotate_filter =
          DlColorFilter::MakeMatrix(rotate_alpha_color_matrix);
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ColorFilter, no bounds",
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setColorFilter(dl_alpha_rotate_filter);
                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(dl_safe_restore, true));
      }
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ColorFilter and bounds",
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setColorFilter(dl_alpha_rotate_filter);
                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(dl_safe_restore, true));
      }
      // clang-format on
    }
 
    {
      // clang-format off
      constexpr float color_matrix[20] = {
          0.5, 0, 0, 0, 0.5,
          0, 0.5, 0, 0, 0.5,
          0, 0, 0.5, 0, 0.5,
          0, 0, 0, 1, 0,
      };
      // clang-format on
      std::shared_ptr<const DlColorFilter> dl_color_filter =
          DlColorFilter::MakeMatrix(color_matrix);
      std::shared_ptr<DlImageFilter> dl_cf_image_filter =
          DlImageFilter::MakeColorFilter(dl_color_filter);
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ImageFilter, no bounds",
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setImageFilter(dl_cf_image_filter);
                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(dl_safe_restore, true));
      }
      {
        RenderWith(testP, env, tolerance,
                   CaseParameters(
                       "saveLayer ImageFilter and bounds",
                       [=](const DlSetupContext& ctx) {
                         DlPaint save_p;
                         save_p.setImageFilter(dl_cf_image_filter);
                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                         ctx.paint.setStrokeWidth(5.0);
                       })
                       .with_restore(dl_safe_restore, true));
      }
      // clang-format on
    }
  }

References flutter::testing::DlSetupContext::canvas, flutter::DlCanvas::ClipRect(), flutter::testing::TestParameters::dl_renderer(), flutter::DlCanvas::DrawPaint(), flutter::DlCanvas::DrawRect(), flutter::testing::DlSetupContext::env, impeller::TRect< T >::Expand(), flutter::DlPaint::getAlpha(), flutter::testing::RenderEnvironment::GetProvider(), flutter::testing::RenderEnvironment::GetTestImage(), flutter::testing::RenderEnvironment::InitializeReference(), flutter::DlColor::kCyan(), flutter::kDecal, flutter::kIntersect, flutter::testing::kRenderBounds, flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, flutter::DlImageFilter::MakeColorFilter(), flutter::testing::MakeColorSource(), flutter::DlColorFilter::MakeMatrix(), flutter::testing::RenderEnvironment::MakeN32(), impeller::TRect< Scalar >::MakeXYWH(), p2, flutter::testing::DlSetupContext::paint, RenderWith(), flutter::DlCanvas::Restore(), flutter::DlCanvas::Save(), flutter::DlCanvas::SaveLayer(), flutter::DlPaint::setAlpha(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setImageFilter(), flutter::DlPaint::setStrokeWidth(), and flutter::DlColor::withAlpha().

Referenced by RenderAll().

RenderWithStrokes()

static void flutter::testing::CanvasCompareTester::RenderWithStrokes ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  tolerance_in  )

inlinestatic

Definition at line 1449 of file dl_rendering_unittests.cc.

                                                                     {
    // The test cases were generated with geometry that will try to fill
    // out the various miter limits used for testing, but they can be off
    // by a couple of pixels so we will relax bounds testing for strokes by
    // a couple of pixels.
 
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    BoundsTolerance tolerance = tolerance_in.addBoundsPadding(2, 2);
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Fill",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kFill);
                   }));
    // clang-format on
 
    // Skia on HW produces a strong miter consistent with width=1.0
    // for any width less than a pixel, but the bounds computations of
    // both DL and SkPicture do not account for this. We will get
    // OOB pixel errors for the highly mitered drawPath geometry if
    // we don't set stroke width to 1.0 for that test on HW.
    // See https://bugs.chromium.org/p/skia/issues/detail?id=14046
    bool no_hairlines =
        testP.is_draw_path() &&
        env.GetProvider()->GetBackendType() != BackendType::kSkiaSoftware;
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Stroke + defaults",
                   [=](const DlSetupContext& ctx) {
                     if (no_hairlines) {
                       ctx.paint.setStrokeWidth(1.0);
                     }
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                   }));
 
    RenderWith(testP, env, tolerance,
               CaseParameters(
                   "Fill + unnecessary StrokeWidth 10",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kFill);
                     ctx.paint.setStrokeWidth(10.0);
                   }));
    // clang-format on
 
    RenderEnvironment stroke_base_env =
        RenderEnvironment::MakeN32(env.GetProvider());
    DlSetup dl_stroke_setup = [=](const DlSetupContext& ctx) {
      ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
      ctx.paint.setStrokeWidth(5.0);
    };
    stroke_base_env.InitializeReference(dl_stroke_setup, testP.dl_renderer());
 
    // clang-format off
    // The following section gets re-formatted on every commit even if it
    // doesn't change.
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 10",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(10.0);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Square Cap",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(DlStrokeCap::kSquare);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Round Cap",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeCap(DlStrokeCap::kRound);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Bevel Join",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kBevel);
                   }));
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Round Join",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kRound);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Miter 10",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(10.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kMiter);
                   }));
 
    RenderWith(testP, stroke_base_env, tolerance,
               CaseParameters(
                   "Stroke Width 5, Miter 0",
                   [=](const DlSetupContext& ctx) {
                     ctx.paint.setDrawStyle(DlDrawStyle::kStroke);
                     ctx.paint.setStrokeWidth(5.0);
                     ctx.paint.setStrokeMiter(0.0);
                     ctx.paint.setStrokeJoin(DlStrokeJoin::kMiter);
                   }));
    // clang-format on
  }

References flutter::testing::BoundsTolerance::addBoundsPadding(), flutter::testing::TestParameters::dl_renderer(), flutter::testing::DlSurfaceProvider::GetBackendType(), flutter::testing::RenderEnvironment::GetProvider(), flutter::testing::RenderEnvironment::InitializeReference(), flutter::testing::TestParameters::is_draw_path(), flutter::kBevel, flutter::kFill, flutter::kMiter, flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::testing::RenderEnvironment::MakeN32(), flutter::testing::DlSetupContext::paint, RenderWith(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeMiter(), and flutter::DlPaint::setStrokeWidth().

Referenced by RenderWithAttributes().

RenderWithTransforms()

static void flutter::testing::CanvasCompareTester::RenderWithTransforms ( const TestParameters &  testP, const RenderEnvironment &  env, const BoundsTolerance &  tolerance  )

inlinestatic

Definition at line 1582 of file dl_rendering_unittests.cc.

                                                                     {
    // If the rendering method does not fill the corners of the original
    // bounds, then the estimate under rotation or skewing will be off
    // so we scale the padding by about 5% to compensate.
    BoundsTolerance skewed_tolerance = tolerance.mulScale(1.05, 1.05);
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Translate 5, 10",  //
            [=](const DlSetupContext& ctx) { ctx.canvas->Translate(5, 10); }));
    RenderWith(  //
        testP, env, tolerance,
        CaseParameters(
            "Scale +5%",  //
            [=](const DlSetupContext& ctx) { ctx.canvas->Scale(1.05, 1.05); }));
    RenderWith(  //
        testP, env, skewed_tolerance,
        CaseParameters(
            "Rotate 5 degrees",  //
            [=](const DlSetupContext& ctx) { ctx.canvas->Rotate(5); }));
    RenderWith(  //
        testP, env, skewed_tolerance,
        CaseParameters(
            "Skew 5%",  //
            [=](const DlSetupContext& ctx) { ctx.canvas->Skew(0.05, 0.05); }));
    {
      // This rather odd transform can cause slight differences in
      // computing in-bounds samples depending on which base rendering
      // routine Skia uses. Making sure our matrix values are powers
      // of 2 reduces, but does not eliminate, these slight differences
      // in calculation when we are comparing rendering with an alpha
      // to rendering opaque colors in the group opacity tests, for
      // example.
      DlScalar tweak = 1.0 / 16.0;
      DlMatrix matrix = DlMatrix::MakeRow(
          // clang-format off
          1.0 + tweak, tweak,       0, 5,
          tweak,       1.0 + tweak, 0, 10,
          0, 0, 1, 0,
          0, 0, 0, 1
          // clang-format on
      );
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform 2D Affine Matrix",
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform(matrix);
              }));
      RenderWith(
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform 2D Affine inline",
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform2DAffine(1.0 + tweak, tweak, 5,
                                              tweak, 1.0 + tweak, 10);
              }));
      // clang-format on
    }
    {
      DlMatrix matrix = DlMatrix::MakeRow(1.0f, 0.0f, 0.0f, kRenderCenterX,  //
                                          0.0f, 1.0f, 0.0f, kRenderCenterY,  //
                                          0.0f, 0.0f, 1.0f, 0.0f,            //
                                          0.0f, 0.0f, .001f, 1.0f);
      matrix = matrix * DlMatrix::MakeRotationX(DlDegrees(3));
      matrix = matrix * DlMatrix::MakeRotationY(DlDegrees(4));
      matrix = matrix.Translate({-kRenderCenterX, -kRenderCenterY, 0.0f});
      // clang-format off
      // The following section gets re-formatted on every commit even if it
      // doesn't change.
      RenderWith(
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform Full Perspective Matrix",
              [=](const DlSetupContext& ctx) {
                ctx.canvas->Transform(matrix);
              }));
      RenderWith(
          testP, env, skewed_tolerance,
          CaseParameters(
              "Transform Full Perspective inline",
              [=](const DlSetupContext& ctx) {
                ctx.canvas->TransformFullPerspective(
                    // These values match what ends up in matrix above
                     0.997564,   0.000000,   0.069756,   0.243591,
                     0.003651,   0.998630,  -0.052208,  -0.228027,
                    -0.069661,   0.052336,   0.996197,   1.732491,
                    -0.000070,   0.000052,   0.000996,   1.001732
                );
              }));
      // clang-format on
    }
  }

References flutter::testing::DlSetupContext::canvas, flutter::testing::kRenderCenterX, flutter::testing::kRenderCenterY, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRow(), flutter::testing::BoundsTolerance::mulScale(), RenderWith(), flutter::DlCanvas::Rotate(), flutter::DlCanvas::Scale(), flutter::DlCanvas::Skew(), flutter::DlCanvas::Transform(), flutter::DlCanvas::Transform2DAffine(), flutter::DlCanvas::TransformFullPerspective(), impeller::Matrix::Translate(), and flutter::DlCanvas::Translate().

Referenced by RenderAll().

save_to_png()

static void flutter::testing::CanvasCompareTester::save_to_png ( const RenderResult &  result, const std::string &  op_desc, const std::string &  reason  )

inlinestatic

Definition at line 1851 of file dl_rendering_unittests.cc.

                                                   {
    if (!save_failure_images_) {
      return;
    }
    if (failure_image_directory_.length() == 0) {
      SetupFailureImageDirectory();
      if (failure_image_directory_.length() == 0) {
        save_failure_images_ = false;
        return;
      }
    }
 
    std::string filename = failure_image_directory_ + "/";
    for (const char& ch : op_desc) {
      filename += (ch == ':' || ch == ' ') ? '_' : ch;
    }
    filename = filename + ".png";
    if (!result.pixel_data->write(filename)) {
      FML_LOG(ERROR) << "Could not write output to " << filename;
    }
    failure_image_filenames_.push_back(filename);
    FML_LOG(ERROR) << reason << ": " << filename;
  }

References FML_LOG, flutter::testing::RenderResult::pixel_data, and SetupFailureImageDirectory().

Referenced by RenderWith().

SetupFailureImageDirectory()

static void flutter::testing::CanvasCompareTester::SetupFailureImageDirectory ( )

inlinestatic

Definition at line 1827 of file dl_rendering_unittests.cc.

                                           {
    std::string base_dir = "./failure_images";
    if (CheckDir(base_dir) == DirectoryStatus::kFailed) {
      return;
    }
    for (int i = 0; i < 10000; i++) {
      std::string sub_dir = std::to_string(i);
      while (sub_dir.length() < 4) {
        sub_dir = "0" + sub_dir;
      }
      std::string try_dir = base_dir + "/" + sub_dir;
      switch (CheckDir(try_dir)) {
        case DirectoryStatus::kExisted:
          break;
        case DirectoryStatus::kCreated:
          failure_image_directory_ = try_dir;
          return;
        case DirectoryStatus::kFailed:
          return;
      }
    }
    FML_LOG(ERROR) << "Too many output directories for failure images";
  }

References CheckDir(), FML_LOG, i, kCreated, kExisted, and kFailed.

Referenced by save_to_png().

showBoundsOverflow()

static void flutter::testing::CanvasCompareTester::showBoundsOverflow ( const std::string &  info, DlIRect &  bounds, const BoundsTolerance *  tolerance, int  pixLeft, int  pixTop, int  pixRight, int  pixBottom  )

inlinestatic

Definition at line 2212 of file dl_rendering_unittests.cc.

                                                {
    int pad_left = std::max(0, pixLeft - bounds.GetLeft());
    int pad_top = std::max(0, pixTop - bounds.GetTop());
    int pad_right = std::max(0, bounds.GetRight() - pixRight);
    int pad_bottom = std::max(0, bounds.GetBottom() - pixBottom);
    DlIRect pix_bounds =
        DlIRect::MakeLTRB(pixLeft, pixTop, pixRight, pixBottom);
    DlISize pix_size = pix_bounds.GetSize();
    int pix_width = pix_size.width;
    int pix_height = pix_size.height;
    int worst_pad_x = std::max(pad_left, pad_right);
    int worst_pad_y = std::max(pad_top, pad_bottom);
    if (tolerance->overflows(pix_bounds, worst_pad_x, worst_pad_y)) {
      FML_LOG(ERROR) << "Computed bounds for " << info;
      FML_LOG(ERROR) << "pix bounds["                        //
                     << pixLeft << ", " << pixTop << " => "  //
                     << pixRight << ", " << pixBottom        //
                     << "]";
      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
      FML_LOG(ERROR) << "Bounds overly conservative by up to "     //
                     << worst_pad_x << ", " << worst_pad_y         //
                     << " (" << (worst_pad_x * 100.0 / pix_width)  //
                     << "%, " << (worst_pad_y * 100.0 / pix_height) << "%)";
      int pix_area = pix_size.Area();
      int dl_area = bounds.Area();
      FML_LOG(ERROR) << "Total overflow area: " << (dl_area - pix_area)  //
                     << " (+" << (dl_area * 100.0 / pix_area - 100.0)    //
                     << "% larger)";
      FML_LOG(ERROR);
    }
  }

References impeller::TRect< T >::Area(), impeller::TSize< T >::Area(), FML_LOG, impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetTop(), impeller::TSize< T >::height, impeller::TRect< T >::MakeLTRB(), flutter::testing::BoundsTolerance::overflows(), and impeller::TSize< T >::width.

Referenced by compareToReference().

Member Data Documentation

DefaultTolerance

BoundsTolerance flutter::testing::CanvasCompareTester::DefaultTolerance

static

Initial value:

=
    BoundsTolerance().addAbsolutePadding(1, 1)

Definition at line 930 of file dl_rendering_unittests.cc.

Referenced by flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

---

The documentation for this class was generated from the following file:

• display_list/testing/dl_rendering_unittests.cc