flutter::testing::DisplayListTestBase< BaseT > Class Template Reference

Inheritance diagram for flutter::testing::DisplayListTestBase< BaseT >:

Public Types
typedef const std::function< void(DlCanvas &)>	DlSetup
typedef const std::function< void(DlCanvas &, DlPaint &, SkRect &rect)>	DlRenderer

Public Member Functions
	DisplayListTestBase ()=default

Static Public Member Functions
static DlOpReceiver &	ToReceiver (DisplayListBuilder &builder)
static sk_sp< DisplayList >	Build (DisplayListInvocation &invocation)
static sk_sp< DisplayList >	Build (size_t g_index, size_t v_index)
static void	check_defaults (DisplayListBuilder &builder, const SkRect &cull_rect=DisplayListBuilder::kMaxCullRect)
static void	verify_inverted_bounds (DlSetup &setup, DlRenderer &renderer, DlPaint paint, SkRect render_rect, SkRect expected_bounds, const std::string &desc)
static void	check_inverted_bounds (DlRenderer &renderer, const std::string &desc)

Detailed Description

template<typename BaseT>
class flutter::testing::DisplayListTestBase< BaseT >

Definition at line 50 of file display_list_unittests.cc.

Member Typedef Documentation

DlRenderer

template<typename BaseT >

typedef const std::function<void(DlCanvas&, DlPaint&, SkRect& rect)> flutter::testing::DisplayListTestBase< BaseT >::DlRenderer

Definition at line 138 of file display_list_unittests.cc.

DlSetup

template<typename BaseT >

typedef const std::function<void(DlCanvas&)> flutter::testing::DisplayListTestBase< BaseT >::DlSetup

Definition at line 136 of file display_list_unittests.cc.

Constructor & Destructor Documentation

DisplayListTestBase()

template<typename BaseT >

flutter::testing::DisplayListTestBase< BaseT >::DisplayListTestBase ( )

default

Member Function Documentation

Build() [1/2]

template<typename BaseT >

static sk_sp< DisplayList > flutter::testing::DisplayListTestBase< BaseT >::Build ( DisplayListInvocation &  invocation )

inlinestatic

Definition at line 58 of file display_list_unittests.cc.

                                                                     {
    DisplayListBuilder builder;
    invocation.Invoke(ToReceiver(builder));
    return builder.Build();
  }

Build() [2/2]

template<typename BaseT >

static sk_sp< DisplayList > flutter::testing::DisplayListTestBase< BaseT >::Build ( size_t  g_index, size_t  v_index  )

inlinestatic

Definition at line 64 of file display_list_unittests.cc.

                                                                  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver =
        DisplayListTestBase<::testing::Test>::ToReceiver(builder);
    uint32_t op_count = 0u;
    size_t byte_count = 0u;
    uint32_t depth = 0u;
    uint32_t render_op_depth_cost = 1u;
    for (size_t i = 0; i < allGroups.size(); i++) {
      DisplayListInvocationGroup& group = allGroups[i];
      size_t j = (i == g_index ? v_index : 0);
      if (j >= group.variants.size()) {
        continue;
      }
      DisplayListInvocation& invocation = group.variants[j];
      op_count += invocation.op_count();
      byte_count += invocation.raw_byte_count();
      depth += invocation.depth_accumulated(render_op_depth_cost);
      invocation.Invoke(receiver);
      render_op_depth_cost =
          invocation.adjust_render_op_depth_cost(render_op_depth_cost);
    }
    sk_sp<DisplayList> dl = builder.Build();
    std::string name;
    if (g_index >= allGroups.size()) {
      name = "Default";
    } else {
      name = allGroups[g_index].op_name;
      if (v_index >= allGroups[g_index].variants.size()) {
        name += " skipped";
      } else {
        name += " variant " + std::to_string(v_index + 1);
      }
    }
    EXPECT_EQ(dl->op_count(false), op_count) << name;
    EXPECT_EQ(dl->bytes(false), byte_count + sizeof(DisplayList)) << name;
    EXPECT_EQ(dl->total_depth(), depth) << name;
    return dl;
  }

