Inheritance diagram for flutter::testing::DisplayListNopTest:

Classes
struct	TestData

Protected Member Functions
	DisplayListNopTest ()

const TestData	make_test_data (DlSurfaceProvider *provider)

const TestData	GetTestData (DlSurfaceProvider *provider)

std::shared_ptr< DlSurfaceInstance >	get_output (DlSurfaceProvider provider, int w, int h, bool snapshot, const std::function< void(DlCanvas )> &renderer)

int	check_color_result (DlColor dst_color, DlColor result_color, int x, int y, const sk_sp< DisplayList > &dl, const std::string &desc)

int	check_image_result (const RenderResult &dst_data, const RenderResult &result_data, const sk_sp< DisplayList > &dl, const std::string &desc)

void	report_results (int all_flags, const sk_sp< DisplayList > &dl, const std::string &desc)

void	test_mode_color_via_filter (DlBlendMode mode, DlColor color)

void	test_mode_color_via_rendering (DlBlendMode mode, DlColor color)

void	test_attributes_image (DlBlendMode mode, DlColor color, const DlColorFilter color_filter, DlImageFilter image_filter)

Protected Attributes
std::vector< DlColor >	test_src_colors

std::vector< DlColor >	test_dst_colors

std::shared_ptr< const DlColorFilter >	color_filter_nomtb

std::shared_ptr< const DlColorFilter >	color_filter_mtb

std::map< DlSurfaceProvider::BackendType, TestData >	test_datas

Static Protected Attributes
static constexpr int	kWasNotNop = 0x1

static constexpr int	kWasMTB = 0x2

Static Protected Attributes inherited from flutter::DisplayListOpFlags
static constexpr DisplayListAttributeFlags	kSaveLayerFlags

static constexpr DisplayListAttributeFlags	kSaveLayerWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawColorFlags

static constexpr DisplayListAttributeFlags	kDrawPaintFlags

static constexpr DisplayListAttributeFlags	kDrawHVLineFlags

static constexpr DisplayListAttributeFlags	kDrawLineFlags

static constexpr DisplayListAttributeFlags	kDrawRectFlags

static constexpr DisplayListAttributeFlags	kDrawOvalFlags

static constexpr DisplayListAttributeFlags	kDrawCircleFlags

static constexpr DisplayListAttributeFlags	kDrawRRectFlags

static constexpr DisplayListAttributeFlags	kDrawDRRectFlags

static constexpr DisplayListAttributeFlags	kDrawRSuperellipseFlags

static constexpr DisplayListAttributeFlags	kDrawPathFlags

static constexpr DisplayListAttributeFlags	kDrawArcNoCenterFlags

static constexpr DisplayListAttributeFlags	kDrawArcWithCenterFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsPointsFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsLinesFlags

static constexpr DisplayListAttributeFlags	kDrawPointsAsPolygonFlags

static constexpr DisplayListAttributeFlags	kDrawVerticesFlags

static constexpr DisplayListAttributeFlags	kDrawImageFlags

static constexpr DisplayListAttributeFlags	kDrawImageWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawImageRectFlags

static constexpr DisplayListAttributeFlags	kDrawImageRectWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawImageNineFlags

static constexpr DisplayListAttributeFlags	kDrawImageNineWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawAtlasFlags

static constexpr DisplayListAttributeFlags	kDrawAtlasWithPaintFlags

static constexpr DisplayListAttributeFlags	kDrawDisplayListFlags

static constexpr DisplayListAttributeFlags	kDrawTextFlags

static constexpr DisplayListAttributeFlags	kDrawShadowFlags

static constexpr DisplayListAttributeFlags	kDrawParagraphFlags

Additional Inherited Members
Public Member Functions inherited from flutter::testing::DisplayListRendering
	DisplayListRendering ()=default

Static Public Member Functions inherited from flutter::testing::DisplayListRendering
static void	SetUpTestSuite ()

static void	TearDownTestSuite ()

static const std::vector< BackendType > &	GetTestBackends ()

static std::unique_ptr< DlSurfaceProvider >	GetProvider (BackendType type)

static void	RenderAll (const TestParameters &params, const BoundsTolerance &tolerance=CanvasCompareTester::DefaultTolerance)

Detailed Description

Definition at line 3735 of file dl_rendering_unittests.cc.

Constructor & Destructor Documentation

◆ DisplayListNopTest()

flutter::testing::DisplayListNopTest::DisplayListNopTest ( )

