flutter::testing Namespace Reference

Typedefs
using	DlGoldenTest = impeller::DlPlayground

Functions
	TEST_P (DlGoldenTest, TextBlurMaskFilterRespectCTM)
	TEST_P (DlGoldenTest, TextBlurMaskFilterDisrespectCTM)
	TEST_P (DlGoldenTest, ShimmerTest)
	TEST_P (DlGoldenTest, StrokedRRectFastBlur)
	TEST_P (DlGoldenTest, LargeDownscaleRrect)
	INSTANTIATE_PLAYGROUND_SUITE (DlGoldenTest)
	TEST_P (DlGoldenTest, CanDrawPaint)
	TEST_P (DlGoldenTest, CanRenderImage)
	TEST_P (DlGoldenTest, Bug147807)
	TEST_P (DlGoldenTest, GaussianVsRRectBlur)
	TEST_P (DlGoldenTest, GaussianVsRRectBlurScaled)
	TEST_P (DlGoldenTest, GaussianVsRRectBlurScaledRotated)
	TEST_P (DlGoldenTest, FastVsGeneralGaussianMaskBlur)
	TEST_P (DlGoldenTest, DashedLinesTest)
	TEST_P (DlGoldenTest, SaveLayerAtFractionalValue)
	TEST_P (DlGoldenTest, BaselineHE)
	TEST_P (DlGoldenTest, MaintainsSpace)
	TEST_P (DlGoldenTest, Subpixel)
	TEST_P (DlGoldenTest, SubpixelScaled)
	TEST_P (DlGoldenTest, SubpixelScaledTranslated)

Typedef Documentation

DlGoldenTest

using flutter::testing::DlGoldenTest = typedef impeller::DlPlayground

Definition at line 17 of file dl_golden_unittests.h.

Function Documentation

INSTANTIATE_PLAYGROUND_SUITE()

flutter::testing::INSTANTIATE_PLAYGROUND_SUITE

(

DlGoldenTest

)

TEST_P() [1/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		BaselineHE
	)

Definition at line 387 of file dl_golden_unittests.cc.

                                 {
  SetWindowSize(impeller::ISize(1024, 200));
  impeller::Scalar font_size = 300;
  auto callback = [&](const char* text,
                      impeller::Scalar scale) -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0, 0, 0));
    builder.DrawPaint(paint);
    builder.Scale(scale, scale);
    RenderTextInCanvasSkia(&builder, text, "Roboto-Regular.ttf",
                           DlPoint::MakeXY(10, 300),
                           TextRenderOptions{
                               .font_size = font_size,
                           });
    return builder.Build();
  };
 
  std::unique_ptr<impeller::testing::Screenshot> right =
      MakeScreenshot(callback("h", 0.444));
  if (!right) {
    GTEST_SKIP() << "making screenshots not supported.";
  }
  std::unique_ptr<impeller::testing::Screenshot> left =
      MakeScreenshot(callback("e", 0.444));
 
  int32_t left_max_y = CalculateMaxY(left.get());
  int32_t right_max_y = CalculateMaxY(right.get());
  int32_t y_diff = std::abs(left_max_y - right_max_y);
  EXPECT_TRUE(y_diff <= 2) << "y diff: " << y_diff;
}

References font_size, and impeller::testing::RenderTextInCanvasSkia().

TEST_P() [2/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		Bug147807
	)