check_defaults()

template<typename BaseT >

static void flutter::testing::DisplayListTestBase< BaseT >::check_defaults ( DisplayListBuilder &  builder, const SkRect &  cull_rect = DisplayListBuilder::kMaxCullRect  )

inlinestatic

Definition at line 104 of file display_list_unittests.cc.

                                                                {
    DlPaint builder_paint = DisplayListBuilderTestingAttributes(builder);
    DlPaint defaults;
 
    EXPECT_EQ(builder_paint.isAntiAlias(), defaults.isAntiAlias());
    EXPECT_EQ(builder_paint.isInvertColors(), defaults.isInvertColors());
    EXPECT_EQ(builder_paint.getColor(), defaults.getColor());
    EXPECT_EQ(builder_paint.getBlendMode(), defaults.getBlendMode());
    EXPECT_EQ(builder_paint.getDrawStyle(), defaults.getDrawStyle());
    EXPECT_EQ(builder_paint.getStrokeWidth(), defaults.getStrokeWidth());
    EXPECT_EQ(builder_paint.getStrokeMiter(), defaults.getStrokeMiter());
    EXPECT_EQ(builder_paint.getStrokeCap(), defaults.getStrokeCap());
    EXPECT_EQ(builder_paint.getStrokeJoin(), defaults.getStrokeJoin());
    EXPECT_EQ(builder_paint.getColorSource(), defaults.getColorSource());
    EXPECT_EQ(builder_paint.getColorFilter(), defaults.getColorFilter());
    EXPECT_EQ(builder_paint.getImageFilter(), defaults.getImageFilter());
    EXPECT_EQ(builder_paint.getMaskFilter(), defaults.getMaskFilter());
    EXPECT_EQ(builder_paint.getPathEffect(), defaults.getPathEffect());
    EXPECT_EQ(builder_paint, defaults);
    EXPECT_TRUE(builder_paint.isDefault());
 
    EXPECT_EQ(builder.GetTransform(), SkMatrix());
    EXPECT_EQ(builder.GetTransformFullPerspective(), SkM44());
 
    EXPECT_EQ(builder.GetLocalClipBounds(), cull_rect);
    EXPECT_EQ(builder.GetDestinationClipBounds(), cull_rect);
 
    EXPECT_EQ(builder.GetSaveCount(), 1);
  }

check_inverted_bounds()

template<typename BaseT >

static void flutter::testing::DisplayListTestBase< BaseT >::check_inverted_bounds ( DlRenderer &  renderer, const std::string &  desc  )

inlinestatic