inlineprotected

Definition at line 3739 of file dl_rendering_unittests.cc.

                       : DisplayListRendering() {
    test_src_colors = {
        DlColor::kBlack().withAlpha(0),     // transparent black
        DlColor::kBlack().withAlpha(0x7f),  // half transparent black
        DlColor::kWhite().withAlpha(0x7f),  // half transparent white
        DlColor::kBlack(),                  // opaque black
        DlColor::kWhite(),                  // opaque white
        DlColor::kRed(),                    // opaque red
        DlColor::kGreen(),                  // opaque green
        DlColor::kBlue(),                   // opaque blue
        DlColor::kDarkGrey(),               // dark grey
        DlColor::kLightGrey(),              // light grey
    };
 
    // We test against a color cube of 3x3x3x3 colors [55,aa,ff]
    // plus transparency as the first color/pixel
    test_dst_colors.push_back(DlColor::kTransparent());
    const int step = 0x55;
    static_assert(step * 3 == 255);
    for (int a = step; a < 256; a += step) {
      for (int r = step; r < 256; r += step) {
        for (int g = step; g < 256; g += step) {
          for (int b = step; b < 256; b += step) {
            test_dst_colors.push_back(DlColor(a << 24 | r << 16 | g << 8 | b));
          }
        }
      }
    }
 
    static constexpr float color_filter_matrix_nomtb[] = {
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
    };
    static constexpr float color_filter_matrix_mtb[] = {
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.0,  //
        0.0001, 0.0001, 0.0001, 0.9997, 0.1,  //
    };
    color_filter_nomtb = DlColorFilter::MakeMatrix(color_filter_matrix_nomtb);
    color_filter_mtb = DlColorFilter::MakeMatrix(color_filter_matrix_mtb);
    EXPECT_FALSE(color_filter_nomtb->modifies_transparent_black());
    EXPECT_TRUE(color_filter_mtb->modifies_transparent_black());
  }