Definition at line 63 of file dl_golden_unittests.cc.

                                {
  Point content_scale = GetContentScale();
  auto draw = [content_scale](DlCanvas* canvas,
                              const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    DlPaint paint;
    paint.setColor(DlColor(0xfffef7ff));
    canvas->DrawRect(DlRect::MakeLTRB(0, 0, 375, 667), paint);
    paint.setColor(DlColor(0xffff9800));
    canvas->DrawRect(DlRect::MakeLTRB(0, 0, 187.5, 333.5), paint);
    paint.setColor(DlColor(0xff9c27b0));
    canvas->DrawRect(DlRect::MakeLTRB(187.5, 0, 375, 333.5), paint);
    paint.setColor(DlColor(0xff4caf50));
    canvas->DrawRect(DlRect::MakeLTRB(0, 333.5, 187.5, 667), paint);
    paint.setColor(DlColor(0xfff44336));
    canvas->DrawRect(DlRect::MakeLTRB(187.5, 333.5, 375, 667), paint);
 
    canvas->Save();
    {
      canvas->ClipRoundRect(
          DlRoundRect::MakeOval(DlRect::MakeLTRB(201.25, 10, 361.25, 170)),
          DlClipOp::kIntersect, true);
      DlRect save_layer_bounds = DlRect::MakeLTRB(201.25, 10, 361.25, 170);
      auto backdrop =
          DlImageFilter::MakeMatrix(DlMatrix::MakeRow(3, 0, 0.0, -280,  //
                                                      0, 3, 0.0, -920,  //
                                                      0, 0, 1.0, 0.0,   //
                                                      0, 0, 0.0, 1.0),
                                    DlImageSampling::kLinear);
      canvas->SaveLayer(save_layer_bounds, /*paint=*/nullptr, backdrop.get());
      {
        canvas->Translate(201.25, 10);
        auto paint = DlPaint()
                         .setAntiAlias(true)
                         .setColor(DlColor(0xff2196f3))
                         .setStrokeWidth(5)
                         .setDrawStyle(DlDrawStyle::kStroke);
        canvas->DrawCircle(DlPoint(80, 80), 80, paint);
      }
      canvas->Restore();
    }
    canvas->Restore();
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [3/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		CanDrawPaint
	)

Definition at line 29 of file dl_golden_unittests.cc.

                                   {
  auto draw = [](DlCanvas* canvas,
                 const std::vector<std::unique_ptr<DlImage>>& images) {
    canvas->Scale(0.2, 0.2);
    DlPaint paint;
    paint.setColor(DlColor::kCyan());
    canvas->DrawPaint(paint);
  };
 
  DisplayListBuilder builder;
  draw(&builder, /*images=*/{});
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [4/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		CanRenderImage
	)

Definition at line 44 of file dl_golden_unittests.cc.

                                     {
  auto draw = [](DlCanvas* canvas, const std::vector<sk_sp<DlImage>>& images) {
    FML_CHECK(images.size() >= 1);
    DlPaint paint;
    paint.setColor(DlColor::kRed());
    canvas->DrawImage(images[0], DlPoint(100.0, 100.0),
                      DlImageSampling::kLinear, &paint);
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  images.emplace_back(CreateDlImageForFixture("kalimba.jpg"));
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [5/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		DashedLinesTest
	)

Definition at line 270 of file dl_golden_unittests.cc.

                                      {
  Point content_scale = GetContentScale();
  auto draw = [content_scale](DlCanvas* canvas,
                              const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->DrawPaint(DlPaint().setColor(DlColor::kWhite()));
 
    auto draw_one = [canvas](DlStrokeCap cap, Scalar x, Scalar y,
                             Scalar dash_on, Scalar dash_off) {
      Point center = Point(x, y);
      Scalar inner = 20.0f;
      Scalar outer = 100.0f;
      DlPaint thick_paint = DlPaint()
                                .setColor(DlColor::kBlue())
                                .setStrokeCap(cap)
                                .setStrokeWidth(8.0f);
      DlPaint middle_paint = DlPaint()
                                 .setColor(DlColor::kGreen())
                                 .setStrokeCap(cap)
                                 .setStrokeWidth(5.0f);
      DlPaint thin_paint = DlPaint()
                               .setColor(DlColor::kMagenta())
                               .setStrokeCap(cap)
                               .setStrokeWidth(2.0f);
      for (int degrees = 0; degrees < 360; degrees += 30) {
        Point delta = Point(1.0f, 0.0f).Rotate(Degrees(degrees));
        canvas->DrawDashedLine(center + inner * delta, center + outer * delta,
                               dash_on, dash_off, thick_paint);
        canvas->DrawDashedLine(center + inner * delta, center + outer * delta,
                               dash_on, dash_off, middle_paint);
        canvas->DrawDashedLine(center + inner * delta, center + outer * delta,
                               dash_on, dash_off, thin_paint);
      }
    };
 
    draw_one(DlStrokeCap::kButt, 150.0f, 150.0f, 15.0f, 10.0f);
    draw_one(DlStrokeCap::kSquare, 400.0f, 150.0f, 15.0f, 10.0f);
    draw_one(DlStrokeCap::kRound, 150.0f, 400.0f, 15.0f, 10.0f);
    draw_one(DlStrokeCap::kRound, 400.0f, 400.0f, 0.0f, 11.0f);
 
    // Make sure the rendering op responds appropriately to clipping
    canvas->Save();
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(275.0f, 225.0f));
    path_builder.LineTo(DlPoint(325.0f, 275.0f));
    path_builder.LineTo(DlPoint(275.0f, 325.0f));
    path_builder.LineTo(DlPoint(225.0f, 275.0f));
    canvas->ClipPath(path_builder.TakePath());
    canvas->DrawColor(DlColor::kYellow());
    draw_one(DlStrokeCap::kRound, 275.0f, 275.0f, 15.0f, 10.0f);
    canvas->Restore();
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::TPoint< T >::Rotate(), and x.

TEST_P() [6/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		FastVsGeneralGaussianMaskBlur
	)

Definition at line 195 of file dl_golden_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  auto blur_sigmas = std::array{5.0f, 10.0f, 20.0f};
  auto blur_colors = std::array{
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::kMaroon(),
  };
 
  auto make_rrect_path = [](const DlRect& rect, DlScalar rx,
                            DlScalar ry) -> DlPath {
    auto add_corner = [](DlPathBuilder& path_builder, DlPoint corner,
                         DlVector2 relative_from, DlVector2 relative_to,
                         bool first) {
      static const auto magic = DlPathBuilder::kArcApproximationMagic;
 
      if (first) {
        path_builder.MoveTo(corner + relative_from);
      } else {
        path_builder.LineTo(corner + relative_from);
      }
      // These fractions should be (1 - magic) to make a proper rrect
      // path, but historically these equations were as written here.
      // On the plus side, they ensure that we will not optimize this
      // path as "Hey, look, it's an RRect", but the DrawPath gaussians
      // will otherwise not be identical to the versions drawn with
      // DrawRoundRect
      path_builder.CubicCurveTo(corner + relative_from * magic,
                                corner + relative_to * magic,
                                corner + relative_to);
    };
 
    DlPathBuilder path_builder;
    add_corner(path_builder, rect.GetRightTop(),  //
               DlVector2(-rx, 0.0f), DlVector2(0.0f, ry), true);
    add_corner(path_builder, rect.GetRightBottom(),  //
               DlVector2(0.0f, -ry), DlVector2(-rx, 0.0f), false);
    add_corner(path_builder, rect.GetLeftBottom(),  //
               DlVector2(rx, 0.0f), DlVector2(0.0f, -ry), false);
    add_corner(path_builder, rect.GetLeftTop(),  //
               DlVector2(0.0f, ry), DlVector2(rx, 0.0f), false);
    return path_builder.TakePath();
  };
 
  for (size_t i = 0; i < blur_sigmas.size(); i++) {
    auto rect = DlRect::MakeXYWH(i * 320.0f + 50.0f, 50.0f, 100.0f, 100.0f);
    DlPaint paint = DlPaint()  //
                        .setColor(blur_colors[i])
                        .setMaskFilter(DlBlurMaskFilter::Make(
                            DlBlurStyle::kNormal, blur_sigmas[i]));
 
    builder.DrawRoundRect(DlRoundRect::MakeRectXY(rect, 10.0f, 10.0f), paint);
    rect = rect.Shift(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 10.0f, 10.0f), paint);
    rect = rect.Shift(-150.0f, 0.0f);
 
    rect = rect.Shift(0.0f, 200.0f);
    builder.DrawRoundRect(DlRoundRect::MakeRectXY(rect, 10.0f, 30.0f), paint);
    rect = rect.Shift(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 10.0f, 20.0f), paint);
    rect = rect.Shift(-150.0f, 0.0f);
 
    rect = rect.Shift(0.0f, 200.0f);
    builder.DrawRoundRect(DlRoundRect::MakeRectXY(rect, 30.0f, 10.0f), paint);
    rect = rect.Shift(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 20.0f, 10.0f), paint);
    rect = rect.Shift(-150.0f, 0.0f);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References x.

TEST_P() [7/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		GaussianVsRRectBlur
	)

Definition at line 141 of file dl_golden_unittests.cc.

                                          {
  Point content_scale = GetContentScale();
  auto draw = [content_scale](DlCanvas* canvas,
                              const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->DrawPaint(DlPaint().setColor(DlColor(0xff112233)));
    DrawBlurGrid(canvas);
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [8/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		GaussianVsRRectBlurScaled
	)

Definition at line 157 of file dl_golden_unittests.cc.

                                                {
  Point content_scale = GetContentScale();
  auto draw = [content_scale](DlCanvas* canvas,
                              const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->DrawPaint(DlPaint().setColor(DlColor(0xff112233)));
    canvas->Scale(0.33, 0.33);
    DrawBlurGrid(canvas);
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [9/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		GaussianVsRRectBlurScaledRotated
	)

Definition at line 174 of file dl_golden_unittests.cc.

                                                       {
  Point content_scale = GetContentScale();
  auto draw = [content_scale](DlCanvas* canvas,
                              const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->Translate(200, 200);
    canvas->DrawPaint(DlPaint().setColor(DlColor(0xff112233)));
    canvas->Scale(0.33, 0.33);
    canvas->Translate(300, 300);
    canvas->Rotate(45);
    canvas->Translate(-300, -300);
    DrawBlurGrid(canvas);
  };
 
  DisplayListBuilder builder;
  std::vector<sk_sp<DlImage>> images;
  draw(&builder, images);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [10/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		LargeDownscaleRrect
	)

Definition at line 181 of file dl_golden_blur_unittests.cc.

                                          {
  impeller::Point content_scale = GetContentScale();
  auto draw = [&](DlCanvas* canvas, const std::vector<sk_sp<DlImage>>& images) {
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->DrawColor(DlColor(0xff111111));
    {
      canvas->Save();
      canvas->Scale(0.25, 0.25);
      DlPaint paint;
      paint.setColor(DlColor::kYellow());
      paint.setMaskFilter(
          DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/1000));
      canvas->DrawCircle(DlPoint(0, 0), 1200, paint);
      canvas->Restore();
    }
 
    DlPaint paint;
    paint.setColor(DlColor::kYellow());
    paint.setMaskFilter(
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/250));
    canvas->DrawCircle(DlPoint(1024, 768), 300, paint);
  };
 
  DisplayListBuilder builder;
  draw(&builder, /*images=*/{});
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

TEST_P() [11/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		MaintainsSpace
	)

Definition at line 419 of file dl_golden_unittests.cc.

                                     {
  SetWindowSize(impeller::ISize(1024, 200));
  impeller::Scalar font_size = 300;
  auto callback = [&](const char* text,
                      impeller::Scalar scale) -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0, 0, 0));
    builder.DrawPaint(paint);
    builder.Scale(scale, scale);
    RenderTextInCanvasSkia(&builder, text, "Roboto-Regular.ttf",
                           DlPoint::MakeXY(10, 300),
                           TextRenderOptions{
                               .font_size = font_size,
                           });
    return builder.Build();
  };
 
  std::optional<int32_t> last_space;
  for (int i = 0; i <= 100; ++i) {
    Scalar scale = 0.440 + i / 1000.0;
    std::unique_ptr<impeller::testing::Screenshot> right =
        MakeScreenshot(callback("ui", scale));
    if (!right) {
      GTEST_SKIP() << "making screenshots not supported.";
    }
 
    int32_t space = CalculateSpaceBetweenUI(right.get());
    if (last_space.has_value()) {
      int32_t diff = abs(space - *last_space);
      EXPECT_TRUE(diff <= 1)
          << "i:" << i << " space:" << space << " last_space:" << *last_space;
    }
    last_space = space;
  }
}

References font_size, and impeller::testing::RenderTextInCanvasSkia().

TEST_P() [12/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		SaveLayerAtFractionalValue
	)

Definition at line 330 of file dl_golden_unittests.cc.

                                                 {
  // Draws a stroked rounded rect at a fractional pixel value. The coverage must
  // be adjusted so that we still have room to draw it, even though it lies on
  // the fractional bounds of the saveLayer.
  DisplayListBuilder builder;
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  auto save_paint = DlPaint().setAlpha(100);
  builder.SaveLayer(std::nullopt, &save_paint);
 
  builder.DrawRoundRect(DlRoundRect::MakeRectRadius(
                            DlRect::MakeLTRB(10.5, 10.5, 200.5, 200.5), 10),
                        DlPaint()
                            .setDrawStyle(DlDrawStyle::kStroke)
                            .setStrokeWidth(1.5)
                            .setColor(DlColor::kBlack()));
  builder.DrawCircle(DlPoint::MakeXY(100, 100), 50.5,
                     DlPaint().setColor(DlColor::kAqua()));
  builder.DrawCircle(DlPoint::MakeXY(110, 110), 50.5,
                     DlPaint().setColor(DlColor::kCyan()));
 
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

TEST_P() [13/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		ShimmerTest
	)

Definition at line 81 of file dl_golden_blur_unittests.cc.

                                  {
  impeller::Point content_scale = GetContentScale();
  auto draw = [&](DlCanvas* canvas, const std::vector<sk_sp<DlImage>>& images,
                  float sigma) {
    canvas->DrawColor(DlColor(0xff111111));
    canvas->Scale(content_scale.x, content_scale.y);
 
    DlPaint paint;
    canvas->DrawImage(images[0], DlPoint(10.135, 10.36334),
                      DlImageSampling::kLinear, &paint);
 
    DlRect save_layer_bounds = DlRect::MakeLTRB(0, 0, 1024, 768);
    auto blur = DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kDecal);
    canvas->ClipRect(DlRect::MakeLTRB(11.125, 10.3737, 911.25, 755.3333));
    canvas->SaveLayer(save_layer_bounds, /*paint=*/nullptr, blur.get());
    canvas->Restore();
  };
 
  std::vector<sk_sp<DlImage>> images;
  images.emplace_back(CreateDlImageForFixture("boston.jpg"));
 
  auto make_screenshot = [&](float sigma) {
    DisplayListBuilder builder;
    draw(&builder, images, sigma);
 
    std::unique_ptr<impeller::testing::Screenshot> screenshot =
        MakeScreenshot(builder.Build());
    return screenshot;
  };
 
  float start_sigma = 10.0f;
  std::unique_ptr<impeller::testing::Screenshot> left =
      make_screenshot(start_sigma);
  if (!left) {
    GTEST_SKIP() << "making screenshots not supported.";
  }
 
  double average_rmse = 0.0;
  const int32_t sample_count = 200;
  for (int i = 1; i <= sample_count; ++i) {
    float sigma = start_sigma + (i / 2.f);
    std::unique_ptr<impeller::testing::Screenshot> right =
        make_screenshot(sigma);
    double rmse = RMSE(left.get(), right.get());
    average_rmse += rmse;
 
    // To debug this output the frames can be written out to disk then
    // transformed to a video with ffmpeg.
    //
    // ## save images command
    // std::stringstream ss;
    // ss << "_" << std::setw(3) << std::setfill('0') << (i - 1);
    // SaveScreenshot(std::move(left), ss.str());
    //
    // ## ffmpeg command
    // ```
    // ffmpeg -framerate 30 -pattern_type glob -i '*.png' \
    //   -c:v libx264 -pix_fmt yuv420p out.mp4
    // ```
    left = std::move(right);
  }
 
  average_rmse = average_rmse / sample_count;
 
  // This is a somewhat arbitrary threshold. It could be increased if we wanted.
  // In the problematic cases previously we should values like 28. Before
  // increasing this you should manually inspect the behavior in
  // `AiksTest.GaussianBlurAnimatedBackdrop`. Average RMSE is a able to catch
  // shimmer but it isn't perfect.
  EXPECT_TRUE(average_rmse < 1.0) << "average_rmse: " << average_rmse;
  // An average rmse of 0 would mean that the blur isn't blurring.
  EXPECT_TRUE(average_rmse >= 0.0) << "average_rmse: " << average_rmse;
}

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

TEST_P() [14/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		StrokedRRectFastBlur
	)

Definition at line 155 of file dl_golden_blur_unittests.cc.

                                           {
  impeller::Point content_scale = GetContentScale();
  DlRect rect = DlRect::MakeXYWH(50, 50, 100, 100);
  DlRoundRect rrect = DlRoundRect::MakeRectRadius(rect, 10.0f);
  DlPaint fill = DlPaint().setColor(DlColor::kBlue());
  DlPaint stroke =
      DlPaint(fill).setDrawStyle(DlDrawStyle::kStroke).setStrokeWidth(10.0f);
  DlPaint blur = DlPaint(fill).setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 5.0, true));
  DlPaint blur_stroke =
      DlPaint(blur).setDrawStyle(DlDrawStyle::kStroke).setStrokeWidth(10.0f);
 
  DisplayListBuilder builder;
  builder.DrawColor(DlColor(0xff111111), DlBlendMode::kSrc);
  builder.Scale(content_scale.x, content_scale.y);
  builder.DrawRoundRect(rrect, fill);
  builder.DrawRoundRect(rrect.Shift(150, 0), stroke);
  builder.DrawRoundRect(rrect.Shift(0, 150), blur);
  builder.DrawRoundRect(rrect.Shift(150, 150), blur_stroke);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

TEST_P() [15/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		Subpixel
	)

Definition at line 489 of file dl_golden_unittests.cc.

                               {
  SetWindowSize(impeller::ISize(1024, 200));
  impeller::Scalar font_size = 200;
  auto callback = [&](Scalar offset_x) -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0, 0, 0));
    builder.DrawPaint(paint);
    RenderTextInCanvasSkia(&builder, "ui", "Roboto-Regular.ttf",
                           DlPoint::MakeXY(offset_x, 180),
                           TextRenderOptions{
                               .font_size = font_size,
                               .is_subpixel = true,
                           });
    return builder.Build();
  };
 
  LeftmostIntensity intensity[5];
  for (int i = 0; i <= 4; ++i) {
    Scalar offset = 10 + (i / 4.0);
    std::unique_ptr<impeller::testing::Screenshot> right =
        MakeScreenshot(callback(offset));
    if (!right) {
      GTEST_SKIP() << "making screenshots not supported.";
    }
    intensity[i] = CalculateLeftmostIntensity(right.get());
    ASSERT_NE(intensity[i].value, 0);
  }
  for (int i = 1; i < 5; ++i) {
    EXPECT_TRUE(intensity[i].x - intensity[i - 1].x == 1 ||
                intensity[i].value < intensity[i - 1].value)
        << i;
  }
  EXPECT_EQ(intensity[4].x - intensity[0].x, 1);
}

References font_size, impeller::testing::RenderTextInCanvasSkia(), value, and x.

TEST_P() [16/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		SubpixelScaled
	)

Definition at line 527 of file dl_golden_unittests.cc.

                                     {
  SetWindowSize(impeller::ISize(1024, 200));
  impeller::Scalar font_size = 200;
  Scalar scalar = 0.75;
  auto callback = [&](Scalar offset_x) -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    builder.Scale(scalar, scalar);
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0, 0, 0));
    builder.DrawPaint(paint);
    RenderTextInCanvasSkia(&builder, "ui", "Roboto-Regular.ttf",
                           DlPoint::MakeXY(offset_x, 180),
                           TextRenderOptions{
                               .font_size = font_size,
                               .is_subpixel = true,
                           });
    return builder.Build();
  };
 
  LeftmostIntensity intensity[5];
  Scalar offset_fraction = 0.25 / scalar;
  for (int i = 0; i <= 4; ++i) {
    Scalar offset = 10 + (offset_fraction * i);
    std::unique_ptr<impeller::testing::Screenshot> right =
        MakeScreenshot(callback(offset));
    if (!right) {
      GTEST_SKIP() << "making screenshots not supported.";
    }
    intensity[i] = CalculateLeftmostIntensity(right.get());
    ASSERT_NE(intensity[i].value, 0);
  }
  for (int i = 1; i < 5; ++i) {
    EXPECT_TRUE(intensity[i].x - intensity[i - 1].x == 1 ||
                intensity[i].value < intensity[i - 1].value)
        << i;
  }
  EXPECT_EQ(intensity[4].x - intensity[0].x, 1);
}