Definition at line 154 of file display_list_unittests.cc.

                                                           {
    SkRect rect = SkRect::MakeLTRB(0.0f, 0.0f, 10.0f, 10.0f);
    SkRect invertedLR = SkRect::MakeLTRB(rect.fRight, rect.fTop,  //
                                         rect.fLeft, rect.fBottom);
    SkRect invertedTB = SkRect::MakeLTRB(rect.fLeft, rect.fBottom,  //
                                         rect.fRight, rect.fTop);
    SkRect invertedLTRB = SkRect::MakeLTRB(rect.fRight, rect.fBottom,  //
                                           rect.fLeft, rect.fTop);
    auto empty_setup = [](DlCanvas&) {};
 
    ASSERT_TRUE(rect.fLeft < rect.fRight);
    ASSERT_TRUE(rect.fTop < rect.fBottom);
    ASSERT_FALSE(rect.isEmpty());
    ASSERT_TRUE(invertedLR.fLeft > invertedLR.fRight);
    ASSERT_TRUE(invertedLR.isEmpty());
    ASSERT_TRUE(invertedTB.fTop > invertedTB.fBottom);
    ASSERT_TRUE(invertedTB.isEmpty());
    ASSERT_TRUE(invertedLTRB.fLeft > invertedLTRB.fRight);
    ASSERT_TRUE(invertedLTRB.fTop > invertedLTRB.fBottom);
    ASSERT_TRUE(invertedLTRB.isEmpty());
 
    DlPaint ref_paint = DlPaint();
    SkRect ref_bounds = rect;
    verify_inverted_bounds(empty_setup, renderer, ref_paint, invertedLR,
                           ref_bounds, desc + " LR swapped");
    verify_inverted_bounds(empty_setup, renderer, ref_paint, invertedTB,
                           ref_bounds, desc + " TB swapped");
    verify_inverted_bounds(empty_setup, renderer, ref_paint, invertedLTRB,
                           ref_bounds, desc + " LR&TB swapped");
 
    // Round joins are used because miter joins greatly pad the bounds,
    // but only on paths. So we use round joins for consistency there.
    // We aren't fully testing all stroke-related bounds computations here,
    // those are more fully tested in the render tests. We are simply
    // checking that they are applied to the ordered bounds.
    DlPaint stroke_paint = DlPaint()                                 //
                               .setDrawStyle(DlDrawStyle::kStroke)   //
                               .setStrokeJoin(DlStrokeJoin::kRound)  //
                               .setStrokeWidth(2.0f);
    SkRect stroke_bounds = rect.makeOutset(1.0f, 1.0f);
    verify_inverted_bounds(empty_setup, renderer, stroke_paint, invertedLR,
                           stroke_bounds, desc + " LR swapped, sw 2");
    verify_inverted_bounds(empty_setup, renderer, stroke_paint, invertedTB,
                           stroke_bounds, desc + " TB swapped, sw 2");
    verify_inverted_bounds(empty_setup, renderer, stroke_paint, invertedLTRB,
                           stroke_bounds, desc + " LR&TB swapped, sw 2");
 
    DlBlurMaskFilter mask_filter(DlBlurStyle::kNormal, 2.0f);
    DlPaint maskblur_paint = DlPaint()  //
                                 .setMaskFilter(&mask_filter);
    SkRect maskblur_bounds = rect.makeOutset(6.0f, 6.0f);
    verify_inverted_bounds(empty_setup, renderer, maskblur_paint, invertedLR,
                           maskblur_bounds, desc + " LR swapped, mask 2");
    verify_inverted_bounds(empty_setup, renderer, maskblur_paint, invertedTB,
                           maskblur_bounds, desc + " TB swapped, mask 2");
    verify_inverted_bounds(empty_setup, renderer, maskblur_paint, invertedLTRB,
                           maskblur_bounds, desc + " LR&TB swapped, mask 2");
 
    DlErodeImageFilter erode_filter(2.0f, 2.0f);
    DlPaint erode_paint = DlPaint()  //
                              .setImageFilter(&erode_filter);
    SkRect erode_bounds = rect.makeInset(2.0f, 2.0f);
    verify_inverted_bounds(empty_setup, renderer, erode_paint, invertedLR,
                           erode_bounds, desc + " LR swapped, erode 2");
    verify_inverted_bounds(empty_setup, renderer, erode_paint, invertedTB,
                           erode_bounds, desc + " TB swapped, erode 2");
    verify_inverted_bounds(empty_setup, renderer, erode_paint, invertedLTRB,
                           erode_bounds, desc + " LR&TB swapped, erode 2");
  }

ToReceiver()

template<typename BaseT >

static DlOpReceiver & flutter::testing::DisplayListTestBase< BaseT >::ToReceiver ( DisplayListBuilder &  builder )

inlinestatic

Definition at line 54 of file display_list_unittests.cc.

                                                               {
    return DisplayListBuilderTestingAccessor(builder);
  }

verify_inverted_bounds()

template<typename BaseT >

static void flutter::testing::DisplayListTestBase< BaseT >::verify_inverted_bounds ( DlSetup &  setup, DlRenderer &  renderer, DlPaint  paint, SkRect  render_rect, SkRect  expected_bounds, const std::string &  desc  )

inlinestatic

Definition at line 140 of file display_list_unittests.cc.

                                                            {
    DisplayListBuilder builder;
    setup(builder);
    renderer(builder, paint, render_rect);
    auto dl = builder.Build();
    EXPECT_EQ(dl->op_count(), 1u) << desc;
    EXPECT_EQ(dl->bounds(), expected_bounds) << desc;
  }

---

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

• display_list/display_list_unittests.cc