References color_filter_mtb, color_filter_nomtb, flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kDarkGrey(), flutter::DlColor::kGreen(), flutter::DlColor::kLightGrey(), flutter::DlColor::kRed(), flutter::DlColor::kTransparent(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeMatrix(), test_dst_colors, test_src_colors, and flutter::DlColor::withAlpha().

Member Function Documentation

◆ check_color_result()

int flutter::testing::DisplayListNopTest::check_color_result	(	DlColor	dst_color,
		DlColor	result_color,
		int	x,
		int	y,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 3910 of file dl_rendering_unittests.cc.

                                                {
    int ret = 0;
    bool is_error = false;
    if (dst_color.isTransparent() && !result_color.isTransparent()) {
      ret |= kWasMTB;
      is_error = !dl->modifies_transparent_black();
    }
    if (result_color != dst_color) {
      ret |= kWasNotNop;
      is_error = (dl->op_count() == 0u);
    }
    if (is_error) {
      FML_LOG(ERROR) << std::hex << dst_color                       //
                     << std::dec << " at " << x << ", " << y        //
                     << " filters to " << std::hex << result_color  //
                     << desc;
    }
    return ret;
  }

References FML_LOG, flutter::DlColor::isTransparent(), x, and y.

◆ check_image_result()

int flutter::testing::DisplayListNopTest::check_image_result	(	const RenderResult &	dst_data,
		const RenderResult &	result_data,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 3935 of file dl_rendering_unittests.cc.

                                                {
    EXPECT_EQ(dst_data.pixel_data->width(), result_data.pixel_data->width());
    EXPECT_EQ(dst_data.pixel_data->height(), result_data.pixel_data->height());
    int all_flags = 0;
    for (uint32_t y = 0; y < dst_data.pixel_data->height(); y++) {
      const uint32_t* dst_pixels = dst_data.pixel_data->addr32(0, y);
      const uint32_t* result_pixels = result_data.pixel_data->addr32(0, y);
      for (uint32_t x = 0; x < dst_data.pixel_data->width(); x++) {
        all_flags |= check_color_result(
            DlColor(dst_pixels[x]), DlColor(result_pixels[x]), x, y, dl, desc);
      }
    }
    return all_flags;
  }

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

◆ get_output()

std::shared_ptr< DlSurfaceInstance > flutter::testing::DisplayListNopTest::get_output	(	DlSurfaceProvider *	provider,
		int	w,
		int	h,
		bool	snapshot,
		const std::function< void(DlCanvas *)> &	renderer
	)

inlineprotected

Definition at line 3895 of file dl_rendering_unittests.cc.

                                                    {
    std::shared_ptr<DlSurfaceInstance> surface =
        provider->MakeOffscreenSurface(w, h, DlSurfaceProvider::kN32Premul);
    DisplayListBuilder builder;
    renderer(&builder);
    surface->RenderDisplayList(builder.Build());
    surface->FlushSubmitCpuSync();
    return surface;
  }

References flutter::DisplayListBuilder::Build(), flutter::h, flutter::testing::DlSurfaceProvider::kN32Premul, flutter::testing::DlSurfaceProvider::MakeOffscreenSurface(), and surface.

Referenced by make_test_data().

◆ GetTestData()

const TestData flutter::testing::DisplayListNopTest::GetTestData ( DlSurfaceProvider * provider )

inlineprotected

Definition at line 3885 of file dl_rendering_unittests.cc.

                                                          {
    auto entry = test_datas.find(provider->GetBackendType());
    if (entry == test_datas.end()) {
      TestData test_data = make_test_data(provider);
      test_datas[provider->GetBackendType()] = test_data;
      return test_data;
    }
    return entry->second;
  }

References flutter::testing::DlSurfaceProvider::GetBackendType().

◆ make_test_data()

const TestData flutter::testing::DisplayListNopTest::make_test_data ( DlSurfaceProvider * provider )

inlineprotected

Definition at line 3803 of file dl_rendering_unittests.cc.

                                                             {
    std::shared_ptr<DlSurfaceInstance> test_surface = get_output(
        provider, test_dst_colors.size(), 1, true, [this](DlCanvas* canvas) {
          int x = 0;
          DlPaint paint;
          paint.setBlendMode(DlBlendMode::kSrc);
          for (DlColor color : test_dst_colors) {
            paint.setColor(color);
            canvas->DrawRect(DlRect::MakeXYWH(x, 0, 1, 1), paint);
            x++;
          }
        });
    sk_sp<DlImage> test_image = test_surface->SnapshotToImage();
    std::shared_ptr<DlPixelData> test_pixels =
        test_surface->SnapshotToPixelData();
 
    // For image-on-image tests, the src and dest images will have repeated
    // rows/columns that have every color, but laid out at right angles to
    // each other so we see an interaction with every test color against
    // every other test color.
    int data_count = test_image->width();
    std::shared_ptr<DlSurfaceInstance> dst_surface =
        get_output(provider, data_count, data_count, true,
                   [&test_image, data_count](DlCanvas* canvas) {
                     ASSERT_EQ(test_image->width(), data_count);
                     ASSERT_EQ(test_image->height(), 1);
                     for (int y = 0; y < data_count; y++) {
                       canvas->DrawImage(test_image, DlPoint(0, y),
                                         DlImageSampling::kNearestNeighbor);
                     }
                   });
    std::shared_ptr<DlPixelData> dst_pixels =
        dst_surface->SnapshotToPixelData();
 
    std::shared_ptr<DlSurfaceInstance> src_surface =
        get_output(provider, data_count, data_count, true,
                   [&test_image, data_count](DlCanvas* canvas) {
                     ASSERT_EQ(test_image->width(), data_count);
                     ASSERT_EQ(test_image->height(), 1);
                     canvas->Translate(data_count, 0);
                     canvas->Rotate(90);
                     for (int y = 0; y < data_count; y++) {
                       canvas->DrawImage(test_image, DlPoint(0, y),
                                         DlImageSampling::kNearestNeighbor);
                     }
                   });
    std::shared_ptr<DlPixelData> src_pixels =
        src_surface->SnapshotToPixelData();
 
    // Double check that the pixel data is laid out in orthogonal stripes
    for (int y = 0; y < data_count; y++) {
      for (int x = 0; x < data_count; x++) {
        EXPECT_EQ(*dst_pixels->addr32(x, y), *test_pixels->addr32(x, 0));
        EXPECT_EQ(*src_pixels->addr32(x, y), *test_pixels->addr32(y, 0));
      }
    }
 
    return {
        .test_image_1d = test_surface->SnapshotToImage(),
        .test_pixels = RenderResult::Make(test_pixels),
 
        .dst_image_2d = dst_surface->SnapshotToImage(),
        .dst_pixels = RenderResult::Make(dst_pixels),
 
        .src_image_2d = src_surface->SnapshotToImage(),
        .src_pixels = RenderResult::Make(src_pixels),
    };
  }

References get_output(), and test_dst_colors.

◆ report_results()

void flutter::testing::DisplayListNopTest::report_results	(	int	all_flags,
		const sk_sp< DisplayList > &	dl,
		const std::string &	desc
	)

inlineprotected

Definition at line 3953 of file dl_rendering_unittests.cc.

                                             {
    if (!dl->modifies_transparent_black()) {
      EXPECT_TRUE((all_flags & kWasMTB) == 0);
    } else if ((all_flags & kWasMTB) == 0) {
      FML_LOG(INFO) << "combination does not affect transparency: " << desc;
    }
    if (dl->op_count() == 0u) {
      EXPECT_TRUE((all_flags & kWasNotNop) == 0);
    } else if ((all_flags & kWasNotNop) == 0) {
      FML_LOG(INFO) << "combination could be classified as a nop: " << desc;
    }
  };

References FML_LOG.

◆ test_attributes_image()

void flutter::testing::DisplayListNopTest::test_attributes_image	(	DlBlendMode	mode,
		DlColor	color,
		const DlColorFilter *	color_filter,
		DlImageFilter *	image_filter
	)

inlineprotected

Definition at line 4049 of file dl_rendering_unittests.cc.

                                                          {
    // if (true) { return; }
    std::stringstream desc_stream;
    desc_stream << " rendering with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string cf_mtb = color_filter
                             ? color_filter->modifies_transparent_black()
                                   ? "modifies transparency"
                                   : "preserves transparency"
                             : "no filter";
    desc_stream << ", CF: " << cf_mtb;
    std::string if_mtb = image_filter
                             ? image_filter->modifies_transparent_black()
                                   ? "modifies transparency"
                                   : "preserves transparency"
                             : "no filter";
    desc_stream << ", IF: " << if_mtb;
    std::string desc = desc_stream.str();
 
    for (BackendType back_end : GetTestBackends()) {
      std::unique_ptr<DlSurfaceProvider> provider = GetProvider(back_end);
      const TestData test_data = GetTestData(provider.get());
      std::string provider_desc = " " + provider->GetBackendName() + desc;
 
      DisplayListBuilder builder_for_properties(DlRect::MakeWH(100.0f, 100.0f));
      DlPaint paint = DlPaint(color)                     //
                          .setBlendMode(mode)            //
                          .setColorFilter(color_filter)  //
                          .setImageFilter(image_filter);
      builder_for_properties.DrawImage(test_data.src_image_2d, DlPoint(0, 0),
                                       DlImageSampling::kNearestNeighbor,
                                       &paint);
      sk_sp<DisplayList> properties_display_list =
          builder_for_properties.Build();
 
      int w = test_data.src_image_2d->width();
      int h = test_data.src_image_2d->height();
      std::shared_ptr<DlSurfaceInstance> result_surface =
          provider->MakeOffscreenSurface(w, h, DlSurfaceProvider::kN32Premul);
      DisplayListBuilder builder_for_rendering;
      builder_for_rendering.Clear(DlColor::kTransparent());
      builder_for_rendering.DrawImage(test_data.dst_image_2d, DlPoint(0, 0),
                                      DlImageSampling::kNearestNeighbor);
      builder_for_rendering.DrawImage(test_data.src_image_2d, DlPoint(0, 0),
                                      DlImageSampling::kNearestNeighbor,
                                      &paint);
      result_surface->RenderDisplayList(builder_for_rendering.Build());
      result_surface->FlushSubmitCpuSync();
      RenderResult result_pixels = RenderResult::Make(result_surface);
 
      int all_flags =
          check_image_result(test_data.dst_pixels, result_pixels,
                             properties_display_list, provider_desc);
      report_results(all_flags, properties_display_list, provider_desc);
    }
  };

References impeller::BlendModeToString(), flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DisplayListBuilder::DrawImage(), flutter::testing::DisplayListNopTest::TestData::dst_image_2d, flutter::testing::DisplayListNopTest::TestData::dst_pixels, flutter::h, flutter::testing::DlSurfaceProvider::kN32Premul, flutter::kNearestNeighbor, flutter::DlColor::kTransparent(), flutter::testing::RenderResult::Make(), impeller::TRect< Scalar >::MakeWH(), flutter::mode, flutter::DlColorFilter::modifies_transparent_black(), flutter::DlImageFilter::modifies_transparent_black(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setImageFilter(), and flutter::testing::DisplayListNopTest::TestData::src_image_2d.

◆ test_mode_color_via_filter()

void flutter::testing::DisplayListNopTest::test_mode_color_via_filter	(	DlBlendMode	mode,
		DlColor	color
	)

inlineprotected

Definition at line 3968 of file dl_rendering_unittests.cc.

                                                                   {
    std::stringstream desc_stream;
    desc_stream << " using SkColorFilter::filterColor() with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string desc = desc_stream.str();
    DisplayListBuilder builder(DlRect::MakeWH(100.0f, 100.0f));
    DlPaint paint = DlPaint(color).setBlendMode(mode);
    builder.DrawRect(DlRect::MakeLTRB(0.0f, 0.0f, 10.0f, 10.0f), paint);
    sk_sp<DisplayList> dl = builder.Build();
    if (dl->modifies_transparent_black()) {
      ASSERT_TRUE(dl->op_count() != 0u);
    }
 
    SkBlendMode sk_mode = static_cast<SkBlendMode>(mode);
    sk_sp<SkColorFilter> sk_color_filter =
        SkColorFilters::Blend(ToSkColor4f(color), nullptr, sk_mode);
    sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
    int all_flags = 0;
    if (sk_color_filter) {
      for (DlColor dst_color : test_dst_colors) {
        SkColor4f dst_color_f = ToSkColor4f(dst_color);
        DlColor result = DlColor(
            sk_color_filter->filterColor4f(dst_color_f, srgb.get(), srgb.get())
                .toSkColor());
        all_flags |=
            check_color_result(dst_color, result, /*x=*/0, /*y=*/0, dl, desc);
      }
      if ((all_flags & kWasMTB) != 0) {
        EXPECT_FALSE(sk_color_filter->isAlphaUnchanged());
      }
    }
    report_results(all_flags, dl, desc);
  };

References impeller::BlendModeToString(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeWH(), flutter::mode, flutter::DlPaint::setBlendMode(), and flutter::ToSkColor4f().

◆ test_mode_color_via_rendering()

void flutter::testing::DisplayListNopTest::test_mode_color_via_rendering	(	DlBlendMode	mode,
		DlColor	color
	)

inlineprotected

Definition at line 4003 of file dl_rendering_unittests.cc.

                                                                      {
    std::stringstream desc_stream;
    desc_stream << " rendering with: ";
    desc_stream << BlendModeToString(mode);
    desc_stream << "/" << color;
    std::string desc = desc_stream.str();
    DisplayListBuilder builder_for_properties;
    DlPaint dl_paint = DlPaint(color).setBlendMode(mode);
    builder_for_properties.DrawRect(DlRect::MakeWH(100, 100), dl_paint);
    sk_sp<DisplayList> properties_display_list = builder_for_properties.Build();
    bool dl_is_elided = properties_display_list->op_count() == 0u;
    bool dl_affects_transparent_pixels =
        properties_display_list->modifies_transparent_black();
    ASSERT_TRUE(!dl_is_elided || !dl_affects_transparent_pixels);
 
    DlPaint paint;
    paint.setBlendMode(mode);
    paint.setColor(color);
    for (BackendType back_end : GetTestBackends()) {
      std::unique_ptr<DlSurfaceProvider> provider = GetProvider(back_end);
      const TestData test_data = GetTestData(provider.get());
      std::string provider_desc = " " + provider->GetBackendName() + desc;
 
      sk_sp<DlImage> test_image = test_data.test_image_1d;
      DlRect test_bounds =
          DlRect::MakeWH(test_image->width(), test_image->height());
      std::shared_ptr<DlSurfaceInstance> result_surface =
          provider->MakeOffscreenSurface(test_image->width(),
                                         test_image->height(),
                                         DlSurfaceProvider::kN32Premul);
      DisplayListBuilder builder_for_rendering;
      builder_for_rendering.Clear(DlColor::kTransparent());
      builder_for_rendering.DrawImage(test_image, DlPoint(0, 0),
                                      DlImageSampling::kNearestNeighbor);
      builder_for_rendering.DrawRect(test_bounds, paint);
      result_surface->RenderDisplayList(builder_for_rendering.Build());
      result_surface->FlushSubmitCpuSync();
      RenderResult result_pixels = RenderResult::Make(result_surface);
 
      int all_flags =
          check_image_result(test_data.test_pixels, result_pixels,
                             properties_display_list, provider_desc);
      report_results(all_flags, properties_display_list, provider_desc);
    }
  };