References font_size, impeller::testing::RenderTextInCanvasSkia(), value, and x.

TEST_P() [17/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		SubpixelScaledTranslated
	)

Definition at line 568 of file dl_golden_unittests.cc.

                                               {
  SetWindowSize(impeller::ISize(1024, 200));
  impeller::Scalar font_size = 200;
  Scalar scalar = 0.75;
  auto callback = [&](Scalar offset_x) -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    builder.Scale(scalar, scalar);
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0, 0, 0));
    builder.DrawPaint(paint);
    builder.Translate(offset_x, 180);
    RenderTextInCanvasSkia(&builder, "ui", "Roboto-Regular.ttf",
                           DlPoint::MakeXY(0, 0),
                           TextRenderOptions{
                               .font_size = font_size,
                               .is_subpixel = true,
                           });
    return builder.Build();
  };
 
  LeftmostIntensity intensity[5];
  Scalar offset_fraction = 0.25 / scalar;
  for (int i = 0; i <= 4; ++i) {
    Scalar offset = 10 + (offset_fraction * i);
    std::unique_ptr<impeller::testing::Screenshot> right =
        MakeScreenshot(callback(offset));
    if (!right) {
      GTEST_SKIP() << "making screenshots not supported.";
    }
    intensity[i] = CalculateLeftmostIntensity(right.get());
    ASSERT_NE(intensity[i].value, 0);
  }
  for (int i = 1; i < 5; ++i) {
    EXPECT_TRUE(intensity[i].x - intensity[i - 1].x == 1 ||
                intensity[i].value < intensity[i - 1].value)
        << i;
  }
  EXPECT_EQ(intensity[4].x - intensity[0].x, 1);
}

