flutter::testing Namespace Reference

Typedefs
using	DlGoldenTest = impeller::DlPlayground

Functions
	TEST_P (DlGoldenTest, TextBlurMaskFilterRespectCTM)
	TEST_P (DlGoldenTest, TextBlurMaskFilterDisrespectCTM)
	TEST_P (DlGoldenTest, ShimmerTest)
	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)

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/11]

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

Definition at line 58 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(SkRect::MakeLTRB(0, 0, 375, 667), paint);
    paint.setColor(DlColor(0xffff9800));
    canvas->DrawRect(SkRect::MakeLTRB(0, 0, 187.5, 333.5), paint);
    paint.setColor(DlColor(0xff9c27b0));
    canvas->DrawRect(SkRect::MakeLTRB(187.5, 0, 375, 333.5), paint);
    paint.setColor(DlColor(0xff4caf50));
    canvas->DrawRect(SkRect::MakeLTRB(0, 333.5, 187.5, 667), paint);
    paint.setColor(DlColor(0xfff44336));
    canvas->DrawRect(SkRect::MakeLTRB(187.5, 333.5, 375, 667), paint);
 
    canvas->Save();
    {
      canvas->ClipRRect(
          SkRRect::MakeOval(SkRect::MakeLTRB(201.25, 10, 361.25, 170)),
          DlCanvas::ClipOp::kIntersect, true);
      SkRect save_layer_bounds = SkRect::MakeLTRB(201.25, 10, 361.25, 170);
      DlMatrixImageFilter backdrop(SkMatrix::MakeAll(3, 0, -280,  //
                                                     0, 3, -920,  //
                                                     0, 0, 1),
                                   DlImageSampling::kLinear);
      canvas->SaveLayer(&save_layer_bounds, /*paint=*/nullptr, &backdrop);
      {
        canvas->Translate(201.25, 10);
        auto paint = DlPaint()
                         .setAntiAlias(true)
                         .setColor(DlColor(0xff2196f3))
                         .setStrokeWidth(5)
                         .setDrawStyle(DlDrawStyle::kStroke);
        canvas->DrawCircle(SkPoint::Make(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() [2/11]

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

Definition at line 24 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() [3/11]

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

Definition at line 39 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], SkPoint::Make(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() [4/11]

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

Definition at line 248 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();
    SkPath clip_path = SkPath();
    clip_path.moveTo(275.0f, 225.0f);
    clip_path.lineTo(325.0f, 275.0f);
    clip_path.lineTo(275.0f, 325.0f);
    clip_path.lineTo(225.0f, 275.0f);
    canvas->ClipPath(clip_path);
    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().

TEST_P() [5/11]

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

Definition at line 186 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 SkRect& rect, DlScalar rx,
                            DlScalar ry) -> SkPath {
    auto add_corner = [](SkPath& path, SkPoint rCorner, SkPoint rEnd) {
      static const auto magic = impeller::PathBuilder::kArcApproximationMagic;
      path.rCubicTo(rCorner.fX * (1.0f - magic), rCorner.fY * (1.0f - magic),
                    rCorner.fX + rEnd.fX * magic, rCorner.fY + rEnd.fY * magic,
                    rCorner.fX + rEnd.fX, rCorner.fY + rEnd.fY);
    };
 
    SkPath path;
    path.moveTo(rect.fRight - rx, rect.fTop);
    add_corner(path, {rx, 0.0f}, {0.0f, ry});
    path.lineTo(rect.fRight, rect.fBottom - ry);
    add_corner(path, {0.0f, ry}, {-rx, 0.0f});
    path.lineTo(rect.fLeft + rx, rect.fBottom);
    add_corner(path, {-rx, 0.0f}, {0.0f, -ry});
    path.lineTo(rect.fLeft, rect.fTop + ry);
    add_corner(path, {0.0f, -ry}, {rx, 0.0f});
    path.close();
    return path;
  };
 
  for (size_t i = 0; i < blur_sigmas.size(); i++) {
    auto rect = SkRect::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.DrawRRect(SkRRect::MakeRectXY(rect, 10.0f, 10.0f), paint);
    rect = rect.makeOffset(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 10.0f, 10.0f), paint);
    rect = rect.makeOffset(-150.0f, 0.0f);
 
    rect = rect.makeOffset(0.0f, 200.0f);
    builder.DrawRRect(SkRRect::MakeRectXY(rect, 10.0f, 30.0f), paint);
    rect = rect.makeOffset(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 10.0f, 20.0f), paint);
    rect = rect.makeOffset(-150.0f, 0.0f);
 
    rect = rect.makeOffset(0.0f, 200.0f);
    builder.DrawRRect(SkRRect::MakeRectXY(rect, 30.0f, 10.0f), paint);
    rect = rect.makeOffset(150.0f, 0.0f);
    builder.DrawPath(make_rrect_path(rect, 20.0f, 10.0f), paint);
    rect = rect.makeOffset(-150.0f, 0.0f);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::PathBuilder::kArcApproximationMagic.

TEST_P() [6/11]

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

Definition at line 132 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() [7/11]

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

Definition at line 148 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() [8/11]

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

Definition at line 165 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() [9/11]

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

Definition at line 155 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], SkPoint::Make(10.135, 10.36334),
                      DlImageSampling::kLinear, &paint);
 
    SkRect save_layer_bounds = SkRect::MakeLTRB(0, 0, 1024, 768);
    DlBlurImageFilter blur(sigma, sigma, DlTileMode::kDecal);
    canvas->ClipRect(SkRect::MakeLTRB(11.125, 10.3737, 911.25, 755.3333));
    canvas->SaveLayer(&save_layer_bounds, /*paint=*/nullptr, &blur);
    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() [10/11]

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

Definition at line 87 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",
                                       SkPoint::Make(101, 101), options));
    options.mask_filter = nullptr;
    options.color = DlColor::kRed();
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",
                                       SkPoint::Make(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() [11/11]

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

Definition at line 60 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",
                                       SkPoint::Make(101, 101), options));
    options.mask_filter = nullptr;
    options.color = DlColor::kRed();
    ASSERT_TRUE(RenderTextInCanvasSkia(canvas, "hello world",
                                       "Roboto-Regular.ttf",
                                       SkPoint::Make(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.