References font_size, impeller::testing::RenderTextInCanvasSkia(), value, and x.

TEST_P() [18/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		TextBlurMaskFilterDisrespectCTM
	)

Definition at line 48 of file dl_golden_blur_unittests.cc.

                                                      {
  impeller::Point content_scale = GetContentScale();
  auto draw = [&](DlCanvas* canvas,
                  const std::vector<std::unique_ptr<DlImage>>& images) {
    canvas->DrawColor(DlColor(0xff111111));
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->Scale(2, 2);
    TextRenderOptions options;
    options.mask_filter =
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/10,
                               /*respect_ctm=*/false);
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",  //
                                       DlPoint(101, 101), options));
    options.mask_filter = nullptr;
    options.color = DlColor::kRed();
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",  //
                                       DlPoint(100, 100), options));
  };
 
  DisplayListBuilder builder;
  draw(&builder, /*images=*/{});
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::testing::RenderTextInCanvasSkia(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

TEST_P() [19/19]

flutter::testing::TEST_P	(	DlGoldenTest	,
		TextBlurMaskFilterRespectCTM
	)

Definition at line 21 of file dl_golden_blur_unittests.cc.

                                                   {
  impeller::Point content_scale = GetContentScale();
  auto draw = [&](DlCanvas* canvas,
                  const std::vector<std::unique_ptr<DlImage>>& images) {
    canvas->DrawColor(DlColor(0xff111111));
    canvas->Scale(content_scale.x, content_scale.y);
    canvas->Scale(2, 2);
    TextRenderOptions options;
    options.mask_filter =
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, /*sigma=*/10,
                               /*respect_ctm=*/true);
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",  //
                                       DlPoint(101, 101), options));
    options.mask_filter = nullptr;
    options.color = DlColor::kRed();
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",  //
                                       DlPoint(100, 100), options));
  };
 
  DisplayListBuilder builder;
  draw(&builder, /*images=*/{});
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::testing::RenderTextInCanvasSkia(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.