Namespaces
namespace	android

namespace	egl

namespace	keycodes

Classes
struct	AOTDataDeleter

class	AutoIsolateShutdown

class	AutoreleasePoolTest

class	AutoreleasePoolTestMixin

class	BoundsTolerance

class	CanvasCompareTester

class	CanvasTestBase

class	CaseParameters

class	ClipExpector

class	ConstantFiringVsyncWaiter

class	CursorHandlerTest

class	DartFixture

class	DartIsolateTest

class	DartNativeBenchmarks

class	DartPersistentHandleTest

class	DartSecondaryIsolateTest

class	DartWeakPersistentHandle

class	DarwinContextMetal

class	DepthExpector

class	DiffContextTest

struct	DisplayListInvocation

struct	DisplayListInvocationGroup

struct	DisplayListJobRenderer

class	DisplayListNopTest

class	DisplayListRenderingTestBase

class	DisplayListStreamDispatcher

class	DisplayListTestBase

struct	DlJobRenderer

class	DlMetalPixelData

class	DlMetalSurfaceInstance

class	DlMetalSurfaceProvider

class	DlOpenGLSurfaceProvider

class	DlOpRecorder
	A custom \|DlOpReceiver\| that records some \|DlOps\| it receives. More...

class	DlPixelData

class	DlSoftwareSurfaceProvider

class	DlSurfaceInstance

class	DlSurfaceInstanceBase

class	DlSurfaceProvider

struct	ELFAOTSymbols

class	EmbedderConfigBuilder

class	EmbedderTest

class	EmbedderTestBackingStoreProducer

class	EmbedderTestCompositor

class	EmbedderTestCompositorGL

class	EmbedderTestCompositorMetal

class	EmbedderTestCompositorSoftware

class	EmbedderTestCompositorVulkan

class	EmbedderTestContext

class	EmbedderTestContextGL

class	EmbedderTestContextMetal

class	EmbedderTestContextSoftware

class	EmbedderTestContextVulkan

class	EmbedderTestMultiBackend

class	EmbedderTestTaskRunner
	A task runner that we expect the embedder to provide but whose implementation is a real FML task runner. More...

struct	EngineDeleter

class	FakeAnimatorDelegate

class	FakeImageGenerator

class	FakePlatformConfigurationClient

class	FakeRefreshRateUpdater

class	FfiNativeTest

class	FixtureTest

class	FlutterEngineTest

class	FlutterMenuPluginTest

class	FlutterWindowsEngineBuilder

class	FlutterWindowsEngineTest

struct	FrozenFlutterDamage

struct	FrozenFlutterPoint

struct	FrozenFlutterRect

struct	FrozenFlutterSemanticsCustomAction

struct	FrozenFlutterSemanticsNode

struct	FrozenFlutterTransformation

class	FuchsiaShellTest

class	ImageDecoderFixtureTest

class	ImageDisposeTest

class	ImpellerRenderResult

struct	IsolateData

class	IsolateStartupFailureTest
	Tests error handling path of `Isolate.spawn()` in the engine. More...

struct	JobRenderer

struct	KeyEventUserData

class	LayerTestBase

class	LayerTreeTest

struct	LoadedELFDeleter

class	LoggerListener

struct	MatrixClipJobRenderer

class	MockAccessibilityBridge

class	MockAccessibilityBridgeNoWindow

class	MockAPKAssetProviderImpl

class	MockBinaryMessenger

class	MockCacheableContainerLayer

class	MockCacheableLayer

class	MockCanvas

class	MockDirectManipulationOwner
	Mock for the \|DirectManipulationOwner\| base class. More...

class	MockDispatchHelper

class	MockFlutterEngineTest

class	MockFlutterWindowsView

class	MockIDirectManipulationContent

class	MockIDirectManipulationViewport

class	MockIMContext

class	MockKeyResponseController

class	MockLayer

class	MockLayerCacheableItem

class	MockLayerTree

class	MockMessageQueue

class	MockRasterCache
	A RasterCache implementation that simulates the act of rendering a Layer or DisplayList without the overhead of rasterization or pixel storage. This implementation is used only for testing proper usage of the RasterCache in layer unit tests. More...

class	MockRasterCacheResult
	A RasterCacheResult implementation that represents a cached Layer or DisplayList without the overhead of storage. More...

class	MockSettings

class	MockSignalHandler

class	MockSignalHandler1

class	MockSignalHandler2

class	MockSyncSwitch

class	MockTextInputManager
	Mock for the \|Window\| base class. More...

class	MockTextInputViewDelegate

class	MockTexture

class	MockViewEmbedder

class	MockWindow
	Mock for the \|FlutterWindow\| base class. More...

class	MockWindowBindingHandler
	Mock for the \|Window\| base class. More...

class	MockWindowBindingHandlerDelegate

class	MockWindowsLifecycleManager

class	MockWindowsProcTable
	Mock for the \|WindowsProcTable\| base class. More...

class	MyNativeClass

class	OncePerBackendWarning

struct	PaintContextHolder

class	PainterTestBase

class	PendingTests

class	PlatformConfigurationTest

class	PlatformHandlerTest

class	PlatformIsolateManagerTest

struct	PrerollContextHolder

struct	RenderContext

class	RenderEnvironment

struct	RenderJobInfo

class	RenderResult

class	SaveLayerBoundsExpector

class	SaveLayerExpector

class	ScopedStubFlutterApi

class	ScopedStubFlutterGlfwApi

class	ScopedStubFlutterWindowsApi

class	SemanticsActionObservation

class	ShellIOManagerTest

class	ShellTest

class	ShellTestPlatformView

class	ShellTestPlatformViewBuilder

class	ShellTestPlatformViewGL

class	ShellTestPlatformViewMetal

class	ShellTestPlatformViewVulkan

class	ShellTestVsyncClock

class	ShellTestVsyncWaiter

class	SignalHandler

class	SinglePixelImageGenerator
	An image generator that always creates a 1x1 single-frame green image. More...

class	SkiaGpuObjectTest

class	SkImageSampling

struct	SkJobRenderer

struct	SkPictureJobRenderer

class	SkRenderResult

class	StreamCapture

class	StubFlutterApi

class	StubFlutterGlfwApi

class	StubFlutterWindowsApi

class	SurfaceMock

class	TestAndroidSurfaceFactory

class	TestAssetResolver

class	TestDartNativeResolver

class	TestDelegate

class	TestFlutterWindowsEngine

class	TestGLSurface

class	TestGPUSurfaceMetalDelegate

class	TestIOManager

class	TestParameters

class	TestRefreshRateReporter

class	TestResourceCacheLimitItem

class	TestResourceContext

class	TestSkObject

class	TestSwitchableGLContext
	The renderer context used for testing. More...

class	TestTimeoutListener

class	TestVsyncWaiter

class	TestVulkanContext

class	TestVulkanImage
	Captures the lifetime of a test VkImage along with its bound memory. More...

class	TestVulkanSurface

class	TextInputPluginTest

class	ThreadCheckingAssetResolver

class	ThreadTest
	A fixture that creates threads with running message loops that are terminated when the test is done (the threads are joined then as well). While this fixture may be used on it's own, it is often sub-classed by other fixtures whose functioning requires threads to be created as necessary. More...

class	TypeConversionsTest

struct	UniqueEngineTraits

class	UnknownImageGenerator
	An Image generator that pretends it can't recognize the data it was given. More...

struct	ViewContent

struct	ViewControllerDeleter

struct	Win32Message

class	WindowsConfigBuilder

class	WindowsLifecycleManagerTest

class	WindowsTest

class	WindowsTestContext

struct	WmCharInfo

struct	WmDeadCharInfo

struct	WmKeyDownInfo

struct	WmKeyUpInfo

struct	WmSysKeyDownInfo

struct	WmSysKeyUpInfo

Typedefs
using	BackendType = DlSurfaceProvider::BackendType

using	ClipOp = DlCanvas::ClipOp

using	PointMode = DlCanvas::PointMode

using	DisplayListTest = DisplayListTestBase<::testing::Test >

using	Builder = DlVertices::Builder

using	SkSetupContext = RenderContext< SkCanvas *, SkPaint &, sk_sp< SkImage > >

using	DlSetupContext = RenderContext< DlCanvas *, DlPaint &, sk_sp< DlImage > >

using	SkRenderContext = RenderContext< SkCanvas *, const SkPaint &, sk_sp< SkImage > >

using	DlRenderContext = RenderContext< DlCanvas *, const DlPaint &, sk_sp< DlImage > >

using	SkSetup = const std::function< void(const SkSetupContext &)>

using	SkRenderer = const std::function< void(const SkRenderContext &)>

using	DlSetup = const std::function< void(const DlSetupContext &)>

using	DlRenderer = const std::function< void(const DlRenderContext &)>

using	PixelFormat = DlSurfaceProvider::PixelFormat

using	DisplayListRendering = DisplayListRenderingTestBase<::testing::Test >

typedef const std::function< void(DlOpReceiver &)>	DlInvoker

using	MetalScreenshotter = impeller::testing::MetalScreenshotter

using	BackdropFilterLayerTest = LayerTest

using	BackdropLayerDiffTest = DiffContextTest

using	ClipPathLayerTest = LayerTest

using	ClipRectLayerTest = LayerTest

using	ClipRRectLayerTest = LayerTest

using	ColorFilterLayerTest = LayerTest

using	ContainerLayerTest = LayerTest

using	ContainerLayerDiffTest = DiffContextTest

using	DisplayListLayerTest = LayerTest

using	DisplayListLayerDiffTest = DiffContextTest

using	ImageFilterLayerTest = LayerTest

using	ImageFilterLayerDiffTest = DiffContextTest

using	OpacityLayerTest = LayerTest

using	OpacityLayerDiffTest = DiffContextTest

using	PerformanceOverlayLayerTest = LayerTest

using	PlatformViewLayerTest = LayerTest

using	ShaderMaskLayerTest = LayerTest

using	TextureLayerTest = LayerTest

using	TextureLayerDiffTest = DiffContextTest

using	TransformLayerTest = LayerTest

using	TransformLayerLayerDiffTest = DiffContextTest

using	RasterCacheTest = LayerTest

using	LayerTest = LayerTestBase<::testing::Test >

using	MockLayerTest = LayerTest

using	DlGoldenTest = impeller::DlPlayground

using	HooksTest = ShellTest

using	SemanticsUpdateBuilderTest = ShellTest

using	DartLifecycleTest = FixtureTest

using	DartVMTest = FixtureTest

using	IsolateDataMap = std::unordered_map< Dart_Isolate, std::vector< std::unique_ptr< IsolateData > > >

using	UnitlessTime = int

using	Generator = std::function< UnitlessTime(int)>

using	PersistentCacheTest = ShellTest

using	IntPipeline = Pipeline< int >

using	Continuation = IntPipeline::ProducerContinuation

using	LayerTreeBuilder = std::function< void(std::shared_ptr< ContainerLayer > root)>

using	FrameContent = std::map< int64_t, ViewContent >

using	CreateVsyncWaiter = std::function< std::unique_ptr< VsyncWaiter >()>

using	FlutterChannelKeyResponderTest = AutoreleasePoolTest

using	FlutterEmbedderExternalTextureTest = AutoreleasePoolTest

using	FlutterViewControllerTest = AutoreleasePoolTest

using	FlutterViewControllerMockEngineTest = MockFlutterEngineTest

using	EmbedderA11yTest = testing::EmbedderTest

using	UniqueEngine = fml::UniqueObject< FlutterEngine, UniqueEngineTraits >

using	EmbedderTest = testing::EmbedderTest

using	SemanticsUpdateCallback2 = std::function< void(const FlutterSemanticsUpdate2 *)>

using	SemanticsUpdateCallback = std::function< void(const FlutterSemanticsUpdate *)>

using	SemanticsNodeCallback = std::function< void(const FlutterSemanticsNode *)>

using	SemanticsActionCallback = std::function< void(const FlutterSemanticsCustomAction *)>

using	LogMessageCallback = std::function< void(const char tag, const char message)>

using	ChannelUpdateCallback = std::function< void(const FlutterChannelUpdate *)>

using	UniqueAOTData = std::unique_ptr< _FlutterEngineAOTData, AOTDataDeleter >

using	EnginePtr = std::unique_ptr< FlutterDesktopEngine, EngineDeleter >

using	ViewControllerPtr = std::unique_ptr< FlutterDesktopViewController, ViewControllerDeleter >

typedef enum flutter::testing::WmFieldExtended	WmFieldExtended

typedef enum flutter::testing::WmFieldContext	WmFieldContext

typedef enum flutter::testing::WmFieldPrevState	WmFieldPrevState

typedef enum flutter::testing::WmFieldTransitionState	WmFieldTransitionState

typedef struct flutter::testing::WmKeyDownInfo	WmKeyDownInfo

typedef struct flutter::testing::WmKeyUpInfo	WmKeyUpInfo

typedef struct flutter::testing::WmCharInfo	WmCharInfo

typedef struct flutter::testing::WmSysKeyDownInfo	WmSysKeyDownInfo

typedef struct flutter::testing::WmSysKeyUpInfo	WmSysKeyUpInfo

typedef struct flutter::testing::WmDeadCharInfo	WmDeadCharInfo

using	CanvasTest = CanvasTestBase<::testing::Test >

using	UniqueLoadedELF = std::unique_ptr< Dart_LoadedElf, LoadedELFDeleter >

using	MockCanvasTest = CanvasTest

using	NativeEntry = std::function< void(Dart_NativeArguments)>

using	FileLoaderTest = FixtureTest

using	DartState = FixtureTest

using	PainterTest = PainterTestBase<::testing::Test >

Enumerations
enum	BenchmarkAttributes { kEmpty = 0 , kStrokedStyle = 1 << 0 , kFilledStyle = 1 << 1 , kHairlineStroke = 1 << 2 , kAntiAliasing = 1 << 3 }

enum class	EmbedderTestContextType { kSoftwareContext , kOpenGLContext , kMetalContext , kVulkanContext }

enum	WmFieldExtended { kNotExtended = 0 , kExtended = 1 }

enum	WmFieldContext { kNoContext = 0 , kAltHeld = 1 }

enum	WmFieldPrevState { kWasUp = 0 , kWasDown = 1 }

enum	WmFieldTransitionState { kBeingReleased = 0 , kBeingPressed = 1 }

enum class	DebuggerStatus { kDontKnow , kAttached }

enum class	MemsetPatternOp { kMemsetPatternOpSetBuffer , kMemsetPatternOpCheckBuffer }

Functions
DlPaint	GetPaintForRun (unsigned attributes)

static void	FlushSubmitCpuSync (const sk_sp< SkSurface > &surface)

void	AnnotateAttributes (unsigned attributes, benchmark::State &state, const DisplayListAttributeFlags flags)

void	BM_DrawLine (benchmark::State &state, BackendType backend_type, unsigned attributes)

void	BM_DrawRect (benchmark::State &state, BackendType backend_type, unsigned attributes)

void	BM_DrawOval (benchmark::State &state, BackendType backend_type, unsigned attributes)

void	BM_DrawCircle (benchmark::State &state, BackendType backend_type, unsigned attributes)

void	BM_DrawRRect (benchmark::State &state, BackendType backend_type, unsigned attributes, SkRRect::Type type)

void	BM_DrawDRRect (benchmark::State &state, BackendType backend_type, unsigned attributes, SkRRect::Type type)

void	BM_DrawArc (benchmark::State &state, BackendType backend_type, unsigned attributes)

std::vector< SkPoint >	GetPolygonPoints (size_t n, SkPoint center, SkScalar r)

void	GetLinesPath (SkPath &path, size_t sides, SkPoint center, float radius)

void	GetQuadsPath (SkPath &path, size_t sides, SkPoint center, float radius)

void	GetConicsPath (SkPath &path, size_t sides, SkPoint center, float radius)

void	GetCubicsPath (SkPath &path, size_t sides, SkPoint center, float radius)

void	MultiplyPath (SkPath &path, SkPath::Verb type, SkPoint center, size_t sides, size_t number, float radius)

std::string	VerbToString (SkPath::Verb type)

void	BM_DrawPath (benchmark::State &state, BackendType backend_type, unsigned attributes, SkPath::Verb type)

std::shared_ptr< DlVertices >	GetTestVertices (SkPoint center, float radius, size_t vertex_count, DlVertexMode mode, size_t &final_vertex_count)

std::string	VertexModeToString (DlVertexMode mode)

void	BM_DrawVertices (benchmark::State &state, BackendType backend_type, unsigned attributes, DlVertexMode mode)

std::vector< SkPoint >	GetTestPoints (size_t count, SkISize canvas_size)

std::string	PointModeToString (DlCanvas::PointMode mode)

void	BM_DrawPoints (benchmark::State &state, BackendType backend_type, unsigned attributes, DlCanvas::PointMode mode)

sk_sp< SkImage >	ImageFromBitmapWithNewID (const SkBitmap &bitmap)

void	BM_DrawImage (benchmark::State &state, BackendType backend_type, unsigned attributes, DlImageSampling options, bool upload_bitmap)

std::string	ConstraintToString (DlCanvas::SrcRectConstraint constraint)

void	BM_DrawImageRect (benchmark::State &state, BackendType backend_type, unsigned attributes, DlImageSampling options, DlCanvas::SrcRectConstraint constraint, bool upload_bitmap)

std::string	FilterModeToString (const DlFilterMode mode)

void	BM_DrawImageNine (benchmark::State &state, BackendType backend_type, unsigned attributes, const DlFilterMode filter, bool upload_bitmap)

void	BM_DrawTextBlob (benchmark::State &state, BackendType backend_type, unsigned attributes)

void	BM_DrawShadow (benchmark::State &state, BackendType backend_type, unsigned attributes, bool transparent_occluder, SkPath::Verb type)

void	BM_SaveLayer (benchmark::State &state, BackendType backend_type, unsigned attributes, size_t save_depth)

	TEST (DisplayListComplexity, EmptyDisplayList)

	TEST (DisplayListComplexity, DisplayListCeiling)

	TEST (DisplayListComplexity, NestedDisplayList)

	TEST (DisplayListComplexity, AntiAliasing)

	TEST (DisplayListComplexity, StrokeWidth)

	TEST (DisplayListComplexity, Style)

	TEST (DisplayListComplexity, SaveLayers)

	TEST (DisplayListComplexity, DrawPath)

	TEST (DisplayListComplexity, DrawShadow)

	TEST (DisplayListComplexity, DrawOval)

	TEST (DisplayListComplexity, DrawCircle)

	TEST (DisplayListComplexity, DrawRRect)

	TEST (DisplayListComplexity, DrawDRRect)

	TEST (DisplayListComplexity, DrawArc)

	TEST (DisplayListComplexity, DrawVertices)

	TEST (DisplayListComplexity, DrawTextBlob)

	TEST (DisplayListComplexity, DrawPoints)

	TEST (DisplayListComplexity, DrawImage)

	TEST (DisplayListComplexity, DrawImageNine)

	TEST (DisplayListComplexity, DrawImageRect)

	TEST (DisplayListComplexity, DrawAtlas)

	TEST_F (DisplayListTest, Defaults)

	TEST_F (DisplayListTest, EmptyBuild)

	TEST_F (DisplayListTest, EmptyRebuild)

	TEST_F (DisplayListTest, BuilderCanBeReused)

	TEST_F (DisplayListTest, SaveRestoreRestoresTransform)

	TEST_F (DisplayListTest, BuildRestoresTransform)

	TEST_F (DisplayListTest, SaveRestoreRestoresClip)

	TEST_F (DisplayListTest, BuildRestoresClip)

	TEST_F (DisplayListTest, BuildRestoresAttributes)

	TEST_F (DisplayListTest, BuilderBoundsTransformComparedToSkia)

	TEST_F (DisplayListTest, BuilderInitialClipBounds)

	TEST_F (DisplayListTest, BuilderInitialClipBoundsNaN)

	TEST_F (DisplayListTest, BuilderClipBoundsAfterClipRect)

	TEST_F (DisplayListTest, BuilderClipBoundsAfterClipRRect)

	TEST_F (DisplayListTest, BuilderClipBoundsAfterClipPath)

	TEST_F (DisplayListTest, BuilderInitialClipBoundsNonZero)

	TEST_F (DisplayListTest, UnclippedSaveLayerContentAccountsForFilter)

	TEST_F (DisplayListTest, ClippedSaveLayerContentAccountsForFilter)

	TEST_F (DisplayListTest, OOBSaveLayerContentCulledWithBlurFilter)

	TEST_F (DisplayListTest, OOBSaveLayerContentCulledWithMatrixFilter)

	TEST_F (DisplayListTest, SingleOpSizes)

	TEST_F (DisplayListTest, SingleOpDisplayListsNotEqualEmpty)

	TEST_F (DisplayListTest, SingleOpDisplayListsRecapturedAreEqual)

	TEST_F (DisplayListTest, SingleOpDisplayListsCompareToEachOther)

	TEST_F (DisplayListTest, SingleOpDisplayListsAreEqualWithOrWithoutRtree)

	TEST_F (DisplayListTest, FullRotationsAreNop)

	TEST_F (DisplayListTest, AllBlendModeNops)

	TEST_F (DisplayListTest, DisplayListsWithVaryingOpComparisons)

	TEST_F (DisplayListTest, DisplayListSaveLayerBoundsWithAlphaFilter)

	TEST_F (DisplayListTest, NestedOpCountMetricsSameAsSkPicture)

	TEST_F (DisplayListTest, DisplayListFullPerspectiveTransformHandling)

	TEST_F (DisplayListTest, DisplayListTransformResetHandling)

	TEST_F (DisplayListTest, SingleOpsMightSupportGroupOpacityBlendMode)

	TEST_F (DisplayListTest, OverlappingOpsDoNotSupportGroupOpacity)

	TEST_F (DisplayListTest, LineOfNonOverlappingOpsSupportGroupOpacity)

	TEST_F (DisplayListTest, CrossOfNonOverlappingOpsSupportGroupOpacity)

	TEST_F (DisplayListTest, SaveLayerFalseSupportsGroupOpacityOverlappingChidren)

	TEST_F (DisplayListTest, SaveLayerTrueSupportsGroupOpacityOverlappingChidren)

	TEST_F (DisplayListTest, SaveLayerFalseWithSrcBlendSupportsGroupOpacity)

	TEST_F (DisplayListTest, SaveLayerTrueWithSrcBlendDoesNotSupportGroupOpacity)

	TEST_F (DisplayListTest, SaveLayerFalseSupportsGroupOpacityWithChildSrcBlend)

	TEST_F (DisplayListTest, SaveLayerTrueSupportsGroupOpacityWithChildSrcBlend)

	TEST_F (DisplayListTest, SaveLayerBoundsSnapshotsImageFilter)

	TEST_F (DisplayListTest, SaveLayerOneSimpleOpInheritsOpacity)

	TEST_F (DisplayListTest, SaveLayerNoAttributesInheritsOpacity)

	TEST_F (DisplayListTest, SaveLayerTwoOverlappingOpsDoesNotInheritOpacity)

	TEST_F (DisplayListTest, NestedSaveLayersMightInheritOpacity)

	TEST_F (DisplayListTest, NestedSaveLayersCanBothSupportOpacityOptimization)

	TEST_F (DisplayListTest, SaveLayerImageFilterDoesNotInheritOpacity)

	TEST_F (DisplayListTest, SaveLayerColorFilterDoesNotInheritOpacity)

	TEST_F (DisplayListTest, SaveLayerSrcBlendDoesNotInheritOpacity)

	TEST_F (DisplayListTest, SaveLayerImageFilterOnChildInheritsOpacity)

	TEST_F (DisplayListTest, SaveLayerColorFilterOnChildDoesNotInheritOpacity)

	TEST_F (DisplayListTest, SaveLayerSrcBlendOnChildDoesNotInheritOpacity)

	TEST_F (DisplayListTest, FlutterSvgIssue661BoundsWereEmpty)

	TEST_F (DisplayListTest, TranslateAffectsCurrentTransform)

	TEST_F (DisplayListTest, ScaleAffectsCurrentTransform)

	TEST_F (DisplayListTest, RotateAffectsCurrentTransform)

	TEST_F (DisplayListTest, SkewAffectsCurrentTransform)

	TEST_F (DisplayListTest, TransformAffectsCurrentTransform)

	TEST_F (DisplayListTest, FullTransformAffectsCurrentTransform)

	TEST_F (DisplayListTest, ClipRectAffectsClipBounds)

	TEST_F (DisplayListTest, ClipRectDoAAAffectsClipBounds)

	TEST_F (DisplayListTest, ClipRectAffectsClipBoundsWithMatrix)

	TEST_F (DisplayListTest, ClipRRectAffectsClipBounds)

	TEST_F (DisplayListTest, ClipRRectDoAAAffectsClipBounds)

	TEST_F (DisplayListTest, ClipRRectAffectsClipBoundsWithMatrix)

	TEST_F (DisplayListTest, ClipPathAffectsClipBounds)

	TEST_F (DisplayListTest, ClipPathDoAAAffectsClipBounds)

	TEST_F (DisplayListTest, ClipPathAffectsClipBoundsWithMatrix)

	TEST_F (DisplayListTest, DiffClipRectDoesNotAffectClipBounds)

	TEST_F (DisplayListTest, DiffClipRRectDoesNotAffectClipBounds)

	TEST_F (DisplayListTest, DiffClipPathDoesNotAffectClipBounds)

	TEST_F (DisplayListTest, ClipPathWithInvertFillTypeDoesNotAffectClipBounds)

	TEST_F (DisplayListTest, DiffClipPathWithInvertFillTypeAffectsClipBounds)

	TEST_F (DisplayListTest, FlatDrawPointsProducesBounds)

static void	test_rtree (const sk_sp< const DlRTree > &rtree, const SkRect &query, std::vector< SkRect > expected_rects, const std::vector< int > &expected_indices, const std::string &file, int line)

	TEST_F (DisplayListTest, RTreeOfSimpleScene)

	TEST_F (DisplayListTest, RTreeOfSaveRestoreScene)

	TEST_F (DisplayListTest, RTreeOfSaveLayerFilterScene)

	TEST_F (DisplayListTest, NestedDisplayListRTreesAreSparse)

	TEST_F (DisplayListTest, RemoveUnnecessarySaveRestorePairs)

	TEST_F (DisplayListTest, CollapseMultipleNestedSaveRestore)

	TEST_F (DisplayListTest, CollapseNestedSaveAndSaveLayerRestore)

	TEST_F (DisplayListTest, RemoveUnnecessarySaveRestorePairsInSetPaint)

	TEST_F (DisplayListTest, TransformTriggersDeferredSave)

	TEST_F (DisplayListTest, Transform2DTriggersDeferredSave)

	TEST_F (DisplayListTest, TransformPerspectiveTriggersDeferredSave)

	TEST_F (DisplayListTest, ResetTransformTriggersDeferredSave)

	TEST_F (DisplayListTest, SkewTriggersDeferredSave)

	TEST_F (DisplayListTest, TranslateTriggersDeferredSave)

	TEST_F (DisplayListTest, ScaleTriggersDeferredSave)

	TEST_F (DisplayListTest, ClipRectTriggersDeferredSave)

	TEST_F (DisplayListTest, ClipRRectTriggersDeferredSave)

	TEST_F (DisplayListTest, ClipPathTriggersDeferredSave)

	TEST_F (DisplayListTest, NOPTranslateDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPScaleDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPRotationDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPSkewDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPTransformDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPTransform2DDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPTransformFullPerspectiveDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, NOPClipDoesNotTriggerDeferredSave)

	TEST_F (DisplayListTest, RTreeOfClippedSaveLayerFilterScene)

	TEST_F (DisplayListTest, RTreeRenderCulling)

	TEST_F (DisplayListTest, DrawSaveDrawCannotInheritOpacity)

	TEST_F (DisplayListTest, DrawUnorderedRect)

	TEST_F (DisplayListTest, DrawUnorderedRoundRect)

	TEST_F (DisplayListTest, DrawUnorderedOval)

	TEST_F (DisplayListTest, DrawUnorderedRectangularPath)

	TEST_F (DisplayListTest, DrawUnorderedOvalPath)

	TEST_F (DisplayListTest, DrawUnorderedRoundRectPathCW)

	TEST_F (DisplayListTest, DrawUnorderedRoundRectPathCCW)

	TEST_F (DisplayListTest, NopOperationsOmittedFromRecords)

	TEST_F (DisplayListTest, ImpellerPathPreferenceIsHonored)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfMaskBlurredRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfImageBlurredRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfStrokedRect)

	TEST_F (DisplayListTest, TranslatedSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, ScaledSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, RotatedSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, TransformResetSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfTranslatedSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfScaledSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfRotatedSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfNestedSimpleRect)

	TEST_F (DisplayListTest, FloodingSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, NestedFloodingSaveLayerBoundsComputationOfSimpleRect)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfFloodingImageFilter)

	TEST_F (DisplayListTest, SaveLayerBoundsComputationOfFloodingColorFilter)

	TEST_F (DisplayListTest, SaveLayerBoundsClipDetectionSimpleUnclippedRect)

	TEST_F (DisplayListTest, SaveLayerBoundsClipDetectionSimpleClippedRect)

	TEST_F (DisplayListTest, SaveContentDepthTest)

	TEST_F (DisplayListTest, FloodingFilteredLayerPushesRestoreOpIndex)

	TEST_F (DisplayListTest, TransformingFilterSaveLayerSimpleContentBounds)

	TEST_F (DisplayListTest, TransformingFilterSaveLayerFloodedContentBounds)

	TEST_F (DisplayListTest, OpacityIncompatibleRenderOpInsideDeferredSave)

	TEST_F (DisplayListTest, MaxBlendModeEmptyDisplayList)

	TEST_F (DisplayListTest, MaxBlendModeSimpleRect)

	TEST_F (DisplayListTest, MaxBlendModeInsideNonDeferredSave)

	TEST_F (DisplayListTest, MaxBlendModeInsideDeferredSave)

	TEST_F (DisplayListTest, MaxBlendModeInsideSaveLayer)

	TEST_F (DisplayListTest, MaxBlendModeInsideNonDefaultBlendedSaveLayer)

	TEST_F (DisplayListTest, MaxBlendModeInsideComplexDeferredSaves)

	TEST_F (DisplayListTest, MaxBlendModeInsideComplexSaveLayers)

	TEST_F (DisplayListTest, BackdropDetectionEmptyDisplayList)

	TEST_F (DisplayListTest, BackdropDetectionSimpleRect)

	TEST_F (DisplayListTest, BackdropDetectionSimpleSaveLayer)

	TEST_F (DisplayListTest, BackdropDetectionNestedSaveLayer)

	TEST_F (DisplayListTest, DrawDisplayListForwardsMaxBlend)

	TEST_F (DisplayListTest, DrawDisplayListForwardsBackdropFlag)

	TEST_F (DisplayListTest, ClipRectCullingPixel6a)

	TEST_F (DisplayListTest, ClipRectCulling)

	TEST_F (DisplayListTest, ClipRectNonCulling)

	TEST_F (DisplayListTest, ClipRectNestedCulling)

	TEST_F (DisplayListTest, ClipRectNestedNonCulling)

	TEST_F (DisplayListTest, ClipRectNestedCullingComplex)

	TEST_F (DisplayListTest, ClipRectNestedNonCullingComplex)

	TEST_F (DisplayListTest, ClipRRectCulling)

	TEST_F (DisplayListTest, ClipRRectNonCulling)

	TEST_F (DisplayListTest, ClipPathNonCulling)

	TEST_F (DisplayListTest, ClipPathRectCulling)

	TEST_F (DisplayListTest, ClipPathRectNonCulling)

	TEST_F (DisplayListTest, ClipPathRRectCulling)

	TEST_F (DisplayListTest, ClipPathRRectNonCulling)

static void	arraysEqual (const uint32_t ints, const DlColor colors, int count)

	TEST (DisplayListColor, ArrayInterchangeableWithUint32)

	TEST (DisplayListColor, DlColorDirectlyComparesToSkColor)

	TEST (DisplayListPaint, ConstructorDefaults)

	TEST (DisplayListPaint, NullPointerSetGet)

	TEST (DisplayListPaint, NullSharedPointerSetGet)

	TEST (DisplayListPaint, ChainingConstructor)

	TEST (DisplayListVertices, MakeWithZeroAndNegativeVerticesAndIndices)

	TEST (DisplayListVertices, MakeWithTexAndColorAndIndices)

	TEST (DisplayListVertices, MakeWithTexAndColor)

	TEST (DisplayListVertices, MakeWithTexAndIndices)

	TEST (DisplayListVertices, MakeWithColorAndIndices)

	TEST (DisplayListVertices, MakeWithTex)

	TEST (DisplayListVertices, MakeWithColor)

	TEST (DisplayListVertices, MakeWithIndices)

	TEST (DisplayListVertices, MakeWithNoOptionalData)

	TEST (DisplayListVertices, MakeWithIndicesButZeroIndexCount)

	TEST (DisplayListVertices, MakeWithIndicesButNegativeIndexCount)

	TEST (DisplayListVertices, BuilderFlags)

	TEST (DisplayListVertices, BuildWithZeroAndNegativeVerticesAndIndices)

	TEST (DisplayListVertices, BuildWithTexAndColorAndIndices)

	TEST (DisplayListVertices, BuildWithTexAndColor)

	TEST (DisplayListVertices, BuildWithTexAndIndices)

	TEST (DisplayListVertices, BuildWithColorAndIndices)

	TEST (DisplayListVertices, BuildWithTexUsingPoints)

	TEST (DisplayListVertices, BuildWithTexUsingFloats)

	TEST (DisplayListVertices, BuildUsingFloatsSameAsPoints)

	TEST (DisplayListVertices, BuildWithColor)

	TEST (DisplayListVertices, BuildWithIndices)

	TEST (DisplayListVertices, BuildWithNoOptionalData)

	TEST (DisplayListVertices, BuildWithNegativeIndexCount)

	TEST (DisplayListVertices, TestEquals)

	TEST (DisplayListVertices, TestNotEquals)

	TEST (DisplayListColorFilter, BlendConstructor)

	TEST (DisplayListColorFilter, BlendShared)

	TEST (DisplayListColorFilter, BlendAsBlend)

	TEST (DisplayListColorFilter, BlendContents)

	TEST (DisplayListColorFilter, BlendEquals)

	TEST (DisplayListColorFilter, BlendNotEquals)

	TEST (DisplayListColorFilter, NopBlendShouldNotCrash)

	TEST (DisplayListColorFilter, MatrixConstructor)

	TEST (DisplayListColorFilter, MatrixShared)

	TEST (DisplayListColorFilter, MatrixAsMatrix)

	TEST (DisplayListColorFilter, MatrixContents)

	TEST (DisplayListColorFilter, MatrixEquals)

	TEST (DisplayListColorFilter, MatrixNotEquals)

	TEST (DisplayListColorFilter, NopMatrixShouldNotCrash)

	TEST (DisplayListColorFilter, SrgbToLinearConstructor)

	TEST (DisplayListColorFilter, SrgbToLinearShared)

	TEST (DisplayListColorFilter, SrgbToLinearEquals)

	TEST (DisplayListColorFilter, LinearToSrgbConstructor)

	TEST (DisplayListColorFilter, LinearToSrgbShared)

	TEST (DisplayListColorFilter, LinearToSrgbEquals)

static sk_sp< DlImage >	MakeTestImage (int w, int h, SkColor color)

	TEST (DisplayListColorSource, ColorConstructor)

	TEST (DisplayListColorSource, ColorShared)

	TEST (DisplayListColorSource, ColorAsColor)

	TEST (DisplayListColorSource, ColorContents)

	TEST (DisplayListColorSource, ColorEquals)

	TEST (DisplayListColorSource, ColorNotEquals)

	TEST (DisplayListColorSource, ImageConstructor)

	TEST (DisplayListColorSource, ImageShared)

	TEST (DisplayListColorSource, ImageAsImage)

	TEST (DisplayListColorSource, ImageContents)

	TEST (DisplayListColorSource, AlphaImageContents)

	TEST (DisplayListColorSource, ImageEquals)

	TEST (DisplayListColorSource, ImageNotEquals)

	TEST (DisplayListColorSource, LinearGradientConstructor)

	TEST (DisplayListColorSource, LinearGradientShared)

	TEST (DisplayListColorSource, LinearGradientAsLinear)

	TEST (DisplayListColorSource, LinearGradientContents)

	TEST (DisplayListColorSource, AlphaLinearGradientContents)

	TEST (DisplayListColorSource, LinearGradientEquals)

	TEST (DisplayListColorSource, LinearGradientNotEquals)

	TEST (DisplayListColorSource, RadialGradientConstructor)

	TEST (DisplayListColorSource, RadialGradientShared)

	TEST (DisplayListColorSource, RadialGradientAsRadial)

	TEST (DisplayListColorSource, RadialGradientContents)

	TEST (DisplayListColorSource, AlphaRadialGradientContents)

	TEST (DisplayListColorSource, RadialGradientEquals)

	TEST (DisplayListColorSource, RadialGradientNotEquals)

	TEST (DisplayListColorSource, ConicalGradientConstructor)

	TEST (DisplayListColorSource, ConicalGradientShared)

	TEST (DisplayListColorSource, ConicalGradientAsConical)

	TEST (DisplayListColorSource, ConicalGradientContents)

	TEST (DisplayListColorSource, AlphaConicalGradientContents)

	TEST (DisplayListColorSource, ConicalGradientEquals)

	TEST (DisplayListColorSource, ConicalGradientNotEquals)

	TEST (DisplayListColorSource, SweepGradientConstructor)

	TEST (DisplayListColorSource, SweepGradientShared)

	TEST (DisplayListColorSource, SweepGradientAsSweep)

	TEST (DisplayListColorSource, SweepGradientContents)

	TEST (DisplayListColorSource, AlphaSweepGradientContents)

	TEST (DisplayListColorSource, SweepGradientEquals)

	TEST (DisplayListColorSource, SweepGradientNotEquals)

	TEST (DisplayListColorSource, RuntimeEffect)

static bool	containsInclusive (const SkRect rect, const SkPoint p)

static bool	containsInclusive (const SkRect rect, const SkPoint quad[4])

static bool	containsInclusive (const SkIRect rect, const SkPoint quad[4])

static bool	containsInclusive (const SkIRect rect, const SkRect bounds)

static void	TestBoundsWithMatrix (const DlImageFilter &filter, const SkMatrix &matrix, const SkRect &sourceBounds, const SkPoint expectedLocalOutputQuad[4])

static void	TestInvalidBounds (const DlImageFilter &filter, const SkMatrix &matrix, const SkRect &localInputBounds)

static void	TestBounds (const DlImageFilter &filter, const SkRect &sourceBounds, const SkPoint expectedLocalOutputQuad[4])

static void	TestBounds (const DlImageFilter &filter, const SkRect &sourceBounds, const SkRect &expectedLocalOutputBounds)

	TEST (DisplayListImageFilter, BlurConstructor)

	TEST (DisplayListImageFilter, BlurShared)

	TEST (DisplayListImageFilter, BlurAsBlur)

	TEST (DisplayListImageFilter, BlurContents)

	TEST (DisplayListImageFilter, BlurEquals)

	TEST (DisplayListImageFilter, BlurWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, BlurNotEquals)

	TEST (DisplayListImageFilter, BlurBounds)

	TEST (DisplayListImageFilter, BlurZeroSigma)

	TEST (DisplayListImageFilter, DilateConstructor)

	TEST (DisplayListImageFilter, DilateShared)

	TEST (DisplayListImageFilter, DilateAsDilate)

	TEST (DisplayListImageFilter, DilateContents)

	TEST (DisplayListImageFilter, DilateEquals)

	TEST (DisplayListImageFilter, DilateWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, DilateNotEquals)

	TEST (DisplayListImageFilter, DilateBounds)

	TEST (DisplayListImageFilter, ErodeConstructor)

	TEST (DisplayListImageFilter, ErodeShared)

	TEST (DisplayListImageFilter, ErodeAsErode)

	TEST (DisplayListImageFilter, ErodeContents)

	TEST (DisplayListImageFilter, ErodeEquals)

	TEST (DisplayListImageFilter, ErodeWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, ErodeNotEquals)

	TEST (DisplayListImageFilter, ErodeBounds)

	TEST (DisplayListImageFilter, MatrixConstructor)

	TEST (DisplayListImageFilter, MatrixShared)

	TEST (DisplayListImageFilter, MatrixAsMatrix)

	TEST (DisplayListImageFilter, MatrixContents)

	TEST (DisplayListImageFilter, MatrixEquals)

	TEST (DisplayListImageFilter, MatrixWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, MatrixNotEquals)

	TEST (DisplayListImageFilter, MatrixBounds)

	TEST (DisplayListImageFilter, ComposeConstructor)

	TEST (DisplayListImageFilter, ComposeShared)

	TEST (DisplayListImageFilter, ComposeAsCompose)

	TEST (DisplayListImageFilter, ComposeContents)

	TEST (DisplayListImageFilter, ComposeEquals)

	TEST (DisplayListImageFilter, ComposeWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, ComposeNotEquals)

	TEST (DisplayListImageFilter, ComposeBounds)

static void	TestUnboundedBounds (DlImageFilter &filter, const SkRect &sourceBounds, const SkRect &expectedOutputBounds, const SkRect &expectedInputBounds)

	TEST (DisplayListImageFilter, ComposeBoundsWithUnboundedInner)

	TEST (DisplayListImageFilter, ComposeBoundsWithUnboundedOuter)

	TEST (DisplayListImageFilter, ComposeBoundsWithUnboundedInnerAndOuter)

	TEST (DisplayListImageFilter, Issue108433)

	TEST (DisplayListImageFilter, ColorFilterConstructor)

	TEST (DisplayListImageFilter, ColorFilterShared)

	TEST (DisplayListImageFilter, ColorFilterAsColorFilter)

	TEST (DisplayListImageFilter, ColorFilterContents)

	TEST (DisplayListImageFilter, ColorFilterEquals)

	TEST (DisplayListImageFilter, ColorFilterWithLocalMatrixEquals)

	TEST (DisplayListImageFilter, ColorFilterNotEquals)

	TEST (DisplayListImageFilter, ColorFilterBounds)

	TEST (DisplayListImageFilter, ColorFilterModifiesTransparencyBounds)

	TEST (DisplayListImageFilter, LocalImageFilterBounds)

	TEST (DisplayListMaskFilter, BlurConstructor)

	TEST (DisplayListMaskFilter, BlurShared)

	TEST (DisplayListMaskFilter, BlurAsBlur)

	TEST (DisplayListMaskFilter, BlurContents)

	TEST (DisplayListMaskFilter, BlurEquals)

	TEST (DisplayListMaskFilter, BlurNotEquals)

void	testEquals (DlMaskFilter a, DlMaskFilter b)

void	testNotEquals (DlMaskFilter a, DlMaskFilter b)

void	testEquals (const std::shared_ptr< const DlMaskFilter > &a, DlMaskFilter *b)

void	testNotEquals (const std::shared_ptr< const DlMaskFilter > &a, DlMaskFilter *b)

void	testEquals (const std::shared_ptr< const DlMaskFilter > &a, const std::shared_ptr< const DlMaskFilter > &b)

void	testNotEquals (const std::shared_ptr< const DlMaskFilter > &a, const std::shared_ptr< const DlMaskFilter > &b)

	TEST (DisplayListMaskFilter, ComparableTemplates)

	TEST (DisplayListGeometryTypes, PointConversion)

	TEST (DisplayListGeometryTypes, RectConversion)

	TEST (DisplayListGeometryTypes, ISizeConversion)

	TEST (DisplayListRegion, EmptyRegion)

	TEST (DisplayListRegion, SingleRectangle)

	TEST (DisplayListRegion, NonOverlappingRectangles1)

	TEST (DisplayListRegion, NonOverlappingRectangles2)

	TEST (DisplayListRegion, NonOverlappingRectangles3)

	TEST (DisplayListRegion, MergeTouchingRectangles)

	TEST (DisplayListRegion, OverlappingRectangles)

	TEST (DisplayListRegion, Deband)

	TEST (DisplayListRegion, Intersects1)

	TEST (DisplayListRegion, Intersects2)

	TEST (DisplayListRegion, Intersection1)

	TEST (DisplayListRegion, Intersection2)

	TEST (DisplayListRegion, Intersection3)

	TEST (DisplayListRegion, Union1)

	TEST (DisplayListRegion, Union2)

	TEST (DisplayListRegion, Union3)

	TEST (DisplayListRegion, UnionEmpty)

void	CheckEquality (const DlRegion &dl_region, const SkRegion &sk_region)

	TEST (DisplayListRegion, TestAgainstSkRegion)

	TEST (DisplayListRTree, NullRectListNonZeroCount)

	TEST (DisplayListRTree, NegativeCount)

	TEST (DisplayListRTree, NullSearchResultVector)

	TEST (DisplayListRTree, NullRectListZeroCount)

	TEST (DisplayListRTree, ManySizes)

	TEST (DisplayListRTree, HugeSize)

	TEST (DisplayListRTree, Grid)

	TEST (DisplayListRTree, OverlappingRects)

	TEST (DisplayListRTree, Region)

	TEST (DisplayListImageFilter, LocalImageSkiaNull)

	TEST (DisplayListSkConversions, ToSkColor)

	TEST (DisplayListSkConversions, ToSkTileMode)

	TEST (DisplayListSkConversions, ToSkBlurStyle)

	TEST (DisplayListSkConversions, ToSkDrawStyle)

	TEST (DisplayListSkConversions, ToSkStrokeCap)

	TEST (DisplayListSkConversions, ToSkStrokeJoin)

	TEST (DisplayListSkConversions, ToSkVertexMode)

	TEST (DisplayListSkConversions, ToSkFilterMode)

	TEST (DisplayListSkConversions, ToSkSrcRectConstraint)

	TEST (DisplayListSkConversions, ToSkSamplingOptions)

	TEST (DisplayListSkConversions, ToSkBlendMode)

	TEST (DisplayListSkConversions, BlendColorFilterModifiesTransparency)

	TEST (DisplayListSkConversions, ConvertWithZeroAndNegativeVerticesAndIndices)

	TEST (DisplayListVertices, ConvertWithZeroAndNegativeVerticesAndIndices)

	TEST (DisplayListColorSource, ConvertRuntimeEffect)

	TEST (DisplayListColorSource, ConvertRuntimeEffectWithNullSampler)

	TEST (DisplayListSkConversions, MatrixColorFilterModifiesTransparency)

	TEST (DisplayListSkConversions, ToSkDitheringEnabledForGradients)

	TEST (DisplayListUtils, OverRestore)

	TEST (DisplayListUtils, SetColorSourceDithersIfGradient)

	TEST (DisplayListUtils, SetColorSourceDoesNotDitherIfNotGradient)

	TEST (DisplayListUtils, SkDispatcherSetColorSourceDithersIfGradient)

	TEST (DisplayListUtils, SkDispatcherSetColorSourceDoesNotDitherIfNotGradient)

static void	DrawCheckerboard (DlCanvas *canvas)

static void	DrawCheckerboard (SkCanvas *canvas)

static std::shared_ptr< DlImageColorSource >	MakeColorSource (const sk_sp< DlImage > &image)

static sk_sp< SkShader >	MakeColorSource (const sk_sp< SkImage > &image)

	TEST_F (DisplayListRendering, DrawPaint)

	TEST_F (DisplayListRendering, DrawOpaqueColor)

	TEST_F (DisplayListRendering, DrawAlphaColor)

	TEST_F (DisplayListRendering, DrawDiagonalLines)

	TEST_F (DisplayListRendering, DrawHorizontalLine)

	TEST_F (DisplayListRendering, DrawVerticalLine)

	TEST_F (DisplayListRendering, DrawDiagonalDashedLines)

	TEST_F (DisplayListRendering, DrawRect)

	TEST_F (DisplayListRendering, DrawOval)

	TEST_F (DisplayListRendering, DrawCircle)

	TEST_F (DisplayListRendering, DrawRRect)

	TEST_F (DisplayListRendering, DrawDRRect)

	TEST_F (DisplayListRendering, DrawPath)

	TEST_F (DisplayListRendering, DrawArc)

	TEST_F (DisplayListRendering, DrawArcCenter)

	TEST_F (DisplayListRendering, DrawPointsAsPoints)

	TEST_F (DisplayListRendering, DrawPointsAsLines)

	TEST_F (DisplayListRendering, DrawPointsAsPolygon)

	TEST_F (DisplayListRendering, DrawVerticesWithColors)

	TEST_F (DisplayListRendering, DrawVerticesWithImage)

	TEST_F (DisplayListRendering, DrawImageNearest)

	TEST_F (DisplayListRendering, DrawImageNearestNoPaint)

	TEST_F (DisplayListRendering, DrawImageLinear)

	TEST_F (DisplayListRendering, DrawImageRectNearest)

	TEST_F (DisplayListRendering, DrawImageRectNearestNoPaint)

	TEST_F (DisplayListRendering, DrawImageRectLinear)

	TEST_F (DisplayListRendering, DrawImageNineNearest)

	TEST_F (DisplayListRendering, DrawImageNineNearestNoPaint)

	TEST_F (DisplayListRendering, DrawImageNineLinear)

	TEST_F (DisplayListRendering, DrawAtlasNearest)

	TEST_F (DisplayListRendering, DrawAtlasNearestNoPaint)

	TEST_F (DisplayListRendering, DrawAtlasLinear)

sk_sp< DisplayList >	makeTestDisplayList ()

	TEST_F (DisplayListRendering, DrawDisplayList)

	TEST_F (DisplayListRendering, DrawTextBlob)

	TEST_F (DisplayListRendering, DrawShadow)

	TEST_F (DisplayListRendering, DrawShadowTransparentOccluder)

	TEST_F (DisplayListRendering, DrawShadowDpr)

	TEST_F (DisplayListRendering, SaveLayerClippedContentStillFilters)

	TEST_F (DisplayListRendering, SaveLayerConsolidation)

	TEST_F (DisplayListRendering, MatrixColorFilterModifyTransparencyCheck)

	TEST_F (DisplayListRendering, MatrixColorFilterOpacityCommuteCheck)

static std::string	BlendModeToString (DlBlendMode mode)

	TEST_F (DisplayListRendering, BlendColorFilterModifyTransparencyCheck)

	TEST_F (DisplayListRendering, BlendColorFilterOpacityCommuteCheck)

	TEST_F (DisplayListNopTest, BlendModeAndColorViaColorFilter)

	TEST_F (DisplayListNopTest, BlendModeAndColorByRendering)

	TEST_F (DisplayListNopTest, BlendModeAndColorAndFiltersByRendering)

template<class T >
static void	TestEquals (T &source1, T &source2)

template<class T >
static void	TestNotEquals (T &source1, T &source2, const std::string &label)

sk_sp< DisplayList >	GetSampleDisplayList ()

sk_sp< DisplayList >	GetSampleNestedDisplayList ()

sk_sp< DisplayList >	GetSampleDisplayList (int ops)

std::vector< DisplayListInvocationGroup >	CreateAllAttributesOps ()

std::vector< DisplayListInvocationGroup >	CreateAllSaveRestoreOps ()

std::vector< DisplayListInvocationGroup >	CreateAllTransformOps ()

std::vector< DisplayListInvocationGroup >	CreateAllClipOps ()

std::vector< DisplayListInvocationGroup >	CreateAllRenderingOps ()

std::vector< DisplayListInvocationGroup >	CreateAllGroups ()

SkFont	CreateTestFontOfSize (SkScalar scalar)

sk_sp< SkTextBlob >	GetTestTextBlob (int index)

static sk_sp< DlImage >	MakeTestImage (int w, int h, int checker_size)

static const DlImageColorSource	kTestSource1 (TestImage1, DlTileMode::kClamp, DlTileMode::kMirror, kLinearSampling)

static const DlBlendColorFilter	kTestBlendColorFilter1 (DlColor::kRed(), DlBlendMode::kDstATop)

static const DlBlendColorFilter	kTestBlendColorFilter2 (DlColor::kBlue(), DlBlendMode::kDstATop)

static const DlBlendColorFilter	kTestBlendColorFilter3 (DlColor::kRed(), DlBlendMode::kDstIn)

static const DlMatrixColorFilter	kTestMatrixColorFilter1 (kRotateColorMatrix)

static const DlMatrixColorFilter	kTestMatrixColorFilter2 (kInvertColorMatrix)

static const DlBlurImageFilter	kTestBlurImageFilter1 (5.0, 5.0, DlTileMode::kClamp)

static const DlBlurImageFilter	kTestBlurImageFilter2 (6.0, 5.0, DlTileMode::kClamp)

static const DlBlurImageFilter	kTestBlurImageFilter3 (5.0, 6.0, DlTileMode::kClamp)

static const DlBlurImageFilter	kTestBlurImageFilter4 (5.0, 5.0, DlTileMode::kDecal)

static const DlDilateImageFilter	kTestDilateImageFilter1 (5.0, 5.0)

static const DlDilateImageFilter	kTestDilateImageFilter2 (6.0, 5.0)

static const DlDilateImageFilter	kTestDilateImageFilter3 (5.0, 6.0)

static const DlErodeImageFilter	kTestErodeImageFilter1 (4.0, 4.0)

static const DlErodeImageFilter	kTestErodeImageFilter2 (4.0, 3.0)

static const DlErodeImageFilter	kTestErodeImageFilter3 (3.0, 4.0)

static const DlMatrixImageFilter	kTestMatrixImageFilter1 (SkMatrix::RotateDeg(45), kNearestSampling)

static const DlMatrixImageFilter	kTestMatrixImageFilter2 (SkMatrix::RotateDeg(85), kNearestSampling)

static const DlMatrixImageFilter	kTestMatrixImageFilter3 (SkMatrix::RotateDeg(45), kLinearSampling)

static const DlComposeImageFilter	kTestComposeImageFilter1 (kTestBlurImageFilter1, kTestMatrixImageFilter1)

static const DlComposeImageFilter	kTestComposeImageFilter2 (kTestBlurImageFilter2, kTestMatrixImageFilter1)

static const DlComposeImageFilter	kTestComposeImageFilter3 (kTestBlurImageFilter1, kTestMatrixImageFilter2)

static const DlColorFilterImageFilter	kTestCFImageFilter1 (kTestBlendColorFilter1)

static const DlColorFilterImageFilter	kTestCFImageFilter2 (kTestBlendColorFilter2)

static const DlBlurMaskFilter	kTestMaskFilter1 (DlBlurStyle::kNormal, 3.0)

static const DlBlurMaskFilter	kTestMaskFilter2 (DlBlurStyle::kNormal, 5.0)

static const DlBlurMaskFilter	kTestMaskFilter3 (DlBlurStyle::kSolid, 3.0)

static const DlBlurMaskFilter	kTestMaskFilter4 (DlBlurStyle::kInner, 3.0)

static const DlBlurMaskFilter	kTestMaskFilter5 (DlBlurStyle::kOuter, 3.0)

static sk_sp< DisplayList >	MakeTestDisplayList (int w, int h, SkColor color)

	TEST (DisplayListAccumulationRect, Constructor)

	TEST (DisplayListAccumulationRect, OnePoint)

	TEST (DisplayListAccumulationRect, TwoPoints)

	TEST (DisplayListAccumulationRect, ThreePoints)

	TEST (DisplayListAccumulationRect, EmptyRect)

	TEST (DisplayListAccumulationRect, TwoRects)

	TEST (DisplayListMatrixClipState, Constructor)

	TEST (DisplayListMatrixClipState, Constructor4x4)

	TEST (DisplayListMatrixClipState, TransformTo4x4)

	TEST (DisplayListMatrixClipState, SetTo4x4)

	TEST (DisplayListMatrixClipState, Translate)

	TEST (DisplayListMatrixClipState, Scale)

	TEST (DisplayListMatrixClipState, Skew)

	TEST (DisplayListMatrixClipState, Rotate)

	TEST (DisplayListMatrixClipState, Transform2DAffine)

	TEST (DisplayListMatrixClipState, TransformFullPerspectiveUsing3x3Matrix)

	TEST (DisplayListMatrixClipState, TransformFullPerspectiveUsing4x4Matrix)

	TEST (DisplayListMatrixClipState, ClipDifference)

	TEST (DisplayListMatrixClipState, ClipPathWithInvertFillType)

	TEST (DisplayListMatrixClipState, DiffClipPathWithInvertFillType)

	TEST (DisplayListMatrixClipState, MapAndClipRectTranslation)

	TEST (DisplayListMatrixClipState, MapAndClipRectScale)

	TEST (DisplayListMatrixClipState, RectCoverage)

	TEST (DisplayListMatrixClipState, RectCoverageAccuracy)

	TEST (DisplayListMatrixClipState, RectCoverageUnderScale)

	TEST (DisplayListMatrixClipState, RectCoverageUnderRotation)

	TEST (DisplayListMatrixClipState, OvalCoverage)

	TEST (DisplayListMatrixClipState, OvalCoverageUnderScale)

	TEST (DisplayListMatrixClipState, OvalCoverageUnderRotation)

	TEST (DisplayListMatrixClipState, RRectCoverage)

	TEST_F (DiffContextTest, ClipAlignment)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithNoMutations)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithScale)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithTranslate)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithRotation90)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithRotation45)

	TEST (EmbeddedViewParams, GetBoundingRectAfterMutationsWithTranslateScaleAndRotation)

	TEST (GLContextSwitchTest, SwitchKeepsContextCurrentWhileInScope)

	TEST_F (BackdropFilterLayerTest, PaintingEmptyLayerDies)

	TEST_F (BackdropFilterLayerTest, PaintBeforePrerollDies)

	TEST_F (BackdropFilterLayerTest, EmptyFilter)

	TEST_F (BackdropFilterLayerTest, SimpleFilter)

	TEST_F (BackdropFilterLayerTest, NonSrcOverBlend)

	TEST_F (BackdropFilterLayerTest, MultipleChildren)

	TEST_F (BackdropFilterLayerTest, Nested)

	TEST_F (BackdropFilterLayerTest, Readback)

	TEST_F (BackdropFilterLayerTest, OpacityInheritance)

	TEST_F (BackdropLayerDiffTest, BackdropLayer)

	TEST_F (BackdropLayerDiffTest, ReadbackOutsideOfPaintArea)

	TEST_F (BackdropLayerDiffTest, BackdropLayerInvalidTransform)

	TEST_F (ClipPathLayerTest, ClipNoneBehaviorDies)

	TEST_F (ClipPathLayerTest, PaintingCulledLayerDies)

	TEST_F (ClipPathLayerTest, ChildOutsideBounds)

	TEST_F (ClipPathLayerTest, FullyContainedChild)

	TEST_F (ClipPathLayerTest, PartiallyContainedChild)

static bool	ReadbackResult (PrerollContext *context, Clip clip_behavior, const std::shared_ptr< Layer > &child, bool before)

	TEST_F (ClipPathLayerTest, OpacityInheritancePainting)

	TEST_F (ClipPathLayerTest, OpacityInheritanceSaveLayerPainting)

	TEST_F (ClipPathLayerTest, LayerCached)

	TEST_F (ClipPathLayerTest, EmptyClipDoesNotCullPlatformView)

static bool	ReadbackResult (PrerollContext *context, Clip clip_behavior, const std::shared_ptr< Layer > &child, bool before)

static bool	ReadbackResult (PrerollContext *context, Clip clip_behavior, const std::shared_ptr< Layer > &child, bool before)

	TEST_F (ClipRRectLayerTest, NoSaveLayerShouldNotCache)

	TEST_F (ColorFilterLayerTest, CacheChild)

	TEST_F (ColorFilterLayerTest, CacheChildren)

	TEST_F (ColorFilterLayerTest, CacheColorFilterLayerSelf)

	TEST_F (ContainerLayerTest, LayerWithParentHasPlatformView)

	TEST_F (ContainerLayerTest, LayerWithParentHasTextureLayer)

	TEST_F (ContainerLayerTest, LayerWithParentHasTextureLayerNeedsResetFlag)

	TEST_F (ContainerLayerTest, Simple)

	TEST_F (ContainerLayerTest, Multiple)

	TEST_F (ContainerLayerTest, MultipleWithEmpty)

	TEST_F (ContainerLayerTest, NeedsSystemComposite)

	TEST_F (ContainerLayerTest, RasterCacheTest)

	TEST_F (ContainerLayerTest, CollectionCacheableLayer)

	TEST_F (ContainerLayerDiffTest, PictureLayerInsertion)

	TEST_F (ContainerLayerDiffTest, PictureInsertion)

	TEST_F (ContainerLayerDiffTest, LayerDeletion)

	TEST_F (ContainerLayerDiffTest, ReplaceLayer)

	TEST_F (DisplayListLayerTest, PaintBeforePrerollInvalidDisplayListDies)

	TEST_F (DisplayListLayerTest, InvalidDisplayListDies)

	TEST_F (DisplayListLayerTest, SimpleDisplayList)

	TEST_F (DisplayListLayerTest, CachingDoesNotChangeCullRect)

	TEST_F (DisplayListLayerTest, SimpleDisplayListOpacityInheritance)

	TEST_F (DisplayListLayerTest, IncompatibleDisplayListOpacityInheritance)

	TEST_F (DisplayListLayerTest, CachedIncompatibleDisplayListOpacityInheritance)

	TEST_F (DisplayListLayerTest, RasterCachePreservesRTree)

	TEST_F (DisplayListLayerDiffTest, SimpleDisplayList)

	TEST_F (DisplayListLayerDiffTest, FractionalTranslation)

	TEST_F (DisplayListLayerDiffTest, FractionalTranslationWithRasterCache)

	TEST_F (DisplayListLayerDiffTest, DisplayListCompare)

	TEST_F (DisplayListLayerTest, LayerTreeSnapshotsWhenEnabled)

	TEST_F (DisplayListLayerTest, NoLayerTreeSnapshotsWhenDisabledByDefault)

	TEST_F (DisplayListLayerTest, DisplayListAccessCountDependsOnVisibility)

	TEST_F (DisplayListLayerTest, OverflowCachedDisplayListOpacityInheritance)

	TEST_F (ImageFilterLayerTest, SimpleFilterWithOffset)

	TEST_F (ImageFilterLayerTest, SimpleFilterBounds)

	TEST_F (ImageFilterLayerTest, CacheImageFilterLayerSelf)

	TEST_F (ImageFilterLayerDiffTest, ImageFilterLayer)

	TEST_F (ImageFilterLayerDiffTest, ImageFilterLayerInflatestChildSize)

	TEST_F (ImageFilterLayerTest, EmptyFilterWithOffset)

	TEST (LayerStateStack, AccessorsDieWithoutDelegate)

	TEST (LayerStateStack, Defaults)

	TEST (LayerStateStack, SingularDelegate)

	TEST (LayerStateStack, OldDelegateIsRolledBack)

	TEST (LayerStateStack, Opacity)

	TEST (LayerStateStack, ColorFilter)

	TEST (LayerStateStack, ImageFilter)

	TEST (LayerStateStack, OpacityAndColorFilterInteraction)

	TEST (LayerStateStack, OpacityAndImageFilterInteraction)

	TEST (LayerStateStack, ColorFilterAndImageFilterInteraction)

	TEST_F (LayerTreeTest, PaintingEmptyLayerDies)

	TEST_F (LayerTreeTest, PaintBeforePrerollDies)

	TEST_F (LayerTreeTest, Simple)

	TEST_F (LayerTreeTest, Multiple)

	TEST_F (LayerTreeTest, MultipleWithEmpty)

	TEST_F (LayerTreeTest, NeedsSystemComposite)

	TEST_F (LayerTreeTest, PrerollContextInitialization)

	TEST_F (LayerTreeTest, PaintContextInitialization)

	TEST (OffscreenSurfaceTest, EmptySurfaceIsInvalid)

	TEST (OffscreenSurfaceTest, OnexOneSurfaceIsValid)

	TEST (OffscreenSurfaceTest, PaintSurfaceBlack)

	TEST_F (OpacityLayerTest, TranslateChildren)

	TEST_F (OpacityLayerTest, ShouldNotCacheChildren)

	TEST_F (OpacityLayerTest, FullyOpaque)

	TEST_F (OpacityLayerTest, FullyTransparent)

	TEST_F (OpacityLayerTest, HalfTransparent)

	TEST_F (OpacityLayerTest, CullRectIsTransformed)

	TEST_F (OpacityLayerTest, OpacityInheritanceCompatibleChild)

	TEST_F (OpacityLayerTest, OpacityInheritanceIncompatibleChild)

	TEST_F (OpacityLayerTest, OpacityInheritanceThroughContainer)

	TEST_F (OpacityLayerTest, OpacityInheritanceThroughTransform)

	TEST_F (OpacityLayerTest, OpacityInheritanceThroughImageFilter)

	TEST_F (OpacityLayerTest, OpacityInheritanceNestedWithCompatibleChild)

	TEST_F (OpacityLayerTest, OpacityInheritanceNestedWithIncompatibleChild)

	TEST_F (OpacityLayerTest, FullyOpaqueWithFractionalValues)

	TEST_F (OpacityLayerTest, FullyTransparentDoesNotCullPlatformView)

	TEST_F (PerformanceOverlayLayerTest, InvalidOptions)

	TEST_F (PerformanceOverlayLayerTest, SimpleRasterizerStatistics)

	TEST_F (PerformanceOverlayLayerTest, MarkAsDirtyWhenResized)

	TEST (PerformanceOverlayLayerDefault, Gold)

	TEST (PerformanceOverlayLayer90fps, Gold)

	TEST (PerformanceOverlayLayer120fps, Gold)

	TEST_F (PlatformViewLayerTest, NullViewEmbedderDoesntPrerollCompositeOrPaint)

	TEST_F (PlatformViewLayerTest, ClippedPlatformViewPrerollsAndPaintsNothing)

	TEST_F (PlatformViewLayerTest, StateTransfer)

static std::shared_ptr< DlColorSource >	MakeFilter (DlColor color)

	TEST_F (ShaderMaskLayerTest, SimpleFilterWithRasterCacheLayerNotCached)

	TEST_F (TextureLayerTest, InvalidTexture)

	TEST_F (TextureLayerTest, PaintingWithLinearSampling)

	TEST_F (TextureLayerDiffTest, TextureInRetainedLayer)

	TEST_F (TransformLayerTest, Identity)

	TEST_F (TransformLayerTest, SimpleM44)

	TEST_F (TransformLayerTest, ComplexM44)

	TEST_F (TransformLayerTest, NestedSeparated)

	TEST_F (TransformLayerLayerDiffTest, Transform)

	TEST_F (TransformLayerLayerDiffTest, TransformNested)

	TEST (MutatorsStack, Initialization)

	TEST (MutatorsStack, CopyConstructor)

	TEST (MutatorsStack, CopyAndUpdateTheCopy)

	TEST (MutatorsStack, PushClipRect)

	TEST (MutatorsStack, PushClipRRect)

	TEST (MutatorsStack, PushClipPath)

	TEST (MutatorsStack, PushTransform)

	TEST (MutatorsStack, PushOpacity)

	TEST (MutatorsStack, PushBackdropFilter)

	TEST (MutatorsStack, Pop)

	TEST (MutatorsStack, Traversal)

	TEST (MutatorsStack, Equality)

	TEST (Mutator, Initialization)

	TEST (Mutator, CopyConstructor)

	TEST (Mutator, Equality)

	TEST (Mutator, UnEquality)

	TEST (RasterCache, SimpleInitialization)

	TEST (RasterCache, MetricsOmitUnpopulatedEntries)

	TEST (RasterCache, ThresholdIsRespectedForDisplayList)

	TEST (RasterCache, AccessThresholdOfZeroDisablesCachingForDisplayList)

	TEST (RasterCache, PictureCacheLimitPerFrameIsRespectedWhenZeroForDisplayList)

	TEST (RasterCache, EvictUnusedCacheEntries)

	TEST (RasterCache, ComputeDeviceRectBasedOnFractionalTranslation)

	TEST (RasterCache, DeviceRectRoundOutForDisplayList)

	TEST (RasterCache, NestedOpCountMetricUsedForDisplayList)

	TEST (RasterCache, NaiveComplexityScoringDisplayList)

	TEST (RasterCache, DisplayListWithSingularMatrixIsNotCached)

	TEST (RasterCache, PrepareLayerTransform)

	TEST (RasterCache, RasterCacheKeyHashFunction)

	TEST (RasterCache, RasterCacheKeySameID)

	TEST (RasterCache, RasterCacheKeySameType)

	TEST (RasterCache, RasterCacheKeyIDEqual)

	TEST (RasterCache, RasterCacheKeyIDHashCode)

	TEST_F (RasterCacheTest, RasterCacheKeyIDLayerChildrenIds)

	TEST (RasterCacheUtilsTest, SkMatrixIntegralTransCTM)

	TEST (RasterCacheUtilsTest, SkM44IntegralTransCTM)

	TEST_F (SkiaGpuObjectTest, QueueSimple)

	TEST_F (SkiaGpuObjectTest, ObjectDestructor)

	TEST_F (SkiaGpuObjectTest, ObjectReset)

	TEST_F (SkiaGpuObjectTest, ObjectResetTwice)

	TEST_F (SkiaGpuObjectTest, UnrefResourceContextInTaskRunnerThread)

static SkRect	MakeRectFromVertices (SkPoint vertices[6])

	TEST (DlVertexPainter, DrawRectIntoVertices)

	TEST (Instrumentation, GetDefaultFrameBudgetTest)

	TEST (Instrumentation, GetOneShotFrameBudgetTest)

	TEST (Instrumentation, GetFrameBudgetFromUpdaterTest)

	TEST (Instrumentation, GetLapByIndexTest)

	TEST (Instrumentation, GetCurrentSampleTest)

	TEST (Instrumentation, GetLapsCount)

	TEST_F (MockLayerTest, SimpleParams)

	TEST_F (MockLayerTest, FakePlatformView)

	TEST_F (MockLayerTest, SaveLayerOnLeafNodesCanvas)

	TEST_F (MockLayerTest, FlagGetSet)

PrerollContextHolder	GetSamplePrerollContextHolder (LayerStateStack &state_stack, RasterCache raster_cache, FixedRefreshRateStopwatch raster_time, FixedRefreshRateStopwatch *ui_time)

PaintContextHolder	GetSamplePaintContextHolder (LayerStateStack &state_stack, RasterCache raster_cache, FixedRefreshRateStopwatch raster_time, FixedRefreshRateStopwatch *ui_time)

bool	RasterCacheItemPrerollAndTryToRasterCache (DisplayListRasterCacheItem &display_list_item, PrerollContext &context, PaintContext &paint_context, const SkMatrix &matrix)

void	RasterCacheItemPreroll (DisplayListRasterCacheItem &display_list_item, PrerollContext &context, const SkMatrix &matrix)

bool	RasterCacheItemTryToRasterCache (DisplayListRasterCacheItem &display_list_item, PaintContext &paint_context)

	TEST (MockTextureTest, Callbacks)

	TEST (MockTextureTest, PaintCalls)

	TEST (MockTextureTest, PaintCallsWithLinearSampling)

	TEST (TextureRegistryTest, UnregisterTextureCallbackTriggered)

	TEST (TextureRegistryTest, GrContextCallbackTriggered)

	TEST (TextureRegistryTest, RegisterTextureTwice)

	TEST (TextureRegistryTest, ReuseSameTextureSlot)

	TEST (TextureRegistryTest, CallsOnGrContextCreatedInInsertionOrder)

	TEST (MathTest, Constants)

	TEST_P (DlGoldenTest, TextBlurMaskFilterRespectCTM)

	TEST_P (DlGoldenTest, TextBlurMaskFilterDisrespectCTM)

	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, DashedLinesTest)

	TEST_F (ShellTest, SceneBuilderBuildAndSceneDisposeReleasesLayerStack)

	TEST_F (ShellTest, EngineLayerDisposeReleasesReference)

	TEST_F (HooksTest, HooksUnitTests)

float	HalfToFloat (uint16_t half)

float	DecodeBGR10 (uint32_t x)

	TEST (ImageDecoderNoGLTest, ImpellerWideGamutDisplayP3)

	TEST (ImageDecoderNoGLTest, ImpellerWideGamutIndexedPng)

	TEST_F (ImageDecoderFixtureTest, CanCreateImageDecoder)

	TEST_F (ImageDecoderFixtureTest, InvalidImageResultsError)

	TEST_F (ImageDecoderFixtureTest, ValidImageResultsInSuccess)

	TEST_F (ImageDecoderFixtureTest, ImpellerUploadToSharedNoGpu)

	TEST_F (ImageDecoderFixtureTest, ImpellerNullColorspace)

	TEST_F (ImageDecoderFixtureTest, ImpellerPixelConversion32F)

	TEST_F (ImageDecoderFixtureTest, ImpellerWideGamutDisplayP3Opaque)

	TEST_F (ImageDecoderFixtureTest, ImpellerNonWideGamut)

	TEST_F (ImageDecoderFixtureTest, ExifDataIsRespectedOnDecode)

	TEST_F (ImageDecoderFixtureTest, CanDecodeWithoutAGPUContext)

	TEST_F (ImageDecoderFixtureTest, CanDecodeWithResizes)

	TEST (ImageDecoderTest, VerifyCodecRepeatCountsForGifAndWebPAreConsistentWithLoopCounts)

	TEST (ImageDecoderTest, VerifySimpleDecoding)

	TEST (ImageDecoderTest, ImagesWithTransparencyArePremulAlpha)

	TEST (ImageDecoderTest, VerifySubpixelDecodingPreservesExifOrientation)

	TEST_F (ImageDecoderFixtureTest, MultiFrameCodecCanBeCollectedBeforeIOTasksFinish)

	TEST_F (ImageDecoderFixtureTest, MultiFrameCodecDidAccessGpuDisabledSyncSwitch)

	TEST_F (ImageDecoderFixtureTest, MultiFrameCodecProducesATextureEvenIfGPUIsDisabledOnImpeller)

	TEST_F (ImageDecoderFixtureTest, NullCheckBuffer)

	TEST_F (ImageDisposeTest, ImageReleasedAfterFrameAndDisposePictureAndLayer)

	TEST_F (ShellTest, EncodeImageGivesExternalTypedData)

	TEST_F (ShellTest, EncodeImageAccessesSyncSwitch)

static sk_sp< SkData >	LoadValidImageFixture ()

	TEST_F (ShellTest, CreateCompatibleReturnsBuiltinImageGeneratorForValidImage)

	TEST_F (ShellTest, CreateCompatibleReturnsNullptrForInvalidImage)

	TEST_F (ShellTest, PositivePriorityTakesPrecedentOverDefaultGenerators)

	TEST_F (ShellTest, DefaultGeneratorsTakePrecedentOverNegativePriority)

	TEST_F (ShellTest, DefaultGeneratorsTakePrecedentOverZeroPriority)

	TEST_F (ShellTest, ImageGeneratorsWithSamePriorityCascadeChronologically)

	TEST_F (ShellTest, ConvertPaintToDlPaint)

	TEST_F (ShellTest, PathVolatilityOldPathsBecomeNonVolatile)

	TEST_F (ShellTest, PathVolatilityGCRemovesPathFromTracker)

	TEST_F (ShellTest, DeterministicRenderingDisablesPathVolatility)

	TEST_F (ShellTest, SingleFrameCodecAccuratelyReportsSize)

	TEST_F (SemanticsUpdateBuilderTest, CanHandleAttributedStrings)

	TEST_F (PlatformConfigurationTest, Initialization)

	TEST_F (PlatformConfigurationTest, WindowMetricsUpdate)

	TEST_F (PlatformConfigurationTest, GetWindowReturnsNullForNonexistentId)

	TEST_F (PlatformConfigurationTest, OnErrorHandlesError)

	TEST_F (PlatformConfigurationTest, OnErrorDoesNotHandleError)

	TEST_F (PlatformConfigurationTest, OnErrorThrows)

	TEST_F (PlatformConfigurationTest, SetDartPerformanceMode)

	TEST_F (ShellTest, PlatformMessageResponseDartPort)

	TEST_F (ShellTest, PlatformMessageResponseDart)

void	CreateSimulatedPointerData (PointerData &data, PointerData::Change change, int64_t device, double dx, double dy, int64_t buttons)

void	CreateSimulatedMousePointerData (PointerData &data, PointerData::Change change, PointerData::SignalKind signal_kind, int64_t device, double dx, double dy, double scroll_delta_x, double scroll_delta_y, int64_t buttons)

void	CreateSimulatedTrackpadGestureData (PointerData &data, PointerData::Change change, int64_t device, double dx, double dy, double pan_x, double pan_y, double scale, double rotation)

void	UnpackPointerPacket (std::vector< PointerData > &output, std::unique_ptr< PointerDataPacket > packet)

	TEST (PointerDataPacketConverterTest, CanConvertPointerDataPacket)

	TEST (PointerDataPacketConverterTest, CanSynthesizeDownAndUp)

	TEST (PointerDataPacketConverterTest, CanUpdatePointerIdentifier)

	TEST (PointerDataPacketConverterTest, AlwaysForwardMoveEvent)

	TEST (PointerDataPacketConverterTest, CanWorkWithDifferentDevices)

	TEST (PointerDataPacketConverterTest, CanSynthesizeAdd)

	TEST (PointerDataPacketConverterTest, CanHandleThreeFingerGesture)

	TEST (PointerDataPacketConverterTest, CanConvertPointerSignals)

	TEST (PointerDataPacketConverterTest, CanConvertTrackpadGesture)

	TEST (PointerDataPacketConverterTest, CanConvertViewId)

void	CreateSimpleSimulatedPointerData (PointerData &data, PointerData::Change change, int64_t device, double dx, double dy, int64_t buttons)

	TEST (PointerDataPacketTest, CanGetPointerData)

	TEST (PointerDataPacketTest, CanGetLength)

	TEST_F (DartIsolateTest, RootIsolateCreationAndShutdown)

	TEST_F (DartIsolateTest, IsolateShutdownCallbackIsInIsolateScope)

	TEST_F (DartIsolateTest, IsolateCanLoadAndRunDartCode)

	TEST_F (DartIsolateTest, IsolateCannotLoadAndRunUnknownDartEntrypoint)

	TEST_F (DartIsolateTest, CanRunDartCodeCodeSynchronously)

	TEST_F (DartIsolateTest, ImpellerFlagIsCorrectWhenTrue)

	TEST_F (DartIsolateTest, ImpellerFlagIsCorrectWhenFalse)

	TEST_F (DartIsolateTest, CanRegisterNativeCallback)

	TEST_F (DartSecondaryIsolateTest, CanLaunchSecondaryIsolates)

	TEST_F (IsolateStartupFailureTest, HandlesIsolateInitializationFailureCorrectly)

	TEST_F (DartIsolateTest, CanReceiveArguments)

	TEST_F (DartIsolateTest, CanCreateServiceIsolate)

	TEST_F (DartIsolateTest, RootIsolateCreateCallbackIsMadeOnceAndBeforeIsolateRunning)

	TEST_F (DartIsolateTest, IsolateCreateCallbacksTakeInstanceSettingsInsteadOfVMSettings)

	TEST_F (DartIsolateTest, InvalidLoadingUnitFails)

	TEST_F (DartIsolateTest, DartPluginRegistrantIsCalled)

	TEST_F (DartIsolateTest, SpawningAnIsolateDoesNotReloadKernel)

	TEST_F (DartIsolateTest, PlatformIsolateCreationAndShutdown)

	TEST_F (DartIsolateTest, PlatformIsolateEarlyShutdown)

	TEST_F (DartIsolateTest, PlatformIsolateSendAndReceive)

	TEST_F (DartIsolateTest, PlatformIsolateCreationAfterManagerShutdown)

	TEST_F (DartIsolateTest, PlatformIsolateManagerShutdownBeforeMainRuns)

	TEST_F (DartIsolateTest, PlatformIsolateMainThrowsError)

	TEST_F (DartLifecycleTest, CanStartAndShutdownVM)

	TEST_F (DartLifecycleTest, CanStartAndShutdownVMOverAndOver)

static std::shared_ptr< DartIsolate >	CreateAndRunRootIsolate (const Settings &settings, const DartVMData &vm, const fml::RefPtr< fml::TaskRunner > &task_runner, std::string entrypoint)

	TEST_F (DartLifecycleTest, DISABLED_ShuttingDownTheVMShutsDownAllIsolates)

	TEST_F (DartIsolateTest, DartPluginRegistrantIsPresent)

	TEST_F (DartIsolateTest, DartPluginRegistrantFromBackgroundIsolate)

	TEST_F (DartIsolateTest, DartPluginRegistrantNotFromBackgroundIsolate)

	TEST_F (DartIsolateTest, DartPluginRegistrantWhenRegisteringBackgroundIsolate)

	TEST_F (DartVMTest, SimpleInitialization)

	TEST_F (DartVMTest, SimpleIsolateNameServer)

	TEST_F (DartVMTest, OldGenHeapSize)

	TEST_F (DartVMTest, DisableTimelineEventHandler)

	TEST_F (DartVMTest, TraceGetTimelineMicrosDoesNotGetClockWhenSystraceIsEnabled)

	TEST_F (DartIsolateTest, DartPluginRegistrantIsNotPresent)

	TEST_F (PlatformIsolateManagerTest, OrdinaryFlow)

	TEST_F (PlatformIsolateManagerTest, EarlyShutdown)

	TEST_F (PlatformIsolateManagerTest, RegistrationAfterShutdown)

	TEST_F (PlatformIsolateManagerTest, MultithreadedCreation)

	TEST_F (TypeConversionsTest, TestFixture)

	TEST_F (TypeConversionsTest, CanConvertEmptyList)

	TEST_F (TypeConversionsTest, CanConvertListOfStrings)

	TEST_F (TypeConversionsTest, CanConvertListOfDoubles)

	TEST_F (TypeConversionsTest, CanConvertListOfInts)

	TEST_F (ShellTest, VSyncTargetTime)

	TEST_F (ShellTest, AnimatorDoesNotNotifyIdleBeforeRender)

	TEST_F (ShellTest, AnimatorDoesNotNotifyDelegateIfPipelineIsNotEmpty)

	TEST (Base64, EncodeStrings)

	TEST (Base64, EncodeBytes)

	TEST (Base64, DecodeStringsSuccess)

	TEST (Base64, DecodeStringsHasErrors)

	TEST (Base64, DecodeBytes)

	TEST (ContextOptionsTest, OpenGLDisablesStencilBuffers)

	TEST (DlOpSpy, DidDrawIsFalseByDefault)

	TEST (DlOpSpy, EmptyDisplayList)

	TEST (DlOpSpy, SetColor)

	TEST (DlOpSpy, SetColorSource)

	TEST (DlOpSpy, DrawColor)

	TEST (DlOpSpy, DrawPaint)

	TEST (DlOpSpy, DrawLine)

	TEST (DlOpSpy, DrawDashedLine)

	TEST (DlOpSpy, DrawRect)

	TEST (DlOpSpy, DrawOval)

	TEST (DlOpSpy, DrawCircle)

	TEST (DlOpSpy, DrawRRect)

	TEST (DlOpSpy, DrawPath)

	TEST (DlOpSpy, DrawArc)

	TEST (DlOpSpy, DrawPoints)

	TEST (DlOpSpy, DrawVertices)

	TEST (DlOpSpy, Images)

	TEST (DlOpSpy, DrawDisplayList)

	TEST (DlOpSpy, DrawTextBlob)

	TEST (DlOpSpy, DrawShadow)

static void	TestSimulatedInputEvents (ShellTest *fixture, int num_events, UnitlessTime base_latency, Generator delivery_time, UnitlessTime frame_time, std::vector< UnitlessTime > &events_consumed_at_frame, bool restart_engine=false)

void	CreateSimulatedPointerData (PointerData &data, PointerData::Change change, double dx, double dy)

	TEST_F (ShellTest, MissAtMostOneFrameForIrregularInputEvents)

	TEST_F (ShellTest, DelayAtMostOneEventForFasterThanVSyncInputEvents)

	TEST_F (ShellTest, HandlesActualIphoneXsInputEvents)

	TEST_F (ShellTest, CanCorrectlyPipePointerPacket)

	TEST_F (ShellTest, CanCorrectlySynthesizePointerPacket)

static void	CheckTextSkData (const sk_sp< SkData > &data, const std::string &expected)

static void	ResetAssetManager ()

static void	CheckTwoSkSLsAreLoaded ()

	TEST_F (PersistentCacheTest, CanLoadSkSLsFromAsset)

	TEST_F (PersistentCacheTest, CanRemoveOldPersistentCache)

	TEST_F (PersistentCacheTest, CanPurgePersistentCache)

	TEST_F (PersistentCacheTest, PurgeAllowsFutureSkSLCache)

	TEST (PipelineTest, ConsumeOneVal)

	TEST (PipelineTest, ContinuationCanOnlyBeUsedOnce)

	TEST (PipelineTest, PushingMoreThanDepthCompletesFirstSubmission)

	TEST (PipelineTest, PushingMultiProcessesInOrder)

	TEST (PipelineTest, ProduceIfEmptyDoesNotConsumeWhenQueueIsNotEmpty)

	TEST (PipelineTest, ProduceIfEmptySuccessfulIfQueueIsEmpty)

	TEST (ResourceCacheLimitCalculatorTest, GetResourceCacheMaxBytes)

	TEST_F (FuchsiaShellTest, LocaltimesVaryOnTimezoneChanges)

	TEST_F (ShellIOManagerTest, ItDoesNotCrashThatSkiaUnrefQueueDrainAfterIOManagerReset)

static std::vector< std::shared_ptr< fml::Mapping > >	ShaderLibraryMappings ()

static fml::scoped_nsprotocol< id< MTLTexture > >	CreateOffscreenTexture (id< MTLDevice > device)

static bool	ValidateShell (Shell *shell)

static bool	RasterizerIsTornDown (Shell *shell)

static void	ValidateDestroyPlatformView (Shell *shell)

static std::string	CreateFlagsString (std::vector< const char * > &flags)

static void	TestDartVmFlags (std::vector< const char * > &flags)

static void	PostSync (const fml::RefPtr< fml::TaskRunner > &task_runner, const fml::closure &task)

static sk_sp< DisplayList >	MakeSizedDisplayList (int width, int height)

	TEST_F (ShellTest, InitializeWithInvalidThreads)

	TEST_F (ShellTest, InitializeWithDifferentThreads)

	TEST_F (ShellTest, InitializeWithSingleThread)

	TEST_F (ShellTest, InitializeWithSingleThreadWhichIsTheCallingThread)

	TEST_F (ShellTest, InitializeWithMultipleThreadButCallingThreadAsPlatformThread)

	TEST_F (ShellTest, InitializeWithDisabledGpu)

	TEST_F (ShellTest, InitializeWithGPUAndPlatformThreadsTheSame)

	TEST_F (ShellTest, FixturesAreFunctional)

	TEST_F (ShellTest, SecondaryIsolateBindingsAreSetupViaShellSettings)

	TEST_F (ShellTest, LastEntrypoint)

	TEST_F (ShellTest, LastEntrypointArgs)

	TEST_F (ShellTest, DisallowedDartVMFlag)

	TEST_F (ShellTest, AllowedDartVMFlag)

	TEST_F (ShellTest, NoNeedToReportTimingsByDefault)

	TEST_F (ShellTest, NeedsReportTimingsIsSetWithCallback)

static void	CheckFrameTimings (const std::vector< FrameTiming > &timings, fml::TimePoint start, fml::TimePoint finish)

	TEST_F (ShellTest, ReportTimingsIsCalled)

	TEST_F (ShellTest, FrameRasterizedCallbackIsCalled)

	TEST_F (ShellTest, ExternalEmbedderNoThreadMerger)

	TEST_F (ShellTest, PushBackdropFilterToVisitedPlatformViews)

	TEST_F (ShellTest, ExternalEmbedderEndFrameIsCalledWhenPostPrerollResultIsResubmit)

	TEST_F (ShellTest, OnPlatformViewDestroyDisablesThreadMerger)

	TEST_F (ShellTest, OnPlatformViewDestroyAfterMergingThreads)

	TEST_F (ShellTest, OnPlatformViewDestroyWhenThreadsAreMerging)

	TEST_F (ShellTest, OnPlatformViewDestroyWithThreadMergerWhileThreadsAreUnmerged)

	TEST_F (ShellTest, OnPlatformViewDestroyWithoutRasterThreadMerger)

	TEST_F (ShellTest, OnPlatformViewDestroyWithStaticThreadMerging)

	TEST_F (ShellTest, GetUsedThisFrameShouldBeSetBeforeEndFrame)

	TEST_F (ShellTest, DISABLED_SkipAndSubmitFrame)

	TEST (SettingsTest, FrameTimingSetsAndGetsProperly)

	TEST_F (ShellTest, ReportTimingsIsCalledImmediatelyAfterTheFirstFrame)

	TEST_F (ShellTest, WaitForFirstFrame)

	TEST_F (ShellTest, WaitForFirstFrameZeroSizeFrame)

	TEST_F (ShellTest, WaitForFirstFrameTimeout)

	TEST_F (ShellTest, WaitForFirstFrameMultiple)

	TEST_F (ShellTest, WaitForFirstFrameInlined)

static size_t	GetRasterizerResourceCacheBytesSync (const Shell &shell)

	TEST_F (ShellTest, MultipleFluttersSetResourceCacheBytes)

	TEST_F (ShellTest, SetResourceCacheSize)

	TEST_F (ShellTest, SetResourceCacheSizeEarly)

	TEST_F (ShellTest, SetResourceCacheSizeNotifiesDart)

	TEST_F (ShellTest, CanCreateImagefromDecompressedBytes)

	TEST_F (ShellTest, TextureFrameMarkedAvailableAndUnregister)

	TEST_F (ShellTest, IsolateCanAccessPersistentIsolateData)

	TEST_F (ShellTest, CanScheduleFrameFromPlatform)

	TEST_F (ShellTest, SecondaryVsyncCallbackShouldBeCalledAfterVsyncCallback)

static void	LogSkData (const sk_sp< SkData > &data, const char *title)

	TEST_F (ShellTest, Screenshot)

	TEST_F (ShellTest, LocaltimesMatch)

	TEST_F (ShellTest, CanRegisterImageDecoders)

	TEST_F (ShellTest, OnServiceProtocolGetSkSLsWorks)

	TEST_F (ShellTest, RasterizerScreenshot)

	TEST_F (ShellTest, RasterizerMakeRasterSnapshot)

	TEST_F (ShellTest, OnServiceProtocolEstimateRasterCacheMemoryWorks)

	TEST_F (ShellTest, OnServiceProtocolRenderFrameWithRasterStatsWorks)

	TEST_F (ShellTest, DISABLED_DiscardLayerTreeOnResize)

	TEST_F (ShellTest, DISABLED_DiscardResubmittedLayerTreeOnResize)

	TEST_F (ShellTest, IgnoresInvalidMetrics)

	TEST_F (ShellTest, IgnoresMetricsUpdateToInvalidView)

	TEST_F (ShellTest, OnServiceProtocolSetAssetBundlePathWorks)

	TEST_F (ShellTest, EngineRootIsolateLaunchesDontTakeVMDataSettings)

	TEST_F (ShellTest, AssetManagerSingle)

	TEST_F (ShellTest, AssetManagerMulti)

	TEST_F (ShellTest, Spawn)

	TEST_F (ShellTest, SpawnWithDartEntrypointArgs)

	TEST_F (ShellTest, IOManagerIsSharedBetweenParentAndSpawnedShell)

	TEST_F (ShellTest, IOManagerInSpawnedShellIsNotNullAfterParentShellDestroyed)

	TEST_F (ShellTest, ImageGeneratorRegistryNotNullAfterParentShellDestroyed)

	TEST_F (ShellTest, UpdateAssetResolverByTypeReplaces)

	TEST_F (ShellTest, UpdateAssetResolverByTypeAppends)

	TEST_F (ShellTest, UpdateAssetResolverByTypeNull)

	TEST_F (ShellTest, UpdateAssetResolverByTypeDoesNotReplaceMismatchType)

	TEST_F (ShellTest, CanCreateShellsWithGLBackend)

	TEST_F (ShellTest, CanCreateShellsWithVulkanBackend)

	TEST_F (ShellTest, CanCreateShellsWithMetalBackend)

	TEST_F (ShellTest, UserTagSetOnStartup)

	TEST_F (ShellTest, PrefetchDefaultFontManager)

	TEST_F (ShellTest, OnPlatformViewCreatedWhenUIThreadIsBusy)

	TEST_F (ShellTest, UIWorkAfterOnPlatformViewDestroyed)

	TEST_F (ShellTest, UsesPlatformMessageHandler)

	TEST_F (ShellTest, SpawnWorksWithOnError)

	TEST_F (ShellTest, ImmutableBufferLoadsAssetOnBackgroundThread)

	TEST_F (ShellTest, PictureToImageSync)

	TEST_F (ShellTest, PictureToImageSyncImpellerNoSurface)

	TEST_F (ShellTest, PluginUtilitiesCallbackHandleErrorHandling)

	TEST_F (ShellTest, NotifyIdleRejectsPastAndNearFuture)

	TEST_F (ShellTest, NotifyIdleNotCalledInLatencyMode)

	TEST_F (ShellTest, NotifyDestroyed)

	TEST_F (ShellTest, PrintsErrorWhenPlatformMessageSentFromWrongThread)

	TEST_F (ShellTest, DiesIfSoftwareRenderingAndImpellerAreEnabledDeathTest)

static void	ParseViewIdsCallback (const Dart_NativeArguments &args, bool hasImplicitView, std::vector< int64_t > viewIds)

	TEST_F (ShellTest, ShellStartsWithImplicitView)

	TEST_F (ShellTest, ShellCanAddViewOrRemoveView)

	TEST_F (ShellTest, ShellCannotAddDuplicateViewId)

	TEST_F (ShellTest, ShellCannotRemoveNonexistentId)

static void	ParseViewWidthsCallback (const Dart_NativeArguments &args, std::map< int64_t, int64_t > *viewWidths)

	TEST_F (ShellTest, ShellFlushesPlatformStatesByMain)

	TEST_F (ShellTest, CanRemoveViewBeforeLaunchingIsolate)

	TEST_F (ShellTest, IgnoresBadAddViewsBeforeLaunchingIsolate)

	TEST_F (ShellTest, RuntimeStageBackendDefaultsToSkSLWithoutImpeller)

	TEST_F (ShellTest, WillLogWarningWhenImpellerIsOptedOut)

	TEST (SwitchesTest, SkiaTraceAllowlistFlag)

	TEST (SwitchesTest, TraceToFile)

	TEST (SwitchesTest, RouteParsedFlag)

	TEST (SwitchesTest, EnableEmbedderAPI)

	TEST (SwitchesTest, NoEnableImpeller)

	TEST (SwitchesTest, EnableAsserts)

	TEST (VariableRefreshRateDisplayTest, ReportCorrectInitialRefreshRate)

	TEST (VariableRefreshRateDisplayTest, ReportCorrectRefreshRateWhenUpdated)

	TEST (VariableRefreshRateDisplayTest, Report0IfReporterSharedPointerIsDestroyedAfterDisplayCreation)

	TEST (VariableRefreshRateDisplayTest, Report0IfReporterSharedPointerIsDestroyedBeforeDisplayCreation)

	TEST (VsyncWaiterTest, NoUnneededAwaitVsync)

static std::shared_ptr< impeller::ContextMTL >	CreateImpellerContext ()

	TEST (GPUSurfaceMetalImpeller, InvalidImpellerContextCreatesCausesSurfaceToBeInvalid)

	TEST (GPUSurfaceMetalImpeller, CanCreateValidSurface)

	TEST (GPUSurfaceMetalImpeller, AcquireFrameFromCAMetalLayerNullChecksDrawable)

	TEST (GPUSurfaceMetalImpeller, AcquireFrameFromCAMetalLayerDoesNotRetainThis)

	TEST (AndroidContextGLImpeller, MSAAFirstAttempt)

	TEST (AndroidContextGLImpeller, FallbackForEmulator)

	TEST (AndroidShellHolder, Create)

	TEST (AndroidShellHolder, HandlePlatformMessage)

	TEST (APKAssetProvider, CloneAndEquals)

fml::RefPtr< fml::RasterThreadMerger >	GetThreadMergerFromPlatformThread (fml::Thread *rasterizer_thread=nullptr)

fml::RefPtr< fml::RasterThreadMerger >	GetThreadMergerFromRasterThread (fml::Thread *platform_thread)

TaskRunners	GetTaskRunnersForFixture ()

	TEST (AndroidExternalViewEmbedder, CompositeEmbeddedView)

	TEST (AndroidExternalViewEmbedder, CancelFrame)

	TEST (AndroidExternalViewEmbedder, RasterizerRunsOnPlatformThread)

	TEST (AndroidExternalViewEmbedder, RasterizerRunsOnRasterizerThread)

	TEST (AndroidExternalViewEmbedder, PlatformViewRect)

	TEST (AndroidExternalViewEmbedder, PlatformViewRectChangedParams)

	TEST (AndroidExternalViewEmbedder, SubmitFlutterView)

	TEST (AndroidExternalViewEmbedder, OverlayCoverTwoPlatformViews)

	TEST (AndroidExternalViewEmbedder, SubmitFrameOverlayComposition)

	TEST (AndroidExternalViewEmbedder, SubmitFramePlatformViewWithoutAnyOverlay)

	TEST (AndroidExternalViewEmbedder, DoesNotCallJNIPlatformThreadOnlyMethods)

	TEST (AndroidExternalViewEmbedder, DestroyOverlayLayersOnSizeChange)

	TEST (AndroidExternalViewEmbedder, DoesNotDestroyOverlayLayersOnSizeChange)

	TEST (AndroidExternalViewEmbedder, SupportsDynamicThreadMerging)

	TEST (AndroidExternalViewEmbedder, DisableThreadMerger)

	TEST (AndroidExternalViewEmbedder, Teardown)

	TEST (AndroidExternalViewEmbedder, TeardownDoesNotCallJNIMethod)

	TEST (SurfacePool, GetLayerAllocateOneLayer)

	TEST (SurfacePool, GetUnusedLayers)

	TEST (SurfacePool, GetLayerRecycle)

	TEST (SurfacePool, GetLayerAllocateTwoLayers)

	TEST (SurfacePool, DestroyLayers)

	TEST (SurfacePool, DestroyLayersFrameSizeChanged)

	TEST (ImageLRU, CanStoreSingleImage)

	TEST (ImageLRU, EvictsLRU)

	TEST (ImageLRU, CanClear)

	TEST (JNIMock, FlutterViewHandlePlatformMessage)

	TEST (PlatformViewShell, UpdateSemanticsDoesFlutterViewUpdateSemantics)

	TEST (PlatformViewShell, UpdateSemanticsDoesFlutterViewUpdateSemanticsWithStringAttribtes)

	TEST (PlatformViewShell, UpdateSemanticsDoesFlutterViewUpdateCustomAccessibilityActions)

	TEST (AndroidPlatformView, SelectsVulkanBasedOnApiLevel)

	TEST (AndroidPlatformView, SoftwareRenderingNotSupportedWithImpeller)

FlutterSemanticsNode2	CreateSemanticsNode (int32_t id, const char label, const std::vector< int32_t > children=nullptr)

	TEST (AccessibilityBridgeTest, BasicTest)

	TEST (AccessibilityBridgeTest, AccessibilityRootId)

	TEST (AccessibilityBridgeTest, AddOrder)

	TEST (AccessibilityBridgeTest, CanFireChildrenChangedCorrectly)

	TEST (AccessibilityBridgeTest, CanHandleSelectionChangeCorrectly)

	TEST (AccessibilityBridgeTest, DoesNotAssignEditableRootToSelectableText)

	TEST (AccessibilityBridgeTest, SwitchHasSwitchRole)

	TEST (AccessibilityBridgeTest, SliderHasSliderRole)

	TEST (AccessibilityBridgeTest, CanSetCheckboxChecked)

	TEST (AccessibilityBridgeTest, CanReparentNode)

	TEST (AccessibilityBridgeTest, CanReparentMultipleNodes)

	TEST (AccessibilityBridgeTest, CanReparentNodeWithChild)

	TEST (AccessibilityBridgeTest, AXTreeManagerTest)

	TEST (AccessibilityBridgeTest, LineBreakingObjectTest)

	TEST (FlutterPlatformNodeDelegateTest, NodeDelegateHasUniqueId)

	TEST (FlutterPlatformNodeDelegateTest, canPerfomActions)

	TEST (FlutterPlatformNodeDelegateTest, canGetAXNode)

	TEST (FlutterPlatformNodeDelegateTest, canCalculateBoundsCorrectly)

	TEST (FlutterPlatformNodeDelegateTest, canCalculateOffScreenBoundsCorrectly)

	TEST (FlutterPlatformNodeDelegateTest, canUseOwnerBridge)

	TEST (FlutterPlatformNodeDelegateTest, selfIsLowestPlatformAncestor)

	TEST (FlutterPlatformNodeDelegateTest, canGetFromNodeID)

FlutterUIPressProxy *	keyDownEvent (UIKeyboardHIDUsage keyCode, UIKeyModifierFlags modifierFlags=0x0, NSTimeInterval timestamp=0.0f, const char characters="", const char charactersIgnoringModifiers="") API_AVAILABLE(ios(13.4))

FlutterUIPressProxy *	keyUpEvent (UIKeyboardHIDUsage keyCode, UIKeyModifierFlags modifierFlags=0x0, NSTimeInterval timestamp=0.0f, const char characters="", const char charactersIgnoringModifiers="") API_AVAILABLE(ios(13.4))

FlutterUIPressProxy *	keyEventWithPhase (UIPressPhase phase, UIKeyboardHIDUsage keyCode, UIKeyModifierFlags modifierFlags=0x0, NSTimeInterval timestamp=0.0f, const char characters="", const char charactersIgnoringModifiers="") API_AVAILABLE(ios(13.4))

	TEST_F (AccessibilityBridgeMacWindowTest, SendsAccessibilityCreateNotificationFlutterViewWindow)

	TEST_F (AccessibilityBridgeMacWindowTest, NonZeroRootNodeId)

	TEST_F (AccessibilityBridgeMacTest, DoesNotSendAccessibilityCreateNotificationWhenHeadless)

	TEST_F (AccessibilityBridgeMacTest, DoesNotSendAccessibilityCreateNotificationWhenNoWindow)

	TEST (FlutterAppDelegateTest, DoesNotCallDelegatesWithoutHandler)

	TEST (FlutterAppDelegateTest, ReceivesOpenURLs)

	TEST (FlutterAppDelegateTest, OperURLsStopsAfterHandled)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillFinishLaunching)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidFinishLaunching)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillBecomeActive)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidBecomeActive)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillResignActive)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidResignActive)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillTerminate)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillHide)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToWillUnhide)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidHide)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidUnhide)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidChangeScreenParameters)

	TEST (FlutterAppLifecycleDelegateTest, RespondsToDidChangeOcclusionState)

	TEST (FlutterAppLifecycleDelegateTest, ReleasesDelegateOnDealloc)

	TEST_F (FlutterChannelKeyResponderTest, BasicKeyEvent)

	TEST_F (FlutterChannelKeyResponderTest, EmptyResponseIsTakenAsHandled)

	TEST_F (FlutterChannelKeyResponderTest, FollowsLayoutMap)

	TEST_F (FlutterEmbedderExternalTextureTest, TestTextureResolution)

	TEST_F (FlutterEmbedderExternalTextureTest, TestPopulateExternalTexture)

	TEST_F (FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVA)

	TEST_F (FlutterEmbedderExternalTextureTest, TestPopulateExternalTextureYUVA2)

	TEST_F (FlutterEmbedderExternalTextureTest, TestPopulateUnsupportedExternalTexture)

	TEST (FlutterEmbedderKeyResponderUnittests, BasicKeyEvent)

	TEST (FlutterEmbedderKeyResponderUnittests, NonAsciiCharacters)

	TEST (FlutterEmbedderKeyResponderUnittests, MultipleCharacters)

	TEST (FlutterEmbedderKeyResponderUnittests, SynthesizeForDuplicateDownEvent)

	TEST (FlutterEmbedderKeyResponderUnittests, IgnoreDuplicateUpEvent)

	TEST (FlutterEmbedderKeyResponderUnittests, ConvertAbruptRepeatEventsToDown)

	TEST (FlutterEmbedderKeyResponderUnittests, ToggleModifiersDuringKeyTap)

	TEST (FlutterEmbedderKeyResponderUnittests, SpecialModiferFlags)

	TEST (FlutterEmbedderKeyResponderUnittests, IdentifyLeftAndRightModifiers)

	TEST (FlutterEmbedderKeyResponderUnittests, SynthesizeMissedModifierEvents)

	TEST (FlutterEmbedderKeyResponderUnittests, SynthesizeMissedModifierEventsInNormalEvents)

	TEST (FlutterEmbedderKeyResponderUnittests, ConvertCapsLockEvents)

	TEST (FlutterEmbedderKeyResponderUnittests, SynchronizeCapsLockStateOnCapsLock)

	TEST (FlutterEmbedderKeyResponderUnittests, SynchronizeCapsLockStateOnNormalKey)

	TEST_F (FlutterEngineTest, CanLaunch)

	TEST_F (FlutterEngineTest, HasNonNullExecutableName)

	TEST_F (FlutterEngineTest, Switches)

	TEST_F (FlutterEngineTest, MessengerSend)

	TEST_F (FlutterEngineTest, CanLogToStdout)

	TEST_F (FlutterEngineTest, DISABLED_BackgroundIsBlack)

	TEST_F (FlutterEngineTest, DISABLED_CanOverrideBackgroundColor)

	TEST_F (FlutterEngineTest, CanToggleAccessibility)

	TEST_F (FlutterEngineTest, CanToggleAccessibilityWhenHeadless)

	TEST_F (FlutterEngineTest, ProducesAccessibilityTreeWhenAddingViews)

	TEST_F (FlutterEngineTest, NativeCallbacks)

	TEST_F (FlutterEngineTest, Compositor)

	TEST_F (FlutterEngineTest, CompositorIgnoresUnknownView)

	TEST_F (FlutterEngineTest, DartEntrypointArguments)

	TEST_F (FlutterEngineTest, FlutterBinaryMessengerDoesNotRetainEngine)

	TEST_F (FlutterEngineTest, FlutterTextureRegistryDoesNotReturnEngine)

	TEST_F (FlutterEngineTest, PublishedValueNilForUnknownPlugin)

	TEST_F (FlutterEngineTest, PublishedValueNSNullIfNoPublishedValue)

	TEST_F (FlutterEngineTest, PublishedValueReturnsLastPublished)

	TEST_F (FlutterEngineTest, MessengerCleanupConnectionWorks)

	TEST_F (FlutterEngineTest, HasStringsWhenPasteboardEmpty)

	TEST_F (FlutterEngineTest, HasStringsWhenPasteboardFull)

	TEST_F (FlutterEngineTest, ResponseAfterEngineDied)

	TEST_F (FlutterEngineTest, ResponseFromBackgroundThread)

	TEST_F (FlutterEngineTest, ThreadSynchronizerNotBlockingRasterThreadAfterShutdown)

	TEST_F (FlutterEngineTest, ManageControllersIfInitiatedByController)

	TEST_F (FlutterEngineTest, ManageControllersIfInitiatedByEngine)

	TEST_F (FlutterEngineTest, HandlesTerminationRequest)

	TEST_F (FlutterEngineTest, IgnoresTerminationRequestIfNotFlutterAppDelegate)

	TEST_F (FlutterEngineTest, HandleAccessibilityEvent)

	TEST_F (FlutterEngineTest, HandleLifecycleStates) API_AVAILABLE(macos(10.9))

	TEST_F (FlutterEngineTest, ForwardsPluginDelegateRegistration)

	TEST_F (FlutterEngineTest, UnregistersPluginsOnEngineDestruction)

	TEST_F (FlutterEngineTest, RunWithEntrypointUpdatesDisplayConfig)

	TEST_F (FlutterEngineTest, NotificationsUpdateDisplays)

	TEST_F (FlutterEngineTest, DisplaySizeIsInPhysicalPixel)

id	CreateMockFlutterEngine (NSString *pasteboardString)

	TEST (FlutterKeyboardManagerUnittests, SinglePrimaryResponder)

	TEST (FlutterKeyboardManagerUnittests, DoublePrimaryResponder)

	TEST (FlutterKeyboardManagerUnittests, SingleFinalResponder)

	TEST (FlutterKeyboardManagerUnittests, EmptyNextResponder)

	TEST (FlutterKeyboardManagerUnittests, GetPressedState)

	TEST (FlutterKeyboardManagerUnittests, KeyboardChannelGetPressedState)

	TEST (FlutterKeyboardManagerUnittests, RacingConditionBetweenKeyAndText)

	TEST (FlutterKeyboardManagerUnittests, CorrectLogicalKeyForLayouts)

	TEST (FlutterKeyboardManagerUnittests, ShouldNotHoldStrongReferenceToViewDelegate)

	TEST_F (FlutterMenuPluginTest, TestSetMenu)

	TEST (FlutterPlatformNodeDelegateMac, Basics)

	TEST (FlutterPlatformNodeDelegateMac, SelectableTextHasCorrectSemantics)

	TEST (FlutterPlatformNodeDelegateMac, SelectableTextWithoutSelectionReturnZeroRange)

	TEST (FlutterPlatformNodeDelegateMac, CanPerformAction)

	TEST (FlutterPlatformNodeDelegateMac, TextFieldUsesFlutterTextField)

	TEST (FlutterPlatformViewController, TestCreatePlatformViewNoMatchingViewType)

	TEST (FlutterPlatformViewController, TestRegisterPlatformViewFactoryAndCreate)

	TEST (FlutterPlatformViewController, TestCreateAndDispose)

	TEST (FlutterPlatformViewController, TestDisposeOnMissingViewId)

	TEST (FlutterPlatformViewController, TestAcceptGesture)

	TEST (FlutterPlatformViewController, TestAcceptGestureOnMissingViewId)

	TEST (FlutterPlatformViewController, TestRejectGesture)

	TEST (FlutterPlatformViewController, TestRejectGestureOnMissingViewId)

static FlutterSurfaceManager *	CreateSurfaceManager (TestView *testView)

static FlutterSurfacePresentInfo *	CreatePresentInfo (FlutterSurface *surface, CGPoint offset=CGPointZero, size_t index=0, const std::vector< FlutterRect > &paintRegion={})

	TEST (FlutterSurfaceManager, MetalTextureSizeMatchesSurfaceSize)

	TEST (FlutterSurfaceManager, TestSurfaceLookupFromTexture)

	TEST (FlutterSurfaceManager, BackBufferCacheDoesNotLeak)

	TEST (FlutterSurfaceManager, SurfacesAreRecycled)

	TEST (FlutterSurfaceManager, BackingStoreCacheSurfaceStuckInUse)

bool	operator== (const CGRect &lhs, const CGRect &rhs)

	TEST (FlutterSurfaceManager, LayerManagement)

	TEST (FlutterTextInputPluginTest, TestEmptyCompositionRange)

	TEST (FlutterTextInputPluginTest, TestSetMarkedTextWithSelectionChange)

	TEST (FlutterTextInputPluginTest, TestSetMarkedTextWithReplacementRange)

	TEST (FlutterTextInputPluginTest, TestComposingRegionRemovedByFramework)

	TEST (FlutterTextInputPluginTest, TestClearClientDuringComposing)

	TEST (FlutterTextInputPluginTest, TestAutocompleteDisabledWhenAutofillNotSet)

	TEST (FlutterTextInputPluginTest, TestAutocompleteEnabledWhenAutofillSet)

	TEST (FlutterTextInputPluginTest, TestAutocompleteEnabledWhenAutofillSetNoHint)

	TEST (FlutterTextInputPluginTest, TestAutocompleteDisabledWhenObscureTextSet)

	TEST (FlutterTextInputPluginTest, TestAutocompleteDisabledWhenPasswordAutofillSet)

	TEST (FlutterTextInputPluginTest, TestAutocompleteDisabledWhenAutofillGroupIncludesPassword)

	TEST (FlutterTextInputPluginTest, TestFirstRectForCharacterRange)

	TEST (FlutterTextInputPluginTest, TestFirstRectForCharacterRangeAtInfinity)

	TEST (FlutterTextInputPluginTest, TestFirstRectForCharacterRangeWithEsotericAffineTransform)

	TEST (FlutterTextInputPluginTest, TestSetEditingStateWithTextEditingDelta)

	TEST (FlutterTextInputPluginTest, TestOperationsThatTriggerDelta)

	TEST (FlutterTextInputPluginTest, TestComposingWithDelta)

	TEST (FlutterTextInputPluginTest, TestComposingWithDeltasWhenSelectionIsActive)

	TEST (FlutterTextInputPluginTest, TestLocalTextAndSelectionUpdateAfterDelta)

	TEST (FlutterTextInputPluginTest, TestPerformKeyEquivalent)

	TEST (FlutterTextInputPluginTest, HandleArrowKeyWhenImePopoverIsActive)

	TEST (FlutterTextInputPluginTest, UnhandledKeyEquivalent)

	TEST (FlutterTextInputPluginTest, TestSelectorsAreForwardedToFramework)

	TEST (FlutterTextInputPluginTest, TestSelectorsNotForwardedToFrameworkIfNoClient)

	TEST (FlutterTextInputPluginTest, TestInsertNewLine)

	TEST (FlutterTextInputPluginTest, TestSendActionDoNotInsertNewLine)

	TEST (FlutterTextInputPluginTest, CanWorkWithFlutterTextField)

	TEST (FlutterTextInputPluginTest, CanNotBecomeResponderIfNoViewController)

	TEST (FlutterTextInputPluginTest, IsAddedAndRemovedFromViewHierarchy)

	TEST (FlutterTextInputPluginTest, FirstResponderIsCorrect)

	TEST (FlutterTextInputPluginTest, HasZeroSizeAndClipsToBounds)

	TEST (FlutterTextInputSemanticsObjectTest, DoesInitialize)

	TEST_F (FlutterViewControllerTest, HasViewThatHidesOtherViewsInAccessibility)

	TEST_F (FlutterViewControllerTest, FlutterViewAcceptsFirstMouse)

	TEST_F (FlutterViewControllerTest, ReparentsPluginWhenAccessibilityDisabled)

	TEST_F (FlutterViewControllerTest, CanSetMouseTrackingModeBeforeViewLoaded)

	TEST_F (FlutterViewControllerMockEngineTest, TestKeyEventsAreSentToFramework)

	TEST_F (FlutterViewControllerMockEngineTest, TestKeyEventsArePropagatedIfNotHandled)

	TEST_F (FlutterViewControllerMockEngineTest, TestKeyEventsAreNotPropagatedIfHandled)

	TEST_F (FlutterViewControllerMockEngineTest, TestCtrlTabKeyEventIsPropagated)

	TEST_F (FlutterViewControllerMockEngineTest, TestKeyEquivalentIsPassedToTextInputPlugin)

	TEST_F (FlutterViewControllerMockEngineTest, TestFlagsChangedEventsArePropagatedIfNotHandled)

	TEST_F (FlutterViewControllerMockEngineTest, TestKeyboardIsRestartedOnEngineRestart)

	TEST_F (FlutterViewControllerMockEngineTest, TestTrackpadGesturesAreSentToFramework)

	TEST_F (FlutterViewControllerMockEngineTest, TestmouseAndGestureEventsAreHandledSeparately)

	TEST_F (FlutterViewControllerMockEngineTest, TestMouseDownUpEventsSentToNextResponder)

	TEST_F (FlutterViewControllerMockEngineTest, TestModifierKeysAreSynthesizedOnMouseMove)

	TEST_F (FlutterViewControllerMockEngineTest, testViewWillAppearCalledMultipleTimes)

	TEST_F (FlutterViewControllerMockEngineTest, testFlutterViewIsConfigured)

	TEST_F (FlutterViewControllerTest, testLookupKeyAssets)

	TEST_F (FlutterViewControllerTest, testLookupKeyAssetsWithPackage)

	TEST_F (FlutterViewControllerTest, testViewControllerIsReleased)

id	CreateMockViewController ()

	TEST (FlutterViewEngineProviderUnittests, GetViewReturnsTheCorrectView)

	TEST (KeyMappingTest, HasExpectedValues)

	TEST (PlatformViewEmbedderTest, HasPlatformMessageHandler)

	TEST (PlatformViewEmbedderTest, Dispatches)

	TEST (PlatformViewEmbedderTest, DeletionDisabledDispatch)

	TEST_F (EmbedderTest, CannotProvideMultipleSemanticsCallbacks)

	TEST_F (EmbedderA11yTest, A11yTreeIsConsistentUsingV3Callbacks)

	TEST_F (EmbedderA11yTest, A11yStringAttributes)

	TEST_F (EmbedderA11yTest, A11yTreeIsConsistentUsingV2Callbacks)

	TEST_F (EmbedderA11yTest, A11yTreeIsConsistentUsingV1Callbacks)

	TEST (EmbedderFrozen, FlutterTransformationIsFrozen)

	TEST (EmbedderFrozen, FlutterRectIsFrozen)

	TEST (EmbedderFrozen, FlutterPointIsFrozen)

	TEST (EmbedderFrozen, FlutterDamageIsFrozen)

	TEST (EmbedderFrozen, FlutterSemanticsNodeIsFrozen)

	TEST (EmbedderFrozen, FlutterSemanticsCustomActionIsFrozen)

	TEST_F (EmbedderTest, CanGetVulkanEmbedderContext)

	TEST_F (EmbedderTest, CanCreateOpenGLRenderingEngine)

	TEST_F (EmbedderTest, MustPreventEngineLaunchWhenRequiredCompositorArgsAreAbsent)

	TEST_F (EmbedderTest, LaunchFailsWhenMultiplePresentCallbacks)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderToOpenGLFramebuffer)

	TEST_F (EmbedderTest, RasterCacheDisabledWithPlatformViews)

	TEST_F (EmbedderTest, RasterCacheEnabled)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderToOpenGLTexture)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderToSoftwareBuffer)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownScene)

	TEST_F (EmbedderTest, CustomCompositorMustWorkWithCustomTaskRunner)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderWithRootLayerOnly)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderWithPlatformLayerOnBottom)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownSceneWithRootSurfaceTransformation)

	TEST_F (EmbedderTest, CanRenderSceneWithoutCustomCompositor)

	TEST_F (EmbedderTest, CanRenderSceneWithoutCustomCompositorWithTransformation)

	TEST_P (EmbedderTestMultiBackend, CanRenderGradientWithoutCompositor)

	TEST_F (EmbedderTest, CanRenderGradientWithoutCompositorWithXform)

	TEST_P (EmbedderTestMultiBackend, CanRenderGradientWithCompositor)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositorWithXform)

	TEST_P (EmbedderTestMultiBackend, CanRenderGradientWithCompositorOnNonRootLayer)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositorOnNonRootLayerWithXform)

	TEST_F (EmbedderTest, VerifyB141980393)

	TEST_F (EmbedderTest, CanCreateEmbedderWithCustomRenderTaskRunner)

	TEST_P (EmbedderTestMultiBackend, CanCreateEmbedderWithCustomRenderTaskRunnerTheSameAsPlatformTaskRunner)

	TEST_P (EmbedderTestMultiBackend, CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurface)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurfaceWithRootSurfaceXformation)

	TEST_F (EmbedderTest, PushingMutlipleFramesSetsUpNewRecordingCanvasWithCustomCompositor)

	TEST_F (EmbedderTest, PushingMutlipleFramesSetsUpNewRecordingCanvasWithoutCustomCompositor)

	TEST_P (EmbedderTestMultiBackend, PlatformViewMutatorsAreValid)

	TEST_F (EmbedderTest, PlatformViewMutatorsAreValidWithPixelRatio)

	TEST_F (EmbedderTest, PlatformViewMutatorsAreValidWithPixelRatioAndRootSurfaceTransformation)

	TEST_F (EmbedderTest, EmptySceneIsAcceptable)

	TEST_F (EmbedderTest, SceneWithNoRootContainerIsAcceptable)

	TEST_F (EmbedderTest, ArcEndCapsAreDrawnCorrectly)

	TEST_F (EmbedderTest, ClipsAreCorrectlyCalculated)

	TEST_F (EmbedderTest, ComplexClipsAreCorrectlyCalculated)

	TEST_F (EmbedderTest, ObjectsCanBePostedViaPorts)

	TEST_F (EmbedderTest, CompositorCanPostZeroLayersForPresentation)

	TEST_F (EmbedderTest, CompositorCanPostOnlyPlatformViews)

	TEST_F (EmbedderTest, CompositorRenderTargetsAreRecycled)

	TEST_F (EmbedderTest, CompositorRenderTargetsAreInStableOrder)

	TEST_F (EmbedderTest, FrameInfoContainsValidWidthAndHeight)

	TEST_F (EmbedderTest, MustNotRunWithBothFBOCallbacksSet)

	TEST_F (EmbedderTest, MustNotRunWithBothPresentCallbacksSet)

	TEST_F (EmbedderTest, MustStillRunWhenPopulateExistingDamageIsNotProvided)

	TEST_F (EmbedderTest, MustRunWhenPopulateExistingDamageIsProvided)

	TEST_F (EmbedderTest, MustRunWithPopulateExistingDamageAndFBOCallback)

	TEST_F (EmbedderTest, MustNotRunWhenPopulateExistingDamageButNoOtherFBOCallback)

	TEST_F (EmbedderTest, PresentInfoContainsValidFBOId)

	TEST_F (EmbedderTest, PresentInfoReceivesFullDamageWhenExistingDamageIsWholeScreen)

	TEST_F (EmbedderTest, PresentInfoReceivesEmptyDamage)

	TEST_F (EmbedderTest, PresentInfoReceivesPartialDamage)

	TEST_F (EmbedderTest, PopulateExistingDamageReceivesValidID)

	TEST_F (EmbedderTest, PopulateExistingDamageReceivesInvalidID)

	TEST_F (EmbedderTest, SetSingleDisplayConfigurationWithDisplayId)

	TEST_F (EmbedderTest, SetSingleDisplayConfigurationWithoutDisplayId)

	TEST_F (EmbedderTest, SetValidMultiDisplayConfiguration)

	TEST_F (EmbedderTest, MultipleDisplaysWithSingleDisplayTrueIsInvalid)

	TEST_F (EmbedderTest, MultipleDisplaysWithSameDisplayIdIsInvalid)

	TEST_F (EmbedderTest, CompositorRenderTargetsNotRecycledWhenAvoidsCacheSet)

	TEST_F (EmbedderTest, SnapshotRenderTargetScalesDownToDriverMax)

	TEST_F (EmbedderTest, ObjectsPostedViaPortsServicedOnSecondaryTaskHeap)

	TEST_F (EmbedderTest, CreateInvalidBackingstoreOpenGLTexture)

	TEST_F (EmbedderTest, CreateInvalidBackingstoreOpenGLFramebuffer)

	TEST_F (EmbedderTest, ExternalTextureGLRefreshedTooOften)

	TEST_F (EmbedderTest, PresentInfoReceivesFullScreenDamageWhenPopulateExistingDamageIsNotProvided)

	TEST_F (EmbedderTest, PresentInfoReceivesJoinedDamageWhenExistingDamageContainsMultipleRects)

	TEST_F (EmbedderTest, CanRenderWithImpellerOpenGL)

	INSTANTIATE_TEST_SUITE_P (EmbedderTestGlVk, EmbedderTestMultiBackend, ::testing::Values(EmbedderTestContextType::kOpenGLContext, EmbedderTestContextType::kVulkanContext))

	TEST_F (EmbedderTest, CanRenderGradientWithMetal)

static sk_sp< SkSurface >	GetSurfaceFromTexture (const sk_sp< GrDirectContext > &skia_context, SkISize texture_size, void *texture)

	TEST_F (EmbedderTest, ExternalTextureMetal)

	TEST_F (EmbedderTest, MetalCompositorMustBeAbleToRenderPlatformViews)

	TEST_F (EmbedderTest, CanRenderSceneWithoutCustomCompositorMetal)

	TEST_F (EmbedderTest, TextureDestructionCallbackCalledWithoutCustomCompositorMetal)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownSceneMetal)

	TEST_F (EmbedderTest, CreateInvalidBackingstoreMetalTexture)

	TEST_F (EmbedderTest, ExternalTextureMetalRefreshedTooOften)

static void	InvokeAllCallbacks (const std::vector< fml::closure > &callbacks)

	TEST (EmbedderTestNoFixture, MustNotRunWithInvalidArgs)

	TEST_F (EmbedderTest, CanLaunchAndShutdownWithValidProjectArgs)

	TEST_F (EmbedderTest, DISABLED_CanLaunchAndShutdownMultipleTimes)

	TEST_F (EmbedderTest, CanInvokeCustomEntrypoint)

	TEST_F (EmbedderTest, CanInvokeCustomEntrypointMacro)

	TEST_F (EmbedderTest, CanTerminateCleanly)

	TEST_F (EmbedderTest, ExecutableNameNotNull)

	TEST_F (EmbedderTest, ImplicitViewNotNull)

	TEST_F (EmbedderTest, CanSpecifyCustomPlatformTaskRunner)

	TEST (EmbedderTestNoFixture, CanGetCurrentTimeInNanoseconds)

	TEST_F (EmbedderTest, CanReloadSystemFonts)

	TEST_F (EmbedderTest, IsolateServiceIdSent)

	TEST_F (EmbedderTest, CanCreateAndCollectCallbacks)

	TEST_F (EmbedderTest, PlatformMessagesCanReceiveResponse)

	TEST_F (EmbedderTest, PlatformMessagesCanBeSentWithoutResponseHandles)

	TEST_F (EmbedderTest, NullPlatformMessagesCanBeSent)

	TEST_F (EmbedderTest, InvalidPlatformMessages)

	TEST_F (EmbedderTest, CanSetCustomLogMessageCallback)

	TEST_F (EmbedderTest, CanSetCustomLogTag)
	Tests that setting a custom log tag works. More...

	TEST_F (EmbedderTest, VMShutsDownWhenNoEnginesInProcess)

	TEST_F (EmbedderTest, DartEntrypointArgs)

	TEST_F (EmbedderTest, VMAndIsolateSnapshotSizesAreRedundantInAOTMode)

	TEST_F (EmbedderTest, CanRenderImplicitView)

	TEST_F (EmbedderTest, CanRenderImplicitViewUsingPresentLayersCallback)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownSceneWithSoftwareCompositor)

	TEST_F (EmbedderTest, NoLayerCreatedForTransparentOverlayOnTopOfPlatformLayer)

	TEST_F (EmbedderTest, NoLayerCreatedForNoOverlayOnTopOfPlatformLayer)

	TEST_F (EmbedderTest, CanCreateInitializedEngine)

	TEST_F (EmbedderTest, CanRunInitializedEngine)

	TEST_F (EmbedderTest, CanDeinitializeAnEngine)

	TEST_F (EmbedderTest, CanAddView)

	TEST_F (EmbedderTest, AddViewSchedulesFrame)

	TEST_F (EmbedderTest, CanRemoveView)

	TEST_F (EmbedderTest, CannotRemoveImplicitView)

	TEST_F (EmbedderTest, CannotAddDuplicateViews)

	TEST_F (EmbedderTest, CanReuseViewIds)

	TEST_F (EmbedderTest, CannotRemoveUnknownView)

	TEST_F (EmbedderTest, ViewOperationsOrdered)

	TEST_F (EmbedderTest, CanRenderMultipleViews)

	TEST_F (EmbedderTest, BackingStoresCorrespondToTheirViews)

	TEST_F (EmbedderTest, CanUpdateLocales)

	TEST_F (EmbedderTest, LocalizationCallbacksCalled)

	TEST_F (EmbedderTest, CanQueryDartAOTMode)

	TEST_F (EmbedderTest, VerifyB143464703WithSoftwareBackend)

	TEST_F (EmbedderTest, CanSendLowMemoryNotification)

	TEST_F (EmbedderTest, CanPostTaskToAllNativeThreads)

	TEST_F (EmbedderTest, InvalidAOTDataSourcesMustReturnError)

	TEST_F (EmbedderTest, MustNotRunWithMultipleAOTSources)

	TEST_F (EmbedderTest, CanCreateAndCollectAValidElfSource)

	TEST_F (EmbedderTest, CanLaunchAndShutdownWithAValidElfSource)

	TEST_F (EmbedderTest, CanSuccessfullyPopulateSpecificJITSnapshotCallbacks)

	TEST_F (EmbedderTest, JITSnapshotCallbacksFailWithInvalidLocation)

	TEST_F (EmbedderTest, CanLaunchEngineWithSpecifiedJITSnapshots)

	TEST_F (EmbedderTest, CanLaunchEngineWithSomeSpecifiedJITSnapshots)

	TEST_F (EmbedderTest, CanLaunchEngineWithInvalidJITSnapshots)

	TEST_F (EmbedderTest, CanLaunchEngineWithUnspecifiedJITSnapshots)

	TEST_F (EmbedderTest, InvalidFlutterWindowMetricsEvent)

static void	expectSoftwareRenderingOutputMatches (EmbedderTest &test, std::string entrypoint, FlutterSoftwarePixelFormat pixfmt, const std::vector< uint8_t > &bytes)

template<typename T >
static void	expectSoftwareRenderingOutputMatches (EmbedderTest &test, std::string entrypoint, FlutterSoftwarePixelFormat pixfmt, T pixelvalue)

	SW_PIXFMT_TEST_F (RedRGBA565xF800, draw_solid_red, kFlutterSoftwarePixelFormatRGB565,(uint16_t) 0xF800)

	SW_PIXFMT_TEST_F (RedRGBA4444xF00F, draw_solid_red, kFlutterSoftwarePixelFormatRGBA4444,(uint16_t) 0xF00F)

	SW_PIXFMT_TEST_F (RedRGBA8888xFFx00x00xFF, draw_solid_red, kFlutterSoftwarePixelFormatRGBA8888,(std::vector< uint8_t >{0xFF, 0x00, 0x00, 0xFF}))

	SW_PIXFMT_TEST_F (RedBGRA8888x00x00xFFxFF, draw_solid_red, kFlutterSoftwarePixelFormatBGRA8888,(std::vector< uint8_t >{0x00, 0x00, 0xFF, 0xFF}))

	SW_PIXFMT_TEST_F (RedGray8x36, draw_solid_red, kFlutterSoftwarePixelFormatGray8,(uint8_t) 0x36)

	SW_PIXFMT_TEST_F (GreenRGB565x07E0, draw_solid_green, kFlutterSoftwarePixelFormatRGB565,(uint16_t) 0x07E0)

	SW_PIXFMT_TEST_F (GreenRGBA4444x0F0F, draw_solid_green, kFlutterSoftwarePixelFormatRGBA4444,(uint16_t) 0x0F0F)

	SW_PIXFMT_TEST_F (GreenRGBA8888x00xFFx00xFF, draw_solid_green, kFlutterSoftwarePixelFormatRGBA8888,(std::vector< uint8_t >{0x00, 0xFF, 0x00, 0xFF}))

	SW_PIXFMT_TEST_F (GreenBGRA8888x00xFFx00xFF, draw_solid_green, kFlutterSoftwarePixelFormatBGRA8888,(std::vector< uint8_t >{0x00, 0xFF, 0x00, 0xFF}))

	SW_PIXFMT_TEST_F (GreenGray8xB6, draw_solid_green, kFlutterSoftwarePixelFormatGray8,(uint8_t) 0xB6)

	SW_PIXFMT_TEST_F (BlueRGB565x001F, draw_solid_blue, kFlutterSoftwarePixelFormatRGB565,(uint16_t) 0x001F)

	SW_PIXFMT_TEST_F (BlueRGBA4444x00FF, draw_solid_blue, kFlutterSoftwarePixelFormatRGBA4444,(uint16_t) 0x00FF)

	SW_PIXFMT_TEST_F (BlueRGBA8888x00x00xFFxFF, draw_solid_blue, kFlutterSoftwarePixelFormatRGBA8888,(std::vector< uint8_t >{0x00, 0x00, 0xFF, 0xFF}))

	SW_PIXFMT_TEST_F (BlueBGRA8888xFFx00x00xFF, draw_solid_blue, kFlutterSoftwarePixelFormatBGRA8888,(std::vector< uint8_t >{0xFF, 0x00, 0x00, 0xFF}))

	SW_PIXFMT_TEST_F (BlueGray8x12, draw_solid_blue, kFlutterSoftwarePixelFormatGray8,(uint8_t) 0x12)

FlutterKeyEventType	UnserializeKeyEventType (uint64_t kind)

FlutterKeyEventDeviceType	UnserializeKeyEventDeviceType (uint64_t source)

void	ExpectKeyEventEq (const FlutterKeyEvent &subject, const FlutterKeyEvent &baseline)

	TEST_F (EmbedderTest, KeyDataIsCorrectlySerialized)

	TEST_F (EmbedderTest, KeyDataAreBuffered)

	TEST_F (EmbedderTest, KeyDataResponseIsCorrectlyInvoked)

	TEST_F (EmbedderTest, BackToBackKeyEventResponsesCorrectlyInvoked)

	TEST_F (EmbedderTest, VsyncCallbackPostedIntoFuture)

	TEST_F (EmbedderTest, CanScheduleFrame)

	TEST_F (EmbedderTest, CanSetNextFrameCallback)

	TEST_F (EmbedderTest, CanSendPointer)

	TEST_F (EmbedderTest, CanSendPointerEventWithViewId)

	TEST_F (EmbedderTest, WindowMetricsEventDefaultsToImplicitView)

	TEST_F (EmbedderTest, IgnoresWindowMetricsEventForUnknownView)

	TEST_F (EmbedderTest, RegisterChannelListener)

	TEST_F (EmbedderTest, PlatformThreadIsolatesWithCustomPlatformTaskRunner)

	TEST (EmbedderProcTable, AllPointersProvided)

	TEST (EmbedderProcTable, NoDuplicatePointers)

	TEST (EmbedderProcTable, CallProc)

sk_sp< SkSurface >	CreateRenderSurface (const FlutterLayer &layer, GrDirectContext *context)

static sk_sp< SkData >	NormalizeImage (const sk_sp< SkImage > &image)

bool	RasterImagesAreSame (const sk_sp< SkImage > &a, const sk_sp< SkImage > &b)

std::string	FixtureNameForBackend (EmbedderTestContextType backend, const std::string &name)
	Prepends a prefix to the name which is unique to the test context type. This is useful for tests that use EmbedderTestMultiBackend and require different fixtures per backend. For OpenGL, the name remains unchanged. More...

EmbedderTestBackingStoreProducer::RenderTargetType	GetRenderTargetFromBackend (EmbedderTestContextType backend, bool opengl_framebuffer)
	Resolves a render target type for a given backend description. This is useful for tests that use EmbedderTestMultiBackend. More...

void	ConfigureBackingStore (FlutterBackingStore &backing_store, EmbedderTestContextType backend, bool opengl_framebuffer)
	Configures per-backend properties for a given backing store. More...

bool	WriteImageToDisk (const fml::UniqueFD &directory, const std::string &name, const sk_sp< SkImage > &image)

bool	ImageMatchesFixture (const std::string &fixture_file_name, const sk_sp< SkImage > &scene_image)

bool	ImageMatchesFixture (const std::string &fixture_file_name, std::future< sk_sp< SkImage > > &scene_image)

bool	SurfacePixelDataMatchesBytes (SkSurface *surface, const std::vector< uint8_t > &bytes)

bool	SurfacePixelDataMatchesBytes (std::future< SkSurface * > &surface_future, const std::vector< uint8_t > &bytes)

void	FilterMutationsByType (const FlutterPlatformViewMutation **mutations, size_t count, FlutterPlatformViewMutationType type, const std::function< void(const FlutterPlatformViewMutation &mutation)> &handler)

void	FilterMutationsByType (const FlutterPlatformView *view, FlutterPlatformViewMutationType type, const std::function< void(const FlutterPlatformViewMutation &mutation)> &handler)

SkMatrix	GetTotalMutationTransformationMatrix (const FlutterPlatformViewMutation **mutations, size_t count)

SkMatrix	GetTotalMutationTransformationMatrix (const FlutterPlatformView *view)

	TEST_F (EmbedderTest, CanSwapOutVulkanCalls)

	TEST (CanvasSpyTest, DrawingIsTracked)

	TEST (CanvasSpyTest, SpiedCanvasIsDrawing)

	TEST (RTree, searchNonOverlappingDrawnRectsNoIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsSingleRectIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsIgnoresNonDrawingRecords)

	TEST (RTree, searchNonOverlappingDrawnRectsMultipleRectIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase1)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase2)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase3)

void	fl_ensure_gtk_init (GLogWriterFunc writer=nullptr)
	Ensures that GTK has been initialized and starts monitoring logs. More...

void	fl_reset_received_gtk_log_levels ()
	Resets the recorded log levels. More...

GLogLevelFlags	fl_get_received_gtk_log_levels ()
	Returns the recorded log levels. More...

	TEST (AccessibilityBridgeWindows, GetParent)

	TEST (AccessibilityBridgeWindows, GetParentOnRootRetunsNullptr)

	TEST (AccessibilityBridgeWindows, DispatchAccessibilityAction)

	TEST (AccessibilityBridgeWindows, OnAccessibilityEventAlert)

	TEST (AccessibilityBridgeWindows, OnAccessibilityEventChildrenChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityEventFocusChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityEventIgnoredChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityImageAnnotationChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityLiveRegionChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityNameChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityHScrollPosChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityVScrollPosChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilitySelectedChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilitySelectedChildrenChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilitySubtreeCreated)

	TEST (AccessibilityBridgeWindows, OnAccessibilityValueChanged)

	TEST (AccessibilityBridgeWindows, OnAccessibilityStateChanged)

	TEST (AccessibilityBridgeWindows, OnDocumentSelectionChanged)

	TEST_F (CompositorOpenGLTest, CreateBackingStore)

	TEST_F (CompositorOpenGLTest, InitializationFailure)

	TEST_F (CompositorOpenGLTest, Present)

	TEST_F (CompositorOpenGLTest, PresentEmpty)

	TEST_F (CompositorOpenGLTest, NoSurfaceIgnored)

	TEST_F (CompositorSoftwareTest, CreateBackingStore)

	TEST_F (CompositorSoftwareTest, Present)

	TEST_F (CompositorSoftwareTest, PresentEmpty)

	TEST_F (CompositorSoftwareTest, PresentMultiLayers)

	TEST_F (CompositorSoftwareTest, PresentOffsetLayers)

	TEST_F (CursorHandlerTest, ActivateSystemCursor)

	TEST_F (CursorHandlerTest, ActivateSystemCursorRequiresView)

	TEST_F (CursorHandlerTest, CreateCustomCursor)

	TEST_F (CursorHandlerTest, SetCustomCursor)

	TEST_F (CursorHandlerTest, SetCustomCursorRequiresView)

	TEST_F (CursorHandlerTest, SetNonexistentCustomCursor)

	TEST_F (CursorHandlerTest, DeleteCustomCursor)

	TEST_F (CursorHandlerTest, DeleteNonexistentCustomCursor)

	TEST (DirectManipulationTest, TestGesture)

	TEST (DirectManipulationTest, TestRounding)

	TEST (DirectManipulationTest, TestInertiaCancelSentForUserCancel)

	TEST (DirectManipulationTest, TestInertiaCamcelNotSentAtInertiaEnd)

	TEST (DirectManipulationTest, TestGestureWithInitialData)

	TEST (DpiUtilsTest, NonZero)

	TEST (DpiUtilsTest, NullHwndUsesPrimaryMonitor)

	TEST (FlutterProjectBundle, BasicPropertiesAbsolutePaths)

	TEST (FlutterProjectBundle, BasicPropertiesRelativePaths)

	TEST (FlutterProjectBundle, SwitchesEmpty)

	TEST (FlutterProjectBundle, DartEntrypointArguments)

	TEST (FlutterProjectBundle, Switches)

	TEST_F (FlutterWindowTest, CreateDestroy)

	TEST_F (FlutterWindowTest, OnBitmapSurfaceUpdated)

	TEST_F (FlutterWindowTest, OnCursorRectUpdatedRegularDPI)

	TEST_F (FlutterWindowTest, OnCursorRectUpdatedHighDPI)

	TEST_F (FlutterWindowTest, OnPointerStarSendsDeviceType)

	TEST_F (FlutterWindowTest, OnScrollCallsGetScrollOffsetMultiplier)

	TEST_F (FlutterWindowTest, OnWindowRepaint)

	TEST_F (FlutterWindowTest, OnThemeChange)

	TEST_F (FlutterWindowTest, AccessibilityNodeWithoutView)

	TEST_F (FlutterWindowTest, AlertNode)

	TEST_F (FlutterWindowTest, LifecycleFocusMessages)

	TEST_F (FlutterWindowTest, CachedLifecycleMessage)

	TEST_F (FlutterWindowTest, UpdateCursor)

	TEST_F (FlutterWindowsEngineTest, RunHeadless)

	TEST_F (FlutterWindowsEngineTest, RunDoesExpectedInitialization)

	TEST_F (FlutterWindowsEngineTest, ConfiguresFrameVsync)

	TEST_F (FlutterWindowsEngineTest, RunWithoutANGLEUsesSoftware)

	TEST_F (FlutterWindowsEngineTest, RunWithoutANGLEOnImpellerFailsToStart)

	TEST_F (FlutterWindowsEngineTest, SendPlatformMessageWithoutResponse)

	TEST_F (FlutterWindowsEngineTest, PlatformMessageRoundTrip)

	TEST_F (FlutterWindowsEngineTest, PlatformMessageRespondOnDifferentThread)

	TEST_F (FlutterWindowsEngineTest, SendPlatformMessageWithResponse)

	TEST_F (FlutterWindowsEngineTest, DispatchSemanticsAction)

	TEST_F (FlutterWindowsEngineTest, SetsThreadPriority)

	TEST_F (FlutterWindowsEngineTest, AddPluginRegistrarDestructionCallback)

	TEST_F (FlutterWindowsEngineTest, ScheduleFrame)

	TEST_F (FlutterWindowsEngineTest, SetNextFrameCallback)

	TEST_F (FlutterWindowsEngineTest, GetExecutableName)

	TEST_F (FlutterWindowsEngineTest, UpdateHighContrastFeature)

	TEST_F (FlutterWindowsEngineTest, PostRasterThreadTask)

	TEST_F (FlutterWindowsEngineTest, AccessibilityAnnouncement)

	TEST_F (FlutterWindowsEngineTest, AccessibilityAnnouncementHeadless)

	TEST_F (FlutterWindowsEngineTest, AccessibilityTooltip)

	TEST_F (FlutterWindowsEngineTest, TestExit)

	TEST_F (FlutterWindowsEngineTest, TestExitCancel)

	TEST_F (FlutterWindowsEngineTest, TestExitSecondCloseMessage)

	TEST_F (FlutterWindowsEngineTest, TestExitCloseMultiWindow)

	TEST_F (FlutterWindowsEngineTest, LifecycleManagerDisabledByDefault)

	TEST_F (FlutterWindowsEngineTest, EnableApplicationLifecycle)

	TEST_F (FlutterWindowsEngineTest, ApplicationLifecycleExternalWindow)

	TEST_F (FlutterWindowsEngineTest, AppStartsInResumedState)

	TEST_F (FlutterWindowsEngineTest, LifecycleStateTransition)

	TEST_F (FlutterWindowsEngineTest, ExternalWindowMessage)

	TEST_F (FlutterWindowsEngineTest, InnerWindowHidden)

	TEST_F (FlutterWindowsEngineTest, EnableLifecycleState)

	TEST_F (FlutterWindowsEngineTest, LifecycleStateToFrom)

	TEST_F (FlutterWindowsEngineTest, ChannelListenedTo)

	TEST_F (FlutterWindowsEngineTest, ReceivePlatformViewMessage)

	TEST_F (FlutterWindowsEngineTest, AddViewFailureDoesNotHang)

	TEST_F (FlutterWindowsEngineTest, RemoveViewFailureDoesNotHang)

	TEST (FlutterWindowsTextureRegistrarTest, CreateDestroy)

	TEST (FlutterWindowsTextureRegistrarTest, RegisterUnregisterTexture)

	TEST (FlutterWindowsTextureRegistrarTest, RegisterUnknownTextureType)

	TEST (FlutterWindowsTextureRegistrarTest, PopulatePixelBufferTexture)

	TEST (FlutterWindowsTextureRegistrarTest, PopulateD3dTextureWithHandle)

	TEST (FlutterWindowsTextureRegistrarTest, PopulateD3dTexture)

	TEST (FlutterWindowsTextureRegistrarTest, PopulateInvalidTexture)

	TEST (FlutterWindowsTextureRegistrarTest, UnregisterTextureWithEngineDownInvokesCallback)

	TEST (WindowsNoFixtureTest, GetTextureRegistrar)

	TEST_F (WindowsTest, LaunchMain)

	TEST_F (WindowsTest, LaunchMainHasNoOutput)

	TEST_F (WindowsTest, LaunchCustomEntrypoint)

	TEST_F (WindowsTest, LaunchCustomEntrypointInEngineRunInvocation)

	TEST_F (WindowsTest, LaunchHeadlessEngine)

	TEST_F (WindowsTest, EngineCanTransitionToHeadless)

	TEST_F (WindowsTest, LaunchRefreshesAccessibility)

	TEST_F (WindowsTest, LaunchConflictingCustomEntrypoints)

	TEST_F (WindowsTest, VerifyNativeFunction)

	TEST_F (WindowsTest, VerifyNativeFunctionWithParameters)

	TEST_F (WindowsTest, PlatformExecutable)

	TEST_F (WindowsTest, VerifyNativeFunctionWithReturn)

	TEST_F (WindowsTest, NextFrameCallback)

	TEST_F (WindowsTest, PresentHeadless)

	TEST_F (WindowsTest, GetViewId)

	TEST_F (WindowsTest, GetGraphicsAdapter)

	TEST_F (WindowsTest, PluginRegistrarGetImplicitView)

	TEST_F (WindowsTest, PluginRegistrarGetView)

	TEST_F (WindowsTest, PluginRegistrarGetViewHeadless)

	TEST_F (WindowsTest, SurfaceOptional)

	TEST_F (WindowsTest, Lifecycle)

	TEST_F (WindowsTest, GetKeyboardStateHeadless)

	TEST_F (WindowsTest, AddRemoveView)

	TEST (FlutterWindowsViewTest, SubMenuExpandedState)

	TEST (FlutterWindowsViewTest, Shutdown)

	TEST (FlutterWindowsViewTest, KeySequence)

	TEST (FlutterWindowsViewTest, EnableSemantics)

	TEST (FlutterWindowsViewTest, AddSemanticsNodeUpdate)

	TEST (FlutterWindowsViewTest, AddSemanticsNodeUpdateWithChildren)

	TEST (FlutterWindowsViewTest, NonZeroSemanticsRoot)

	TEST (FlutterWindowsViewTest, AccessibilityHitTesting)

	TEST (FlutterWindowsViewTest, WindowResizeTests)

	TEST (FlutterWindowsViewTest, TestEmptyFrameResizes)

	TEST (FlutterWindowsViewTest, WindowResizeRace)

	TEST (FlutterWindowsViewTest, WindowResizeInvalidSurface)

	TEST (FlutterWindowsViewTest, WindowResizeWithoutSurface)

	TEST (FlutterWindowsViewTest, WindowRepaintTests)

	TEST (FlutterWindowsViewTest, CheckboxNativeState)

	TEST (FlutterWindowsViewTest, SwitchNativeState)

	TEST (FlutterWindowsViewTest, TooltipNodeData)

	TEST (FlutterWindowsViewTest, DisablesVSyncAtStartup)

	TEST (FlutterWindowsViewTest, EnablesVSyncAtStartup)

	TEST (FlutterWindowsViewTest, DisablesVSyncAfterStartup)

	TEST (FlutterWindowsViewTest, EnablesVSyncAfterStartup)

	TEST (FlutterWindowsViewTest, UpdatesVSyncOnDwmUpdates)

	TEST (KeyboardKeyChannelHandlerTest, KeyboardHookHandling)

	TEST (KeyboardKeyChannelHandlerTest, ExtendedKeysAreSentToRedispatch)

	TEST (KeyboardKeyChannelHandlerTest, DeadKeysDoNotCrash)

	TEST (KeyboardKeyChannelHandlerTest, EmptyResponsesDoNotCrash)

	TEST (KeyboardKeyEmbedderHandlerTest, ConvertChar32ToUtf8)

	TEST (KeyboardKeyEmbedderHandlerTest, BasicKeyPressingAndHolding)

	TEST (KeyboardKeyEmbedderHandlerTest, ToggleNumLockDuringNumpadPress)

	TEST (KeyboardKeyEmbedderHandlerTest, ImeEventsAreIgnored)

	TEST (KeyboardKeyEmbedderHandlerTest, ModifierKeysByExtendedBit)

	TEST (KeyboardKeyEmbedderHandlerTest, ModifierKeysByVirtualKey)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeModifierLeftKeyDownWhenNotPressed)

	TEST (KeyboardKeyEmbedderHandlerTest, DoNotSynthesizeModifierDownWhenPressed)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeModifierUpWhenPressed)

	TEST (KeyboardKeyEmbedderHandlerTest, DoNotSynthesizeModifierUpWhenNotPressed)

	TEST (KeyboardKeyEmbedderHandlerTest, RepeatedDownIsIgnored)

	TEST (KeyboardKeyEmbedderHandlerTest, AbruptRepeatIsConvertedToDown)

	TEST (KeyboardKeyEmbedderHandlerTest, AbruptUpIsIgnored)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncPressingState)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledState)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledStateByItselfsUp)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeForDesyncToggledStateByItselfsDown)

	TEST (KeyboardKeyEmbedderHandlerTest, SynthesizeWithInitialTogglingState)

	TEST (KeyboardKeyEmbedderHandlerTest, SysKeyPress)

	TEST (KeyboardKeyHandlerTest, SingleDelegateWithAsyncResponds)

	TEST (KeyboardKeyHandlerTest, SingleDelegateWithSyncResponds)

	TEST (KeyboardKeyHandlerTest, HandlerGetPressedState)

	TEST (KeyboardKeyHandlerTest, KeyboardChannelGetPressedState)

	TEST_F (KeyboardTest, LowerCaseAHandled)

	TEST_F (KeyboardTest, LowerCaseAUnhandled)

	TEST_F (KeyboardTest, ArrowLeftHandled)

	TEST_F (KeyboardTest, ArrowLeftUnhandled)

	TEST_F (KeyboardTest, ShiftLeftUnhandled)

	TEST_F (KeyboardTest, ShiftRightUnhandled)

	TEST_F (KeyboardTest, CtrlLeftUnhandled)

	TEST_F (KeyboardTest, CtrlRightUnhandled)

	TEST_F (KeyboardTest, AltLeftUnhandled)

	TEST_F (KeyboardTest, AltRightUnhandled)

	TEST_F (KeyboardTest, MetaLeftUnhandled)

	TEST_F (KeyboardTest, MetaRightUnhandled)

	TEST_F (KeyboardTest, RepeatA)

	TEST_F (KeyboardTest, RestartClearsKeyboardState)

	TEST_F (KeyboardTest, ShiftLeftKeyA)

	TEST_F (KeyboardTest, CtrlLeftKeyA)

	TEST_F (KeyboardTest, CtrlLeftDigit1)

	TEST_F (KeyboardTest, Digit1OnFrenchLayout)

	TEST_F (KeyboardTest, AltGrModifiedKey)

	TEST_F (KeyboardTest, AltGrTwice)

	TEST_F (KeyboardTest, DeadKeyThatCombines)

	TEST_F (KeyboardTest, DeadKeyWithoutDeadMaskThatCombines)

	TEST_F (KeyboardTest, DeadKeyThatDoesNotCombine)

	TEST_F (KeyboardTest, DeadKeyTwiceThenLetter)

	TEST_F (KeyboardTest, MultibyteCharacter)

	TEST_F (KeyboardTest, SynthesizeModifiers)

	TEST_F (KeyboardTest, ImeExtendedEventsAreIgnored)

	TEST_F (KeyboardTest, UpOnlyImeEventsAreCorrectlyHandled)

	TEST_F (KeyboardTest, SlowFrameworkResponse)

	TEST_F (KeyboardTest, SlowFrameworkResponseForIdenticalEvents)

	TEST_F (KeyboardTest, TextInputSubmit)

	TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithFastResponse)

void	VietnameseTelexAddDiacriticWithSlowResponse (WindowsTestContext &context, bool backspace_response)

	TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithSlowFalseResponse)

	TEST_F (KeyboardTest, VietnameseTelexAddDiacriticWithSlowTrueResponse)

	TEST_F (KeyboardTest, DoubleCapsLock)

	TEST (KeyboardWin32CommonTest, EncodeUtf16)

	TEST_F (PlatformHandlerTest, GetClipboardData)

	TEST_F (PlatformHandlerTest, GetClipboardDataRejectsUnknownContentType)

	TEST_F (PlatformHandlerTest, GetClipboardDataRequiresView)

	TEST_F (PlatformHandlerTest, GetClipboardDataReportsOpenFailure)

	TEST_F (PlatformHandlerTest, GetClipboardDataReportsGetDataFailure)

	TEST_F (PlatformHandlerTest, ClipboardHasStrings)

	TEST_F (PlatformHandlerTest, ClipboardHasStringsReturnsFalse)

	TEST_F (PlatformHandlerTest, ClipboardHasStringsRejectsUnknownContentType)

	TEST_F (PlatformHandlerTest, ClipboardHasStringsRequiresView)

	TEST_F (PlatformHandlerTest, ClipboardHasStringsIgnoresPermissionErrors)

	TEST_F (PlatformHandlerTest, ClipboardHasStringsReportsErrors)

	TEST_F (PlatformHandlerTest, ClipboardSetData)

	TEST_F (PlatformHandlerTest, ClipboardSetDataTextMustBeString)

	TEST_F (PlatformHandlerTest, ClipboardSetDataUnknownType)

	TEST_F (PlatformHandlerTest, ClipboardSetDataRequiresView)

	TEST_F (PlatformHandlerTest, ClipboardSetDataReportsOpenFailure)

	TEST_F (PlatformHandlerTest, ClipboardSetDataReportsSetDataFailure)

	TEST_F (PlatformHandlerTest, PlaySystemSound)

	TEST_F (PlatformHandlerTest, SystemExitApplicationRequired)

	TEST_F (PlatformHandlerTest, SystemExitApplicationCancelableCancel)

	TEST_F (PlatformHandlerTest, SystemExitApplicationCancelableExit)

	TEST (SequentialIdGeneratorTest, RemoveMultipleNumbers)

	TEST (SequentialIdGeneratorTest, MaybeRemoveNumbers)

	TEST (SettingsPluginTest, SendSettingsSendsMessage)

	TEST (SettingsPluginTest, SendSettingsGetsSettings)

	TEST (SettingsPluginTest, StartWatchingStartsWatchingChanges)

	TEST (SettingsPluginTest, HighContrastModeHonored)

	TEST (SystemUtils, GetPreferredLanguageInfo)

	TEST (SystemUtils, GetPreferredLanguages)

	TEST (SystemUtils, ParseLanguageNameGeneric)

	TEST (SystemUtils, ParseLanguageNameWithRegion)

	TEST (SystemUtils, ParseLanguageNameWithScript)

	TEST (SystemUtils, ParseLanguageNameWithRegionAndScript)

	TEST (SystemUtils, ParseLanguageNameWithSuplementalLanguage)

	TEST (SystemUtils, ParseLanguageNameWithThreeCharacterLanguage)

	TEST (SystemUtils, GetUserTimeFormat)

	TEST (SystemUtils, Prefer24HourTimeHandlesEmptyFormat)

	TEST (SystemUtils, Prefer24HourTimeHandles12Hour)

	TEST (SystemUtils, Prefer24HourTimeHandles24Hour)

	TEST (TaskRunnerTest, MaybeExecuteTaskWithExactOrder)

	TEST (TaskRunnerTest, MaybeExecuteTaskOnlyExpired)

char *	clone_string (const char *string)

::testing::AssertionResult	_EventEquals (const char expr_event, const char expr_expected, const FlutterKeyEvent &event, const FlutterKeyEvent &expected)

LPARAM	CreateKeyEventLparam (USHORT scancode, bool extended, bool was_down, USHORT repeat_count, bool context_code, bool transition_state)

void	MockEmbedderApiForKeyboard (EngineModifier &modifier, std::shared_ptr< MockKeyResponseController > response_controller)

	TEST (TestKeyboard, CloneString)

	TEST (TestKeyboard, CreateKeyEventLparam)

	TEST_F (TextInputPluginTest, TextMethodsWorksWithEmptyModel)

	TEST_F (TextInputPluginTest, ClearClientResetsComposing)

	TEST_F (TextInputPluginTest, ClearClientRequiresView)

	TEST_F (TextInputPluginTest, VerifyComposingSendStateUpdate)

	TEST_F (TextInputPluginTest, VerifyInputActionNewlineInsertNewLine)

	TEST_F (TextInputPluginTest, VerifyInputActionSendDoesNotInsertNewLine)

	TEST_F (TextInputPluginTest, TextEditingWorksWithDeltaModel)

	TEST_F (TextInputPluginTest, CompositionCursorPos)

	TEST_F (TextInputPluginTest, TransformCursorRect)

	TEST_F (TextInputPluginTest, SetMarkedTextRectRequiresView)

	TEST (WindowProcDelegateManagerTest, CallsCorrectly)

	TEST (WindowProcDelegateManagerTest, ReplacementRegister)

	TEST (WindowProcDelegateManagerTest, RegisterMultiple)

	TEST (WindowProcDelegateManagerTest, Ordered)

	TEST (WindowProcDelegateManagerTest, ConflictingDelegates)

	TEST (WindowProcDelegateManagerTest, Unregister)

	TEST (MockWindow, CreateDestroy)

	TEST (MockWindow, GetDpiAfterCreate)

	TEST (MockWindow, VerticalScroll)

	TEST (MockWindow, OnImeCompositionCompose)

	TEST (MockWindow, OnImeCompositionResult)

	TEST (MockWindow, OnImeCompositionResultAndCompose)

	TEST (MockWindow, OnImeCompositionClearChange)

	TEST (MockWindow, HorizontalScroll)

	TEST (MockWindow, MouseLeave)

	TEST (MockWindow, KeyDown)

	TEST (MockWindow, KeyUp)

	TEST (MockWindow, SysKeyDown)

	TEST (MockWindow, SysKeyUp)

	TEST (MockWindow, KeyDownPrintable)

	TEST (MockWindow, KeyDownWithCtrl)

	TEST (MockWindow, KeyDownWithCtrlToggled)

	TEST (MockWindow, Paint)

	TEST (MockWindow, PointerHitTest)

	TEST (MockWindow, TouchPadHitTest)

	TEST (MockWindow, UnknownPointerTypeSkipsDirectManipulation)

	TEST (MockWindow, DISABLED_GetObjectUia)

	TEST_F (WindowsLifecycleManagerTest, StateTransitions)

bool	NumberNear (double a, double b)

std::unique_ptr< AutoIsolateShutdown >	RunDartCodeInIsolateOnUITaskRunner (DartVMRef &vm_ref, const Settings &p_settings, const TaskRunners &task_runners, std::string entrypoint, const std::vector< std::string > &args, const std::string &kernel_file_path, fml::WeakPtr< IOManager > io_manager, const std::shared_ptr< VolatilePathTracker > &volatile_path_tracker, std::unique_ptr< PlatformConfiguration > platform_configuration)

std::unique_ptr< AutoIsolateShutdown >	RunDartCodeInIsolate (DartVMRef &vm_ref, const Settings &settings, const TaskRunners &task_runners, std::string entrypoint, const std::vector< std::string > &args, const std::string &kernel_file_path, fml::WeakPtr< IOManager > io_manager, std::shared_ptr< VolatilePathTracker > volatile_path_tracker, std::unique_ptr< PlatformConfiguration > platform_configuration)

void	RunDartCodeInIsolate (DartVMRef &vm_ref, std::unique_ptr< AutoIsolateShutdown > &result, const Settings &settings, const TaskRunners &task_runners, std::string entrypoint, const std::vector< std::string > &args, const std::string &fixtures_path, fml::WeakPtr< IOManager > io_manager={}, std::shared_ptr< VolatilePathTracker > volatile_path_tracker=nullptr, std::unique_ptr< PlatformConfiguration > platform_configuration=nullptr)

DebuggerStatus	GetDebuggerStatus ()

bool	DisplayListsEQ_Verbose (const DisplayList a, const DisplayList b)

bool	DisplayListsNE_Verbose (const DisplayList a, const DisplayList b)

bool	DisplayListsEQ_Verbose (const DisplayList &a, const DisplayList &b)

bool	DisplayListsEQ_Verbose (const sk_sp< const DisplayList > &a, const sk_sp< const DisplayList > &b)

bool	DisplayListsNE_Verbose (const DisplayList &a, const DisplayList &b)

bool	DisplayListsNE_Verbose (const sk_sp< const DisplayList > &a, const sk_sp< const DisplayList > &b)

ELFAOTSymbols	LoadELFSymbolFromFixturesIfNeccessary (std::string elf_filename)
	Attempts to resolve AOT symbols from the portable ELF loader. This location is automatically resolved from the fixtures generator. This only returns valid symbols when the VM is configured for AOT. More...

ELFAOTSymbols	LoadELFSplitSymbolFromFixturesIfNeccessary (std::string elf_split_filename)
	Attempts to resolve split loading unit AOT symbols from the portable ELF loader. If the dart code does not make use of deferred libraries, then there will be no split .so to load. This only returns valid symbols when the VM is configured for AOT. More...

bool	PrepareSettingsForAOTWithSymbols (Settings &settings, const ELFAOTSymbols &symbols)
	Prepare the settings objects various AOT mappings resolvers with the symbols already loaded. This method does nothing in non-AOT runtime modes. More...

std::string	TestStatusAsString (const ::testing::TestResult *result)

std::string	TestLabel (const ::testing::TestInfo &info)

std::string	TestTimeAsString (const ::testing::TestResult *result)

static std::ostream &	operator<< (std::ostream &os, const SkPoint &r)

static std::ostream &	operator<< (std::ostream &os, const SkRect &r)

static std::ostream &	operator<< (std::ostream &os, const SkRRect &r)

static std::ostream &	operator<< (std::ostream &os, const SkPath &r)

static std::ostream &	operator<< (std::ostream &os, const SkM44 &m)

bool	operator== (const MockCanvas::SaveData &a, const MockCanvas::SaveData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::SaveData &data)

bool	operator== (const MockCanvas::SaveLayerData &a, const MockCanvas::SaveLayerData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::SaveLayerData &data)

bool	operator== (const MockCanvas::RestoreData &a, const MockCanvas::RestoreData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::RestoreData &data)

bool	operator== (const MockCanvas::ConcatMatrixData &a, const MockCanvas::ConcatMatrixData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::ConcatMatrixData &data)

bool	operator== (const MockCanvas::SetMatrixData &a, const MockCanvas::SetMatrixData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::SetMatrixData &data)

bool	operator== (const MockCanvas::DrawRectData &a, const MockCanvas::DrawRectData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawRectData &data)

bool	operator== (const MockCanvas::DrawPathData &a, const MockCanvas::DrawPathData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawPathData &data)

bool	operator== (const MockCanvas::DrawTextData &a, const MockCanvas::DrawTextData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawTextData &data)

bool	operator== (const MockCanvas::DrawImageData &a, const MockCanvas::DrawImageData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawImageData &data)

bool	operator== (const MockCanvas::DrawImageDataNoPaint &a, const MockCanvas::DrawImageDataNoPaint &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawImageDataNoPaint &data)

bool	operator== (const MockCanvas::DrawDisplayListData &a, const MockCanvas::DrawDisplayListData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawDisplayListData &data)

bool	operator== (const MockCanvas::DrawShadowData &a, const MockCanvas::DrawShadowData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawShadowData &data)

bool	operator== (const MockCanvas::ClipRectData &a, const MockCanvas::ClipRectData &b)

static std::ostream &	operator<< (std::ostream &os, const MockCanvas::ClipEdgeStyle &style)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::ClipRectData &data)

bool	operator== (const MockCanvas::ClipRRectData &a, const MockCanvas::ClipRRectData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::ClipRRectData &data)

bool	operator== (const MockCanvas::ClipPathData &a, const MockCanvas::ClipPathData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::ClipPathData &data)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawCallData &data)

bool	operator== (const MockCanvas::DrawCall &a, const MockCanvas::DrawCall &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawCall &draw)

bool	operator== (const MockCanvas::DrawPaintData &a, const MockCanvas::DrawPaintData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawPaintData &data)

	TEST_F (MockCanvasTest, DrawRRectDies)

	TEST_F (MockCanvasTest, DrawCalls)

void	PostTaskSync (const fml::RefPtr< fml::TaskRunner > &task_runner, const std::function< void()> &function)

const fml::CommandLine &	GetArgsForProcess ()

void	SetArgsForProcess (int argc, char **argv)

static const uint8_t *	DartNativeEntrySymbolCallback (Dart_NativeFunction function)

static std::string	GetEGLError ()

static bool	HasExtension (const char extensions, const char name)

static void	CheckSwanglekExtensions ()

static EGLDisplay	CreateSwangleDisplay ()

template<class T >
auto	WeakPtr (std::shared_ptr< T > pointer)

static std::string	GetTestNameFromTestInfo (const ::testing::TestInfo &test_info)

std::string	GetCurrentTestName ()
	Gets the name of the currently running test. This is useful in generating logs or assets based on test name. More...

std::string	GetDefaultKernelFilePath ()
	Returns the default path to kernel_blob.bin. This file is within the directory returned by `GetFixturesPath()`. More...

fml::UniqueFD	OpenFixturesDirectory ()
	Opens the fixtures directory for the unit-test harness. More...

fml::UniqueFD	OpenFixture (const std::string &fixture_name)
	Opens a fixture of the given file name. More...

std::unique_ptr< fml::Mapping >	OpenFixtureAsMapping (const std::string &fixture_name)
	Opens a fixture of the given file name and returns a mapping to its contents. More...

sk_sp< SkData >	OpenFixtureAsSkData (const std::string &fixture_name)
	Opens a fixture of the given file name and returns a Skia SkData holding its contents. More...

bool	MemsetPatternSetOrCheck (uint8_t *buffer, size_t size, MemsetPatternOp op)
	Depending on the operation, either scribbles a known pattern into the buffer or checks if that pattern is present in an existing buffer. This is a portable variant of the memset_pattern class of methods that also happen to do assert that the same pattern exists. More...

bool	MemsetPatternSetOrCheck (std::vector< uint8_t > &buffer, MemsetPatternOp op)

const char *	GetSourcePath ()

const char *	GetFixturesPath ()
	Returns the directory containing the test fixture for the target if this target has fixtures configured. If there are no fixtures, this is a link error. If you see a linker error on this symbol, the unit-test target needs to depend on a `test_fixtures` target. More...

const char *	GetTestingAssetsPath ()
	Returns the directory containing assets shared across all tests. More...

	TEST_F (FileLoaderTest, CanonicalizesFileUrlCorrectly)

	TEST_F (DartPersistentHandleTest, ClearAfterShutdown)

	TEST_F (DartState, CurrentWithNullDataDoesNotSegfault)

	TEST_F (DartState, IsShuttingDown)

	TEST_F (DartWeakPersistentHandle, ClearImmediately)

	TEST_F (DartWeakPersistentHandle, ClearLaterCc)

	TEST_F (DartWeakPersistentHandle, ClearLaterDart)

	TEST_F (DartWeakPersistentHandle, ClearOnShutdown)

void	Nop ()

	TEST_F (FfiNativeTest, FfiBindingCallNop)

	TEST_F (FfiNativeTest, SerialiseNop)

bool	EchoBool (bool arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoBool)

	TEST_F (FfiNativeTest, SerialiseEchoBool)

intptr_t	EchoIntPtr (intptr_t arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoIntPtr)

	TEST_F (FfiNativeTest, SerialiseEchoIntPtr)

double	EchoDouble (double arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoDouble)

	TEST_F (FfiNativeTest, SerialiseEchoDouble)

Dart_Handle	EchoHandle (Dart_Handle str)

	TEST_F (FfiNativeTest, FfiBindingCallEchoHandle)

	TEST_F (FfiNativeTest, SerialiseEchoHandle)

std::string	EchoString (std::string arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoString)

	TEST_F (FfiNativeTest, SerialiseEchoString)

std::u16string	EchoU16String (std::u16string arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoU16String)

	TEST_F (FfiNativeTest, SerialiseEchoU16String)

std::vector< std::string >	EchoVector (const std::vector< std::string > &arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoVector)

	TEST_F (FfiNativeTest, SerialiseEchoVector)

intptr_t	EchoWrappable (MyNativeClass *arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoWrappable)

	TEST_F (FfiNativeTest, SerialiseEchoWrappable)

tonic::Float32List	EchoTypedList (tonic::Float32List arg)

	TEST_F (FfiNativeTest, FfiBindingCallEchoTypedList)

	TEST_F (FfiNativeTest, SerialiseEchoTypedList)

	TEST_F (FfiNativeTest, FfiBindingCallClassMemberFunction)

	TEST_F (FfiNativeTest, SerialiseClassMemberFunction)

	TEST_F (FfiNativeTest, FfiBindingCallClassMemberMethod)

	TEST_F (FfiNativeTest, SerialiseClassMemberMethod)

	TEST_F (PainterTest, DrawsSolidLineSkia)

	TEST_F (PainterTest, DrawDashedLineSkia)

Variables
constexpr size_t	kLinesToDraw = 10000

constexpr size_t	kRectsToDraw = 5000

constexpr size_t	kOvalsToDraw = 1000

constexpr size_t	kCirclesToDraw = 5000

constexpr size_t	kRRectsToDraw = 5000

constexpr size_t	kDRRectsToDraw = 2000

constexpr size_t	kArcSweepSetsToDraw = 1000

constexpr size_t	kImagesToDraw = 500

constexpr size_t	kFixedCanvasSize = 1024

static std::vector< testing::DisplayListInvocationGroup >	allGroups

static const float	kMatrix [20]

static const sk_sp< DlRuntimeEffect >	kTestRuntimeEffect1

static const sk_sp< DlRuntimeEffect >	kTestRuntimeEffect2

static const sk_sp< DlImage >	kTestImage1 = MakeTestImage(10, 10, SK_ColorGREEN)

static const sk_sp< DlImage >	kTestAlphaImage1

static const SkMatrix	kTestMatrix1

static const SkMatrix	kTestMatrix2

static constexpr int	kTestStopCount = 3

static constexpr DlColor	kTestColors [kTestStopCount]

static const DlColor	kTestAlphaColors [kTestStopCount]

static constexpr float	kTestStops [kTestStopCount]

static constexpr float	kTestStops2 [kTestStopCount]

static constexpr SkPoint	kTestPoints [2]

static constexpr SkPoint	kTestPoints2 [2]

static const DlColor	kTestColors [2]

static const float	kTestStops [2] = {0.0f, 1.0f}

static const auto	kTestLinearGradient

constexpr int	kTestWidth = 200

constexpr int	kTestHeight = 200

constexpr int	kRenderWidth = 100

constexpr int	kRenderHeight = 100

constexpr int	kRenderHalfWidth = 50

constexpr int	kRenderHalfHeight = 50

constexpr int	kRenderLeft = (kTestWidth - kRenderWidth) / 2

constexpr int	kRenderTop = (kTestHeight - kRenderHeight) / 2

constexpr int	kRenderRight = kRenderLeft + kRenderWidth

constexpr int	kRenderBottom = kRenderTop + kRenderHeight

constexpr int	kRenderCenterX = (kRenderLeft + kRenderRight) / 2

constexpr int	kRenderCenterY = (kRenderTop + kRenderBottom) / 2

constexpr SkScalar	kRenderRadius = std::min(kRenderWidth, kRenderHeight) / 2.0

constexpr SkScalar	kRenderCornerRadius = kRenderRadius / 5.0

constexpr SkPoint	kTestCenter = SkPoint::Make(kTestWidth / 2, kTestHeight / 2)

constexpr SkRect	kTestBounds2 = SkRect::MakeWH(kTestWidth, kTestHeight)

constexpr SkRect	kRenderBounds

constexpr SkScalar	kMiterExtremeDiamondOffsetX = kRenderHeight * 0.04

constexpr SkScalar	kMiter10DiamondOffsetX = kRenderHeight * 0.051

constexpr SkScalar	kMiter4DiamondOffsetX = kRenderHeight * 0.14

constexpr SkScalar	kMiterExtremeDiamondOffsetY = kRenderWidth * 0.04

constexpr SkScalar	kMiter10DiamondOffsetY = kRenderWidth * 0.051

constexpr SkScalar	kMiter4DiamondOffsetY = kRenderWidth * 0.14

constexpr SkScalar	kXOffset0 = kRenderCenterX + 0.5

constexpr SkScalar	kXOffsetL1 = kXOffset0 - kMiter4DiamondOffsetX

constexpr SkScalar	kXOffsetL2 = kXOffsetL1 - kMiter10DiamondOffsetX

constexpr SkScalar	kXOffsetL3 = kXOffsetL2 - kMiter10DiamondOffsetX

constexpr SkScalar	kXOffsetR1 = kXOffset0 + kMiter4DiamondOffsetX

constexpr SkScalar	kXOffsetR2 = kXOffsetR1 + kMiterExtremeDiamondOffsetX

constexpr SkScalar	kXOffsetR3 = kXOffsetR2 + kMiterExtremeDiamondOffsetX

constexpr SkPoint	kVerticalMiterDiamondPoints []

const int	kVerticalMiterDiamondPointCount

constexpr SkScalar	kYOffset0 = kRenderCenterY + 0.5

constexpr SkScalar	kYOffsetU1 = kXOffset0 - kMiter4DiamondOffsetY

constexpr SkScalar	kYOffsetU2 = kYOffsetU1 - kMiter10DiamondOffsetY

constexpr SkScalar	kYOffsetU3 = kYOffsetU2 - kMiter10DiamondOffsetY

constexpr SkScalar	kYOffsetD1 = kXOffset0 + kMiter4DiamondOffsetY

constexpr SkScalar	kYOffsetD2 = kYOffsetD1 + kMiterExtremeDiamondOffsetY

constexpr SkScalar	kYOffsetD3 = kYOffsetD2 + kMiterExtremeDiamondOffsetY

const SkPoint	kHorizontalMiterDiamondPoints []

const int	kHorizontalMiterDiamondPointCount

static const SkSetup	kEmptySkSetup = [](const SkSetupContext&) {}

static const SkRenderer	kEmptySkRenderer = [](const SkRenderContext&) {}

static const DlSetup	kEmptyDlSetup = [](const DlSetupContext&) {}

static const DlRenderer	kEmptyDlRenderer = [](const DlRenderContext&) {}

constexpr SkPoint	kEndPoints []

const DlColor	kColors []

constexpr float	kStops []

constexpr float	kRotateColorMatrix [20]

constexpr float	kInvertColorMatrix [20]

static DlImageSampling	kNearestSampling = DlImageSampling::kNearestNeighbor

static DlImageSampling	kLinearSampling = DlImageSampling::kLinear

static auto	TestImage1 = MakeTestImage(40, 40, 5)

static auto	TestImage2 = MakeTestImage(50, 50, 5)

static auto	TestSkImage = MakeTestImage(30, 30, 5)->skia_image()

static const std::shared_ptr< DlColorSource >	kTestSource2

static const std::shared_ptr< DlColorSource >	kTestSource3

static const std::shared_ptr< DlColorSource >	kTestSource4

static const std::shared_ptr< DlColorSource >	kTestSource5

constexpr SkRect	kTestBounds = SkRect::MakeLTRB(10, 10, 50, 60)

static const SkRRect	kTestRRect = SkRRect::MakeRectXY(kTestBounds, 5, 5)

static const SkRRect	kTestRRectRect = SkRRect::MakeRect(kTestBounds)

static const SkRRect	kTestInnerRRect

static const SkPath	kTestPathRect = SkPath::Rect(kTestBounds)

static const SkPath	kTestPathOval = SkPath::Oval(kTestBounds)

static const SkPath	kTestPath1

static const SkPath	kTestPath2

static const SkPath	kTestPath3

static const SkMatrix	kTestMatrix1 = SkMatrix::Scale(2, 2)

static const SkMatrix	kTestMatrix2 = SkMatrix::RotateDeg(45)

static std::shared_ptr< const DlVertices >	TestVertices1

static std::shared_ptr< const DlVertices >	TestVertices2

static sk_sp< DisplayList >	TestDisplayList1

static sk_sp< DisplayList >	TestDisplayList2

static thread_local std::unique_ptr< int >	current_context

static std::vector< RasterCacheItem * >	raster_cache_items_

const std::string	kKernelFileName = "plugin_registrant_kernel_blob.bin"

const std::string	kElfFileName = "plugin_registrant_app_elf_snapshot.so"

static thread_local std::unique_ptr< IsolateDataMap >	isolate_data_map_

constexpr int64_t	kImplicitViewId = 0

static constexpr char	kTooltip [] = "tooltip"

constexpr uint64_t	kScanCodeKeyA = 0x1e

constexpr uint64_t	kVirtualKeyA = 0x41

static std::shared_ptr< MockKeyResponseController >	stored_response_controller

constexpr LRESULT	kWmResultZero = 0

constexpr LRESULT	kWmResultDefault = 0xDEADC0DE

constexpr LRESULT	kWmResultDontCheck = 0xFFFF1234

constexpr const char *	kDefaultAOTAppELFFileName = "app_elf_snapshot.so"

constexpr const char *	kDefaultAOTAppELFSplitFileName

constexpr SkISize	kSize = SkISize::Make(64, 64)

static constexpr SkRect	kEmptyRect = SkRect::MakeEmpty()

static fml::CommandLine	gProcessArgs

static std::mutex	gIsolateResolversMutex

static std::map< Dart_Isolate, std::weak_ptr< TestDartNativeResolver > >	gIsolateResolvers

tonic::DartWeakPersistentValue	global_weak_persistent_value

static const std::string	kEmojiFontFile

static const std::string	kEmojiFontName

Typedef Documentation

◆ BackdropFilterLayerTest

using flutter::testing::BackdropFilterLayerTest = typedef LayerTest

Definition at line 18 of file backdrop_filter_layer_unittests.cc.

◆ BackdropLayerDiffTest

using flutter::testing::BackdropLayerDiffTest = typedef DiffContextTest

Definition at line 424 of file backdrop_filter_layer_unittests.cc.

◆ BackendType

typedef DlSurfaceProvider::BackendType flutter::testing::BackendType

Definition at line 33 of file dl_benchmarks.h.

◆ Builder

using flutter::testing::Builder = typedef DlVertices::Builder

Definition at line 372 of file dl_vertices_unittests.cc.

◆ CanvasTest

using flutter::testing::CanvasTest = typedef CanvasTestBase<::testing::Test>

Definition at line 31 of file canvas_test.h.

◆ ChannelUpdateCallback

using flutter::testing::ChannelUpdateCallback = typedef std::function<void(const FlutterChannelUpdate*)>

Definition at line 36 of file embedder_test_context.h.

◆ ClipOp

typedef DlCanvas::ClipOp flutter::testing::ClipOp

Definition at line 50 of file display_list_unittests.cc.

◆ ClipPathLayerTest

using flutter::testing::ClipPathLayerTest = typedef LayerTest

Definition at line 22 of file clip_path_layer_unittests.cc.

◆ ClipRectLayerTest

using flutter::testing::ClipRectLayerTest = typedef LayerTest

Definition at line 21 of file clip_rect_layer_unittests.cc.

◆ ClipRRectLayerTest

using flutter::testing::ClipRRectLayerTest = typedef LayerTest

Definition at line 21 of file clip_rrect_layer_unittests.cc.

◆ ColorFilterLayerTest

using flutter::testing::ColorFilterLayerTest = typedef LayerTest

Definition at line 26 of file color_filter_layer_unittests.cc.

◆ ContainerLayerDiffTest

using flutter::testing::ContainerLayerDiffTest = typedef DiffContextTest

Definition at line 563 of file container_layer_unittests.cc.

◆ ContainerLayerTest

using flutter::testing::ContainerLayerTest = typedef LayerTest

Definition at line 22 of file container_layer_unittests.cc.

◆ Continuation

using flutter::testing::Continuation = typedef IntPipeline::ProducerContinuation

Definition at line 19 of file pipeline_unittests.cc.

◆ CreateVsyncWaiter

using flutter::testing::CreateVsyncWaiter = typedef std::function<std::unique_ptr<VsyncWaiter>()>

Definition at line 17 of file vsync_waiters_test.h.

◆ DartLifecycleTest

using flutter::testing::DartLifecycleTest = typedef FixtureTest

Definition at line 17 of file dart_lifecycle_unittests.cc.

◆ DartState

using flutter::testing::DartState = typedef FixtureTest

Definition at line 14 of file dart_state_unittest.cc.

◆ DartVMTest

using flutter::testing::DartVMTest = typedef FixtureTest

Definition at line 14 of file dart_vm_unittests.cc.

◆ DisplayListLayerDiffTest

using flutter::testing::DisplayListLayerDiffTest = typedef DiffContextTest

Definition at line 355 of file display_list_layer_unittests.cc.

◆ DisplayListLayerTest

using flutter::testing::DisplayListLayerTest = typedef LayerTest

Definition at line 20 of file display_list_layer_unittests.cc.

◆ DisplayListRendering

using flutter::testing::DisplayListRendering = typedef DisplayListRenderingTestBase<::testing::Test>

Definition at line 2796 of file dl_rendering_unittests.cc.

◆ DisplayListTest

using flutter::testing::DisplayListTest = typedef DisplayListTestBase<::testing::Test>

Definition at line 231 of file display_list_unittests.cc.

◆ DlGoldenTest

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

Definition at line 17 of file dl_golden_unittests.h.

◆ DlInvoker

typedef const std::function<void(DlOpReceiver&)> flutter::testing::DlInvoker

Definition at line 24 of file dl_test_snippets.h.

◆ DlRenderContext

using flutter::testing::DlRenderContext = typedef RenderContext<DlCanvas*, const DlPaint&, sk_sp<DlImage> >

Definition at line 353 of file dl_rendering_unittests.cc.

◆ DlRenderer

using flutter::testing::DlRenderer = typedef const std::function<void(const DlRenderContext&)>

Definition at line 359 of file dl_rendering_unittests.cc.

◆ DlSetup

using flutter::testing::DlSetup = typedef const std::function<void(const DlSetupContext&)>

Definition at line 358 of file dl_rendering_unittests.cc.

◆ DlSetupContext

using flutter::testing::DlSetupContext = typedef RenderContext<DlCanvas*, DlPaint&, sk_sp<DlImage> >

Definition at line 350 of file dl_rendering_unittests.cc.

◆ EmbedderA11yTest

using flutter::testing::EmbedderA11yTest = typedef testing::EmbedderTest

Definition at line 29 of file embedder_a11y_unittests.cc.

◆ EmbedderTest

typedef testing::EmbedderTest flutter::testing::EmbedderTest

Definition at line 47 of file embedder_gl_unittests.cc.

◆ EnginePtr

using flutter::testing::EnginePtr = typedef std::unique_ptr<FlutterDesktopEngine, EngineDeleter>

Definition at line 29 of file windows_test_config_builder.h.

◆ FileLoaderTest

using flutter::testing::FileLoaderTest = typedef FixtureTest

Definition at line 14 of file file_loader_unittests.cc.

◆ FlutterChannelKeyResponderTest

using flutter::testing::FlutterChannelKeyResponderTest = typedef AutoreleasePoolTest

Definition at line 73 of file FlutterChannelKeyResponderTest.mm.

◆ FlutterEmbedderExternalTextureTest

using flutter::testing::FlutterEmbedderExternalTextureTest = typedef AutoreleasePoolTest

Definition at line 71 of file FlutterEmbedderExternalTextureTest.mm.

◆ FlutterViewControllerMockEngineTest

using flutter::testing::FlutterViewControllerMockEngineTest = typedef MockFlutterEngineTest

Definition at line 180 of file FlutterViewControllerTest.mm.

◆ FlutterViewControllerTest

using flutter::testing::FlutterViewControllerTest = typedef AutoreleasePoolTest

Definition at line 179 of file FlutterViewControllerTest.mm.

◆ FrameContent

using flutter::testing::FrameContent = typedef std::map<int64_t, ViewContent>

Definition at line 37 of file shell_test.h.

◆ Generator

using flutter::testing::Generator = typedef std::function<UnitlessTime(int)>

Definition at line 20 of file input_events_unittests.cc.

◆ HooksTest

using flutter::testing::HooksTest = typedef ShellTest

Definition at line 21 of file hooks_unittests.cc.

◆ ImageFilterLayerDiffTest

using flutter::testing::ImageFilterLayerDiffTest = typedef DiffContextTest

Definition at line 623 of file image_filter_layer_unittests.cc.

◆ ImageFilterLayerTest

using flutter::testing::ImageFilterLayerTest = typedef LayerTest

Definition at line 24 of file image_filter_layer_unittests.cc.

◆ IntPipeline

using flutter::testing::IntPipeline = typedef Pipeline<int>

Definition at line 18 of file pipeline_unittests.cc.

◆ IsolateDataMap

using flutter::testing::IsolateDataMap = typedef std::unordered_map<Dart_Isolate, std::vector<std::unique_ptr<IsolateData> >>

Definition at line 27 of file platform_isolate_manager_unittests.cc.

◆ LayerTest

using flutter::testing::LayerTest = typedef LayerTestBase<::testing::Test>

Definition at line 210 of file layer_test.h.

◆ LayerTreeBuilder

using flutter::testing::LayerTreeBuilder = typedef std::function<void(std::shared_ptr<ContainerLayer> root)>

Definition at line 33 of file shell_test.h.

◆ LogMessageCallback

using flutter::testing::LogMessageCallback = typedef std::function<void(const char* tag, const char* message)>

Definition at line 34 of file embedder_test_context.h.

◆ MetalScreenshotter

using flutter::testing::MetalScreenshotter = typedef impeller::testing::MetalScreenshotter

Definition at line 16 of file dl_test_surface_metal.h.

◆ MockCanvasTest

using flutter::testing::MockCanvasTest = typedef CanvasTest

Definition at line 13 of file mock_canvas_unittests.cc.

◆ MockLayerTest

using flutter::testing::MockLayerTest = typedef LayerTest

Definition at line 14 of file mock_layer_unittests.cc.

◆ NativeEntry

using flutter::testing::NativeEntry = typedef std::function<void(Dart_NativeArguments)>

Definition at line 29 of file test_dart_native_resolver.h.

◆ OpacityLayerDiffTest

using flutter::testing::OpacityLayerDiffTest = typedef DiffContextTest

Definition at line 650 of file opacity_layer_unittests.cc.

◆ OpacityLayerTest

using flutter::testing::OpacityLayerTest = typedef LayerTest

Definition at line 27 of file opacity_layer_unittests.cc.

◆ PainterTest

using flutter::testing::PainterTest = typedef PainterTestBase<::testing::Test>

Definition at line 184 of file paragraph_unittests.cc.

◆ PerformanceOverlayLayerTest

using flutter::testing::PerformanceOverlayLayerTest = typedef LayerTest

Definition at line 132 of file performance_overlay_layer_unittests.cc.

◆ PersistentCacheTest

using flutter::testing::PersistentCacheTest = typedef ShellTest

Definition at line 24 of file persistent_cache_unittests.cc.

◆ PixelFormat

typedef DlSurfaceProvider::PixelFormat flutter::testing::PixelFormat

Definition at line 365 of file dl_rendering_unittests.cc.

◆ PlatformViewLayerTest

using flutter::testing::PlatformViewLayerTest = typedef LayerTest

Definition at line 18 of file platform_view_layer_unittests.cc.

◆ PointMode

typedef DlCanvas::PointMode flutter::testing::PointMode

Definition at line 51 of file display_list_unittests.cc.

◆ RasterCacheTest

using flutter::testing::RasterCacheTest = typedef LayerTest

Definition at line 748 of file raster_cache_unittests.cc.

◆ SemanticsActionCallback

using flutter::testing::SemanticsActionCallback = typedef std::function<void(const FlutterSemanticsCustomAction*)>

Definition at line 32 of file embedder_test_context.h.

◆ SemanticsNodeCallback

using flutter::testing::SemanticsNodeCallback = typedef std::function<void(const FlutterSemanticsNode*)>

Definition at line 31 of file embedder_test_context.h.

◆ SemanticsUpdateBuilderTest

using flutter::testing::SemanticsUpdateBuilderTest = typedef ShellTest

Definition at line 13 of file semantics_update_builder_unittests.cc.

◆ SemanticsUpdateCallback

using flutter::testing::SemanticsUpdateCallback = typedef std::function<void(const FlutterSemanticsUpdate*)>

Definition at line 29 of file embedder_test_context.h.

◆ SemanticsUpdateCallback2

using flutter::testing::SemanticsUpdateCallback2 = typedef std::function<void(const FlutterSemanticsUpdate2*)>

Definition at line 27 of file embedder_test_context.h.

◆ ShaderMaskLayerTest

using flutter::testing::ShaderMaskLayerTest = typedef LayerTest

Definition at line 22 of file shader_mask_layer_unittests.cc.

◆ SkRenderContext

using flutter::testing::SkRenderContext = typedef RenderContext<SkCanvas*, const SkPaint&, sk_sp<SkImage> >

Definition at line 351 of file dl_rendering_unittests.cc.

◆ SkRenderer

using flutter::testing::SkRenderer = typedef const std::function<void(const SkRenderContext&)>

Definition at line 357 of file dl_rendering_unittests.cc.

◆ SkSetup

using flutter::testing::SkSetup = typedef const std::function<void(const SkSetupContext&)>

Definition at line 356 of file dl_rendering_unittests.cc.

◆ SkSetupContext

using flutter::testing::SkSetupContext = typedef RenderContext<SkCanvas*, SkPaint&, sk_sp<SkImage> >

Definition at line 349 of file dl_rendering_unittests.cc.

◆ TextureLayerDiffTest

using flutter::testing::TextureLayerDiffTest = typedef DiffContextTest

Definition at line 99 of file texture_layer_unittests.cc.

◆ TextureLayerTest

using flutter::testing::TextureLayerTest = typedef LayerTest

Definition at line 17 of file texture_layer_unittests.cc.

◆ TransformLayerLayerDiffTest

using flutter::testing::TransformLayerLayerDiffTest = typedef DiffContextTest

Definition at line 475 of file transform_layer_unittests.cc.

◆ TransformLayerTest

using flutter::testing::TransformLayerTest = typedef LayerTest

Definition at line 15 of file transform_layer_unittests.cc.

◆ UniqueAOTData

using flutter::testing::UniqueAOTData = typedef std::unique_ptr<_FlutterEngineAOTData, AOTDataDeleter>

Definition at line 46 of file embedder_test_context.h.

◆ UniqueEngine

using flutter::testing::UniqueEngine = typedef fml::UniqueObject<FlutterEngine, UniqueEngineTraits>

Definition at line 28 of file embedder_config_builder.h.

◆ UniqueLoadedELF

using flutter::testing::UniqueLoadedELF = typedef std::unique_ptr<Dart_LoadedElf, LoadedELFDeleter>

Definition at line 31 of file elf_loader.h.

◆ UnitlessTime

using flutter::testing::UnitlessTime = typedef int

Definition at line 16 of file input_events_unittests.cc.

◆ ViewControllerPtr

using flutter::testing::ViewControllerPtr = typedef std::unique_ptr<FlutterDesktopViewController, ViewControllerDeleter>

Definition at line 40 of file windows_test_config_builder.h.

◆ WmCharInfo

typedef struct flutter::testing::WmCharInfo flutter::testing::WmCharInfo

◆ WmDeadCharInfo

typedef struct flutter::testing::WmDeadCharInfo flutter::testing::WmDeadCharInfo

◆ WmFieldContext

typedef enum flutter::testing::WmFieldContext flutter::testing::WmFieldContext

◆ WmFieldExtended

typedef enum flutter::testing::WmFieldExtended flutter::testing::WmFieldExtended

◆ WmFieldPrevState

typedef enum flutter::testing::WmFieldPrevState flutter::testing::WmFieldPrevState

◆ WmFieldTransitionState

typedef enum flutter::testing::WmFieldTransitionState flutter::testing::WmFieldTransitionState

◆ WmKeyDownInfo

typedef struct flutter::testing::WmKeyDownInfo flutter::testing::WmKeyDownInfo

◆ WmKeyUpInfo

typedef struct flutter::testing::WmKeyUpInfo flutter::testing::WmKeyUpInfo

◆ WmSysKeyDownInfo

typedef struct flutter::testing::WmSysKeyDownInfo flutter::testing::WmSysKeyDownInfo

◆ WmSysKeyUpInfo

typedef struct flutter::testing::WmSysKeyUpInfo flutter::testing::WmSysKeyUpInfo

Enumeration Type Documentation

◆ BenchmarkAttributes

enum flutter::testing::BenchmarkAttributes

Enumerator
kEmpty
kStrokedStyle
kFilledStyle
kHairlineStroke
kAntiAliasing

Definition at line 23 of file dl_benchmarks.h.

                         {
  kEmpty = 0,
  kStrokedStyle = 1 << 0,
  kFilledStyle = 1 << 1,
  kHairlineStroke = 1 << 2,
  kAntiAliasing = 1 << 3
};

◆ DebuggerStatus

enum class flutter::testing::DebuggerStatus

strong

Enumerator
kDontKnow
kAttached

Definition at line 13 of file debugger_detection.h.

                          {
  kDontKnow,
  kAttached,
};

◆ EmbedderTestContextType

enum class flutter::testing::EmbedderTestContextType

strong

Enumerator
kSoftwareContext
kOpenGLContext
kMetalContext
kVulkanContext

Definition at line 48 of file embedder_test_context.h.

                                   {
  kSoftwareContext,
  kOpenGLContext,
  kMetalContext,
  kVulkanContext,
};

◆ MemsetPatternOp

enum class flutter::testing::MemsetPatternOp

strong

Enumerator
kMemsetPatternOpSetBuffer
kMemsetPatternOpCheckBuffer

Definition at line 96 of file testing.h.

                           {
  kMemsetPatternOpSetBuffer,
  kMemsetPatternOpCheckBuffer,
};

◆ WmFieldContext

enum flutter::testing::WmFieldContext

Enumerator
kNoContext
kAltHeld

Definition at line 32 of file wm_builders.h.

                            {
  kNoContext = 0,
  kAltHeld = 1,
} WmFieldContext;

◆ WmFieldExtended

enum flutter::testing::WmFieldExtended

Enumerator
kNotExtended
kExtended

Definition at line 27 of file wm_builders.h.

                             {
  kNotExtended = 0,
  kExtended = 1,
} WmFieldExtended;

◆ WmFieldPrevState

enum flutter::testing::WmFieldPrevState

Enumerator
kWasUp
kWasDown

Definition at line 37 of file wm_builders.h.

                              {
  kWasUp = 0,
  kWasDown = 1,
} WmFieldPrevState;

◆ WmFieldTransitionState

enum flutter::testing::WmFieldTransitionState

Enumerator
kBeingReleased
kBeingPressed

Definition at line 42 of file wm_builders.h.

                                    {
  kBeingReleased = 0,
  kBeingPressed = 1,
} WmFieldTransitionState;

Function Documentation

◆ _EventEquals()

testing::AssertionResult flutter::testing::_EventEquals	(	const char *	expr_event,
		const char *	expr_expected,
		const FlutterKeyEvent &	event,
		const FlutterKeyEvent &	expected
	)

Definition at line 63 of file test_keyboard.cc.

                                                                         {
  _RETURN_IF_NOT_EQUALS(event.struct_size, sizeof(FlutterKeyEvent));
  _RETURN_IF_NOT_EQUALS(event.type, expected.type);
  _RETURN_IF_NOT_EQUALS(event.physical, expected.physical);
  _RETURN_IF_NOT_EQUALS(event.logical, expected.logical);
  if ((event.character == nullptr) != (expected.character == nullptr) ||
      strcmp(event.character, expected.character) != 0) {
    return ::testing::AssertionFailure()
           << "Expected equality of these values:\n  expected.character\n    "
           << _print_character(expected.character) << "\n  Actual: \n    "
           << _print_character(event.character);
  }
  _RETURN_IF_NOT_EQUALS(event.synthesized, expected.synthesized);
  return ::testing::AssertionSuccess();
}

◆ AnnotateAttributes()

void flutter::testing::AnnotateAttributes	(	unsigned	attributes,
		benchmark::State &	state,
		const DisplayListAttributeFlags	flags
	)

Definition at line 56 of file dl_benchmarks.cc.

                                                               {
  if (flags.always_stroked()) {
    state.counters["HairlineStroke"] = attributes & kHairlineStroke ? 1 : 0;
  }
  if (flags.applies_style()) {
    state.counters["HairlineStroke"] = attributes & kHairlineStroke ? 1 : 0;
    state.counters["StrokedStyle"] = attributes & kStrokedStyle ? 1 : 0;
    state.counters["FilledStyle"] = attributes & kFilledStyle ? 1 : 0;
  }
  if (flags.applies_anti_alias()) {
    state.counters["AntiAliasing"] = attributes & kAntiAliasing ? 1 : 0;
  }
}

◆ arraysEqual()

static void flutter::testing::arraysEqual	(	const uint32_t *	ints,
		const DlColor *	colors,
		int	count
	)

static

Definition at line 13 of file dl_color_unittests.cc.

                                   {
  for (int i = 0; i < count; i++) {
    EXPECT_TRUE(ints[i] == colors[i].argb());
  }
}

◆ BlendModeToString()

static std::string flutter::testing::BlendModeToString ( DlBlendMode mode )

static

Definition at line 4210 of file dl_rendering_unittests.cc.

                                                     {
  switch (mode) {
#define MODE_CASE(m)   \
  case DlBlendMode::m: \
    return #m;
    FOR_EACH_BLEND_MODE_ENUM(MODE_CASE)
#undef MODE_CASE
  }
}

◆ BM_DrawArc()

void flutter::testing::BM_DrawArc	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 426 of file dl_benchmarks.cc.

                                     {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state,
                     DisplayListOpFlags::kDrawArcNoCenterFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkScalar starting_angle = 0.0f;
  SkScalar offset = 0.5f;
 
  // Just some random sweeps that will mostly circumnavigate the circle
  std::vector<SkScalar> segment_sweeps = {5.5f,  -10.0f, 42.0f, 71.7f, 90.0f,
                                          37.5f, 17.9f,  32.0f, 379.4f};
 
  SkRect bounds = SkRect::MakeLTRB(0, 0, length, length);
 
  state.counters["DrawCallCount"] = kArcSweepSetsToDraw * segment_sweeps.size();
  for (size_t i = 0; i < kArcSweepSetsToDraw; i++) {
    for (SkScalar sweep : segment_sweeps) {
      builder.DrawArc(bounds, starting_angle, sweep, false, paint);
      starting_angle += sweep + 5.0f;
    }
    bounds.offset(offset, offset);
    if (bounds.right() > canvas_size) {
      bounds.offset(-canvas_size, 0);
    }
    if (bounds.bottom() > canvas_size) {
      bounds.offset(0, -canvas_size);
    }
  }
 
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawArc-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawCircle()

void flutter::testing::BM_DrawCircle	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 222 of file dl_benchmarks.cc.

                                        {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawCircleFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkScalar radius = length / 2.0f;
  const SkScalar offset = 0.5f;
 
  SkPoint center = SkPoint::Make(radius, radius);
 
  state.counters["DrawCallCount"] = kCirclesToDraw;
  for (size_t i = 0; i < kCirclesToDraw; i++) {
    builder.DrawCircle(center, radius, paint);
    center.offset(offset, offset);
    if (center.x() + radius > canvas_size) {
      center.set(radius, center.y());
    }
    if (center.y() + radius > canvas_size) {
      center.set(center.x(), radius);
    }
  }
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawCircle-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawDRRect()

void flutter::testing::BM_DrawDRRect	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		SkRRect::Type	type
	)

Definition at line 351 of file dl_benchmarks.cc.

                                     {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawDRRectFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkVector radii[4] = {};
  switch (type) {
    case SkRRect::Type::kSimple_Type:
      radii[0] = SkVector::Make(5.0f, 5.0f);
      radii[1] = SkVector::Make(5.0f, 5.0f);
      radii[2] = SkVector::Make(5.0f, 5.0f);
      radii[3] = SkVector::Make(5.0f, 5.0f);
      break;
    case SkRRect::Type::kNinePatch_Type:
      radii[0] = SkVector::Make(5.0f, 7.0f);
      radii[1] = SkVector::Make(3.0f, 7.0f);
      radii[2] = SkVector::Make(3.0f, 4.0f);
      radii[3] = SkVector::Make(5.0f, 4.0f);
      break;
    case SkRRect::Type::kComplex_Type:
      radii[0] = SkVector::Make(5.0f, 4.0f);
      radii[1] = SkVector::Make(4.0f, 5.0f);
      radii[2] = SkVector::Make(3.0f, 6.0f);
      radii[3] = SkVector::Make(8.0f, 7.0f);
      break;
    default:
      break;
  }
 
  const SkScalar offset = 0.5f;
  const SkScalar multiplier = length / 16.0f;
  SkRRect rrect, rrect_2;
 
  SkVector set_radii[4];
  for (size_t i = 0; i < 4; i++) {
    set_radii[i] = radii[i] * multiplier;
  }
  rrect.setRectRadii(SkRect::MakeLTRB(0, 0, length, length), set_radii);
 
  state.counters["DrawCallCount"] = kDRRectsToDraw;
  for (size_t i = 0; i < kDRRectsToDraw; i++) {
    rrect.inset(0.1f * length, 0.1f * length, &rrect_2);
    builder.DrawDRRect(rrect, rrect_2, paint);
    rrect.offset(offset, offset);
    if (rrect.rect().right() > canvas_size) {
      rrect.offset(-canvas_size, 0);
    }
    if (rrect.rect().bottom() > canvas_size) {
      rrect.offset(0, -canvas_size);
    }
  }
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawDRRect-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawImage()

void flutter::testing::BM_DrawImage	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		DlImageSampling	options,
		bool	upload_bitmap
	)

Definition at line 936 of file dl_benchmarks.cc.

                                      {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state,
                     DisplayListOpFlags::kDrawImageWithPaintFlags);
 
  size_t bitmap_size = state.range(0);
  size_t canvas_size = 2 * bitmap_size;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  sk_sp<SkImage> image;
  std::shared_ptr<DlSurfaceInstance> offscreen_instance;
  sk_sp<SkSurface> offscreen;
  SkBitmap bitmap;
 
  if (upload_bitmap) {
    SkImageInfo info = SkImageInfo::Make(bitmap_size, bitmap_size,
                                         SkColorType::kRGBA_8888_SkColorType,
                                         SkAlphaType::kPremul_SkAlphaType);
    bitmap.allocPixels(info, 0);
    bitmap.eraseColor(SK_ColorBLUE);
  } else {
    offscreen_instance =
        surface_provider->MakeOffscreenSurface(bitmap_size, bitmap_size);
    offscreen = offscreen_instance->sk_surface();
    offscreen->getCanvas()->clear(SK_ColorRED);
  }
 
  SkScalar offset = 0.5f;
  SkPoint dst = SkPoint::Make(0, 0);
 
  state.counters["DrawCallCount"] = kImagesToDraw;
  for (size_t i = 0; i < kImagesToDraw; i++) {
    image = upload_bitmap ? ImageFromBitmapWithNewID(bitmap)
                          : offscreen->makeImageSnapshot();
    builder.DrawImage(DlImage::Make(image), dst, options, &paint);
 
    dst.offset(offset, offset);
    if (dst.x() + bitmap_size > canvas_size) {
      dst.set(0, dst.y());
    }
    if (dst.y() + bitmap_size > canvas_size) {
      dst.set(dst.x(), 0);
    }
  }
 
  auto display_list = builder.Build();
 
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawImage-" +
                  (upload_bitmap ? "Upload-" : "Texture-") +
                  std::to_string(bitmap_size) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawImageNine()

void flutter::testing::BM_DrawImageNine	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		const DlFilterMode	filter,
		bool	upload_bitmap
	)

Definition at line 1106 of file dl_benchmarks.cc.

                                          {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state,
                     DisplayListOpFlags::kDrawImageNineWithPaintFlags);
 
  size_t bitmap_size = state.range(0);
  size_t canvas_size = 2 * bitmap_size;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkIRect center = SkIRect::MakeXYWH(bitmap_size / 4, bitmap_size / 4,
                                     bitmap_size / 2, bitmap_size / 2);
 
  sk_sp<SkImage> image;
  std::shared_ptr<DlSurfaceInstance> offscreen_instance;
  sk_sp<SkSurface> offscreen;
  SkBitmap bitmap;
 
  if (upload_bitmap) {
    SkImageInfo info = SkImageInfo::Make(bitmap_size, bitmap_size,
                                         SkColorType::kRGBA_8888_SkColorType,
                                         SkAlphaType::kPremul_SkAlphaType);
    bitmap.allocPixels(info, 0);
    bitmap.eraseColor(SK_ColorBLUE);
  } else {
    offscreen_instance =
        surface_provider->MakeOffscreenSurface(bitmap_size, bitmap_size);
    offscreen = offscreen_instance->sk_surface();
    offscreen->getCanvas()->clear(SK_ColorRED);
  }
 
  SkScalar offset = 0.5f;
  SkRect dst =
      SkRect::MakeXYWH(0.0f, 0.0f, bitmap_size * 0.75f, bitmap_size * 0.75f);
 
  state.counters["DrawCallCount"] = kImagesToDraw;
  for (size_t i = 0; i < kImagesToDraw; i++) {
    image = upload_bitmap ? ImageFromBitmapWithNewID(bitmap)
                          : offscreen->makeImageSnapshot();
    builder.DrawImageNine(DlImage::Make(image), center, dst, filter, &paint);
    dst.offset(offset, offset);
    if (dst.right() > canvas_size) {
      dst.offsetTo(0, dst.y());
    }
    if (dst.bottom() > canvas_size) {
      dst.offsetTo(dst.x(), 0);
    }
  }
 
  auto display_list = builder.Build();
 
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawImageNine-" +
                  (upload_bitmap ? "Upload-" : "Texture-") +
                  FilterModeToString(filter) + "-" +
                  std::to_string(bitmap_size) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawImageRect()

void flutter::testing::BM_DrawImageRect	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		DlImageSampling	options,
		DlCanvas::SrcRectConstraint	constraint,
		bool	upload_bitmap
	)

Definition at line 1018 of file dl_benchmarks.cc.

                                          {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state,
                     DisplayListOpFlags::kDrawImageRectWithPaintFlags);
 
  size_t bitmap_size = state.range(0);
  size_t canvas_size = 2 * bitmap_size;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  sk_sp<SkImage> image;
  std::shared_ptr<DlSurfaceInstance> offscreen_instance;
  sk_sp<SkSurface> offscreen;
  SkBitmap bitmap;
 
  if (upload_bitmap) {
    SkImageInfo info = SkImageInfo::Make(bitmap_size, bitmap_size,
                                         SkColorType::kRGBA_8888_SkColorType,
                                         SkAlphaType::kPremul_SkAlphaType);
    bitmap.allocPixels(info, 0);
    bitmap.eraseColor(SK_ColorBLUE);
  } else {
    offscreen_instance =
        surface_provider->MakeOffscreenSurface(bitmap_size, bitmap_size);
    offscreen = offscreen_instance->sk_surface();
    offscreen->getCanvas()->clear(SK_ColorRED);
  }
 
  SkScalar offset = 0.5f;
  SkRect src = SkRect::MakeXYWH(bitmap_size / 4.0f, bitmap_size / 4.0f,
                                bitmap_size / 2.0f, bitmap_size / 2.0f);
  SkRect dst =
      SkRect::MakeXYWH(0.0f, 0.0f, bitmap_size * 0.75f, bitmap_size * 0.75f);
 
  state.counters["DrawCallCount"] = kImagesToDraw;
  for (size_t i = 0; i < kImagesToDraw; i++) {
    image = upload_bitmap ? ImageFromBitmapWithNewID(bitmap)
                          : offscreen->makeImageSnapshot();
    builder.DrawImageRect(DlImage::Make(image), src, dst, options, &paint,
                          constraint);
    dst.offset(offset, offset);
    if (dst.right() > canvas_size) {
      dst.offsetTo(0, dst.y());
    }
    if (dst.bottom() > canvas_size) {
      dst.offsetTo(dst.x(), 0);
    }
  }
 
  auto display_list = builder.Build();
 
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawImageRect-" +
                  (upload_bitmap ? "Upload-" : "Texture-") +
                  ConstraintToString(constraint) + "-" +
                  std::to_string(bitmap_size) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawLine()

void flutter::testing::BM_DrawLine	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 89 of file dl_benchmarks.cc.

                                      {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawLineFlags);
 
  size_t length = state.range(0);
 
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  state.counters["DrawCallCount"] = kLinesToDraw;
  for (size_t i = 0; i < kLinesToDraw; i++) {
    builder.DrawLine(SkPoint::Make(i % length, 0),
                     SkPoint::Make(length - i % length, length), paint);
  }
 
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawLine-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawOval()

void flutter::testing::BM_DrawOval	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 176 of file dl_benchmarks.cc.

                                      {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawOvalFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkRect rect = SkRect::MakeXYWH(0, 0, length * 1.5f, length);
  const SkScalar offset = 0.5f;
 
  state.counters["DrawCallCount"] = kOvalsToDraw;
  for (size_t i = 0; i < kOvalsToDraw; i++) {
    builder.DrawOval(rect, paint);
    rect.offset(offset, offset);
    if (rect.right() > canvas_size) {
      rect.offset(-canvas_size, 0);
    }
    if (rect.bottom() > canvas_size) {
      rect.offset(0, -canvas_size);
    }
  }
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawOval-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawPath()

void flutter::testing::BM_DrawPath	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		SkPath::Verb	type
	)

Definition at line 641 of file dl_benchmarks.cc.

                                  {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawPathFlags);
 
  size_t length = kFixedCanvasSize;
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkPath path;
 
  std::string label = VerbToString(type);
  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
  float radius = length * 0.25f;
  state.SetComplexityN(state.range(0));
 
  MultiplyPath(path, type, center, 20, state.range(0), radius);
 
  state.counters["VerbCount"] = path.countVerbs();
  state.counters["DrawCallCount"] = 1;
 
  builder.DrawPath(path, paint);
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawPath-" + label +
                  "-" + std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawPoints()

void flutter::testing::BM_DrawPoints	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		DlCanvas::PointMode	mode
	)

Definition at line 875 of file dl_benchmarks.cc.

                                           {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  switch (mode) {
    case DlCanvas::PointMode::kPoints:
      AnnotateAttributes(attributes, state,
                         DisplayListOpFlags::kDrawPointsAsPointsFlags);
      break;
    case DlCanvas::PointMode::kLines:
      AnnotateAttributes(attributes, state,
                         DisplayListOpFlags::kDrawPointsAsLinesFlags);
      break;
    case DlCanvas::PointMode::kPolygon:
      AnnotateAttributes(attributes, state,
                         DisplayListOpFlags::kDrawPointsAsPolygonFlags);
      break;
  }
 
  size_t length = kFixedCanvasSize;
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  size_t point_count = state.range(0);
  state.SetComplexityN(point_count);
  state.counters["PointCount"] = point_count;
  state.counters["DrawCallCount"] = 1;
 
  std::vector<SkPoint> points =
      GetTestPoints(point_count, SkISize::Make(length, length));
  builder.DrawPoints(mode, points.size(), points.data(), paint);
 
  auto display_list = builder.Build();
 
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawPoints-" +
                  PointModeToString(mode) + "-" + std::to_string(point_count) +
                  ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawRect()

void flutter::testing::BM_DrawRect	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 127 of file dl_benchmarks.cc.

                                      {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawRectFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  // As rects have SkScalar dimensions, we want to ensure that we also
  // draw rects with non-integer position and size
  const SkScalar offset = 0.5f;
  SkRect rect = SkRect::MakeLTRB(0, 0, length, length);
 
  state.counters["DrawCallCount"] = kRectsToDraw;
  for (size_t i = 0; i < kRectsToDraw; i++) {
    builder.DrawRect(rect, paint);
    rect.offset(offset, offset);
    if (rect.right() > canvas_size) {
      rect.offset(-canvas_size, 0);
    }
    if (rect.bottom() > canvas_size) {
      rect.offset(0, -canvas_size);
    }
  }
 
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawRect-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawRRect()

void flutter::testing::BM_DrawRRect	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		SkRRect::Type	type
	)

Definition at line 270 of file dl_benchmarks.cc.

                                    {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawRRectFlags);
 
  size_t length = state.range(0);
  size_t canvas_size = length * 2;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkVector radii[4] = {};
  switch (type) {
    case SkRRect::Type::kSimple_Type:
      radii[0] = SkVector::Make(5.0f, 5.0f);
      radii[1] = SkVector::Make(5.0f, 5.0f);
      radii[2] = SkVector::Make(5.0f, 5.0f);
      radii[3] = SkVector::Make(5.0f, 5.0f);
      break;
    case SkRRect::Type::kNinePatch_Type:
      radii[0] = SkVector::Make(5.0f, 2.0f);
      radii[1] = SkVector::Make(3.0f, 2.0f);
      radii[2] = SkVector::Make(3.0f, 4.0f);
      radii[3] = SkVector::Make(5.0f, 4.0f);
      break;
    case SkRRect::Type::kComplex_Type:
      radii[0] = SkVector::Make(5.0f, 4.0f);
      radii[1] = SkVector::Make(4.0f, 5.0f);
      radii[2] = SkVector::Make(3.0f, 6.0f);
      radii[3] = SkVector::Make(2.0f, 7.0f);
      break;
    default:
      break;
  }
 
  const SkScalar offset = 0.5f;
  const SkScalar multiplier = length / 16.0f;
  SkRRect rrect;
 
  SkVector set_radii[4];
  for (size_t i = 0; i < 4; i++) {
    set_radii[i] = radii[i] * multiplier;
  }
  rrect.setRectRadii(SkRect::MakeLTRB(0, 0, length, length), set_radii);
 
  state.counters["DrawCallCount"] = kRRectsToDraw;
  for (size_t i = 0; i < kRRectsToDraw; i++) {
    builder.DrawRRect(rrect, paint);
    rrect.offset(offset, offset);
    if (rrect.rect().right() > canvas_size) {
      rrect.offset(-canvas_size, 0);
    }
    if (rrect.rect().bottom() > canvas_size) {
      rrect.offset(0, -canvas_size);
    }
  }
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawRRect-" +
                  std::to_string(state.range(0)) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawShadow()

void flutter::testing::BM_DrawShadow	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		bool	transparent_occluder,
		SkPath::Verb	type
	)

Definition at line 1229 of file dl_benchmarks.cc.

                                    {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawShadowFlags);
 
  size_t length = kFixedCanvasSize;
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkPath path;
 
  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
  float radius = length * 0.25f;
 
  switch (type) {
    case SkPath::Verb::kLine_Verb:
      GetLinesPath(path, 10, center, radius);
      break;
    case SkPath::Verb::kQuad_Verb:
      GetQuadsPath(path, 10, center, radius);
      break;
    case SkPath::Verb::kConic_Verb:
      GetConicsPath(path, 10, center, radius);
      break;
    case SkPath::Verb::kCubic_Verb:
      GetCubicsPath(path, 10, center, radius);
      break;
    default:
      break;
  }
 
  float elevation = state.range(0);
  state.counters["DrawCallCount"] = 1;
 
  // We can hardcode dpr to 1.0f as we're varying elevation, and dpr is only
  // ever used in conjunction with elevation.
  builder.DrawShadow(path, DlColor(SK_ColorBLUE), elevation,
                     transparent_occluder, 1.0f);
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawShadow-" +
                  VerbToString(type) + "-" +
                  (transparent_occluder ? "Transparent-" : "Opaque-") +
                  std::to_string(elevation) + "-" + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawTextBlob()

void flutter::testing::BM_DrawTextBlob	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes
	)

Definition at line 1184 of file dl_benchmarks.cc.

                                          {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawTextBlobFlags);
 
  size_t draw_calls = state.range(0);
  size_t canvas_size = kFixedCanvasSize;
  surface_provider->InitializeSurface(canvas_size, canvas_size);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  state.counters["DrawCallCount_Varies"] = draw_calls;
  state.counters["GlyphCount"] = draw_calls;
  char character[2] = {'A', '\0'};
 
  for (size_t i = 0; i < draw_calls; i++) {
    character[0] = 'A' + (i % 26);
    auto blob = SkTextBlob::MakeFromString(character, CreateTestFontOfSize(20));
    builder.DrawTextBlob(blob, 50.0f, 50.0f, paint);
  }
 
  auto display_list = builder.Build();
 
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawTextBlob-" +
                  std::to_string(draw_calls) + ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_DrawVertices()

void flutter::testing::BM_DrawVertices	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		DlVertexMode	mode
	)

Definition at line 779 of file dl_benchmarks.cc.

                                        {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kDrawVerticesFlags);
 
  size_t length = kFixedCanvasSize;
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
 
  float radius = length / 4.0f;
 
  size_t vertex_count, total_vertex_count = 0;
  size_t disc_count = state.range(0);
 
  std::vector<SkPoint> center_points =
      GetPolygonPoints(disc_count, center, radius / 4.0f);
 
  state.counters["DrawCallCount"] = center_points.size();
  for (SkPoint p : center_points) {
    std::shared_ptr<DlVertices> vertices =
        GetTestVertices(p, radius, 50, mode, vertex_count);
    total_vertex_count += vertex_count;
    builder.DrawVertices(vertices.get(), DlBlendMode::kSrc, paint);
  }
 
  state.counters["VertexCount"] = total_vertex_count;
  state.SetComplexityN(total_vertex_count);
 
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-DrawVertices-" +
                  std::to_string(disc_count) + "-" + VertexModeToString(mode) +
                  ".png";
  surface_provider->Snapshot(filename);
}

◆ BM_SaveLayer()

void flutter::testing::BM_SaveLayer	(	benchmark::State &	state,
		BackendType	backend_type,
		unsigned	attributes,
		size_t	save_depth
	)

Definition at line 1295 of file dl_benchmarks.cc.

                                     {
  auto surface_provider = DlSurfaceProvider::Create(backend_type);
  DisplayListBuilder builder;
  DlPaint paint = GetPaintForRun(attributes);
 
  AnnotateAttributes(attributes, state, DisplayListOpFlags::kSaveLayerFlags);
 
  size_t length = kFixedCanvasSize;
  surface_provider->InitializeSurface(length, length);
  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
 
  size_t save_layer_calls = state.range(0);
 
  // Ensure we draw two overlapping rects to avoid any peephole optimisations
  SkRect rect1 = SkRect::MakeLTRB(0, 0, 0.75f * length, 0.75f * length);
  SkRect rect2 =
      SkRect::MakeLTRB(0.25f * length, 0.25f * length, length, length);
 
  state.counters["DrawCallCount_Varies"] = save_layer_calls * save_depth;
  for (size_t i = 0; i < save_layer_calls; i++) {
    for (size_t j = 0; j < save_depth; j++) {
      builder.SaveLayer(nullptr, nullptr);
      builder.DrawRect(rect1, paint);
      builder.DrawRect(rect2, paint);
    }
    for (size_t j = 0; j < save_depth; j++) {
      builder.Restore();
    }
  }
  auto display_list = builder.Build();
 
  // We only want to time the actual rasterization.
  for ([[maybe_unused]] auto _ : state) {
    canvas.DrawDisplayList(display_list);
    FlushSubmitCpuSync(surface);
  }
 
  auto filename = surface_provider->backend_name() + "-SaveLayer-" +
                  std::to_string(save_depth) + "-" +
                  std::to_string(save_layer_calls) + ".png";
  surface_provider->Snapshot(filename);
}

◆ CheckEquality()

void flutter::testing::CheckEquality	(	const DlRegion &	dl_region,
		const SkRegion &	sk_region
	)

Definition at line 344 of file dl_region_unittests.cc.

                                                                         {
  EXPECT_EQ(dl_region.bounds(), sk_region.getBounds());
 
  // Do not deband the rectangles - identical to SkRegion::Iterator
  auto rects = dl_region.getRects(false);
 
  std::vector<SkIRect> skia_rects;
 
  auto iterator = SkRegion::Iterator(sk_region);
  while (!iterator.done()) {
    skia_rects.push_back(iterator.rect());
    iterator.next();
  }
 
  EXPECT_EQ(rects, skia_rects);
}

◆ CheckFrameTimings()

static void flutter::testing::CheckFrameTimings	(	const std::vector< FrameTiming > &	timings,
		fml::TimePoint	start,
		fml::TimePoint	finish
	)

static

Definition at line 722 of file shell_unittests.cc.

                                                   {
  fml::TimePoint last_frame_start;
  for (size_t i = 0; i < timings.size(); i += 1) {
    // Ensure that timings are sorted.
    ASSERT_TRUE(timings[i].Get(FrameTiming::kPhases[0]) >= last_frame_start);
    last_frame_start = timings[i].Get(FrameTiming::kPhases[0]);
 
    fml::TimePoint last_phase_time;
    for (auto phase : FrameTiming::kPhases) {
      // raster finish wall time doesn't use the same clock base
      // as rest of the frame timings.
      if (phase == FrameTiming::kRasterFinishWallTime) {
        continue;
      }
 
      ASSERT_TRUE(timings[i].Get(phase) >= start);
      ASSERT_TRUE(timings[i].Get(phase) <= finish);
 
      // phases should have weakly increasing time points
      ASSERT_TRUE(last_phase_time <= timings[i].Get(phase));
      last_phase_time = timings[i].Get(phase);
    }
  }
}

◆ CheckSwanglekExtensions()

static void flutter::testing::CheckSwanglekExtensions ( )

static

Definition at line 98 of file test_gl_surface.cc.

                                      {
  const char* extensions = ::eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
  FML_CHECK(HasExtension(extensions, "EGL_EXT_platform_base")) << extensions;
  FML_CHECK(HasExtension(extensions, "EGL_ANGLE_platform_angle_vulkan"))
      << extensions;
  FML_CHECK(HasExtension(extensions,
                         "EGL_ANGLE_platform_angle_device_type_swiftshader"))
      << extensions;
}

◆ CheckTextSkData()

static void flutter::testing::CheckTextSkData	(	const sk_sp< SkData > &	data,
		const std::string &	expected
	)

static

Definition at line 26 of file persistent_cache_unittests.cc.

                                                       {
  std::string data_string(reinterpret_cast<const char*>(data->bytes()),
                          data->size());
  ASSERT_EQ(data_string, expected);
}

◆ CheckTwoSkSLsAreLoaded()

static void flutter::testing::CheckTwoSkSLsAreLoaded ( )

static

Definition at line 38 of file persistent_cache_unittests.cc.

                                     {
  auto shaders = PersistentCache::GetCacheForProcess()->LoadSkSLs();
  ASSERT_EQ(shaders.size(), 2u);
}

◆ clone_string()

char * flutter::testing::clone_string ( const char * string )

Definition at line 16 of file test_keyboard.cc.

                                       {
  if (string == nullptr) {
    return nullptr;
  }
  size_t len = strlen(string);
  char* result = new char[len + 1];
  strcpy(result, string);
  return result;
}

◆ ConfigureBackingStore()

void flutter::testing::ConfigureBackingStore	(	FlutterBackingStore &	backing_store,
		EmbedderTestContextType	backend,
		bool	opengl_framebuffer
	)

Configures per-backend properties for a given backing store.

Parameters

[in]	backing_store	The backing store to configure.
[in]	backend	The test context type used to decide which backend the backing store will be used with.
[in]	opengl_framebuffer	Ignored for all non-OpenGL backends. Flutter supports rendering to both OpenGL textures and framebuffers. When false, the backing store is configured to be an OpenGL texture.

Definition at line 109 of file embedder_unittests_util.cc.

                                                    {
  switch (backend) {
    case EmbedderTestContextType::kVulkanContext:
      backing_store.type = kFlutterBackingStoreTypeVulkan;
      break;
    case EmbedderTestContextType::kOpenGLContext:
      if (opengl_framebuffer) {
        backing_store.type = kFlutterBackingStoreTypeOpenGL;
        backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
      } else {
        backing_store.type = kFlutterBackingStoreTypeOpenGL;
        backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
      }
      break;
    case EmbedderTestContextType::kMetalContext:
      backing_store.type = kFlutterBackingStoreTypeMetal;
      break;
    case EmbedderTestContextType::kSoftwareContext:
      backing_store.type = kFlutterBackingStoreTypeSoftware;
      break;
  }
}

◆ ConstraintToString()

std::string flutter::testing::ConstraintToString ( DlCanvas::SrcRectConstraint constraint )

Definition at line 1003 of file dl_benchmarks.cc.

                                                                   {
  switch (constraint) {
    case DlCanvas::SrcRectConstraint::kStrict:
      return "Strict";
    case DlCanvas::SrcRectConstraint::kFast:
      return "Fast";
    default:
      return "Unknown";
  }
}

◆ containsInclusive() [1/4]

static bool flutter::testing::containsInclusive	(	const SkIRect	rect,
		const SkPoint	quad[4]
	)

static

Definition at line 49 of file dl_image_filter_unittests.cc.

                                                                         {
  return containsInclusive(SkRect::Make(rect), quad);
}

◆ containsInclusive() [2/4]

static bool flutter::testing::containsInclusive	(	const SkIRect	rect,
		const SkRect	bounds
	)

static

Definition at line 53 of file dl_image_filter_unittests.cc.

                                                                       {
  return (bounds.fLeft >= rect.fLeft - 1E-9 &&
          bounds.fTop >= rect.fTop - 1E-9 &&
          bounds.fRight <= rect.fRight + 1E-9 &&
          bounds.fBottom <= rect.fBottom + 1E-9);
}

◆ containsInclusive() [3/4]

static bool flutter::testing::containsInclusive	(	const SkRect	rect,
		const SkPoint	p
	)

static

Definition at line 30 of file dl_image_filter_unittests.cc.

                                                                  {
  // Test with a slight offset of 1E-9 to "forgive" IEEE bit-rounding
  // Ending up with bounds that are off by 1E-9 (these numbers are all
  // being tested in device space with this method) will be off by a
  // negligible amount of a pixel that wouldn't contribute to changing
  // the color of a pixel.
  return (p.fX >= rect.fLeft - 1E-9 &&   //
          p.fX <= rect.fRight + 1E-9 &&  //
          p.fY >= rect.fTop - 1E-9 &&    //
          p.fY <= rect.fBottom + 1E-9);
}

◆ containsInclusive() [4/4]

static bool flutter::testing::containsInclusive	(	const SkRect	rect,
		const SkPoint	quad[4]
	)

static

Definition at line 42 of file dl_image_filter_unittests.cc.

                                                                        {
  return (containsInclusive(rect, quad[0]) &&  //
          containsInclusive(rect, quad[1]) &&  //
          containsInclusive(rect, quad[2]) &&  //
          containsInclusive(rect, quad[3]));
}

◆ CreateAllAttributesOps()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllAttributesOps ( )

Definition at line 48 of file dl_test_snippets.cc.

                                                               {
  return {
      {"SetAntiAlias",
       {
           {0, 8, 0, [](DlOpReceiver& r) { r.setAntiAlias(true); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setAntiAlias(false); }},
       }},
      {"SetInvertColors",
       {
           {0, 8, 0, [](DlOpReceiver& r) { r.setInvertColors(true); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setInvertColors(false); }},
       }},
      {"SetStrokeCap",
       {
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setStrokeCap(DlStrokeCap::kRound); }},
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setStrokeCap(DlStrokeCap::kSquare); }},
           {0, 0, 0,
            [](DlOpReceiver& r) { r.setStrokeCap(DlStrokeCap::kButt); }},
       }},
      {"SetStrokeJoin",
       {
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setStrokeJoin(DlStrokeJoin::kBevel); }},
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setStrokeJoin(DlStrokeJoin::kRound); }},
           {0, 0, 0,
            [](DlOpReceiver& r) { r.setStrokeJoin(DlStrokeJoin::kMiter); }},
       }},
      {"SetStyle",
       {
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setDrawStyle(DlDrawStyle::kStroke); }},
           {0, 8, 0,
            [](DlOpReceiver& r) {
              r.setDrawStyle(DlDrawStyle::kStrokeAndFill);
            }},
           {0, 0, 0,
            [](DlOpReceiver& r) { r.setDrawStyle(DlDrawStyle::kFill); }},
       }},
      {"SetStrokeWidth",
       {
           {0, 8, 0, [](DlOpReceiver& r) { r.setStrokeWidth(1.0); }},
           {0, 8, 0, [](DlOpReceiver& r) { r.setStrokeWidth(5.0); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setStrokeWidth(0.0); }},
       }},
      {"SetStrokeMiter",
       {
           {0, 8, 0, [](DlOpReceiver& r) { r.setStrokeMiter(0.0); }},
           {0, 8, 0, [](DlOpReceiver& r) { r.setStrokeMiter(5.0); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setStrokeMiter(4.0); }},
       }},
      {"SetColor",
       {
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setColor(DlColor(SK_ColorGREEN)); }},
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setColor(DlColor(SK_ColorBLUE)); }},
           {0, 0, 0,
            [](DlOpReceiver& r) { r.setColor(DlColor(SK_ColorBLACK)); }},
       }},
      {"SetBlendMode",
       {
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setBlendMode(DlBlendMode::kSrcIn); }},
           {0, 8, 0,
            [](DlOpReceiver& r) { r.setBlendMode(DlBlendMode::kDstIn); }},
           {0, 0, 0,
            [](DlOpReceiver& r) { r.setBlendMode(DlBlendMode::kSrcOver); }},
       }},
      {"SetColorSource",
       {
           {0, 96, 0, [](DlOpReceiver& r) { r.setColorSource(&kTestSource1); }},
           // stop_count * (sizeof(float) + sizeof(uint32_t)) = 80
           {0, 80 + 6 * 4, 0,
            [](DlOpReceiver& r) { r.setColorSource(kTestSource2.get()); }},
           {0, 80 + 6 * 4, 0,
            [](DlOpReceiver& r) { r.setColorSource(kTestSource3.get()); }},
           {0, 88 + 6 * 4, 0,
            [](DlOpReceiver& r) { r.setColorSource(kTestSource4.get()); }},
           {0, 80 + 6 * 4, 0,
            [](DlOpReceiver& r) { r.setColorSource(kTestSource5.get()); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setColorSource(nullptr); }},
       }},
      {"SetImageFilter",
       {
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestBlurImageFilter1); }},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestBlurImageFilter2); }},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestBlurImageFilter3); }},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestBlurImageFilter4); }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestDilateImageFilter1);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestDilateImageFilter2);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestDilateImageFilter3);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestErodeImageFilter1); }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestErodeImageFilter2); }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestErodeImageFilter3); }},
           {0, 64, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestMatrixImageFilter1);
            }},
           {0, 64, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestMatrixImageFilter2);
            }},
           {0, 64, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestMatrixImageFilter3);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestComposeImageFilter1);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestComposeImageFilter2);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(&kTestComposeImageFilter3);
            }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestCFImageFilter1); }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setImageFilter(&kTestCFImageFilter2); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setImageFilter(nullptr); }},
           {0, 24, 0,
            [](DlOpReceiver& r) {
              r.setImageFilter(
                  kTestBlurImageFilter1
                      .makeWithLocalMatrix(SkMatrix::Translate(2, 2))
                      .get());
            }},
       }},
      {"SetColorFilter",
       {
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setColorFilter(&kTestBlendColorFilter1); }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setColorFilter(&kTestBlendColorFilter2); }},
           {0, 24, 0,
            [](DlOpReceiver& r) { r.setColorFilter(&kTestBlendColorFilter3); }},
           {0, 96, 0,
            [](DlOpReceiver& r) {
              r.setColorFilter(&kTestMatrixColorFilter1);
            }},
           {0, 96, 0,
            [](DlOpReceiver& r) {
              r.setColorFilter(&kTestMatrixColorFilter2);
            }},
           {0, 16, 0,
            [](DlOpReceiver& r) {
              r.setColorFilter(DlSrgbToLinearGammaColorFilter::kInstance.get());
            }},
           {0, 16, 0,
            [](DlOpReceiver& r) {
              r.setColorFilter(DlLinearToSrgbGammaColorFilter::kInstance.get());
            }},
           {0, 0, 0, [](DlOpReceiver& r) { r.setColorFilter(nullptr); }},
       }},
      {"SetMaskFilter",
       {
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setMaskFilter(&kTestMaskFilter1); }, 0u,
            2u},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setMaskFilter(&kTestMaskFilter2); }, 0u,
            2u},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setMaskFilter(&kTestMaskFilter3); }, 0u,
            2u},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setMaskFilter(&kTestMaskFilter4); }, 0u,
            2u},
           {0, 32, 0,
            [](DlOpReceiver& r) { r.setMaskFilter(&kTestMaskFilter5); }, 0u,
            2u},
           {0, 0, 0, [](DlOpReceiver& r) { r.setMaskFilter(nullptr); }, 0u, 1u},
       }},
  };
}

◆ CreateAllClipOps()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllClipOps ( )

Definition at line 401 of file dl_test_snippets.cc.

                                                         {
  return {
      {"ClipRect",
       {
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipRect(kTestBounds, DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipRect(kTestBounds.makeOffset(1, 1),
                         DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipRect(kTestBounds, DlCanvas::ClipOp::kIntersect, false);
            }},
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipRect(kTestBounds, DlCanvas::ClipOp::kDifference, true);
            }},
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipRect(kTestBounds, DlCanvas::ClipOp::kDifference, false);
            }},
       }},
      {"ClipRRect",
       {
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipRRect(kTestRRect, DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipRRect(kTestRRect.makeOffset(1, 1),
                          DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipRRect(kTestRRect, DlCanvas::ClipOp::kIntersect, false);
            }},
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipRRect(kTestRRect, DlCanvas::ClipOp::kDifference, true);
            }},
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipRRect(kTestRRect, DlCanvas::ClipOp::kDifference, false);
            }},
       }},
      {"ClipPath",
       {
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath1, DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath2, DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath3, DlCanvas::ClipOp::kIntersect, true);
            }},
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath1, DlCanvas::ClipOp::kIntersect, false);
            }},
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath1, DlCanvas::ClipOp::kDifference, true);
            }},
           {1, 40, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPath1, DlCanvas::ClipOp::kDifference, false);
            }},
           // clipPath(rect) becomes clipRect
           {1, 24, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPathRect, DlCanvas::ClipOp::kIntersect, true);
            }},
           // clipPath(oval) becomes clipRRect
           {1, 64, 0,
            [](DlOpReceiver& r) {
              r.clipPath(kTestPathOval, DlCanvas::ClipOp::kIntersect, true);
            }},
       }},
  };
}

◆ CreateAllGroups()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllGroups ( )

Definition at line 971 of file dl_test_snippets.cc.

                                                        {
  std::vector<DisplayListInvocationGroup> result;
  auto all_attribute_ops = CreateAllAttributesOps();
  std::move(all_attribute_ops.begin(), all_attribute_ops.end(),
            std::back_inserter(result));
  auto all_save_restore_ops = CreateAllSaveRestoreOps();
  std::move(all_save_restore_ops.begin(), all_save_restore_ops.end(),
            std::back_inserter(result));
  auto all_transform_ops = CreateAllTransformOps();
  std::move(all_transform_ops.begin(), all_transform_ops.end(),
            std::back_inserter(result));
  auto all_clip_ops = CreateAllClipOps();
  std::move(all_clip_ops.begin(), all_clip_ops.end(),
            std::back_inserter(result));
  auto all_rendering_ops = CreateAllRenderingOps();
  std::move(all_rendering_ops.begin(), all_rendering_ops.end(),
            std::back_inserter(result));
  return result;
}

◆ CreateAllRenderingOps()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllRenderingOps ( )

Definition at line 491 of file dl_test_snippets.cc.

                                                              {
  return {
      {"DrawPaint",
       {
           {1, 8, 1, [](DlOpReceiver& r) { r.drawPaint(); }},
       }},
      {"DrawColor",
       {
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawColor(DlColor(SK_ColorBLUE), DlBlendMode::kSrcIn);
            }},
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawColor(DlColor(SK_ColorBLUE), DlBlendMode::kDstOut);
            }},
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawColor(DlColor(SK_ColorCYAN), DlBlendMode::kSrcIn);
            }},
       }},
      {"DrawLine",
       {
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawLine({0, 0}, {10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawLine({1, 0}, {10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawLine({0, 1}, {10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawLine({0, 0}, {20, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawLine({0, 0}, {10, 20});
            }},
       }},
      {"DrawDashedLine",
       {
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 0}, {10, 10}, 4.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({1, 0}, {10, 10}, 4.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 1}, {10, 10}, 4.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 0}, {20, 10}, 4.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 0}, {10, 20}, 4.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 0}, {10, 10}, 5.0f, 2.0f);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawDashedLine({0, 0}, {10, 10}, 4.0f, 3.0f);
            }},
       }},
      {"DrawRect",
       {
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawRect({0, 0, 10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawRect({0, 1, 10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawRect({0, 0, 20, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawRect({0, 0, 10, 20});
            }},
       }},
      {"DrawOval",
       {
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawOval({0, 0, 10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawOval({0, 1, 10, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawOval({0, 0, 20, 10});
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawOval({0, 0, 10, 20});
            }},
       }},
      {"DrawCircle",
       {
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawCircle({0, 0}, 10);
            }},
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawCircle({0, 5}, 10);
            }},
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawCircle({0, 0}, 20);
            }},
       }},
      {"DrawRRect",
       {
           {1, 56, 1, [](DlOpReceiver& r) { r.drawRRect(kTestRRect); }},
           {1, 56, 1,
            [](DlOpReceiver& r) { r.drawRRect(kTestRRect.makeOffset(5, 5)); }},
       }},
      {"DrawDRRect",
       {
           {1, 112, 1,
            [](DlOpReceiver& r) { r.drawDRRect(kTestRRect, kTestInnerRRect); }},
           {1, 112, 1,
            [](DlOpReceiver& r) {
              r.drawDRRect(kTestRRect.makeOffset(5, 5),
                           kTestInnerRRect.makeOffset(4, 4));
            }},
       }},
      {"DrawPath",
       {
           {1, 40, 1, [](DlOpReceiver& r) { r.drawPath(kTestPath1); }},
           {1, 40, 1, [](DlOpReceiver& r) { r.drawPath(kTestPath2); }},
           {1, 40, 1, [](DlOpReceiver& r) { r.drawPath(kTestPath3); }},
           {1, 40, 1, [](DlOpReceiver& r) { r.drawPath(kTestPathRect); }},
           {1, 40, 1, [](DlOpReceiver& r) { r.drawPath(kTestPathOval); }},
       }},
      {"DrawArc",
       {
           {1, 32, 1,
            [](DlOpReceiver& r) { r.drawArc(kTestBounds, 45, 270, false); }},
           {1, 32, 1,
            [](DlOpReceiver& r) {
              r.drawArc(kTestBounds.makeOffset(1, 1), 45, 270, false);
            }},
           {1, 32, 1,
            [](DlOpReceiver& r) { r.drawArc(kTestBounds, 30, 270, false); }},
           {1, 32, 1,
            [](DlOpReceiver& r) { r.drawArc(kTestBounds, 45, 260, false); }},
           {1, 32, 1,
            [](DlOpReceiver& r) { r.drawArc(kTestBounds, 45, 270, true); }},
       }},
      {"DrawPoints",
       {
           {1, 8 + TestPointCount * 8, 1,
            [](DlOpReceiver& r) {
              r.drawPoints(DlCanvas::PointMode::kPoints, TestPointCount,
                           kTestPoints);
            }},
           {1, 8 + (TestPointCount - 1) * 8, 1,
            [](DlOpReceiver& r) {
              r.drawPoints(DlCanvas::PointMode::kPoints, TestPointCount - 1,
                           kTestPoints);
            }},
           {1, 8 + TestPointCount * 8, 1,
            [](DlOpReceiver& r) {
              r.drawPoints(DlCanvas::PointMode::kLines, TestPointCount,
                           kTestPoints);
            }},
           {1, 8 + TestPointCount * 8, 1,
            [](DlOpReceiver& r) {
              r.drawPoints(DlCanvas::PointMode::kPolygon, TestPointCount,
                           kTestPoints);
            }},
       }},
      {"DrawVertices",
       {
           {1, 112, 1,
            [](DlOpReceiver& r) {
              r.drawVertices(TestVertices1.get(), DlBlendMode::kSrcIn);
            }},
           {1, 112, 1,
            [](DlOpReceiver& r) {
              r.drawVertices(TestVertices1.get(), DlBlendMode::kDstIn);
            }},
           {1, 112, 1,
            [](DlOpReceiver& r) {
              r.drawVertices(TestVertices2.get(), DlBlendMode::kSrcIn);
            }},
       }},
      {"DrawImage",
       {
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage1, {10, 10}, kNearestSampling, false);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage1, {10, 10}, kNearestSampling, true);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage1, {20, 10}, kNearestSampling, false);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage1, {10, 20}, kNearestSampling, false);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage1, {10, 10}, kLinearSampling, false);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawImage(TestImage2, {10, 10}, kNearestSampling, false);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              auto dl_image = DlImage::Make(TestSkImage);
              r.drawImage(dl_image, {10, 10}, kNearestSampling, false);
            }},
       }},
      {"DrawImageRect",
       {
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              kNearestSampling, true,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kStrict);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 25, 20}, {10, 10, 80, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 20, 20}, {10, 10, 85, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              kLinearSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              r.drawImageRect(TestImage2, {10, 10, 15, 15}, {10, 10, 80, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
           {1, 56, 1,
            [](DlOpReceiver& r) {
              auto dl_image = DlImage::Make(TestSkImage);
              r.drawImageRect(dl_image, {10, 10, 15, 15}, {10, 10, 80, 80},
                              kNearestSampling, false,
                              DlCanvas::SrcRectConstraint::kFast);
            }},
       }},
      {"DrawImageNine",
       {
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              DlFilterMode::kNearest, false);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              DlFilterMode::kNearest, true);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage1, {10, 10, 25, 20}, {10, 10, 80, 80},
                              DlFilterMode::kNearest, false);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage1, {10, 10, 20, 20}, {10, 10, 85, 80},
                              DlFilterMode::kNearest, false);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage1, {10, 10, 20, 20}, {10, 10, 80, 80},
                              DlFilterMode::kLinear, false);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawImageNine(TestImage2, {10, 10, 15, 15}, {10, 10, 80, 80},
                              DlFilterMode::kNearest, false);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              auto dl_image = DlImage::Make(TestSkImage);
              r.drawImageNine(dl_image, {10, 10, 15, 15}, {10, 10, 80, 80},
                              DlFilterMode::kNearest, false);
            }},
       }},
      {"DrawAtlas",
       {
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr,
                          false);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr, true);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{0, 1, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr,
                          false);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 25, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr,
                          false);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kLinearSampling, nullptr, false);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                          DlBlendMode::kDstIn, kNearestSampling, nullptr,
                          false);
            }},
           {1, 64 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              static SkRect cull_rect = {0, 0, 200, 200};
              r.drawAtlas(TestImage2, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, &cull_rect,
                          false);
            }},
           {1, 48 + 32 + 8 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              static DlColor colors[] = {DlColor::kBlue(), DlColor::kGreen()};
              r.drawAtlas(TestImage1, xforms, texs, colors, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr,
                          false);
            }},
           {1, 64 + 32 + 8 + 8, 1,
            [](DlOpReceiver& r) {
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              static DlColor colors[] = {DlColor::kBlue(), DlColor::kGreen()};
              static SkRect cull_rect = {0, 0, 200, 200};
              r.drawAtlas(TestImage1, xforms, texs, colors, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, &cull_rect,
                          false);
            }},
           {1, 48 + 32 + 8, 1,
            [](DlOpReceiver& r) {
              auto dl_image = DlImage::Make(TestSkImage);
              static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
              static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
              r.drawAtlas(dl_image, xforms, texs, nullptr, 2,
                          DlBlendMode::kSrcIn, kNearestSampling, nullptr,
                          false);
            }},
       }},
      {"DrawDisplayList",
       {
           {1, 16, 1,
            [](DlOpReceiver& r) { r.drawDisplayList(TestDisplayList1, 1.0); },
            1u},
           {1, 16, 1,
            [](DlOpReceiver& r) { r.drawDisplayList(TestDisplayList1, 0.5); },
            1u},
           {1, 16, 1,
            [](DlOpReceiver& r) { r.drawDisplayList(TestDisplayList2, 1.0); },
            1u},
           {1, 16, 1,
            [](DlOpReceiver& r) {
              r.drawDisplayList(MakeTestDisplayList(10, 10, SK_ColorRED), 1.0);
            },
            1u},
       }},
      {"DrawTextBlob",
       {
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawTextBlob(GetTestTextBlob(1), 10, 10);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawTextBlob(GetTestTextBlob(1), 20, 10);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawTextBlob(GetTestTextBlob(1), 10, 20);
            }},
           {1, 24, 1,
            [](DlOpReceiver& r) {
              r.drawTextBlob(GetTestTextBlob(2), 10, 10);
            }},
       }},
      {"DrawShadow",
       {
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath1, DlColor(SK_ColorGREEN), 1.0, false, 1.0);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath2, DlColor(SK_ColorGREEN), 1.0, false, 1.0);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath1, DlColor(SK_ColorBLUE), 1.0, false, 1.0);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath1, DlColor(SK_ColorGREEN), 2.0, false, 1.0);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath1, DlColor(SK_ColorGREEN), 1.0, true, 1.0);
            }},
           {1, 48, 1,
            [](DlOpReceiver& r) {
              r.drawShadow(kTestPath1, DlColor(SK_ColorGREEN), 1.0, false, 2.5);
            }},
       }},
  };
}

◆ CreateAllSaveRestoreOps()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllSaveRestoreOps ( )

Definition at line 246 of file dl_test_snippets.cc.

                                                                {
  return {
      {"Save(Layer)+Restore",
       {
           // There are many reasons that save and restore can elide content,
           // including whether or not there are any draw operations between
           // them, whether or not there are any state changes to restore, and
           // whether group rendering (opacity) optimizations can allow
           // attributes to be distributed to the children. To prevent those
           // cases we include at least one clip operation and 2 overlapping
           // rendering primitives between each save/restore pair.
           {5, 96, 2,
            [](DlOpReceiver& r) {
              r.save();
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({5, 5, 15, 15});
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 120, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({5, 5, 15, 15});
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 120, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({5, 5, 15, 15});
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           // For saveLayer calls with bounds, we need at least one unclipped
           // draw command so that the bounds are not reduced in size to the
           // clip dimensions on the re-dispatch.
           {5, 120, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(&kTestBounds, SaveLayerOptions::kNoAttributes);
              r.drawRect(kTestBounds);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 120, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(&kTestBounds, SaveLayerOptions::kWithAttributes);
              r.drawRect(kTestBounds);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 136, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(nullptr, SaveLayerOptions::kNoAttributes,
                          &kTestCFImageFilter1);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({5, 5, 15, 15});
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 136, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(nullptr, SaveLayerOptions::kWithAttributes,
                          &kTestCFImageFilter1);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({5, 5, 15, 15});
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 136, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(&kTestBounds, SaveLayerOptions::kNoAttributes,
                          &kTestCFImageFilter1);
              r.drawRect(kTestBounds);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
           {5, 136, 3,
            [](DlOpReceiver& r) {
              r.saveLayer(&kTestBounds, SaveLayerOptions::kWithAttributes,
                          &kTestCFImageFilter1);
              r.drawRect(kTestBounds);
              r.clipRect({0, 0, 25, 25}, DlCanvas::ClipOp::kIntersect, true);
              r.drawRect({10, 10, 20, 20});
              r.restore();
            }},
       }},
  };
}

◆ CreateAllTransformOps()

std::vector< DisplayListInvocationGroup > flutter::testing::CreateAllTransformOps ( )

Definition at line 340 of file dl_test_snippets.cc.

                                                              {
  return {
      {"Translate",
       {
           {1, 16, 0, [](DlOpReceiver& r) { r.translate(10, 10); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.translate(10, 15); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.translate(15, 10); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.translate(0, 0); }},
       }},
      {"Scale",
       {
           {1, 16, 0, [](DlOpReceiver& r) { r.scale(2, 2); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.scale(2, 3); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.scale(3, 2); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.scale(1, 1); }},
       }},
      {"Rotate",
       {
           {1, 8, 0, [](DlOpReceiver& r) { r.rotate(30); }},
           {1, 8, 0, [](DlOpReceiver& r) { r.rotate(45); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.rotate(0); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.rotate(360); }},
       }},
      {"Skew",
       {
           {1, 16, 0, [](DlOpReceiver& r) { r.skew(0.1, 0.1); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.skew(0.1, 0.2); }},
           {1, 16, 0, [](DlOpReceiver& r) { r.skew(0.2, 0.1); }},
           {0, 0, 0, [](DlOpReceiver& r) { r.skew(0, 0); }},
       }},
      {"Transform2DAffine",
       {
           {1, 32, 0,
            [](DlOpReceiver& r) { r.transform2DAffine(0, 1, 12, 1, 0, 33); }},
           // r.transform(identity) is ignored
           {0, 0, 0,
            [](DlOpReceiver& r) { r.transform2DAffine(1, 0, 0, 0, 1, 0); }},
       }},
      {"TransformFullPerspective",
       {
           {1, 72, 0,
            [](DlOpReceiver& r) {
              r.transformFullPerspective(0, 1, 0, 12, 1, 0, 0, 33, 3, 2, 5, 29,
                                         0, 0, 0, 12);
            }},
           // r.transform(2D affine) is reduced to 2x3
           {1, 32, 0,
            [](DlOpReceiver& r) {
              r.transformFullPerspective(2, 1, 0, 4, 1, 3, 0, 5, 0, 0, 1, 0, 0,
                                         0, 0, 1);
            }},
           // r.transform(identity) is ignored
           {0, 0, 0,
            [](DlOpReceiver& r) {
              r.transformFullPerspective(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0,
                                         0, 0, 1);
            }},
       }},
  };
}

◆ CreateAndRunRootIsolate()

static std::shared_ptr< DartIsolate > flutter::testing::CreateAndRunRootIsolate	(	const Settings &	settings,
		const DartVMData &	vm,
		const fml::RefPtr< fml::TaskRunner > &	task_runner,
		std::string	entrypoint
	)

static

Definition at line 46 of file dart_lifecycle_unittests.cc.

                          {
  FML_CHECK(!entrypoint.empty());
  TaskRunners runners("io.flutter.test", task_runner, task_runner, task_runner,
                      task_runner);
 
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(runners);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = entrypoint.c_str();
  auto isolate =
      DartIsolate::CreateRunningRootIsolate(
          vm.GetSettings(),                    // settings
          vm.GetIsolateSnapshot(),             // isolate_snapshot
          {},                                  // platform configuration
          DartIsolate::Flags{},                // flags
          nullptr,                             // root isolate create callback
          settings.isolate_create_callback,    // isolate create callback
          settings.isolate_shutdown_callback,  // isolate shutdown callback,
          entrypoint,                          // dart entrypoint
          std::nullopt,                        // dart entrypoint library
          {},                                  // dart entrypoint arguments
          std::move(isolate_configuration),    // isolate configuration
          context                              // engine context
          )
          .lock();
 
  if (!isolate) {
    FML_LOG(ERROR) << "Could not launch the root isolate.";
    return nullptr;
  }
 
  return isolate;
}

◆ CreateFlagsString()

static std::string flutter::testing::CreateFlagsString ( std::vector< const char * > & flags )

static

Definition at line 357 of file shell_unittests.cc.

                                                                  {
  if (flags.empty()) {
    return "";
  }
  std::string flags_string = flags[0];
  for (size_t i = 1; i < flags.size(); ++i) {
    flags_string += ",";
    flags_string += flags[i];
  }
  return flags_string;
}

◆ CreateImpellerContext()

static std::shared_ptr< impeller::ContextMTL > flutter::testing::CreateImpellerContext ( )

static

Definition at line 45 of file gpu_surface_metal_impeller_unittests.mm.

                                                                 {
  std::vector<std::shared_ptr<fml::Mapping>> shader_mappings = {
      std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_data,
                                             impeller_entity_shaders_length),
      std::make_shared<fml::NonOwnedMapping>(impeller_modern_shaders_data,
                                             impeller_modern_shaders_length),
      std::make_shared<fml::NonOwnedMapping>(impeller_framebuffer_blend_shaders_data,
                                             impeller_framebuffer_blend_shaders_length),
  };
  auto sync_switch = std::make_shared<fml::SyncSwitch>(false);
  return impeller::ContextMTL::Create(shader_mappings, sync_switch, "Impeller Library");
}

◆ CreateKeyEventLparam()

LPARAM flutter::testing::CreateKeyEventLparam	(	USHORT	scancode,
		bool	extended,
		bool	was_down,
		USHORT	repeat_count,
		bool	context_code,
		bool	transition_state
	)

Definition at line 82 of file test_keyboard.cc.

                                                   {
  return ((LPARAM(transition_state) << 31) | (LPARAM(was_down) << 30) |
          (LPARAM(context_code) << 29) | (LPARAM(extended ? 0x1 : 0x0) << 24) |
          (LPARAM(scancode) << 16) | LPARAM(repeat_count));
}

◆ CreateMockFlutterEngine()

id flutter::testing::CreateMockFlutterEngine ( NSString * pasteboardString )

Definition at line 76 of file FlutterEngineTestUtils.mm.

                                                       {
  NSString* fixtures = @(testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                      project:project
                                       allowHeadlessExecution:true];
 
  FakePasteboard* pasteboardMock = [[FakePasteboard alloc] init];
  [pasteboardMock setString:pasteboardString forType:NSPasteboardTypeString];
  engine.pasteboard = pasteboardMock;
  id engineMock = OCMPartialMock(engine);
  return engineMock;
}

◆ CreateMockViewController()

id flutter::testing::CreateMockViewController ( )

Definition at line 9 of file FlutterViewControllerTestUtils.mm.

                              {
  {
    NSString* fixtures = @(testing::GetFixturesPath());
    FlutterDartProject* project = [[FlutterDartProject alloc]
        initWithAssetsPath:fixtures
               ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
    FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:project];
    id viewControllerMock = OCMPartialMock(viewController);
    return viewControllerMock;
  }
}

◆ CreateOffscreenTexture()

static fml::scoped_nsprotocol< id< MTLTexture > > flutter::testing::CreateOffscreenTexture ( id< MTLDevice > device )

static

Definition at line 20 of file shell_test_platform_view_metal.mm.

                                                                                         {
  auto descriptor =
      [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
                                                         width:800
                                                        height:600
                                                     mipmapped:NO];
  descriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
  return fml::scoped_nsprotocol<id<MTLTexture>>{[device newTextureWithDescriptor:descriptor]};
}

◆ CreatePresentInfo()

static FlutterSurfacePresentInfo * flutter::testing::CreatePresentInfo	(	FlutterSurface *	surface,
		CGPoint	offset = `CGPointZero`,
		size_t	index = `0`,
		const std::vector< FlutterRect > &	paintRegion = `{}`
	)

static

Definition at line 51 of file FlutterSurfaceManagerTest.mm.

                                                {}) {
  FlutterSurfacePresentInfo* res = [[FlutterSurfacePresentInfo alloc] init];
  res.surface = surface;
  res.offset = offset;
  res.zIndex = index;
  res.paintRegion = paintRegion;
  return res;
}

◆ CreateRenderSurface()

sk_sp< SkSurface > flutter::testing::CreateRenderSurface	(	const FlutterLayer &	layer,
		GrDirectContext *	context
	)

Definition at line 21 of file embedder_unittests_util.cc.

                                                               {
  const auto image_info =
      SkImageInfo::MakeN32Premul(layer.size.width, layer.size.height);
  auto surface = context ? SkSurfaces::RenderTarget(
                               context,                   // context
                               skgpu::Budgeted::kNo,      // budgeted
                               image_info,                // image info
                               1,                         // sample count
                               kTopLeft_GrSurfaceOrigin,  // surface origin
                               nullptr,                   // surface properties
                               false                      // mipmaps
 
                               )
                         : SkSurfaces::Raster(image_info);
  FML_CHECK(surface != nullptr);
  return surface;
}

◆ CreateSemanticsNode()

FlutterSemanticsNode2 flutter::testing::CreateSemanticsNode	(	int32_t	id,
		const char *	label,
		const std::vector< int32_t > *	children = `nullptr`
	)

Definition at line 18 of file accessibility_bridge_unittests.cc.

                                                  {
  return {
      .id = id,
      .flags = static_cast<FlutterSemanticsFlag>(0),
      .actions = static_cast<FlutterSemanticsAction>(0),
      .text_selection_base = -1,
      .text_selection_extent = -1,
      .label = label,
      .hint = "",
      .value = "",
      .increased_value = "",
      .decreased_value = "",
      .child_count = children ? children->size() : 0,
      .children_in_traversal_order = children ? children->data() : nullptr,
      .custom_accessibility_actions_count = 0,
      .tooltip = "",
  };
}

◆ CreateSimpleSimulatedPointerData()

void flutter::testing::CreateSimpleSimulatedPointerData	(	PointerData &	data,
		PointerData::Change	change,
		int64_t	device,
		double	dx,
		double	dy,
		int64_t	buttons
	)

Definition at line 15 of file pointer_data_packet_unittests.cc.

                                                       {
  data.time_stamp = 0;
  data.change = change;
  data.kind = PointerData::DeviceKind::kTouch;
  data.signal_kind = PointerData::SignalKind::kNone;
  data.device = device;
  data.pointer_identifier = 0;
  data.physical_x = dx;
  data.physical_y = dy;
  data.physical_delta_x = 0.0;
  data.physical_delta_y = 0.0;
  data.buttons = buttons;
  data.obscured = 0;
  data.synthesized = 0;
  data.pressure = 0.0;
  data.pressure_min = 0.0;
  data.pressure_max = 0.0;
  data.distance = 0.0;
  data.distance_max = 0.0;
  data.size = 0.0;
  data.radius_major = 0.0;
  data.radius_minor = 0.0;
  data.radius_min = 0.0;
  data.radius_max = 0.0;
  data.orientation = 0.0;
  data.tilt = 0.0;
  data.platformData = 0;
  data.scroll_delta_x = 0.0;
  data.scroll_delta_y = 0.0;
}

◆ CreateSimulatedMousePointerData()

void flutter::testing::CreateSimulatedMousePointerData	(	PointerData &	data,
		PointerData::Change	change,
		PointerData::SignalKind	signal_kind,
		int64_t	device,
		double	dx,
		double	dy,
		double	scroll_delta_x,
		double	scroll_delta_y,
		int64_t	buttons
	)

Definition at line 73 of file pointer_data_packet_converter_unittests.cc.

                                                      {
  data.time_stamp = 0;
  data.change = change;
  data.kind = PointerData::DeviceKind::kMouse;
  data.signal_kind = signal_kind;
  data.device = device;
  data.pointer_identifier = 0;
  data.physical_x = dx;
  data.physical_y = dy;
  data.physical_delta_x = 0.0;
  data.physical_delta_y = 0.0;
  data.buttons = buttons;
  data.obscured = 0;
  data.synthesized = 0;
  data.pressure = 0.0;
  data.pressure_min = 0.0;
  data.pressure_max = 0.0;
  data.distance = 0.0;
  data.distance_max = 0.0;
  data.size = 0.0;
  data.radius_major = 0.0;
  data.radius_minor = 0.0;
  data.radius_min = 0.0;
  data.radius_max = 0.0;
  data.orientation = 0.0;
  data.tilt = 0.0;
  data.platformData = 0;
  data.scroll_delta_x = scroll_delta_x;
  data.scroll_delta_y = scroll_delta_y;
  data.view_id = kImplicitViewId;
}

◆ CreateSimulatedPointerData() [1/2]

void flutter::testing::CreateSimulatedPointerData	(	PointerData &	data,
		PointerData::Change	change,
		double	dx,
		double	dy
	)

Definition at line 161 of file input_events_unittests.cc.

                                           {
  data.time_stamp = 0;
  data.change = change;
  data.kind = PointerData::DeviceKind::kTouch;
  data.signal_kind = PointerData::SignalKind::kNone;
  data.device = 0;
  data.pointer_identifier = 0;
  data.physical_x = dx;
  data.physical_y = dy;
  data.physical_delta_x = 0.0;
  data.physical_delta_y = 0.0;
  data.buttons = 0;
  data.obscured = 0;
  data.synthesized = 0;
  data.pressure = 0.0;
  data.pressure_min = 0.0;
  data.pressure_max = 0.0;
  data.distance = 0.0;
  data.distance_max = 0.0;
  data.size = 0.0;
  data.radius_major = 0.0;
  data.radius_minor = 0.0;
  data.radius_min = 0.0;
  data.radius_max = 0.0;
  data.orientation = 0.0;
  data.tilt = 0.0;
  data.platformData = 0;
  data.scroll_delta_x = 0.0;
  data.scroll_delta_y = 0.0;
  data.view_id = kImplicitViewId;
}

◆ CreateSimulatedPointerData() [2/2]

void flutter::testing::CreateSimulatedPointerData	(	PointerData &	data,
		PointerData::Change	change,
		int64_t	device,
		double	dx,
		double	dy,
		int64_t	buttons
	)

Definition at line 36 of file pointer_data_packet_converter_unittests.cc.

                                                 {
  data.time_stamp = 0;
  data.change = change;
  data.kind = PointerData::DeviceKind::kTouch;
  data.signal_kind = PointerData::SignalKind::kNone;
  data.device = device;
  data.pointer_identifier = 0;
  data.physical_x = dx;
  data.physical_y = dy;
  data.physical_delta_x = 0.0;
  data.physical_delta_y = 0.0;
  data.buttons = buttons;
  data.obscured = 0;
  data.synthesized = 0;
  data.pressure = 0.0;
  data.pressure_min = 0.0;
  data.pressure_max = 0.0;
  data.distance = 0.0;
  data.distance_max = 0.0;
  data.size = 0.0;
  data.radius_major = 0.0;
  data.radius_minor = 0.0;
  data.radius_min = 0.0;
  data.radius_max = 0.0;
  data.orientation = 0.0;
  data.tilt = 0.0;
  data.platformData = 0;
  data.scroll_delta_x = 0.0;
  data.scroll_delta_y = 0.0;
  data.view_id = kImplicitViewId;
}

◆ CreateSimulatedTrackpadGestureData()

void flutter::testing::CreateSimulatedTrackpadGestureData	(	PointerData &	data,
		PointerData::Change	change,
		int64_t	device,
		double	dx,
		double	dy,
		double	pan_x,
		double	pan_y,
		double	scale,
		double	rotation
	)

Definition at line 113 of file pointer_data_packet_converter_unittests.cc.

                                                         {
  data.time_stamp = 0;
  data.change = change;
  data.kind = PointerData::DeviceKind::kMouse;
  data.signal_kind = PointerData::SignalKind::kNone;
  data.device = device;
  data.pointer_identifier = 0;
  data.physical_x = dx;
  data.physical_y = dy;
  data.physical_delta_x = 0.0;
  data.physical_delta_y = 0.0;
  data.buttons = 0;
  data.obscured = 0;
  data.synthesized = 0;
  data.pressure = 0.0;
  data.pressure_min = 0.0;
  data.pressure_max = 0.0;
  data.distance = 0.0;
  data.distance_max = 0.0;
  data.size = 0.0;
  data.radius_major = 0.0;
  data.radius_minor = 0.0;
  data.radius_min = 0.0;
  data.radius_max = 0.0;
  data.orientation = 0.0;
  data.tilt = 0.0;
  data.platformData = 0;
  data.scroll_delta_x = 0.0;
  data.scroll_delta_y = 0.0;
  data.pan_x = pan_x;
  data.pan_y = pan_y;
  data.pan_delta_x = 0.0;
  data.pan_delta_y = 0.0;
  data.scale = scale;
  data.rotation = rotation;
  data.view_id = 0;
}

◆ CreateSurfaceManager()

static FlutterSurfaceManager * flutter::testing::CreateSurfaceManager ( TestView * testView )

static

Definition at line 41 of file FlutterSurfaceManagerTest.mm.

                                                                       {
  id<MTLDevice> device = MTLCreateSystemDefaultDevice();
  id<MTLCommandQueue> commandQueue = [device newCommandQueue];
  CALayer* layer = reinterpret_cast<CALayer*>(testView.layer);
  return [[FlutterSurfaceManager alloc] initWithDevice:device
                                          commandQueue:commandQueue
                                                 layer:layer
                                              delegate:testView];
}

◆ CreateSwangleDisplay()

static EGLDisplay flutter::testing::CreateSwangleDisplay ( )

static

Definition at line 108 of file test_gl_surface.cc.

                                         {
  CheckSwanglekExtensions();
 
  PFNEGLGETPLATFORMDISPLAYEXTPROC egl_get_platform_display_EXT =
      reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(
          eglGetProcAddress("eglGetPlatformDisplayEXT"));
  FML_CHECK(egl_get_platform_display_EXT)
      << "eglGetPlatformDisplayEXT not available.";
 
  const EGLint display_config[] = {
      EGL_PLATFORM_ANGLE_TYPE_ANGLE,
      EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE,
      EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE,
      EGL_PLATFORM_ANGLE_DEVICE_TYPE_SWIFTSHADER_ANGLE,
      EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE,
      EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE,
      EGL_NONE,
  };
 
  return egl_get_platform_display_EXT(
      EGL_PLATFORM_ANGLE_ANGLE,
      reinterpret_cast<EGLNativeDisplayType*>(EGL_DEFAULT_DISPLAY),
      display_config);
}

◆ CreateTestFontOfSize()

SkFont flutter::testing::CreateTestFontOfSize ( SkScalar scalar )

Definition at line 991 of file dl_test_snippets.cc.

                                             {
  static constexpr const char* kTestFontFixture = "Roboto-Regular.ttf";
  auto mapping = flutter::testing::OpenFixtureAsSkData(kTestFontFixture);
  FML_CHECK(mapping);
  return SkFont{txt::GetDefaultFontManager()->makeFromData(mapping), scalar};
}

◆ DartNativeEntrySymbolCallback()

static const uint8_t * flutter::testing::DartNativeEntrySymbolCallback ( Dart_NativeFunction function )

static

Definition at line 76 of file test_dart_native_resolver.cc.

                                  {
  return reinterpret_cast<const uint8_t*>("¯\\_(ツ)_/¯");
}

◆ DecodeBGR10()

float flutter::testing::DecodeBGR10 ( uint32_t x )

Definition at line 68 of file image_decoder_no_gl_unittests.cc.

                              {
  const float max = 1.25098f;
  const float min = -0.752941f;
  const float intercept = min;
  const float slope = (max - min) / 1024.0f;
  return (x * slope) + intercept;
}

◆ DisplayListsEQ_Verbose() [1/3]

bool flutter::testing::DisplayListsEQ_Verbose	(	const DisplayList &	a,
		const DisplayList &	b
	)

inline

Definition at line 17 of file display_list_testing.h.

                                                                               {
  return DisplayListsEQ_Verbose(&a, &b);
}

◆ DisplayListsEQ_Verbose() [2/3]

bool flutter::testing::DisplayListsEQ_Verbose	(	const DisplayList *	a,
		const DisplayList *	b
	)

Definition at line 15 of file display_list_testing.cc.

                                                                        {
  if (a->Equals(b)) {
    return true;
  }
  FML_LOG(ERROR) << std::endl
                 << std::endl
                 << *a << std::endl
                 << "not identical to ..." << std::endl
                 << std::endl
                 << *b;
  return false;
}

◆ DisplayListsEQ_Verbose() [3/3]

bool flutter::testing::DisplayListsEQ_Verbose	(	const sk_sp< const DisplayList > &	a,
		const sk_sp< const DisplayList > &	b
	)

inline

Definition at line 20 of file display_list_testing.h.

                                                                      {
  return DisplayListsEQ_Verbose(a.get(), b.get());
}

◆ DisplayListsNE_Verbose() [1/3]

bool flutter::testing::DisplayListsNE_Verbose	(	const DisplayList &	a,
		const DisplayList &	b
	)

inline

Definition at line 25 of file display_list_testing.h.

                                                                               {
  return DisplayListsNE_Verbose(&a, &b);
}

◆ DisplayListsNE_Verbose() [2/3]

bool flutter::testing::DisplayListsNE_Verbose	(	const DisplayList *	a,
		const DisplayList *	b
	)

Definition at line 28 of file display_list_testing.cc.

                                                                        {
  if (a->Equals(b)) {
    FML_LOG(ERROR) << std::endl
                   << "DisplayLists are both the same:" << std::endl
                   << *a;
    return false;
  }
  return true;
}

◆ DisplayListsNE_Verbose() [3/3]

bool flutter::testing::DisplayListsNE_Verbose	(	const sk_sp< const DisplayList > &	a,
		const sk_sp< const DisplayList > &	b
	)

inline

Definition at line 28 of file display_list_testing.h.

                                                                      {
  return DisplayListsNE_Verbose(a.get(), b.get());
}

◆ DrawCheckerboard() [1/2]

static void flutter::testing::DrawCheckerboard ( DlCanvas * canvas )

static

Definition at line 171 of file dl_rendering_unittests.cc.

                                               {
  DlPaint p0, p1;
  p0.setDrawStyle(DlDrawStyle::kFill);
  p0.setColor(DlColor(0xff00fe00));  // off-green
  p1.setDrawStyle(DlDrawStyle::kFill);
  p1.setColor(DlColor::kBlue());
  // Some pixels need some transparency for DstIn testing
  p1.setAlpha(128);
  int cbdim = 5;
  int width = canvas->GetBaseLayerSize().width();
  int height = canvas->GetBaseLayerSize().height();
  for (int y = 0; y < width; y += cbdim) {
    for (int x = 0; x < height; x += cbdim) {
      DlPaint& cellp = ((x + y) & 1) == 0 ? p0 : p1;
      canvas->DrawRect(SkRect::MakeXYWH(x, y, cbdim, cbdim), cellp);
    }
  }
}

◆ DrawCheckerboard() [2/2]

static void flutter::testing::DrawCheckerboard ( SkCanvas * canvas )

static

Definition at line 190 of file dl_rendering_unittests.cc.

                                               {
  DlSkCanvasAdapter dl_canvas(canvas);
  DrawCheckerboard(&dl_canvas);
}

◆ EchoBool()

bool flutter::testing::EchoBool ( bool arg )

Definition at line 153 of file ffi_native_unittest.cc.

                        {
  EXPECT_TRUE(arg);
  return arg;
}

◆ EchoDouble()

double flutter::testing::EchoDouble ( double arg )

Definition at line 193 of file ffi_native_unittest.cc.

                              {
  EXPECT_EQ(arg, 23.0);
  return arg;
}

◆ EchoHandle()

Dart_Handle flutter::testing::EchoHandle ( Dart_Handle str )

Definition at line 210 of file ffi_native_unittest.cc.

                                        {
  const char* c_str = nullptr;
  Dart_StringToCString(str, &c_str);
  EXPECT_STREQ(c_str, "Hello EchoHandle");
  return str;
}

◆ EchoIntPtr()

intptr_t flutter::testing::EchoIntPtr ( intptr_t arg )

Definition at line 170 of file ffi_native_unittest.cc.

                                  {
  EXPECT_EQ(arg, 23);
  return arg;
}

◆ EchoString()

std::string flutter::testing::EchoString ( std::string arg )

Definition at line 229 of file ffi_native_unittest.cc.

                                    {
  EXPECT_STREQ(arg.c_str(), "Hello EchoString");
  return arg;
}

◆ EchoTypedList()

tonic::Float32List flutter::testing::EchoTypedList ( tonic::Float32List arg )

Definition at line 303 of file ffi_native_unittest.cc.

                                                     {
  EXPECT_NEAR(arg[1], 3.14, 0.01);
  return arg;
}

◆ EchoU16String()

std::u16string flutter::testing::EchoU16String ( std::u16string arg )

Definition at line 246 of file ffi_native_unittest.cc.

                                             {
  EXPECT_EQ(arg, u"Hello EchoU16String");
  return arg;
}

◆ EchoVector()

std::vector< std::string > flutter::testing::EchoVector ( const std::vector< std::string > & arg )

Definition at line 263 of file ffi_native_unittest.cc.

                                                                 {
  EXPECT_STREQ(arg[0].c_str(), "Hello EchoVector");
  return arg;
}

◆ EchoWrappable()

intptr_t flutter::testing::EchoWrappable ( MyNativeClass * arg )

Definition at line 280 of file ffi_native_unittest.cc.

                                           {
  EXPECT_EQ(arg->_value, 0x1234);
  return arg->_value;
}

◆ ExpectKeyEventEq()

void flutter::testing::ExpectKeyEventEq	(	const FlutterKeyEvent &	subject,
		const FlutterKeyEvent &	baseline
	)

Definition at line 2894 of file embedder_unittests.cc.

                                                       {
  EXPECT_EQ(subject.timestamp, baseline.timestamp);
  EXPECT_EQ(subject.type, baseline.type);
  EXPECT_EQ(subject.physical, baseline.physical);
  EXPECT_EQ(subject.logical, baseline.logical);
  EXPECT_EQ(subject.synthesized, baseline.synthesized);
  EXPECT_EQ(subject.device_type, baseline.device_type);
}

◆ expectSoftwareRenderingOutputMatches() [1/2]

static void flutter::testing::expectSoftwareRenderingOutputMatches	(	EmbedderTest &	test,
		std::string	entrypoint,
		FlutterSoftwarePixelFormat	pixfmt,
		const std::vector< uint8_t > &	bytes
	)

static

Definition at line 2708 of file embedder_unittests.cc.

                                     {
  auto& context =
      test.GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  fml::AutoResetWaitableEvent latch;
  bool matches = false;
 
  builder.SetSoftwareRendererConfig();
  builder.SetCompositor();
  builder.SetDartEntrypoint(std::move(entrypoint));
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer2,
      pixfmt);
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  context.GetCompositor().SetNextPresentCallback(
      [&matches, &bytes, &latch](FlutterViewId view_id,
                                 const FlutterLayer** layers,
                                 size_t layers_count) {
        ASSERT_EQ(layers[0]->type, kFlutterLayerContentTypeBackingStore);
        ASSERT_EQ(layers[0]->backing_store->type,
                  kFlutterBackingStoreTypeSoftware2);
        matches = SurfacePixelDataMatchesBytes(
            static_cast<SkSurface*>(
                layers[0]->backing_store->software2.user_data),
            bytes);
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1;
  event.height = 1;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
  ASSERT_TRUE(matches);
 
  engine.reset();
}

◆ expectSoftwareRenderingOutputMatches() [2/2]

template<typename T >

static void flutter::testing::expectSoftwareRenderingOutputMatches	(	EmbedderTest &	test,
		std::string	entrypoint,
		FlutterSoftwarePixelFormat	pixfmt,
		T	pixelvalue
	)

static

Definition at line 2760 of file embedder_unittests.cc.

                  {
  uint8_t* bytes = reinterpret_cast<uint8_t*>(&pixelvalue);
  return expectSoftwareRenderingOutputMatches(
      test, std::move(entrypoint), pixfmt,
      std::vector<uint8_t>(bytes, bytes + sizeof(T)));
}

◆ FilterModeToString()

std::string flutter::testing::FilterModeToString ( const DlFilterMode mode )

Definition at line 1090 of file dl_benchmarks.cc.

                                                      {
  switch (mode) {
    case DlFilterMode::kNearest:
      return "Nearest";
    case DlFilterMode::kLinear:
      return "Linear";
    default:
      return "Unknown";
  }
}

◆ FilterMutationsByType() [1/2]

void flutter::testing::FilterMutationsByType	(	const FlutterPlatformView *	view,
		FlutterPlatformViewMutationType	type,
		const std::function< void(const FlutterPlatformViewMutation &mutation)> &	handler
	)

Definition at line 282 of file embedder_unittests_util.cc.

                 {
  return FilterMutationsByType(view->mutations, view->mutations_count, type,
                               handler);
}

◆ FilterMutationsByType() [2/2]

void flutter::testing::FilterMutationsByType	(	const FlutterPlatformViewMutation **	mutations,
		size_t	count,
		FlutterPlatformViewMutationType	type,
		const std::function< void(const FlutterPlatformViewMutation &mutation)> &	handler
	)

Definition at line 262 of file embedder_unittests_util.cc.

                 {
  if (mutations == nullptr) {
    return;
  }
 
  for (size_t i = 0; i < count; ++i) {
    const FlutterPlatformViewMutation* mutation = mutations[i];
    if (mutation->type != type) {
      continue;
    }
 
    handler(*mutation);
  }
}

◆ FixtureNameForBackend()

std::string flutter::testing::FixtureNameForBackend	(	EmbedderTestContextType	backend,
		const std::string &	name
	)

Prepends a prefix to the name which is unique to the test context type. This is useful for tests that use EmbedderTestMultiBackend and require different fixtures per backend. For OpenGL, the name remains unchanged.

Parameters

[in]	backend	The test context type used to determine the prepended prefix (e.g. `vk_[name]` for Vulkan).
[in]	name	The name of the fixture without any special prefixes.

Definition at line 79 of file embedder_unittests_util.cc.

                                                         {
  switch (backend) {
    case EmbedderTestContextType::kVulkanContext:
      return "vk_" + name;
    default:
      return name;
  }
}

◆ fl_ensure_gtk_init()

void flutter::testing::fl_ensure_gtk_init ( GLogWriterFunc writer = nullptr )

Ensures that GTK has been initialized and starts monitoring logs.

Ensures that GTK has been initialized. If GTK has not been initialized, it will be initialized using gtk_init(). It will also set the GTK log writer function to monitor the log output, recording the log levels that have been received in a bitfield accessible via fl_get_received_gtk_log_levels

To retrieve the bitfield of recorded log levels, use fl_get_received_gtk_log_levels().

Parameters

[in] writer The custom log writer function to use. If nullptr, or it returns G_LOG_WRITER_UNHANDLED, the default log writer function will be called.

Definition at line 35 of file fl_test_gtk_logs.cc.

                                               {
  if (!gtk_initialized) {
    gtk_init(0, nullptr);
    g_log_set_writer_func(log_writer, nullptr, nullptr);
    gtk_initialized = true;
  }
  fl_reset_received_gtk_log_levels();
  log_writer_cb = writer;
}

◆ fl_get_received_gtk_log_levels()

GLogLevelFlags flutter::testing::fl_get_received_gtk_log_levels ( )

Returns the recorded log levels.

Returns a bitfield containing the GTK log levels that have been seen since the last time they were reset.

Returns: A GLogLevelFlags bitfield representing the recorded log levels.

Definition at line 49 of file fl_test_gtk_logs.cc.

                                                {
  return fl_received_log_levels;
}

◆ fl_reset_received_gtk_log_levels()

void flutter::testing::fl_reset_received_gtk_log_levels ( )

Resets the recorded log levels.

Resets the recorded GTK log levels to zero.

Definition at line 45 of file fl_test_gtk_logs.cc.

                                        {
  fl_received_log_levels = (GLogLevelFlags)0x0;
}

◆ FlushSubmitCpuSync()

static void flutter::testing::FlushSubmitCpuSync ( const sk_sp< SkSurface > & surface )

static

Definition at line 46 of file dl_benchmarks.cc.

                                                                {
  if (!surface) {
    return;
  }
  if (GrDirectContext* dContext =
          GrAsDirectContext(surface->recordingContext())) {
    dContext->flushAndSubmit(surface.get(), GrSyncCpu::kYes);
  }
}

◆ GetArgsForProcess()

const fml::CommandLine & flutter::testing::GetArgsForProcess ( )

Definition at line 12 of file test_args.cc.

                                          {
  return gProcessArgs;
}

◆ GetConicsPath()

void flutter::testing::GetConicsPath	(	SkPath &	path,
		size_t	sides,
		SkPoint	center,
		float	radius
	)

Definition at line 542 of file dl_benchmarks.cc.

                                                                             {
  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
  std::vector<SkPoint> control_points =
      GetPolygonPoints(sides * 2, center, radius * 0.8f);
 
  path.moveTo(points[0]);
  for (size_t i = 1; i < sides; i++) {
    path.conicTo(control_points[2 * i - 1], points[i], 3.7f);
  }
  path.conicTo(control_points[2 * sides - 1], points[0], 3.7f);
  path.close();
}

◆ GetCubicsPath()

void flutter::testing::GetCubicsPath	(	SkPath &	path,
		size_t	sides,
		SkPoint	center,
		float	radius
	)

Definition at line 565 of file dl_benchmarks.cc.

                                                                             {
  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
  std::vector<SkPoint> inner_control_points =
      GetPolygonPoints(sides * 3, center, radius * 0.8f);
  std::vector<SkPoint> outer_control_points =
      GetPolygonPoints(sides * 3, center, radius * 1.2f);
 
  path.moveTo(points[0]);
  for (size_t i = 1; i < sides; i++) {
    path.cubicTo(inner_control_points[3 * i - 2],
                 outer_control_points[3 * i - 1], points[i]);
  }
  path.cubicTo(inner_control_points[3 * sides - 2],
               outer_control_points[3 * sides - 1], points[0]);
  path.close();
}

◆ GetCurrentTestName()

std::string flutter::testing::GetCurrentTestName ( )

Gets the name of the currently running test. This is useful in generating logs or assets based on test name.

Returns: The current test name.

Definition at line 15 of file testing.cc.

                               {
  return ::testing::UnitTest::GetInstance()->current_test_info()->name();
}

◆ GetDebuggerStatus()

DebuggerStatus flutter::testing::GetDebuggerStatus ( )

Definition at line 25 of file debugger_detection.cc.

                                   {
#if FML_OS_MACOSX
  // From Technical Q&A QA1361 Detecting the Debugger
  // https://developer.apple.com/library/archive/qa/qa1361/_index.html
  int management_info_base[4];
  struct kinfo_proc info;
  size_t size;
 
  // Initialize the flags so that, if sysctl fails for some bizarre
  // reason, we get a predictable result.
  info.kp_proc.p_flag = 0;
 
  // Initialize management_info_base, which tells sysctl the info we want, in
  // this case we're looking for information about a specific process ID.
  management_info_base[0] = CTL_KERN;
  management_info_base[1] = KERN_PROC;
  management_info_base[2] = KERN_PROC_PID;
  management_info_base[3] = getpid();
 
  // Call sysctl.
 
  size = sizeof(info);
  auto status =
      ::sysctl(management_info_base,
               sizeof(management_info_base) / sizeof(*management_info_base),
               &info, &size, NULL, 0);
  FML_CHECK(status == 0);
 
  // We're being debugged if the P_TRACED flag is set.
  return ((info.kp_proc.p_flag & P_TRACED) != 0) ? DebuggerStatus::kAttached
                                                 : DebuggerStatus::kDontKnow;
 
#elif FML_OS_WIN
  return ::IsDebuggerPresent() ? DebuggerStatus::kAttached
                               : DebuggerStatus::kDontKnow;
 
#else
  return DebuggerStatus::kDontKnow;
#endif
}  // namespace testing

◆ GetDefaultKernelFilePath()

std::string flutter::testing::GetDefaultKernelFilePath ( )

Returns the default path to kernel_blob.bin. This file is within the directory returned by GetFixturesPath().

Returns: The kernel file path.

Definition at line 19 of file testing.cc.

                                     {
  return fml::paths::JoinPaths({GetFixturesPath(), "kernel_blob.bin"});
}

◆ GetEGLError()

static std::string flutter::testing::GetEGLError ( )

static

Definition at line 30 of file test_gl_surface.cc.

                               {
  std::stringstream stream;
 
  auto error = ::eglGetError();
 
  stream << "EGL Result: '";
 
  switch (error) {
    case EGL_SUCCESS:
      stream << "EGL_SUCCESS";
      break;
    case EGL_NOT_INITIALIZED:
      stream << "EGL_NOT_INITIALIZED";
      break;
    case EGL_BAD_ACCESS:
      stream << "EGL_BAD_ACCESS";
      break;
    case EGL_BAD_ALLOC:
      stream << "EGL_BAD_ALLOC";
      break;
    case EGL_BAD_ATTRIBUTE:
      stream << "EGL_BAD_ATTRIBUTE";
      break;
    case EGL_BAD_CONTEXT:
      stream << "EGL_BAD_CONTEXT";
      break;
    case EGL_BAD_CONFIG:
      stream << "EGL_BAD_CONFIG";
      break;
    case EGL_BAD_CURRENT_SURFACE:
      stream << "EGL_BAD_CURRENT_SURFACE";
      break;
    case EGL_BAD_DISPLAY:
      stream << "EGL_BAD_DISPLAY";
      break;
    case EGL_BAD_SURFACE:
      stream << "EGL_BAD_SURFACE";
      break;
    case EGL_BAD_MATCH:
      stream << "EGL_BAD_MATCH";
      break;
    case EGL_BAD_PARAMETER:
      stream << "EGL_BAD_PARAMETER";
      break;
    case EGL_BAD_NATIVE_PIXMAP:
      stream << "EGL_BAD_NATIVE_PIXMAP";
      break;
    case EGL_BAD_NATIVE_WINDOW:
      stream << "EGL_BAD_NATIVE_WINDOW";
      break;
    case EGL_CONTEXT_LOST:
      stream << "EGL_CONTEXT_LOST";
      break;
    default:
      stream << "Unknown";
  }
 
  stream << "' (0x" << std::hex << error << std::dec << ").";
  return stream.str();
}

◆ GetFixturesPath()

const char * flutter::testing::GetFixturesPath ( )

Returns the directory containing the test fixture for the target if this target has fixtures configured. If there are no fixtures, this is a link error. If you see a linker error on this symbol, the unit-test target needs to depend on a test_fixtures target.

Returns: The fixtures path.

◆ GetLinesPath()

void flutter::testing::GetLinesPath	(	SkPath &	path,
		size_t	sides,
		SkPoint	center,
		float	radius
	)

Definition at line 501 of file dl_benchmarks.cc.

                                                                            {
  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
  path.moveTo(points[0]);
  for (size_t i = 1; i < sides; i++) {
    path.lineTo(points[i]);
  }
  path.lineTo(points[0]);
  path.close();
}

◆ GetPaintForRun()

DlPaint flutter::testing::GetPaintForRun ( unsigned attributes )

Definition at line 23 of file dl_benchmarks.cc.

                                            {
  DlPaint paint;
 
  if (attributes & kStrokedStyle && attributes & kFilledStyle) {
    // Not currently exposed by Flutter, but we can probably benchmark this in
    // the future
    paint.setDrawStyle(DlDrawStyle::kStrokeAndFill);
  } else if (attributes & kStrokedStyle) {
    paint.setDrawStyle(DlDrawStyle::kStroke);
  } else if (attributes & kFilledStyle) {
    paint.setDrawStyle(DlDrawStyle::kFill);
  }
 
  if (attributes & kHairlineStroke) {
    paint.setStrokeWidth(0.0f);
  } else {
    paint.setStrokeWidth(1.0f);
  }
 
  paint.setAntiAlias(attributes & kAntiAliasing);
  return paint;
}

◆ GetPolygonPoints()

std::vector< SkPoint > flutter::testing::GetPolygonPoints	(	size_t	n,
		SkPoint	center,
		SkScalar	r
	)

Definition at line 481 of file dl_benchmarks.cc.

                                                                          {
  std::vector<SkPoint> points;
  SkScalar x, y;
  float angle;
  float full_circle = 2.0f * M_PI;
  for (size_t i = 0; i < n; i++) {
    angle = (full_circle / static_cast<float>(n)) * static_cast<float>(i);
    x = center.x() + r * std::cosf(angle);
    y = center.y() + r * std::sinf(angle);
    points.push_back(SkPoint::Make(x, y));
  }
  return points;
}

◆ GetQuadsPath()

void flutter::testing::GetQuadsPath	(	SkPath &	path,
		size_t	sides,
		SkPoint	center,
		float	radius
	)

Definition at line 520 of file dl_benchmarks.cc.

                                                                            {
  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
  std::vector<SkPoint> control_points =
      GetPolygonPoints(sides * 2, center, radius * 0.8f);
 
  path.moveTo(points[0]);
  for (size_t i = 1; i < sides; i++) {
    path.quadTo(control_points[2 * i - 1], points[i]);
  }
  path.quadTo(control_points[2 * sides - 1], points[0]);
  path.close();
}

◆ GetRasterizerResourceCacheBytesSync()

static size_t flutter::testing::GetRasterizerResourceCacheBytesSync ( const Shell & shell )

static

Definition at line 1666 of file shell_unittests.cc.

                                                                      {
  size_t bytes = 0;
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell.GetTaskRunners().GetRasterTaskRunner(), [&]() {
        if (auto rasterizer = shell.GetRasterizer()) {
          bytes = rasterizer->GetResourceCacheMaxBytes().value_or(0U);
        }
        latch.Signal();
      });
  latch.Wait();
  return bytes;
}

◆ GetRenderTargetFromBackend()

EmbedderTestBackingStoreProducer::RenderTargetType flutter::testing::GetRenderTargetFromBackend	(	EmbedderTestContextType	backend,
		bool	opengl_framebuffer
	)

Resolves a render target type for a given backend description. This is useful for tests that use EmbedderTestMultiBackend.

Parameters

[in]	backend	The test context type to resolve the render target for.
[in]	opengl_framebuffer	Ignored for all non-OpenGL backends. Flutter supports rendering to both OpenGL textures and framebuffers. When false, the OpenGL texture render target type is returned.

Definition at line 89 of file embedder_unittests_util.cc.

                             {
  switch (backend) {
    case EmbedderTestContextType::kVulkanContext:
      return EmbedderTestBackingStoreProducer::RenderTargetType::kVulkanImage;
    case EmbedderTestContextType::kOpenGLContext:
      if (opengl_framebuffer) {
        return EmbedderTestBackingStoreProducer::RenderTargetType::
            kOpenGLFramebuffer;
      }
      return EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture;
    case EmbedderTestContextType::kMetalContext:
      return EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture;
    case EmbedderTestContextType::kSoftwareContext:
      return EmbedderTestBackingStoreProducer::RenderTargetType::
          kSoftwareBuffer;
  }
}

◆ GetSampleDisplayList() [1/2]

sk_sp< DisplayList > flutter::testing::GetSampleDisplayList ( )

Definition at line 15 of file dl_test_snippets.cc.

                                          {
  DisplayListBuilder builder(SkRect::MakeWH(150, 100));
  builder.DrawRect(SkRect::MakeXYWH(10, 10, 80, 80), DlPaint(DlColor::kRed()));
  return builder.Build();
}

◆ GetSampleDisplayList() [2/2]

sk_sp< DisplayList > flutter::testing::GetSampleDisplayList ( int ops )

Definition at line 36 of file dl_test_snippets.cc.

                                                 {
  DisplayListBuilder builder(SkRect::MakeWH(150, 100));
  for (int i = 0; i < ops; i++) {
    builder.DrawColor(DlColor::kRed(), DlBlendMode::kSrc);
  }
  return builder.Build();
}

◆ GetSampleNestedDisplayList()

sk_sp< DisplayList > flutter::testing::GetSampleNestedDisplayList ( )

Definition at line 21 of file dl_test_snippets.cc.

                                                {
  DisplayListBuilder builder(SkRect::MakeWH(150, 100));
  DlPaint paint;
  for (int y = 10; y <= 60; y += 10) {
    for (int x = 10; x <= 60; x += 10) {
      paint.setColor(((x + y) % 20) == 10 ? DlColor(SK_ColorRED)
                                          : DlColor(SK_ColorBLUE));
      builder.DrawRect(SkRect::MakeXYWH(x, y, 80, 80), paint);
    }
  }
  DisplayListBuilder outer_builder(SkRect::MakeWH(150, 100));
  outer_builder.DrawDisplayList(builder.Build());
  return outer_builder.Build();
}

◆ GetSamplePaintContextHolder()

PaintContextHolder flutter::testing::GetSamplePaintContextHolder	(	LayerStateStack &	state_stack,
		RasterCache *	raster_cache,
		FixedRefreshRateStopwatch *	raster_time,
		FixedRefreshRateStopwatch *	ui_time
	)

Definition at line 113 of file mock_raster_cache.cc.

                                        {
  sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
  PaintContextHolder holder = {// clang-format off
    {
        .state_stack                   = state_stack,
        .canvas                        = nullptr,
        .gr_context                    = nullptr,
        .dst_color_space               = srgb,
        .view_embedder                 = nullptr,
        .raster_time                   = *raster_time,
        .ui_time                       = *ui_time,
        .texture_registry              = nullptr,
        .raster_cache                  = raster_cache,
    },
                               // clang-format on
                               srgb};
 
  return holder;
}

◆ GetSamplePrerollContextHolder()

PrerollContextHolder flutter::testing::GetSamplePrerollContextHolder	(	LayerStateStack &	state_stack,
		RasterCache *	raster_cache,
		FixedRefreshRateStopwatch *	raster_time,
		FixedRefreshRateStopwatch *	ui_time
	)

Definition at line 84 of file mock_raster_cache.cc.

                                        {
  sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
 
  PrerollContextHolder holder = {
      {
          // clang-format off
          .raster_cache                  = raster_cache,
          .gr_context                    = nullptr,
          .view_embedder                 = nullptr,
          .state_stack                   = state_stack,
          .dst_color_space               = srgb,
          .surface_needs_readback        = false,
          .raster_time                   = *raster_time,
          .ui_time                       = *ui_time,
          .texture_registry              = nullptr,
          .has_platform_view             = false,
          .has_texture_layer             = false,
          .raster_cached_entries         = &raster_cache_items_,
          // clang-format on
      },
      srgb};
 
  return holder;
}

◆ GetSourcePath()

const char * flutter::testing::GetSourcePath ( )

◆ GetSurfaceFromTexture()

static sk_sp< SkSurface > flutter::testing::GetSurfaceFromTexture	(	const sk_sp< GrDirectContext > &	skia_context,
		SkISize	texture_size,
		void *	texture
	)

static

Definition at line 64 of file embedder_metal_unittests.mm.

                                                             {
  GrMtlTextureInfo info;
  info.fTexture.reset([(id<MTLTexture>)texture retain]);
  GrBackendTexture backend_texture = GrBackendTextures::MakeMtl(
      texture_size.width(), texture_size.height(), skgpu::Mipmapped::kNo, info);
 
  return SkSurfaces::WrapBackendTexture(skia_context.get(), backend_texture,
                                        kTopLeft_GrSurfaceOrigin, 1, kBGRA_8888_SkColorType,
                                        nullptr, nullptr);
}

◆ GetTaskRunnersForFixture()

TaskRunners flutter::testing::GetTaskRunnersForFixture ( )

Definition at line 97 of file external_view_embedder_unittests.cc.

                                       {
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto& loop = fml::MessageLoop::GetCurrent();
  return {
      "test",
      loop.GetTaskRunner(),  // platform
      loop.GetTaskRunner(),  // raster
      loop.GetTaskRunner(),  // ui
      loop.GetTaskRunner()   // io
  };
}

◆ GetTestingAssetsPath()

const char * flutter::testing::GetTestingAssetsPath ( )

Returns the directory containing assets shared across all tests.

Returns: The testing assets path.

◆ GetTestNameFromTestInfo()

static std::string flutter::testing::GetTestNameFromTestInfo ( const ::testing::TestInfo & test_info )

static

Definition at line 86 of file test_timeout_listener.cc.

                                      {
  std::stringstream stream;
  stream << test_info.test_suite_name();
  stream << ".";
  stream << test_info.name();
  if (auto type_param = test_info.type_param()) {
    stream << "/" << type_param;
  }
  if (auto value_param = test_info.value_param()) {
    stream << "/" << value_param;
  }
  return stream.str();
}

◆ GetTestPoints()

std::vector< SkPoint > flutter::testing::GetTestPoints	(	size_t	count,
		SkISize	canvas_size
	)

Definition at line 835 of file dl_benchmarks.cc.

                                                                    {
  std::vector<SkPoint> points;
 
  // Some arbitrary offsets to use when building the list of points
  std::vector<SkScalar> delta_x = {10.0f, 6.3f, 15.0f, 3.5f, 22.6f, 4.7f};
  std::vector<SkScalar> delta_y = {9.3f, -5.4f, 8.5f, -12.0f, 19.2f, -19.6f};
 
  SkPoint current = SkPoint::Make(0.0f, 0.0f);
  for (size_t i = 0; i < count; i++) {
    points.push_back(current);
    current.offset(delta_x[i % delta_x.size()], delta_y[i % delta_y.size()]);
    if (current.x() > canvas_size.width()) {
      current.offset(-canvas_size.width(), 25.0f);
    }
    if (current.y() > canvas_size.height()) {
      current.offset(0.0f, -canvas_size.height());
    }
  }
 
  return points;
}

◆ GetTestTextBlob()

sk_sp< SkTextBlob > flutter::testing::GetTestTextBlob ( int index )

Definition at line 998 of file dl_test_snippets.cc.

                                             {
  static std::map<int, sk_sp<SkTextBlob>> text_blobs;
  auto it = text_blobs.find(index);
  if (it != text_blobs.end()) {
    return it->second;
  }
  std::string text = "TestBlob" + std::to_string(index);
  sk_sp<SkTextBlob> blob =
      SkTextBlob::MakeFromText(text.c_str(), text.size(),
                               CreateTestFontOfSize(20), SkTextEncoding::kUTF8);
  text_blobs.insert(std::make_pair(index, blob));
  return blob;
}

◆ GetTestVertices()

std::shared_ptr< DlVertices > flutter::testing::GetTestVertices	(	SkPoint	center,
		float	radius,
		size_t	vertex_count,
		DlVertexMode	mode,
		size_t &	final_vertex_count
	)

Definition at line 694 of file dl_benchmarks.cc.

                                                                        {
  size_t outer_vertex_count = vertex_count / 2;
  std::vector<SkPoint> outer_points =
      GetPolygonPoints(outer_vertex_count, center, radius);
 
  std::vector<SkPoint> vertices;
  std::vector<DlColor> colors;
 
  switch (mode) {
    case DlVertexMode::kTriangleFan:
      // Calling the points on the outer circle O_0, O_1, O_2, ..., and
      // the center point C, this should create a triangle fan with vertices
      // C, O_0, O_1, O_2, O_3, ...
      vertices.push_back(center);
      colors.push_back(DlColor(SK_ColorCYAN));
      for (size_t i = 0; i <= outer_points.size(); i++) {
        vertices.push_back(outer_points[i % outer_points.size()]);
        if (i % 3 == 0) {
          colors.push_back(DlColor(SK_ColorRED));
        } else if (i % 3 == 1) {
          colors.push_back(DlColor(SK_ColorGREEN));
        } else {
          colors.push_back(DlColor(SK_ColorBLUE));
        }
      }
      break;
    case DlVertexMode::kTriangles:
      // Calling the points on the outer circle O_0, O_1, O_2, ..., and
      // the center point C, this should create a series of triangles with
      // vertices O_0, O_1, C, O_1, O_2, C, O_2, O_3, C, ...
      for (size_t i = 0; i < outer_vertex_count; i++) {
        vertices.push_back(outer_points[i % outer_points.size()]);
        colors.push_back(DlColor(SK_ColorRED));
        vertices.push_back(outer_points[(i + 1) % outer_points.size()]);
        colors.push_back(DlColor(SK_ColorGREEN));
        vertices.push_back(center);
        colors.push_back(DlColor(SK_ColorBLUE));
      }
      break;
    case DlVertexMode::kTriangleStrip:
      // Calling the points on the outer circle O_0, O_1, O_2, ..., and
      // the center point C, this should create a strip with vertices
      // O_0, O_1, C, O_2, O_3, C, O_4, O_5, C, ...
      for (size_t i = 0; i <= outer_vertex_count; i++) {
        vertices.push_back(outer_points[i % outer_points.size()]);
        colors.push_back(i % 2 ? DlColor(SK_ColorRED) : DlColor(SK_ColorGREEN));
        if (i % 2 == 1) {
          vertices.push_back(center);
          colors.push_back(DlColor(SK_ColorBLUE));
        }
      }
      break;
    default:
      break;
  }
 
  final_vertex_count = vertices.size();
  return DlVertices::Make(mode, vertices.size(), vertices.data(), nullptr,
                          colors.data());
}

◆ GetThreadMergerFromPlatformThread()

fml::RefPtr< fml::RasterThreadMerger > flutter::testing::GetThreadMergerFromPlatformThread ( fml::Thread * rasterizer_thread = nullptr )

Definition at line 69 of file external_view_embedder_unittests.cc.

                                            {
  // Assume the current thread is the platform thread.
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto platform_queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
 
  if (!rasterizer_thread) {
    return fml::MakeRefCounted<fml::RasterThreadMerger>(platform_queue_id,
                                                        platform_queue_id);
  }
  auto rasterizer_queue_id =
      rasterizer_thread->GetTaskRunner()->GetTaskQueueId();
  return fml::MakeRefCounted<fml::RasterThreadMerger>(platform_queue_id,
                                                      rasterizer_queue_id);
}

◆ GetThreadMergerFromRasterThread()

fml::RefPtr< fml::RasterThreadMerger > flutter::testing::GetThreadMergerFromRasterThread ( fml::Thread * platform_thread )

Definition at line 85 of file external_view_embedder_unittests.cc.

                                {
  auto platform_queue_id = platform_thread->GetTaskRunner()->GetTaskQueueId();
 
  // Assume the current thread is the raster thread.
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto rasterizer_queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
 
  return fml::MakeRefCounted<fml::RasterThreadMerger>(platform_queue_id,
                                                      rasterizer_queue_id);
}

◆ GetTotalMutationTransformationMatrix() [1/2]

SkMatrix flutter::testing::GetTotalMutationTransformationMatrix ( const FlutterPlatformView * view )

Definition at line 305 of file embedder_unittests_util.cc.

                                                                               {
  return GetTotalMutationTransformationMatrix(view->mutations,
                                              view->mutations_count);
}

◆ GetTotalMutationTransformationMatrix() [2/2]

SkMatrix flutter::testing::GetTotalMutationTransformationMatrix	(	const FlutterPlatformViewMutation **	mutations,
		size_t	count
	)

Definition at line 291 of file embedder_unittests_util.cc.

                  {
  SkMatrix collected;
 
  FilterMutationsByType(
      mutations, count, kFlutterPlatformViewMutationTypeTransformation,
      [&](const auto& mutation) {
        collected.preConcat(SkMatrixMake(mutation.transformation));
      });
 
  return collected;
}

◆ HalfToFloat()

float flutter::testing::HalfToFloat ( uint16_t half )

Definition at line 52 of file image_decoder_no_gl_unittests.cc.

                                 {
  switch (half) {
    case 0x7c00:
      return std::numeric_limits<float>::infinity();
    case 0xfc00:
      return -std::numeric_limits<float>::infinity();
  }
  bool negative = half >> 15;
  uint16_t exponent = (half >> 10) & 0x1f;
  uint16_t fraction = half & 0x3ff;
  float fExponent = exponent - 15.0f;
  float fFraction = static_cast<float>(fraction) / 1024.f;
  float pow_value = powf(2.0f, fExponent);
  return (negative ? -1.f : 1.f) * pow_value * (1.0f + fFraction);
}

◆ HasExtension()

static bool flutter::testing::HasExtension	(	const char *	extensions,
		const char *	name
	)

static

Definition at line 91 of file test_gl_surface.cc.

                                                                   {
  const char* r = strstr(extensions, name);
  auto len = strlen(name);
  // check that the extension name is terminated by space or null terminator
  return r != nullptr && (r[len] == ' ' || r[len] == 0);
}

◆ ImageFromBitmapWithNewID()

sk_sp< SkImage > flutter::testing::ImageFromBitmapWithNewID ( const SkBitmap & bitmap )

Definition at line 925 of file dl_benchmarks.cc.

                                                                {
  // If we create an SkPixmap with a ref to the SkBitmap's pixel data,
  // then create an SkImage from that, we always get a new generation ID,
  // so we will avoid hitting the cache.
  SkPixmap pixmap;
  bitmap.peekPixels(&pixmap);
  return SkImages::RasterFromPixmap(pixmap, nullptr, nullptr);
}

◆ ImageMatchesFixture() [1/2]

bool flutter::testing::ImageMatchesFixture	(	const std::string &	fixture_file_name,
		const sk_sp< SkImage > &	scene_image
	)

Definition at line 152 of file embedder_unittests_util.cc.

                                                            {
  fml::FileMapping fixture_image_mapping(OpenFixture(fixture_file_name));
 
  FML_CHECK(fixture_image_mapping.GetSize() != 0u)
      << "Could not find fixture: " << fixture_file_name;
 
  auto encoded_image = SkData::MakeWithoutCopy(
      fixture_image_mapping.GetMapping(), fixture_image_mapping.GetSize());
  auto fixture_image =
      SkImages::DeferredFromEncodedData(std::move(encoded_image))
          ->makeRasterImage();
 
  FML_CHECK(fixture_image) << "Could not create image from fixture: "
                           << fixture_file_name;
 
  FML_CHECK(scene_image) << "Invalid scene image.";
 
  auto scene_image_subset = scene_image->makeSubset(
      nullptr,
      SkIRect::MakeWH(fixture_image->width(), fixture_image->height()));
 
  FML_CHECK(scene_image_subset)
      << "Could not create image subset for fixture comparison: "
      << scene_image_subset;
 
  const auto images_are_same =
      RasterImagesAreSame(scene_image_subset, fixture_image);
 
  // If the images are not the same, this predicate is going to indicate test
  // failure. Dump both the actual image and the expectation to disk to the
  // test author can figure out what went wrong.
  if (!images_are_same) {
    const auto fixtures_path = GetFixturesPath();
 
    const auto actual_file_name = "actual_" + fixture_file_name;
    const auto expect_file_name = "expectation_" + fixture_file_name;
 
    auto fixtures_fd = OpenFixturesDirectory();
 
    FML_CHECK(
        WriteImageToDisk(fixtures_fd, actual_file_name, scene_image_subset))
        << "Could not write file to disk: " << actual_file_name;
 
    FML_CHECK(WriteImageToDisk(fixtures_fd, expect_file_name, fixture_image))
        << "Could not write file to disk: " << expect_file_name;
 
    FML_LOG(ERROR) << "Image did not match expectation." << std::endl
                   << "Expected:"
                   << fml::paths::JoinPaths({fixtures_path, expect_file_name})
                   << std::endl
                   << "Got:"
                   << fml::paths::JoinPaths({fixtures_path, actual_file_name})
                   << std::endl;
  }
  return images_are_same;
}

◆ ImageMatchesFixture() [2/2]

bool flutter::testing::ImageMatchesFixture	(	const std::string &	fixture_file_name,
		std::future< sk_sp< SkImage > > &	scene_image
	)

Definition at line 210 of file embedder_unittests_util.cc.

                                                                 {
  return ImageMatchesFixture(fixture_file_name, scene_image.get());
}

◆ INSTANTIATE_PLAYGROUND_SUITE()

flutter::testing::INSTANTIATE_PLAYGROUND_SUITE ( DlGoldenTest )

◆ INSTANTIATE_TEST_SUITE_P()

flutter::testing::INSTANTIATE_TEST_SUITE_P	(	EmbedderTestGlVk	,
		EmbedderTestMultiBackend	,
		::testing::Values(EmbedderTestContextType::kOpenGLContext, EmbedderTestContextType::kVulkanContext)
	)

◆ InvokeAllCallbacks()

static void flutter::testing::InvokeAllCallbacks ( const std::vector< fml::closure > & callbacks )

static

Definition at line 24 of file embedder_test_compositor.cc.

                                                                       {
  for (const auto& callback : callbacks) {
    if (callback) {
      callback();
    }
  }
}

◆ keyDownEvent()

FlutterUIPressProxy * flutter::testing::keyDownEvent	(	UIKeyboardHIDUsage	keyCode,
		UIKeyModifierFlags	modifierFlags = `0x0`,
		NSTimeInterval	timestamp = `0.0f`,
		const char *	characters = `""`,
		const char *	charactersIgnoringModifiers = `""`
	)

Definition at line 90 of file FlutterFakeKeyEvents.mm.

                             {
  return keyEventWithPhase(UIPressPhaseBegan, keyCode, modifierFlags, timestamp, characters,
                           charactersIgnoringModifiers);
}

◆ keyEventWithPhase()

FlutterUIPressProxy * flutter::testing::keyEventWithPhase	(	UIPressPhase	phase,
		UIKeyboardHIDUsage	keyCode,
		UIKeyModifierFlags	modifierFlags = `0x0`,
		NSTimeInterval	timestamp = `0.0f`,
		const char *	characters = `""`,
		const char *	charactersIgnoringModifiers = `""`
	)

Definition at line 109 of file FlutterFakeKeyEvents.mm.

                             {
  FML_DCHECK(!(modifierFlags & kModifierFlagSidedMask))
      << "iOS doesn't supply modifier side flags, so don't create events with them.";
  UIKey* key =
      [[FakeUIKey alloc] initWithData:keyCode
                        modifierFlags:modifierFlags
                           characters:[NSString stringWithUTF8String:characters]
          charactersIgnoringModifiers:[NSString stringWithUTF8String:charactersIgnoringModifiers]];
 
  return [[FakeUIPressProxy alloc] initWithData:phase
                                            key:key
                                           type:UIEventTypePresses
                                      timestamp:timestamp];
}

◆ keyUpEvent()

FlutterUIPressProxy * flutter::testing::keyUpEvent	(	UIKeyboardHIDUsage	keyCode,
		UIKeyModifierFlags	modifierFlags = `0x0`,
		NSTimeInterval	timestamp = `0.0f`,
		const char *	characters = `""`,
		const char *	charactersIgnoringModifiers = `""`
	)

Definition at line 100 of file FlutterFakeKeyEvents.mm.

                                                                                                  {
  return keyEventWithPhase(UIPressPhaseEnded, keyCode, modifierFlags, timestamp, characters,
                           charactersIgnoringModifiers);
}

◆ kTestBlendColorFilter1()

static const DlBlendColorFilter flutter::testing::kTestBlendColorFilter1	(	DlColor::kRed()	,
		DlBlendMode::kDstATop
	)

static

◆ kTestBlendColorFilter2()

static const DlBlendColorFilter flutter::testing::kTestBlendColorFilter2	(	DlColor::kBlue()	,
		DlBlendMode::kDstATop
	)

static

◆ kTestBlendColorFilter3()

static const DlBlendColorFilter flutter::testing::kTestBlendColorFilter3	(	DlColor::kRed()	,
		DlBlendMode::kDstIn
	)

static

◆ kTestBlurImageFilter1()

static const DlBlurImageFilter flutter::testing::kTestBlurImageFilter1	(	5.	0,
		5.	0,
		DlTileMode::kClamp
	)

static

◆ kTestBlurImageFilter2()

static const DlBlurImageFilter flutter::testing::kTestBlurImageFilter2	(	6.	0,
		5.	0,
		DlTileMode::kClamp
	)

static

◆ kTestBlurImageFilter3()

static const DlBlurImageFilter flutter::testing::kTestBlurImageFilter3	(	5.	0,
		6.	0,
		DlTileMode::kClamp
	)

static

◆ kTestBlurImageFilter4()

static const DlBlurImageFilter flutter::testing::kTestBlurImageFilter4	(	5.	0,
		5.	0,
		DlTileMode::kDecal
	)

static

◆ kTestCFImageFilter1()

static const DlColorFilterImageFilter flutter::testing::kTestCFImageFilter1 ( kTestBlendColorFilter1 )

static

◆ kTestCFImageFilter2()

static const DlColorFilterImageFilter flutter::testing::kTestCFImageFilter2 ( kTestBlendColorFilter2 )

static

◆ kTestComposeImageFilter1()

static const DlComposeImageFilter flutter::testing::kTestComposeImageFilter1	(	kTestBlurImageFilter1	,
		kTestMatrixImageFilter1
	)

static

◆ kTestComposeImageFilter2()

static const DlComposeImageFilter flutter::testing::kTestComposeImageFilter2	(	kTestBlurImageFilter2	,
		kTestMatrixImageFilter1
	)

static

◆ kTestComposeImageFilter3()

static const DlComposeImageFilter flutter::testing::kTestComposeImageFilter3	(	kTestBlurImageFilter1	,
		kTestMatrixImageFilter2
	)

static

◆ kTestDilateImageFilter1()

static const DlDilateImageFilter flutter::testing::kTestDilateImageFilter1	(	5.	0,
		5.	0
	)

static

◆ kTestDilateImageFilter2()

static const DlDilateImageFilter flutter::testing::kTestDilateImageFilter2	(	6.	0,
		5.	0
	)

static

◆ kTestDilateImageFilter3()

static const DlDilateImageFilter flutter::testing::kTestDilateImageFilter3	(	5.	0,
		6.	0
	)

static

◆ kTestErodeImageFilter1()

static const DlErodeImageFilter flutter::testing::kTestErodeImageFilter1	(	4.	0,
		4.	0
	)

static

◆ kTestErodeImageFilter2()

static const DlErodeImageFilter flutter::testing::kTestErodeImageFilter2	(	4.	0,
		3.	0
	)

static

◆ kTestErodeImageFilter3()

static const DlErodeImageFilter flutter::testing::kTestErodeImageFilter3	(	3.	0,
		4.	0
	)

static

◆ kTestMaskFilter1()

static const DlBlurMaskFilter flutter::testing::kTestMaskFilter1	(	DlBlurStyle::kNormal	,
		3.	0
	)

static

◆ kTestMaskFilter2()

static const DlBlurMaskFilter flutter::testing::kTestMaskFilter2	(	DlBlurStyle::kNormal	,
		5.	0
	)

static

◆ kTestMaskFilter3()

static const DlBlurMaskFilter flutter::testing::kTestMaskFilter3	(	DlBlurStyle::kSolid	,
		3.	0
	)

static

◆ kTestMaskFilter4()

static const DlBlurMaskFilter flutter::testing::kTestMaskFilter4	(	DlBlurStyle::kInner	,
		3.	0
	)

static

◆ kTestMaskFilter5()

static const DlBlurMaskFilter flutter::testing::kTestMaskFilter5	(	DlBlurStyle::kOuter	,
		3.	0
	)

static

◆ kTestMatrixColorFilter1()

static const DlMatrixColorFilter flutter::testing::kTestMatrixColorFilter1 ( kRotateColorMatrix )

static

◆ kTestMatrixColorFilter2()

static const DlMatrixColorFilter flutter::testing::kTestMatrixColorFilter2 ( kInvertColorMatrix )

static

◆ kTestMatrixImageFilter1()

static const DlMatrixImageFilter flutter::testing::kTestMatrixImageFilter1	(	SkMatrix::RotateDeg(45)	,
		kNearestSampling
	)

static

◆ kTestMatrixImageFilter2()

static const DlMatrixImageFilter flutter::testing::kTestMatrixImageFilter2	(	SkMatrix::RotateDeg(85)	,
		kNearestSampling
	)

static

◆ kTestMatrixImageFilter3()

static const DlMatrixImageFilter flutter::testing::kTestMatrixImageFilter3	(	SkMatrix::RotateDeg(45)	,
		kLinearSampling
	)

static

◆ kTestSource1()

static const DlImageColorSource flutter::testing::kTestSource1	(	TestImage1	,
		DlTileMode::kClamp	,
		DlTileMode::kMirror	,
		kLinearSampling
	)

static

◆ LoadELFSplitSymbolFromFixturesIfNeccessary()

ELFAOTSymbols flutter::testing::LoadELFSplitSymbolFromFixturesIfNeccessary ( std::string elf_split_filename )

Attempts to resolve split loading unit AOT symbols from the portable ELF loader. If the dart code does not make use of deferred libraries, then there will be no split .so to load. This only returns valid symbols when the VM is configured for AOT.

Parameters

[in] elf_split_filename The split AOT ELF filename from the fixtures generator.

Returns: The loaded ELF symbols.

Definition at line 66 of file elf_loader.cc.

                                  {
  if (!DartVM::IsRunningPrecompiledCode()) {
    return {};
  }
 
  const auto elf_path =
      fml::paths::JoinPaths({GetFixturesPath(), std::move(elf_split_filename)});
 
  if (!fml::IsFile(elf_path)) {
    // We do not log here, as there is no expectation for a split library to
    // exist.
    return {};
  }
 
  ELFAOTSymbols symbols;
 
#if OS_FUCHSIA
  // TODO(gw280): https://github.com/flutter/flutter/issues/50285
  // Dart doesn't implement Dart_LoadELF on Fuchsia
  FML_LOG(ERROR) << "Dart doesn't implement Dart_LoadELF on Fuchsia";
  return {};
#else
  // Must not be freed.
  const char* error = nullptr;
 
  auto loaded_elf =
      Dart_LoadELF(elf_path.c_str(),             // file path
                   0,                            // file offset
                   &error,                       // error (out)
                   &symbols.vm_snapshot_data,    // vm snapshot data (out)
                   &symbols.vm_snapshot_instrs,  // vm snapshot instrs (out)
                   &symbols.vm_isolate_data,     // vm isolate data (out)
                   &symbols.vm_isolate_instrs    // vm isolate instr (out)
      );
 
  if (loaded_elf == nullptr) {
    FML_LOG(ERROR)
        << "Could not fetch AOT symbols from loaded ELF. Attempts "
           "to launch the Dart VM with these AOT symbols  will fail. Error: "
        << error;
    return {};
  }
 
  symbols.loaded_elf.reset(loaded_elf);
 
  return symbols;
#endif
}

◆ LoadELFSymbolFromFixturesIfNeccessary()

ELFAOTSymbols flutter::testing::LoadELFSymbolFromFixturesIfNeccessary ( std::string elf_filename )

Attempts to resolve AOT symbols from the portable ELF loader. This location is automatically resolved from the fixtures generator. This only returns valid symbols when the VM is configured for AOT.

Parameters

[in] elf_filename The AOT ELF filename from the fixtures generator.

Returns: The loaded ELF symbols.

Definition at line 17 of file elf_loader.cc.

                                                                            {
  if (!DartVM::IsRunningPrecompiledCode()) {
    return {};
  }
 
  const auto elf_path =
      fml::paths::JoinPaths({GetFixturesPath(), std::move(elf_filename)});
 
  if (!fml::IsFile(elf_path)) {
    FML_LOG(ERROR) << "App AOT file does not exist for this fixture. Attempts "
                      "to launch the Dart VM with these AOT symbols will fail.";
    return {};
  }
 
  ELFAOTSymbols symbols;
 
#if OS_FUCHSIA
  // TODO(gw280): https://github.com/flutter/flutter/issues/50285
  // Dart doesn't implement Dart_LoadELF on Fuchsia
  FML_LOG(ERROR) << "Dart doesn't implement Dart_LoadELF on Fuchsia";
  return {};
#else
  // Must not be freed.
  const char* error = nullptr;
 
  auto loaded_elf =
      Dart_LoadELF(elf_path.c_str(),             // file path
                   0,                            // file offset
                   &error,                       // error (out)
                   &symbols.vm_snapshot_data,    // vm snapshot data (out)
                   &symbols.vm_snapshot_instrs,  // vm snapshot instrs (out)
                   &symbols.vm_isolate_data,     // vm isolate data (out)
                   &symbols.vm_isolate_instrs    // vm isolate instr (out)
      );
 
  if (loaded_elf == nullptr) {
    FML_LOG(ERROR)
        << "Could not fetch AOT symbols from loaded ELF. Attempts "
           "to launch the Dart VM with these AOT symbols  will fail. Error: "
        << error;
    return {};
  }
 
  symbols.loaded_elf.reset(loaded_elf);
 
  return symbols;
#endif  // OS_FUCHSIA
}

◆ LoadValidImageFixture()

static sk_sp< SkData > flutter::testing::LoadValidImageFixture ( )

static

Definition at line 16 of file image_generator_registry_unittests.cc.

                                             {
  auto fixture_mapping = OpenFixtureAsMapping("DashInNooglerHat.jpg");
 
  // Remap to sk_sp<SkData>.
  SkData::ReleaseProc on_release = [](const void* ptr, void* context) -> void {
    delete reinterpret_cast<fml::FileMapping*>(context);
  };
  auto data = SkData::MakeWithProc(fixture_mapping->GetMapping(),
                                   fixture_mapping->GetSize(), on_release,
                                   fixture_mapping.get());
 
  if (data) {
    fixture_mapping.release();
  }
 
  return data;
}

◆ LogSkData()

static void flutter::testing::LogSkData	(	const sk_sp< SkData > &	data,
		const char *	title
	)

static

Definition at line 2159 of file shell_unittests.cc.

                                                                    {
  FML_LOG(ERROR) << "---------- " << title;
  std::ostringstream ostr;
  for (size_t i = 0; i < data->size();) {
    ostr << std::hex << std::setfill('0') << std::setw(2)
         << static_cast<int>(data->bytes()[i]) << " ";
    i++;
    if (i % 16 == 0 || i == data->size()) {
      FML_LOG(ERROR) << ostr.str();
      ostr.str("");
      ostr.clear();
    }
  }
}

◆ MakeColorSource() [1/2]

static std::shared_ptr< DlImageColorSource > flutter::testing::MakeColorSource ( const sk_sp< DlImage > & image )

static

Definition at line 195 of file dl_rendering_unittests.cc.

                                 {
  return std::make_shared<DlImageColorSource>(image,                //
                                              DlTileMode::kRepeat,  //
                                              DlTileMode::kRepeat,  //
                                              DlImageSampling::kLinear);
}

◆ MakeColorSource() [2/2]

static sk_sp< SkShader > flutter::testing::MakeColorSource ( const sk_sp< SkImage > & image )

static

Definition at line 203 of file dl_rendering_unittests.cc.

                                                                    {
  return image->makeShader(SkTileMode::kRepeat,  //
                           SkTileMode::kRepeat,  //
                           SkImageSampling::kLinear);
}

◆ MakeFilter()

static std::shared_ptr< DlColorSource > flutter::testing::MakeFilter ( DlColor color )

static

Definition at line 24 of file shader_mask_layer_unittests.cc.

                                                              {
  DlColor colors[] = {
      color.withAlpha(0x7f),
      color,
  };
  float stops[] = {
      0,
      1,
  };
  return DlColorSource::MakeLinear(SkPoint::Make(0, 0), SkPoint::Make(10, 10),
                                   2, colors, stops, DlTileMode::kRepeat);
}

◆ MakeRectFromVertices()

static SkRect flutter::testing::MakeRectFromVertices ( SkPoint vertices[6] )

static

Definition at line 11 of file stopwatch_dl_unittests.cc.

                                                        {
  // "Combine" the vertices to form a rectangle.
  auto const left = std::min(vertices[0].x(), vertices[5].x());
  auto const top = std::min(vertices[0].y(), vertices[1].y());
  auto const right = std::max(vertices[1].x(), vertices[2].x());
  auto const bottom = std::max(vertices[2].y(), vertices[3].y());
 
  return SkRect::MakeLTRB(left, top, right, bottom);
}

◆ MakeSizedDisplayList()

static sk_sp< DisplayList > flutter::testing::MakeSizedDisplayList	(	int	width,
		int	height
	)

static

Definition at line 391 of file shell_unittests.cc.

                                                                      {
  DisplayListBuilder builder(SkRect::MakeXYWH(0, 0, width, height));
  builder.DrawRect(SkRect::MakeXYWH(0, 0, width, height),
                   DlPaint(DlColor::kRed()));
  return builder.Build();
}

◆ makeTestDisplayList()

sk_sp< DisplayList > flutter::testing::makeTestDisplayList ( )

Definition at line 3642 of file dl_rendering_unittests.cc.

                                         {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kFill);
  paint.setColor(DlColor(SK_ColorRED));
  builder.DrawRect({kRenderLeft, kRenderTop, kRenderCenterX, kRenderCenterY},
                   paint);
  paint.setColor(DlColor(SK_ColorBLUE));
  builder.DrawRect({kRenderCenterX, kRenderTop, kRenderRight, kRenderCenterY},
                   paint);
  paint.setColor(DlColor(SK_ColorGREEN));
  builder.DrawRect({kRenderLeft, kRenderCenterY, kRenderCenterX, kRenderBottom},
                   paint);
  paint.setColor(DlColor(SK_ColorYELLOW));
  builder.DrawRect(
      {kRenderCenterX, kRenderCenterY, kRenderRight, kRenderBottom}, paint);
  return builder.Build();
}

◆ MakeTestDisplayList()

static sk_sp< DisplayList > flutter::testing::MakeTestDisplayList	(	int	w,
		int	h,
		SkColor	color
	)

static

Definition at line 208 of file dl_test_snippets.h.

                                                                           {
  DisplayListBuilder builder;
  builder.DrawRect(SkRect::MakeWH(w, h), DlPaint(DlColor(color)));
  return builder.Build();
}

◆ MakeTestImage() [1/2]

static sk_sp< DlImage > flutter::testing::MakeTestImage	(	int	w,
		int	h,
		int	checker_size
	)

static

Definition at line 67 of file dl_test_snippets.h.

                                                                    {
  sk_sp<SkSurface> surface =
      SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h));
  SkCanvas* canvas = surface->getCanvas();
  SkPaint p0, p1;
  p0.setStyle(SkPaint::kFill_Style);
  p0.setColor(SK_ColorGREEN);
  p1.setStyle(SkPaint::kFill_Style);
  p1.setColor(SK_ColorBLUE);
  p1.setAlpha(128);
  for (int y = 0; y < w; y += checker_size) {
    for (int x = 0; x < h; x += checker_size) {
      SkPaint& cellp = ((x + y) & 1) == 0 ? p0 : p1;
      canvas->drawRect(SkRect::MakeXYWH(x, y, checker_size, checker_size),
                       cellp);
    }
  }
  return DlImage::Make(surface->makeImageSnapshot());
}

◆ MakeTestImage() [2/2]

static sk_sp< DlImage > flutter::testing::MakeTestImage	(	int	w,
		int	h,
		SkColor	color
	)

static

Definition at line 21 of file dl_color_source_unittests.cc.

                                                                 {
  sk_sp<SkSurface> surface;
  if (SkColorGetA(color) < 255) {
    surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h));
  } else {
    SkImageInfo info =
        SkImageInfo::MakeN32(w, h, SkAlphaType::kOpaque_SkAlphaType);
    surface = SkSurfaces::Raster(info);
  }
  SkCanvas* canvas = surface->getCanvas();
  canvas->drawColor(color);
  return DlImage::Make(surface->makeImageSnapshot());
}

◆ MemsetPatternSetOrCheck() [1/2]

bool flutter::testing::MemsetPatternSetOrCheck	(	std::vector< uint8_t > &	buffer,
		MemsetPatternOp	op
	)

Definition at line 120 of file testing.cc.

                                                                             {
  return MemsetPatternSetOrCheck(buffer.data(), buffer.size(), op);
}

◆ MemsetPatternSetOrCheck() [2/2]

bool flutter::testing::MemsetPatternSetOrCheck	(	uint8_t *	buffer,
		size_t	size,
		MemsetPatternOp	op
	)

Depending on the operation, either scribbles a known pattern into the buffer or checks if that pattern is present in an existing buffer. This is a portable variant of the memset_pattern class of methods that also happen to do assert that the same pattern exists.

Parameters

	buffer	The buffer
[in]	size	The size
[in]	op	The operation

Returns: If the result of the operation was a success.

Definition at line 79 of file testing.cc.

                                                                               {
  if (buffer == nullptr) {
    return false;
  }
 
  auto pattern = reinterpret_cast<const uint8_t*>("dErP");
  constexpr auto pattern_length = 4;
 
  uint8_t* start = buffer;
  uint8_t* p = buffer;
 
  while ((start + size) - p >= pattern_length) {
    switch (op) {
      case MemsetPatternOp::kMemsetPatternOpSetBuffer:
        memmove(p, pattern, pattern_length);
        break;
      case MemsetPatternOp::kMemsetPatternOpCheckBuffer:
        if (memcmp(pattern, p, pattern_length) != 0) {
          return false;
        }
        break;
    };
    p += pattern_length;
  }
 
  if ((start + size) - p != 0) {
    switch (op) {
      case MemsetPatternOp::kMemsetPatternOpSetBuffer:
        memmove(p, pattern, (start + size) - p);
        break;
      case MemsetPatternOp::kMemsetPatternOpCheckBuffer:
        if (memcmp(pattern, p, (start + size) - p) != 0) {
          return false;
        }
        break;
    }
  }
 
  return true;
}

◆ MockEmbedderApiForKeyboard()

void flutter::testing::MockEmbedderApiForKeyboard	(	EngineModifier &	modifier,
		std::shared_ptr< MockKeyResponseController >	response_controller
	)

Definition at line 101 of file test_keyboard.cc.

                                                                  {
  stored_response_controller = response_controller;
  // This mock handles channel messages.
  modifier.embedder_api()
      .SendPlatformMessage = [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
                                const FlutterPlatformMessage* message) {
    if (std::string(message->channel) == std::string("flutter/settings")) {
      return kSuccess;
    }
    if (std::string(message->channel) == std::string("flutter/keyevent")) {
      stored_response_controller->HandleChannelMessage([message](bool handled) {
        auto response = _keyHandlingResponse(handled);
        auto response_handle = message->response_handle;
        if (response_handle->callback != nullptr) {
          response_handle->callback(response->data(), response->size(),
                                    response_handle->user_data);
        }
      });
      return kSuccess;
    }
    if (std::string(message->channel) == std::string("flutter/textinput")) {
      std::unique_ptr<rapidjson::Document> document =
          flutter::JsonMessageCodec::GetInstance().DecodeMessage(
              message->message, message->message_size);
      if (document == nullptr) {
        return kInvalidArguments;
      }
      stored_response_controller->HandleTextInputMessage(std::move(document));
      return kSuccess;
    }
    return kSuccess;
  };
 
  // This mock handles key events sent through the embedder API.
  modifier.embedder_api().SendKeyEvent =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, const FlutterKeyEvent* event,
         FlutterKeyEventCallback callback, void* user_data) {
        stored_response_controller->HandleEmbedderMessage(
            event, [callback, user_data](bool handled) {
              if (callback != nullptr) {
                callback(handled, user_data);
              }
            });
        return kSuccess;
      };
 
  // The following mocks enable channel mocking.
  modifier.embedder_api().PlatformMessageCreateResponseHandle =
      [](auto engine, auto data_callback, auto user_data, auto response_out) {
        auto response_handle = new FlutterPlatformMessageResponseHandle();
        response_handle->user_data = user_data;
        response_handle->callback = data_callback;
        *response_out = response_handle;
        return kSuccess;
      };
 
  modifier.embedder_api().PlatformMessageReleaseResponseHandle =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         FlutterPlatformMessageResponseHandle* response) {
        delete response;
        return kSuccess;
      };
 
  // The following mock disables responses for method channels sent from the
  // embedding to the framework. (No code uses the response yet.)
  modifier.embedder_api().SendPlatformMessageResponse =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         const FlutterPlatformMessageResponseHandle* handle,
         const uint8_t* data, size_t data_length) { return kSuccess; };
 
  // The following mocks allows RunWithEntrypoint to be run, which creates a
  // non-empty FlutterEngine and enables SendKeyEvent.
 
  modifier.embedder_api().Run =
      [](size_t version, const FlutterRendererConfig* config,
         const FlutterProjectArgs* args, void* user_data,
         FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
 
        return kSuccess;
      };
  // Any time the associated EmbedderEngine will be mocked, such as here,
  // the Update accessibility features must not attempt to actually push the
  // update
  modifier.embedder_api().UpdateAccessibilityFeatures =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         FlutterAccessibilityFeature flags) { return kSuccess; };
  modifier.embedder_api().UpdateLocales =
      [](auto engine, const FlutterLocale** locales, size_t locales_count) {
        return kSuccess;
      };
  modifier.embedder_api().SendWindowMetricsEvent =
      [](auto engine, const FlutterWindowMetricsEvent* event) {
        return kSuccess;
      };
  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
  modifier.embedder_api().NotifyDisplayUpdate =
      [](auto engine, const FlutterEngineDisplaysUpdateType update_type,
         const FlutterEngineDisplay* embedder_displays,
         size_t display_count) { return kSuccess; };
}

◆ MultiplyPath()

void flutter::testing::MultiplyPath	(	SkPath &	path,
		SkPath::Verb	type,
		SkPoint	center,
		size_t	sides,
		size_t	number,
		float	radius
	)

Definition at line 590 of file dl_benchmarks.cc.

                                {
  std::vector<SkPoint> center_points =
      GetPolygonPoints(number, center, radius / 2.0f);
 
  for (SkPoint p : center_points) {
    switch (type) {
      case SkPath::Verb::kLine_Verb:
        GetLinesPath(path, sides, p, radius);
        break;
      case SkPath::Verb::kQuad_Verb:
        GetQuadsPath(path, sides, p, radius);
        break;
      case SkPath::Verb::kConic_Verb:
        GetConicsPath(path, sides, p, radius);
        break;
      case SkPath::Verb::kCubic_Verb:
        GetCubicsPath(path, sides, p, radius);
        break;
      default:
        break;
    }
  }
}

◆ Nop()

void flutter::testing::Nop ( )

Definition at line 140 of file ffi_native_unittest.cc.

140{}

◆ NormalizeImage()

static sk_sp< SkData > flutter::testing::NormalizeImage ( const sk_sp< SkImage > & image )

static

Definition at line 41 of file embedder_unittests_util.cc.

                                                                 {
  // To avoid clipping, convert to a very wide gamut, and a high bit depth.
  sk_sp<SkColorSpace> norm_colorspace = SkColorSpace::MakeRGB(
      SkNamedTransferFn::kRec2020, SkNamedGamut::kRec2020);
  SkImageInfo norm_image_info =
      SkImageInfo::Make(image->width(), image->height(),
                        SkColorType::kR16G16B16A16_unorm_SkColorType,
                        SkAlphaType::kUnpremul_SkAlphaType, norm_colorspace);
  size_t row_bytes = norm_image_info.minRowBytes();
  size_t size = norm_image_info.computeByteSize(row_bytes);
  sk_sp<SkData> data = SkData::MakeUninitialized(size);
  if (!data) {
    FML_CHECK(false) << "Unable to allocate data.";
  }
 
  bool success = image->readPixels(norm_image_info, data->writable_data(),
                                   row_bytes, 0, 0);
  if (!success) {
    FML_CHECK(false) << "Unable to read pixels.";
  }
 
  return data;
}

◆ NumberNear()

bool flutter::testing::NumberNear	(	double	a,
		double	b
	)

inline

Definition at line 13 of file assertions.h.

                                           {
  static const double epsilon = 1e-3;
  return (a > (b - epsilon)) && (a < (b + epsilon));
}

◆ OpenFixture()

fml::UniqueFD flutter::testing::OpenFixture ( const std::string & fixture_name )

Opens a fixture of the given file name.

Parameters

[in] fixture_name The fixture name

Returns: The file descriptor of the given fixture. An invalid file descriptor is returned in case the fixture is not found.

Definition at line 37 of file testing.cc.

                                                       {
  if (fixture_name.size() == 0) {
    FML_LOG(ERROR) << "Invalid fixture name.";
    return {};
  }
 
  auto fixtures_directory = OpenFixturesDirectory();
 
  auto fixture_fd = fml::OpenFile(fixtures_directory,         // base directory
                                  fixture_name.c_str(),       // path
                                  false,                      // create
                                  fml::FilePermission::kRead  // permission
  );
  if (!fixture_fd.is_valid()) {
    FML_LOG(ERROR) << "Could not open fixture for path: " << GetFixturesPath()
                   << "/" << fixture_name << ".";
    return {};
  }
 
  return fixture_fd;
}

◆ OpenFixtureAsMapping()

std::unique_ptr< fml::Mapping > flutter::testing::OpenFixtureAsMapping ( const std::string & fixture_name )

Opens a fixture of the given file name and returns a mapping to its contents.

Parameters

[in] fixture_name The fixture name

Returns: A mapping to the contents of fixture or null if the fixture does not exist or its contents cannot be mapped in.

Definition at line 59 of file testing.cc.

                                   {
  return fml::FileMapping::CreateReadOnly(OpenFixture(fixture_name));
}

◆ OpenFixtureAsSkData()

sk_sp< SkData > flutter::testing::OpenFixtureAsSkData ( const std::string & fixture_name )

Opens a fixture of the given file name and returns a Skia SkData holding its contents.

Parameters

[in] fixture_name The fixture name

Returns: An SkData, or null if the fixture does not exist or its contents cannot be mapped in.

Definition at line 64 of file testing.cc.

                                                                 {
  auto mapping = flutter::testing::OpenFixtureAsMapping(fixture_name);
  if (!mapping) {
    return nullptr;
  }
  auto data = SkData::MakeWithProc(
      mapping->GetMapping(), mapping->GetSize(),
      [](const void* ptr, void* context) {
        delete reinterpret_cast<fml::Mapping*>(context);
      },
      mapping.get());
  mapping.release();
  return data;
}

◆ OpenFixturesDirectory()

fml::UniqueFD flutter::testing::OpenFixturesDirectory ( )

Opens the fixtures directory for the unit-test harness.

Returns: The file descriptor of the fixtures directory.

Definition at line 23 of file testing.cc.

                                    {
  auto fixtures_directory =
      OpenDirectory(GetFixturesPath(),          // path
                    false,                      // create
                    fml::FilePermission::kRead  // permission
      );
 
  if (!fixtures_directory.is_valid()) {
    FML_LOG(ERROR) << "Could not open fixtures directory.";
    return {};
  }
  return fixtures_directory;
}

◆ operator<<() [1/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::ClipEdgeStyle &	style
	)

static

Definition at line 510 of file mock_canvas.cc.

                                                                      {
  return os << (style == MockCanvas::kSoftClipEdgeStyle ? "kSoftEdges"
                                                        : "kHardEdges");
}

◆ operator<<() [2/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::ClipPathData &	data
	)

Definition at line 536 of file mock_canvas.cc.

                                                             {
  return os << data.path << " " << data.clip_op << " " << data.style;
}

◆ operator<<() [3/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::ClipRectData &	data
	)

Definition at line 516 of file mock_canvas.cc.

                                                             {
  return os << data.rect << " " << data.clip_op << " " << data.style;
}

◆ operator<<() [4/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::ClipRRectData &	data
	)

Definition at line 526 of file mock_canvas.cc.

                                                              {
  return os << data.rrect << " " << data.clip_op << " " << data.style;
}

◆ operator<<() [5/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::ConcatMatrixData &	data
	)

Definition at line 411 of file mock_canvas.cc.

                                                                 {
  return os << data.matrix;
}

◆ operator<<() [6/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawCall &	draw
	)

Definition at line 551 of file mock_canvas.cc.

                                                                       {
  return os << "[Layer: " << draw.layer << ", Data: " << draw.data << "]";
}

◆ operator<<() [7/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawCallData &	data
	)

Definition at line 541 of file mock_canvas.cc.

                                                             {
  std::visit([&os](auto& d) { os << d; }, data);
  return os;
}

◆ operator<<() [8/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawDisplayListData &	data
	)

Definition at line 486 of file mock_canvas.cc.

                                                                    {
  auto dl = data.display_list;
  return os << "[" << dl->unique_id() << " " << dl->op_count() << " "
            << dl->bytes() << "] " << data.opacity;
}

◆ operator<<() [9/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawImageData &	data
	)

Definition at line 463 of file mock_canvas.cc.

                                                              {
  return os << data.image << " " << data.x << " " << data.y << " "
            << data.options << " " << data.paint;
}

◆ operator<<() [10/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawImageDataNoPaint &	data
	)

Definition at line 475 of file mock_canvas.cc.

                                                                     {
  return os << data.image << " " << data.x << " " << data.y << " "
            << data.options;
}

◆ operator<<() [11/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawPaintData &	data
	)

Definition at line 560 of file mock_canvas.cc.

                                                              {
  return os << data.paint;
}

◆ operator<<() [12/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawPathData &	data
	)

Definition at line 441 of file mock_canvas.cc.

                                                             {
  return os << data.path << " " << data.paint;
}

◆ operator<<() [13/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawRectData &	data
	)

Definition at line 431 of file mock_canvas.cc.

                                                             {
  return os << data.rect << " " << data.paint;
}

◆ operator<<() [14/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawShadowData &	data
	)

Definition at line 499 of file mock_canvas.cc.

                                                               {
  return os << data.path << " " << data.color << " " << data.elevation << " "
            << data.transparent_occluder << " " << data.dpr;
}

◆ operator<<() [15/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::DrawTextData &	data
	)

Definition at line 452 of file mock_canvas.cc.

                                                             {
  return os << data.serialized_text << " " << data.paint << " " << data.offset;
}

◆ operator<<() [16/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::RestoreData &	data
	)

Definition at line 401 of file mock_canvas.cc.

                                                            {
  return os << data.restore_to_layer;
}

◆ operator<<() [17/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::SaveData &	data
	)

Definition at line 379 of file mock_canvas.cc.

                                                                       {
  return os << data.save_to_layer;
}

◆ operator<<() [18/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::SaveLayerData &	data
	)

Definition at line 390 of file mock_canvas.cc.

                                                              {
  return os << data.save_bounds << " " << data.restore_paint << " "
            << data.backdrop_filter << " " << data.save_to_layer;
}

◆ operator<<() [19/24]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockCanvas::SetMatrixData &	data
	)

Definition at line 421 of file mock_canvas.cc.

                                                              {
  return os << data.matrix;
}

◆ operator<<() [20/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkM44 &	m
	)

static

Definition at line 363 of file mock_canvas.cc.

                                                              {
  os << m.rc(0, 0) << ", " << m.rc(0, 1) << ", " << m.rc(0, 2) << ", "
     << m.rc(0, 3) << std::endl;
  os << m.rc(1, 0) << ", " << m.rc(1, 1) << ", " << m.rc(1, 2) << ", "
     << m.rc(1, 3) << std::endl;
  os << m.rc(2, 0) << ", " << m.rc(2, 1) << ", " << m.rc(2, 2) << ", "
     << m.rc(2, 3) << std::endl;
  os << m.rc(3, 0) << ", " << m.rc(3, 1) << ", " << m.rc(3, 2) << ", "
     << m.rc(3, 3);
  return os;
}

◆ operator<<() [21/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkPath &	r
	)

static

Definition at line 356 of file mock_canvas.cc.

                                                               {
  return os << "Valid: " << r.isValid()
            << ", FillType: " << static_cast<int>(r.getFillType())
            << ", Bounds: " << r.getBounds();
}

◆ operator<<() [22/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkPoint &	r
	)

static

Definition at line 342 of file mock_canvas.cc.

                                                                {
  return os << "XY: " << r.fX << ", " << r.fY;
}

◆ operator<<() [23/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkRect &	r
	)

static

Definition at line 346 of file mock_canvas.cc.

                                                               {
  return os << "LTRB: " << r.fLeft << ", " << r.fTop << ", " << r.fRight << ", "
            << r.fBottom;
}

◆ operator<<() [24/24]

static std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkRRect &	r
	)

static

Definition at line 351 of file mock_canvas.cc.

                                                                {
  return os << "LTRB: " << r.rect().fLeft << ", " << r.rect().fTop << ", "
            << r.rect().fRight << ", " << r.rect().fBottom;
}

◆ operator==() [1/18]

bool flutter::testing::operator==	(	const CGRect &	lhs,
		const CGRect &	rhs
	)

inline

Definition at line 198 of file FlutterSurfaceManagerTest.mm.

                                                             {
  return CGRectEqualToRect(lhs, rhs);
}

◆ operator==() [2/18]

bool flutter::testing::operator==	(	const MockCanvas::ClipPathData &	a,
		const MockCanvas::ClipPathData &	b
	)

Definition at line 531 of file mock_canvas.cc.

                                                 {
  return a.path == b.path && a.clip_op == b.clip_op && a.style == b.style;
}

◆ operator==() [3/18]

bool flutter::testing::operator==	(	const MockCanvas::ClipRectData &	a,
		const MockCanvas::ClipRectData &	b
	)

Definition at line 505 of file mock_canvas.cc.

                                                 {
  return a.rect == b.rect && a.clip_op == b.clip_op && a.style == b.style;
}

◆ operator==() [4/18]

bool flutter::testing::operator==	(	const MockCanvas::ClipRRectData &	a,
		const MockCanvas::ClipRRectData &	b
	)

Definition at line 521 of file mock_canvas.cc.

                                                  {
  return a.rrect == b.rrect && a.clip_op == b.clip_op && a.style == b.style;
}

◆ operator==() [5/18]

bool flutter::testing::operator==	(	const MockCanvas::ConcatMatrixData &	a,
		const MockCanvas::ConcatMatrixData &	b
	)

Definition at line 406 of file mock_canvas.cc.

                                                     {
  return a.matrix == b.matrix;
}

◆ operator==() [6/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawCall &	a,
		const MockCanvas::DrawCall &	b
	)

Definition at line 547 of file mock_canvas.cc.

                                                                          {
  return a.layer == b.layer && a.data == b.data;
}

◆ operator==() [7/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawDisplayListData &	a,
		const MockCanvas::DrawDisplayListData &	b
	)

Definition at line 481 of file mock_canvas.cc.

                                                        {
  return a.display_list->Equals(b.display_list) && a.opacity == b.opacity;
}

◆ operator==() [8/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawImageData &	a,
		const MockCanvas::DrawImageData &	b
	)

Definition at line 457 of file mock_canvas.cc.

                                                  {
  return a.image == b.image && a.x == b.x && a.y == b.y &&
         a.options == b.options && a.paint == b.paint;
}

◆ operator==() [9/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawImageDataNoPaint &	a,
		const MockCanvas::DrawImageDataNoPaint &	b
	)

Definition at line 469 of file mock_canvas.cc.

                                                         {
  return a.image == b.image && a.x == b.x && a.y == b.y &&
         a.options == b.options;
}

◆ operator==() [10/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawPaintData &	a,
		const MockCanvas::DrawPaintData &	b
	)

Definition at line 555 of file mock_canvas.cc.

                                                  {
  return a.paint == b.paint;
}

◆ operator==() [11/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawPathData &	a,
		const MockCanvas::DrawPathData &	b
	)

Definition at line 436 of file mock_canvas.cc.

                                                 {
  return a.path == b.path && a.paint == b.paint;
}

◆ operator==() [12/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawRectData &	a,
		const MockCanvas::DrawRectData &	b
	)

Definition at line 426 of file mock_canvas.cc.

                                                 {
  return a.rect == b.rect && a.paint == b.paint;
}

◆ operator==() [13/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawShadowData &	a,
		const MockCanvas::DrawShadowData &	b
	)

Definition at line 493 of file mock_canvas.cc.

                                                   {
  return a.path == b.path && a.color == b.color && a.elevation == b.elevation &&
         a.transparent_occluder == b.transparent_occluder && a.dpr == b.dpr;
}

◆ operator==() [14/18]

bool flutter::testing::operator==	(	const MockCanvas::DrawTextData &	a,
		const MockCanvas::DrawTextData &	b
	)

Definition at line 446 of file mock_canvas.cc.

                                                 {
  return a.serialized_text->equals(b.serialized_text.get()) &&
         a.paint == b.paint && a.offset == b.offset;
}

◆ operator==() [15/18]

bool flutter::testing::operator==	(	const MockCanvas::RestoreData &	a,
		const MockCanvas::RestoreData &	b
	)

Definition at line 396 of file mock_canvas.cc.

                                                {
  return a.restore_to_layer == b.restore_to_layer;
}

◆ operator==() [16/18]

bool flutter::testing::operator==	(	const MockCanvas::SaveData &	a,
		const MockCanvas::SaveData &	b
	)

Definition at line 375 of file mock_canvas.cc.

                                                                          {
  return a.save_to_layer == b.save_to_layer;
}

◆ operator==() [17/18]

bool flutter::testing::operator==	(	const MockCanvas::SaveLayerData &	a,
		const MockCanvas::SaveLayerData &	b
	)

Definition at line 383 of file mock_canvas.cc.

                                                  {
  return a.save_bounds == b.save_bounds && a.restore_paint == b.restore_paint &&
         Equals(a.backdrop_filter, b.backdrop_filter) &&
         a.save_to_layer == b.save_to_layer;
}

◆ operator==() [18/18]

bool flutter::testing::operator==	(	const MockCanvas::SetMatrixData &	a,
		const MockCanvas::SetMatrixData &	b
	)

Definition at line 416 of file mock_canvas.cc.

                                                  {
  return a.matrix == b.matrix;
}

◆ ParseViewIdsCallback()

static void flutter::testing::ParseViewIdsCallback	(	const Dart_NativeArguments &	args,
		bool *	hasImplicitView,
		std::vector< int64_t > *	viewIds
	)

static

Definition at line 4436 of file shell_unittests.cc.

                                                              {
  Dart_Handle exception = nullptr;
  viewIds->clear();
  *hasImplicitView =
      tonic::DartConverter<bool>::FromArguments(args, 0, exception);
  ASSERT_EQ(exception, nullptr);
  *viewIds = tonic::DartConverter<std::vector<int64_t>>::FromArguments(
      args, 1, exception);
  ASSERT_EQ(exception, nullptr);
}

◆ ParseViewWidthsCallback()

static void flutter::testing::ParseViewWidthsCallback	(	const Dart_NativeArguments &	args,
		std::map< int64_t, int64_t > *	viewWidths
	)

static

Definition at line 4668 of file shell_unittests.cc.

                                                                          {
  Dart_Handle exception = nullptr;
  viewWidths->clear();
  std::vector<int64_t> viewWidthPacket =
      tonic::DartConverter<std::vector<int64_t>>::FromArguments(args, 0,
                                                                exception);
  ASSERT_EQ(exception, nullptr);
  ASSERT_EQ(viewWidthPacket.size() % 2, 0ul);
  for (size_t packetIndex = 0; packetIndex < viewWidthPacket.size();
       packetIndex += 2) {
    (*viewWidths)[viewWidthPacket[packetIndex]] =
        viewWidthPacket[packetIndex + 1];
  }
}

◆ PointModeToString()

std::string flutter::testing::PointModeToString ( DlCanvas::PointMode mode )

Definition at line 857 of file dl_benchmarks.cc.

                                                    {
  switch (mode) {
    case DlCanvas::PointMode::kLines:
      return "Lines";
    case DlCanvas::PointMode::kPolygon:
      return "Polygon";
    case DlCanvas::PointMode::kPoints:
    default:
      return "Points";
  }
}

◆ PostSync()

static void flutter::testing::PostSync	(	const fml::RefPtr< fml::TaskRunner > &	task_runner,
		const fml::closure &	task
	)

static

Definition at line 381 of file shell_unittests.cc.

                                             {
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(task_runner, [&latch, &task] {
    task();
    latch.Signal();
  });
  latch.Wait();
}

◆ PostTaskSync()

void flutter::testing::PostTaskSync	(	const fml::RefPtr< fml::TaskRunner > &	task_runner,
		const std::function< void()> &	function
	)

Definition at line 12 of file post_task_sync.cc.

                                                       {
  fml::AutoResetWaitableEvent latch;
  task_runner->PostTask([&] {
    function();
    latch.Signal();
  });
  latch.Wait();
}

◆ PrepareSettingsForAOTWithSymbols()

bool flutter::testing::PrepareSettingsForAOTWithSymbols	(	Settings &	settings,
		const ELFAOTSymbols &	symbols
	)

Prepare the settings objects various AOT mappings resolvers with the symbols already loaded. This method does nothing in non-AOT runtime modes.

Warning: The symbols must not be collected till all shell instantiations made using the settings object are collected.

Parameters

	[in/out]	settings The settings whose AOT resolvers to populate.
[in]	symbols	The symbols used to populate the settings object.

Returns: If the settings object was correctly updated.

Definition at line 116 of file elf_loader.cc.

                                                                    {
  if (!DartVM::IsRunningPrecompiledCode()) {
    return false;
  }
  settings.vm_snapshot_data = [&]() {
    return std::make_unique<fml::NonOwnedMapping>(symbols.vm_snapshot_data, 0u);
  };
  settings.isolate_snapshot_data = [&]() {
    return std::make_unique<fml::NonOwnedMapping>(symbols.vm_isolate_data, 0u);
  };
  settings.vm_snapshot_instr = [&]() {
    return std::make_unique<fml::NonOwnedMapping>(symbols.vm_snapshot_instrs,
                                                  0u);
  };
  settings.isolate_snapshot_instr = [&]() {
    return std::make_unique<fml::NonOwnedMapping>(symbols.vm_isolate_instrs,
                                                  0u);
  };
  return true;
}

◆ RasterCacheItemPreroll()

void flutter::testing::RasterCacheItemPreroll	(	DisplayListRasterCacheItem &	display_list_item,
		PrerollContext &	context,
		const SkMatrix &	matrix
	)

Definition at line 147 of file mock_raster_cache.cc.

                                                    {
  display_list_item.PrerollSetup(&context, matrix);
  display_list_item.PrerollFinalize(&context, matrix);
}

◆ RasterCacheItemPrerollAndTryToRasterCache()

bool flutter::testing::RasterCacheItemPrerollAndTryToRasterCache	(	DisplayListRasterCacheItem &	display_list_item,
		PrerollContext &	context,
		PaintContext &	paint_context,
		const SkMatrix &	matrix
	)

Definition at line 137 of file mock_raster_cache.cc.

                            {
  RasterCacheItemPreroll(display_list_item, context, matrix);
  context.raster_cache->EvictUnusedCacheEntries();
  return RasterCacheItemTryToRasterCache(display_list_item, paint_context);
}

◆ RasterCacheItemTryToRasterCache()

bool flutter::testing::RasterCacheItemTryToRasterCache	(	DisplayListRasterCacheItem &	display_list_item,
		PaintContext &	paint_context
	)

Definition at line 154 of file mock_raster_cache.cc.

                                 {
  if (display_list_item.cache_state() ==
      RasterCacheItem::CacheState::kCurrent) {
    return display_list_item.TryToPrepareRasterCache(paint_context);
  }
  return false;
}

◆ RasterImagesAreSame()

bool flutter::testing::RasterImagesAreSame	(	const sk_sp< SkImage > &	a,
		const sk_sp< SkImage > &	b
	)

Definition at line 65 of file embedder_unittests_util.cc.

                                                                           {
  if (!a || !b) {
    return false;
  }
 
  FML_CHECK(!a->isTextureBacked());
  FML_CHECK(!b->isTextureBacked());
 
  sk_sp<SkData> normalized_a = NormalizeImage(a);
  sk_sp<SkData> normalized_b = NormalizeImage(b);
 
  return normalized_a->equals(normalized_b.get());
}

◆ RasterizerIsTornDown()

static bool flutter::testing::RasterizerIsTornDown ( Shell * shell )

static

Definition at line 335 of file shell_unittests.cc.

                                               {
  fml::AutoResetWaitableEvent latch;
  bool is_torn_down = false;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(),
      [shell, &latch, &is_torn_down]() {
        is_torn_down = shell->GetRasterizer()->IsTornDown();
        latch.Signal();
      });
  latch.Wait();
  return is_torn_down;
}

◆ ReadbackResult() [1/3]

static bool flutter::testing::ReadbackResult	(	PrerollContext *	context,
		Clip	clip_behavior,
		const std::shared_ptr< Layer > &	child,
		bool	before
	)

static

Definition at line 245 of file clip_path_layer_unittests.cc.

                                        {
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkPath layer_path = SkPath().addRect(layer_bounds);
  auto layer = std::make_shared<ClipPathLayer>(layer_path, clip_behavior);
  if (child != nullptr) {
    layer->Add(child);
  }
  context->surface_needs_readback = before;
  layer->Preroll(context);
  return context->surface_needs_readback;
}

◆ ReadbackResult() [2/3]

static bool flutter::testing::ReadbackResult	(	PrerollContext *	context,
		Clip	clip_behavior,
		const std::shared_ptr< Layer > &	child,
		bool	before
	)

static

Definition at line 235 of file clip_rect_layer_unittests.cc.

                                        {
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  auto layer = std::make_shared<ClipRectLayer>(layer_bounds, clip_behavior);
  if (child != nullptr) {
    layer->Add(child);
  }
  context->surface_needs_readback = before;
  layer->Preroll(context);
  return context->surface_needs_readback;
}

◆ ReadbackResult() [3/3]

static bool flutter::testing::ReadbackResult	(	PrerollContext *	context,
		Clip	clip_behavior,
		const std::shared_ptr< Layer > &	child,
		bool	before
	)

static

Definition at line 242 of file clip_rrect_layer_unittests.cc.

                                        {
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkRRect layer_rrect = SkRRect::MakeRect(layer_bounds);
  auto layer = std::make_shared<ClipRRectLayer>(layer_rrect, clip_behavior);
  if (child != nullptr) {
    layer->Add(child);
  }
  context->surface_needs_readback = before;
  layer->Preroll(context);
  return context->surface_needs_readback;
}

◆ ResetAssetManager()

static void flutter::testing::ResetAssetManager ( )

static

Definition at line 33 of file persistent_cache_unittests.cc.

                                {
  PersistentCache::SetAssetManager(nullptr);
  ASSERT_EQ(PersistentCache::GetCacheForProcess()->LoadSkSLs().size(), 0u);
}

◆ RunDartCodeInIsolate() [1/2]

std::unique_ptr< AutoIsolateShutdown > flutter::testing::RunDartCodeInIsolate	(	DartVMRef &	vm_ref,
		const Settings &	settings,
		const TaskRunners &	task_runners,
		std::string	entrypoint,
		const std::vector< std::string > &	args,
		const std::string &	kernel_file_path,
		fml::WeakPtr< IOManager >	io_manager,
		std::shared_ptr< VolatilePathTracker >	volatile_path_tracker,
		std::unique_ptr< PlatformConfiguration >	platform_configuration
	)

Definition at line 155 of file dart_isolate_runner.cc.

                                                                 {
  std::unique_ptr<AutoIsolateShutdown> result;
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(
      task_runners.GetUITaskRunner(), fml::MakeCopyable([&]() mutable {
        result = RunDartCodeInIsolateOnUITaskRunner(
            vm_ref, settings, task_runners, entrypoint, args, kernel_file_path,
            io_manager, volatile_path_tracker,
            std::move(platform_configuration));
        latch.Signal();
      }));
  latch.Wait();
  return result;
}

◆ RunDartCodeInIsolate() [2/2]

void flutter::testing::RunDartCodeInIsolate	(	DartVMRef &	vm_ref,
		std::unique_ptr< AutoIsolateShutdown > &	result,
		const Settings &	settings,
		const TaskRunners &	task_runners,
		std::string	entrypoint,
		const std::vector< std::string > &	args,
		const std::string &	fixtures_path,
		fml::WeakPtr< IOManager >	io_manager = `{}`,
		std::shared_ptr< VolatilePathTracker >	volatile_path_tracker = `nullptr`,
		std::unique_ptr< PlatformConfiguration >	platform_configuration = `nullptr`
	)

◆ RunDartCodeInIsolateOnUITaskRunner()

std::unique_ptr< AutoIsolateShutdown > flutter::testing::RunDartCodeInIsolateOnUITaskRunner	(	DartVMRef &	vm_ref,
		const Settings &	p_settings,
		const TaskRunners &	task_runners,
		std::string	entrypoint,
		const std::vector< std::string > &	args,
		const std::string &	kernel_file_path,
		fml::WeakPtr< IOManager >	io_manager,
		const std::shared_ptr< VolatilePathTracker > &	volatile_path_tracker,
		std::unique_ptr< PlatformConfiguration >	platform_configuration
	)

Definition at line 67 of file dart_isolate_runner.cc.

                                                                 {
  FML_CHECK(task_runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  if (!vm_ref) {
    return nullptr;
  }
 
  auto vm_data = vm_ref.GetVMData();
 
  if (!vm_data) {
    return nullptr;
  }
 
  auto settings = p_settings;
 
  if (!DartVM::IsRunningPrecompiledCode()) {
    if (!fml::IsFile(kernel_file_path)) {
      FML_LOG(ERROR) << "Could not locate kernel file.";
      return nullptr;
    }
 
    auto kernel_file = fml::OpenFile(kernel_file_path.c_str(), false,
                                     fml::FilePermission::kRead);
 
    if (!kernel_file.is_valid()) {
      FML_LOG(ERROR) << "Kernel file descriptor was invalid.";
      return nullptr;
    }
 
    auto kernel_mapping = std::make_unique<fml::FileMapping>(kernel_file);
 
    if (kernel_mapping->GetMapping() == nullptr) {
      FML_LOG(ERROR) << "Could not set up kernel mapping.";
      return nullptr;
    }
 
    settings.application_kernels = fml::MakeCopyable(
        [kernel_mapping = std::move(kernel_mapping)]() mutable -> Mappings {
          Mappings mappings;
          mappings.emplace_back(std::move(kernel_mapping));
          return mappings;
        });
  }
 
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(task_runners);
  context.io_manager = std::move(io_manager);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = entrypoint.c_str();
  context.enable_impeller = p_settings.enable_impeller;
 
  auto isolate =
      DartIsolate::CreateRunningRootIsolate(
          settings,                            // settings
          vm_data->GetIsolateSnapshot(),       // isolate snapshot
          std::move(platform_configuration),   // platform configuration
          DartIsolate::Flags{},                // flags
          nullptr,                             // root isolate create callback
          settings.isolate_create_callback,    // isolate create callback
          settings.isolate_shutdown_callback,  // isolate shutdown callback
          entrypoint,                          // entrypoint
          std::nullopt,                        // library
          args,                                // args
          std::move(isolate_configuration),    // isolate configuration
          context                              // engine context
          )
          .lock();
 
  if (!isolate) {
    FML_LOG(ERROR) << "Could not create running isolate.";
    return nullptr;
  }
 
  return std::make_unique<AutoIsolateShutdown>(
      isolate, context.task_runners.GetUITaskRunner());
}

◆ SetArgsForProcess()

void flutter::testing::SetArgsForProcess	(	int	argc,
		char **	argv
	)

Definition at line 16 of file test_args.cc.

                                              {
  gProcessArgs = fml::CommandLineFromArgcArgv(argc, argv);
}

◆ ShaderLibraryMappings()

static std::vector< std::shared_ptr< fml::Mapping > > flutter::testing::ShaderLibraryMappings ( )

static

Definition at line 21 of file shell_test_platform_view_gl.cc.

                                                                    {
  return {
      std::make_shared<fml::NonOwnedMapping>(
          impeller_entity_shaders_gles_data,
          impeller_entity_shaders_gles_length),
#if IMPELLER_ENABLE_3D
      std::make_shared<fml::NonOwnedMapping>(
          impeller_scene_shaders_gles_data, impeller_scene_shaders_gles_length),
#endif
  };
}

◆ SurfacePixelDataMatchesBytes() [1/2]

bool flutter::testing::SurfacePixelDataMatchesBytes	(	SkSurface *	surface,
		const std::vector< uint8_t > &	bytes
	)

Definition at line 215 of file embedder_unittests_util.cc.

                                                                   {
  SkPixmap pixmap;
  auto ok = surface->peekPixels(&pixmap);
  if (!ok) {
    return false;
  }
 
  auto matches = (pixmap.rowBytes() == bytes.size()) &&
                 (memcmp(bytes.data(), pixmap.addr(), bytes.size()) == 0);
 
  if (!matches) {
    FML_LOG(ERROR) << "SkImage pixel data didn't match bytes.";
 
    {
      const uint8_t* addr = static_cast<const uint8_t*>(pixmap.addr());
      std::stringstream stream;
      for (size_t i = 0; i < pixmap.computeByteSize(); ++i) {
        stream << "0x" << std::setfill('0') << std::setw(2) << std::uppercase
               << std::hex << static_cast<int>(addr[i]);
        if (i != pixmap.computeByteSize() - 1) {
          stream << ", ";
        }
      }
      FML_LOG(ERROR) << "  Actual:   " << stream.str();
    }
    {
      std::stringstream stream;
      for (auto b = bytes.begin(); b != bytes.end(); ++b) {
        stream << "0x" << std::setfill('0') << std::setw(2) << std::uppercase
               << std::hex << static_cast<int>(*b);
        if (b != bytes.end() - 1) {
          stream << ", ";
        }
      }
      FML_LOG(ERROR) << "  Expected: " << stream.str();
    }
  }
 
  return matches;
}

◆ SurfacePixelDataMatchesBytes() [2/2]

bool flutter::testing::SurfacePixelDataMatchesBytes	(	std::future< SkSurface * > &	surface_future,
		const std::vector< uint8_t > &	bytes
	)

Definition at line 257 of file embedder_unittests_util.cc.

                                                                   {
  return SurfacePixelDataMatchesBytes(surface_future.get(), bytes);
}

◆ SW_PIXFMT_TEST_F() [1/15]

flutter::testing::SW_PIXFMT_TEST_F	(	BlueBGRA8888xFFx00x00xFF	,
		draw_solid_blue	,
		kFlutterSoftwarePixelFormatBGRA8888	,
		(std::vector< uint8_t >{0xFF, 0x00, 0x00, 0xFF})
	)

◆ SW_PIXFMT_TEST_F() [2/15]

flutter::testing::SW_PIXFMT_TEST_F	(	BlueGray8x12	,
		draw_solid_blue	,
		kFlutterSoftwarePixelFormatGray8	,
		(uint8_t)	0x12
	)

◆ SW_PIXFMT_TEST_F() [3/15]

flutter::testing::SW_PIXFMT_TEST_F	(	BlueRGB565x001F	,
		draw_solid_blue	,
		kFlutterSoftwarePixelFormatRGB565	,
		(uint16_t)	0x001F
	)

◆ SW_PIXFMT_TEST_F() [4/15]

flutter::testing::SW_PIXFMT_TEST_F	(	BlueRGBA4444x00FF	,
		draw_solid_blue	,
		kFlutterSoftwarePixelFormatRGBA4444	,
		(uint16_t)	0x00FF
	)

◆ SW_PIXFMT_TEST_F() [5/15]

flutter::testing::SW_PIXFMT_TEST_F	(	BlueRGBA8888x00x00xFFxFF	,
		draw_solid_blue	,
		kFlutterSoftwarePixelFormatRGBA8888	,
		(std::vector< uint8_t >{0x00, 0x00, 0xFF, 0xFF})
	)

◆ SW_PIXFMT_TEST_F() [6/15]

flutter::testing::SW_PIXFMT_TEST_F	(	GreenBGRA8888x00xFFx00xFF	,
		draw_solid_green	,
		kFlutterSoftwarePixelFormatBGRA8888	,
		(std::vector< uint8_t >{0x00, 0xFF, 0x00, 0xFF})
	)

◆ SW_PIXFMT_TEST_F() [7/15]

flutter::testing::SW_PIXFMT_TEST_F	(	GreenGray8xB6	,
		draw_solid_green	,
		kFlutterSoftwarePixelFormatGray8	,
		(uint8_t)	0xB6
	)

◆ SW_PIXFMT_TEST_F() [8/15]

flutter::testing::SW_PIXFMT_TEST_F	(	GreenRGB565x07E0	,
		draw_solid_green	,
		kFlutterSoftwarePixelFormatRGB565	,
		(uint16_t)	0x07E0
	)

◆ SW_PIXFMT_TEST_F() [9/15]

flutter::testing::SW_PIXFMT_TEST_F	(	GreenRGBA4444x0F0F	,
		draw_solid_green	,
		kFlutterSoftwarePixelFormatRGBA4444	,
		(uint16_t)	0x0F0F
	)

◆ SW_PIXFMT_TEST_F() [10/15]

flutter::testing::SW_PIXFMT_TEST_F	(	GreenRGBA8888x00xFFx00xFF	,
		draw_solid_green	,
		kFlutterSoftwarePixelFormatRGBA8888	,
		(std::vector< uint8_t >{0x00, 0xFF, 0x00, 0xFF})
	)

◆ SW_PIXFMT_TEST_F() [11/15]

flutter::testing::SW_PIXFMT_TEST_F	(	RedBGRA8888x00x00xFFxFF	,
		draw_solid_red	,
		kFlutterSoftwarePixelFormatBGRA8888	,
		(std::vector< uint8_t >{0x00, 0x00, 0xFF, 0xFF})
	)

◆ SW_PIXFMT_TEST_F() [12/15]

flutter::testing::SW_PIXFMT_TEST_F	(	RedGray8x36	,
		draw_solid_red	,
		kFlutterSoftwarePixelFormatGray8	,
		(uint8_t)	0x36
	)

◆ SW_PIXFMT_TEST_F() [13/15]

flutter::testing::SW_PIXFMT_TEST_F	(	RedRGBA4444xF00F	,
		draw_solid_red	,
		kFlutterSoftwarePixelFormatRGBA4444	,
		(uint16_t)	0xF00F
	)

◆ SW_PIXFMT_TEST_F() [14/15]

flutter::testing::SW_PIXFMT_TEST_F	(	RedRGBA565xF800	,
		draw_solid_red	,
		kFlutterSoftwarePixelFormatRGB565	,
		(uint16_t)	0xF800
	)

◆ SW_PIXFMT_TEST_F() [15/15]

flutter::testing::SW_PIXFMT_TEST_F	(	RedRGBA8888xFFx00x00xFF	,
		draw_solid_red	,
		kFlutterSoftwarePixelFormatRGBA8888	,
		(std::vector< uint8_t >{0xFF, 0x00, 0x00, 0xFF})
	)

◆ TEST() [1/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		AccessibilityRootId
	)

Definition at line 72 of file accessibility_bridge_unittests.cc.

                                                   {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  std::vector<int32_t> children{456, 789};
  FlutterSemanticsNode2 root = CreateSemanticsNode(123, "root", &children);
  FlutterSemanticsNode2 child1 = CreateSemanticsNode(456, "child 1");
  FlutterSemanticsNode2 child2 = CreateSemanticsNode(789, "child 2");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(123).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(456).lock();
  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(789).lock();
  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 123);
  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
 
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], 456);
  EXPECT_EQ(root_node->GetData().child_ids[1], 789);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(child1_node->GetChildCount(), 0);
  EXPECT_EQ(child1_node->GetName(), "child 1");
 
  EXPECT_EQ(child2_node->GetChildCount(), 0);
  EXPECT_EQ(child2_node->GetName(), "child 2");
 
  ASSERT_FALSE(fake_delegate);
}

◆ TEST() [2/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		AddOrder
	)

Definition at line 109 of file accessibility_bridge_unittests.cc.

                                        {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  std::vector<int32_t> root_children{34, 56};
  std::vector<int32_t> child2_children{78};
  std::vector<int32_t> child3_children{90};
  FlutterSemanticsNode2 root = CreateSemanticsNode(12, "root", &root_children);
  FlutterSemanticsNode2 child1 = CreateSemanticsNode(34, "child 1");
  FlutterSemanticsNode2 child2 =
      CreateSemanticsNode(56, "child 2", &child2_children);
  FlutterSemanticsNode2 child3 =
      CreateSemanticsNode(78, "child 3", &child3_children);
  FlutterSemanticsNode2 child4 = CreateSemanticsNode(90, "child 4");
 
  bridge->AddFlutterSemanticsNodeUpdate(child3);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
  bridge->AddFlutterSemanticsNodeUpdate(child4);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(12).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(34).lock();
  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(56).lock();
  auto child3_node = bridge->GetFlutterPlatformNodeDelegateFromID(78).lock();
  auto child4_node = bridge->GetFlutterPlatformNodeDelegateFromID(90).lock();
 
  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 12);
  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
 
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], 34);
  EXPECT_EQ(root_node->GetData().child_ids[1], 56);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(child1_node->GetChildCount(), 0);
  EXPECT_EQ(child1_node->GetName(), "child 1");
 
  EXPECT_EQ(child2_node->GetChildCount(), 1);
  EXPECT_EQ(child2_node->GetData().child_ids[0], 78);
  EXPECT_EQ(child2_node->GetName(), "child 2");
 
  EXPECT_EQ(child3_node->GetChildCount(), 1);
  EXPECT_EQ(child3_node->GetData().child_ids[0], 90);
  EXPECT_EQ(child3_node->GetName(), "child 3");
 
  EXPECT_EQ(child4_node->GetChildCount(), 0);
  EXPECT_EQ(child4_node->GetName(), "child 4");
}

◆ TEST() [3/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		AXTreeManagerTest
	)

Definition at line 546 of file accessibility_bridge_unittests.cc.

                                                 {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  ui::AXTreeID tree_id = bridge->GetTreeID();
  ui::AXTreeManager* manager =
      ui::AXTreeManagerMap::GetInstance().GetManager(tree_id);
  ASSERT_EQ(manager, static_cast<ui::AXTreeManager*>(bridge.get()));
}

◆ TEST() [4/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		BasicTest
	)

Definition at line 40 of file accessibility_bridge_unittests.cc.

                                         {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  std::vector<int32_t> children{1, 2};
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(child1_node->GetChildCount(), 0);
  EXPECT_EQ(child1_node->GetName(), "child 1");
 
  EXPECT_EQ(child2_node->GetChildCount(), 0);
  EXPECT_EQ(child2_node->GetName(), "child 2");
}

◆ TEST() [5/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanFireChildrenChangedCorrectly
	)

Definition at line 160 of file accessibility_bridge_unittests.cc.

                                                               {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  std::vector<int32_t> children{1};
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  EXPECT_EQ(root_node->GetChildCount(), 1);
  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(child1_node->GetChildCount(), 0);
  EXPECT_EQ(child1_node->GetName(), "child 1");
  bridge->accessibility_events.clear();
 
  // Add a child to root.
  root.child_count = 2;
  int32_t new_children[] = {1, 2};
  root.children_in_traversal_order = new_children;
 
  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->CommitUpdates();
 
  root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
  EXPECT_EQ(bridge->accessibility_events.size(), size_t{2});
  std::set<ui::AXEventGenerator::Event> actual_event{
      bridge->accessibility_events.begin(), bridge->accessibility_events.end()};
  EXPECT_THAT(actual_event,
              Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED));
  EXPECT_THAT(actual_event,
              Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED));
}

◆ TEST() [6/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanHandleSelectionChangeCorrectly
	)

Definition at line 208 of file accessibility_bridge_unittests.cc.

                                                                 {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsFocused);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  const ui::AXTreeData& tree = bridge->GetAXTreeData();
  EXPECT_EQ(tree.sel_anchor_object_id, ui::AXNode::kInvalidAXID);
  bridge->accessibility_events.clear();
 
  // Update the selection.
  root.text_selection_base = 0;
  root.text_selection_extent = 5;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  EXPECT_EQ(tree.sel_anchor_object_id, 0);
  EXPECT_EQ(tree.sel_anchor_offset, 0);
  EXPECT_EQ(tree.sel_focus_object_id, 0);
  EXPECT_EQ(tree.sel_focus_offset, 5);
  ASSERT_EQ(bridge->accessibility_events.size(), size_t{2});
  EXPECT_EQ(bridge->accessibility_events[0],
            ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED);
  EXPECT_EQ(bridge->accessibility_events[1],
            ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED);
}

◆ TEST() [7/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanReparentMultipleNodes
	)

Definition at line 372 of file accessibility_bridge_unittests.cc.

                                                        {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  int32_t root_id = 0;
  int32_t intermediary1_id = 1;
  int32_t intermediary2_id = 2;
  int32_t leaf1_id = 3;
  int32_t leaf2_id = 4;
  int32_t leaf3_id = 5;
 
  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
  std::vector<int32_t> intermediary1_children{leaf1_id};
  std::vector<int32_t> intermediary2_children{leaf2_id, leaf3_id};
  FlutterSemanticsNode2 root =
      CreateSemanticsNode(root_id, "root", &root_children);
  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
      intermediary1_id, "intermediary 1", &intermediary1_children);
  FlutterSemanticsNode2 intermediary2 = CreateSemanticsNode(
      intermediary2_id, "intermediary 2", &intermediary2_children);
  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
  FlutterSemanticsNode2 leaf2 = CreateSemanticsNode(leaf2_id, "leaf 2");
  FlutterSemanticsNode2 leaf3 = CreateSemanticsNode(leaf3_id, "leaf 3");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
  bridge->CommitUpdates();
  bridge->accessibility_events.clear();
 
  // Swap intermediary 1's and intermediary2's children.
  int32_t new_intermediary1_children[] = {leaf2_id, leaf3_id};
  intermediary1.child_count = 2;
  intermediary1.children_in_traversal_order = new_intermediary1_children;
 
  int32_t new_intermediary2_children[] = {leaf1_id};
  intermediary2.child_count = 1;
  intermediary2.children_in_traversal_order = new_intermediary2_children;
 
  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
  auto intermediary1_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
  auto intermediary2_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
  auto leaf1_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
  auto leaf2_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(leaf2_id).lock();
  auto leaf3_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(leaf3_id).lock();
 
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary1_id);
  EXPECT_EQ(root_node->GetData().child_ids[1], intermediary2_id);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(intermediary1_node->GetChildCount(), 2);
  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf2_id);
  EXPECT_EQ(intermediary1_node->GetData().child_ids[1], leaf3_id);
  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
 
  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], leaf1_id);
  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
 
  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
 
  EXPECT_EQ(leaf2_node->GetChildCount(), 0);
  EXPECT_EQ(leaf2_node->GetName(), "leaf 2");
 
  EXPECT_EQ(leaf3_node->GetChildCount(), 0);
  EXPECT_EQ(leaf3_node->GetName(), "leaf 3");
 
  // Intermediary 1 and intermediary 2 have new children.
  // Leaf 1, 2, and 3 are all moved.
  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(3));
}

◆ TEST() [8/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanReparentNode
	)

Definition at line 309 of file accessibility_bridge_unittests.cc.

                                               {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  std::vector<int32_t> root_children{1};
  std::vector<int32_t> child1_children{2};
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &root_children);
  FlutterSemanticsNode2 child1 =
      CreateSemanticsNode(1, "child 1", &child1_children);
  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->CommitUpdates();
  bridge->accessibility_events.clear();
 
  // Reparent child2 from child1 to the root.
  child1.child_count = 0;
  child1.children_in_traversal_order = nullptr;
 
  int32_t new_root_children[] = {1, 2};
  root.child_count = 2;
  root.children_in_traversal_order = new_root_children;
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(child1);
  bridge->AddFlutterSemanticsNodeUpdate(child2);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
 
  EXPECT_EQ(root_node->GetChildCount(), 2);
  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(child1_node->GetChildCount(), 0);
  EXPECT_EQ(child1_node->GetName(), "child 1");
 
  EXPECT_EQ(child2_node->GetChildCount(), 0);
  EXPECT_EQ(child2_node->GetName(), "child 2");
 
  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
 
  // Child2 is moved from child1 to root.
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
 
  // Child1 is no longer a parent. It loses its group role and disables its
  // 'clip children' attribute.
  EXPECT_THAT(
      bridge->accessibility_events,
      Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
}

◆ TEST() [9/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanReparentNodeWithChild
	)

Definition at line 466 of file accessibility_bridge_unittests.cc.

                                                        {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  int32_t root_id = 0;
  int32_t intermediary1_id = 1;
  int32_t intermediary2_id = 2;
  int32_t leaf1_id = 3;
 
  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
  std::vector<int32_t> intermediary1_children{leaf1_id};
  FlutterSemanticsNode2 root =
      CreateSemanticsNode(root_id, "root", &root_children);
  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
      intermediary1_id, "intermediary 1", &intermediary1_children);
  FlutterSemanticsNode2 intermediary2 =
      CreateSemanticsNode(intermediary2_id, "intermediary 2");
  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
  bridge->CommitUpdates();
  bridge->accessibility_events.clear();
 
  // Move intermediary1 from root to intermediary 2.
  int32_t new_root_children[] = {intermediary2_id};
  root.child_count = 1;
  root.children_in_traversal_order = new_root_children;
 
  int32_t new_intermediary2_children[] = {intermediary1_id};
  intermediary2.child_count = 1;
  intermediary2.children_in_traversal_order = new_intermediary2_children;
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
  auto intermediary1_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
  auto intermediary2_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
  auto leaf1_node =
      bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
 
  EXPECT_EQ(root_node->GetChildCount(), 1);
  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary2_id);
  EXPECT_EQ(root_node->GetName(), "root");
 
  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], intermediary1_id);
  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
 
  EXPECT_EQ(intermediary1_node->GetChildCount(), 1);
  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf1_id);
  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
 
  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
 
  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
 
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
 
  // Intermediary 2 becomes a parent node. It updates to group role and enables
  // its 'clip children' attribute.
  EXPECT_THAT(
      bridge->accessibility_events,
      Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
  EXPECT_THAT(bridge->accessibility_events,
              Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
}

◆ TEST() [10/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		CanSetCheckboxChecked
	)

Definition at line 292 of file accessibility_bridge_unittests.cc.

                                                     {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsChecked);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
  EXPECT_EQ(root_node->GetData().GetCheckedState(),
            ax::mojom::CheckedState::kTrue);
}

◆ TEST() [11/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		DoesNotAssignEditableRootToSelectableText
	)

Definition at line 240 of file accessibility_bridge_unittests.cc.

                                                                         {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsReadOnly);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  EXPECT_FALSE(root_node->GetData().GetBoolAttribute(
      ax::mojom::BoolAttribute::kEditableRoot));
}

◆ TEST() [12/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		LineBreakingObjectTest
	)

Definition at line 556 of file accessibility_bridge_unittests.cc.

                                                      {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  const int32_t root_id = 0;
 
  FlutterSemanticsNode2 root = CreateSemanticsNode(root_id, "root", {});
 
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
  auto root_data = root_node->GetData();
  EXPECT_TRUE(root_data.HasBoolAttribute(
      ax::mojom::BoolAttribute::kIsLineBreakingObject));
  EXPECT_TRUE(root_data.GetBoolAttribute(
      ax::mojom::BoolAttribute::kIsLineBreakingObject));
}

◆ TEST() [13/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		SliderHasSliderRole
	)

Definition at line 271 of file accessibility_bridge_unittests.cc.

                                                   {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsSlider |
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasEnabledState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsEnabled |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsFocusable);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSlider);
}

◆ TEST() [14/715]

flutter::testing::TEST	(	AccessibilityBridgeTest	,
		SwitchHasSwitchRole
	)

Definition at line 256 of file accessibility_bridge_unittests.cc.

                                                   {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasEnabledState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsEnabled);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
}

◆ TEST() [15/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		DispatchAccessibilityAction
	)

Definition at line 269 of file accessibility_bridge_windows_unittests.cc.

                                                              {
  auto engine = GetTestEngine();
  FlutterWindowsViewSpy view{
      engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
  EngineModifier modifier{engine.get()};
  modifier.SetImplicitView(&view);
  view.OnUpdateSemanticsEnabled(true);
 
  auto bridge = view.accessibility_bridge().lock();
  PopulateAXTree(bridge);
 
  FlutterSemanticsAction actual_action = kFlutterSemanticsActionTap;
  modifier.embedder_api().DispatchSemanticsAction = MOCK_ENGINE_PROC(
      DispatchSemanticsAction,
      ([&actual_action](FLUTTER_API_SYMBOL(FlutterEngine) engine, uint64_t id,
                        FlutterSemanticsAction action, const uint8_t* data,
                        size_t data_length) {
        actual_action = action;
        return kSuccess;
      }));
 
  AccessibilityBridgeWindows delegate(&view);
  delegate.DispatchAccessibilityAction(1, kFlutterSemanticsActionCopy, {});
  EXPECT_EQ(actual_action, kFlutterSemanticsActionCopy);
}

◆ TEST() [16/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		GetParent
	)

Definition at line 237 of file accessibility_bridge_windows_unittests.cc.

                                            {
  auto engine = GetTestEngine();
  FlutterWindowsViewSpy view{
      engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
  EngineModifier modifier{engine.get()};
  modifier.SetImplicitView(&view);
  view.OnUpdateSemanticsEnabled(true);
 
  auto bridge = view.accessibility_bridge().lock();
  PopulateAXTree(bridge);
 
  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  EXPECT_EQ(node0_delegate->GetNativeViewAccessible(),
            node1_delegate->GetParent());
}

◆ TEST() [17/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		GetParentOnRootRetunsNullptr
	)

Definition at line 254 of file accessibility_bridge_windows_unittests.cc.

                                                               {
  auto engine = GetTestEngine();
  FlutterWindowsViewSpy view{
      engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
  EngineModifier modifier{engine.get()};
  modifier.SetImplicitView(&view);
  view.OnUpdateSemanticsEnabled(true);
 
  auto bridge = view.accessibility_bridge().lock();
  PopulateAXTree(bridge);
 
  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_TRUE(node0_delegate->GetParent() == nullptr);
}

◆ TEST() [18/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityEventAlert
	)

Definition at line 295 of file accessibility_bridge_windows_unittests.cc.

                                                            {
  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::ALERT,
                            ax::mojom::Event::kAlert);
}

◆ TEST() [19/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityEventChildrenChanged
	)

Definition at line 300 of file accessibility_bridge_windows_unittests.cc.

                                                                      {
  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::CHILDREN_CHANGED,
                            ax::mojom::Event::kChildrenChanged);
}

◆ TEST() [20/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityEventFocusChanged
	)

Definition at line 305 of file accessibility_bridge_windows_unittests.cc.

                                                                   {
  auto engine = GetTestEngine();
  FlutterWindowsViewSpy view{
      engine.get(), std::make_unique<NiceMock<MockWindowBindingHandler>>()};
  EngineModifier modifier{engine.get()};
  modifier.SetImplicitView(&view);
  view.OnUpdateSemanticsEnabled(true);
 
  auto bridge = GetAccessibilityBridgeSpy(view);
  PopulateAXTree(bridge);
 
  bridge->ResetRecords();
  bridge->OnAccessibilityEvent({AXNodeFromID(bridge, 1),
                                {ui::AXEventGenerator::Event::FOCUS_CHANGED,
                                 ax::mojom::EventFrom::kNone,
                                 {}}});
  ASSERT_EQ(bridge->dispatched_events().size(), 1);
  EXPECT_EQ(bridge->dispatched_events()[0].event_type,
            ax::mojom::Event::kFocus);
 
  ASSERT_EQ(bridge->focused_nodes().size(), 1);
  EXPECT_EQ(bridge->focused_nodes()[0], 1);
}

◆ TEST() [21/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityEventIgnoredChanged
	)

Definition at line 329 of file accessibility_bridge_windows_unittests.cc.

                                                                     {
  // Static test nodes with no text, hint, or scrollability are ignored.
  ExpectWinEventFromAXEvent(4, ui::AXEventGenerator::Event::IGNORED_CHANGED,
                            ax::mojom::Event::kHide);
}

◆ TEST() [22/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityHScrollPosChanged
	)

Definition at line 351 of file accessibility_bridge_windows_unittests.cc.

                                                                   {
  ExpectWinEventFromAXEvent(
      1, ui::AXEventGenerator::Event::SCROLL_HORIZONTAL_POSITION_CHANGED,
      ax::mojom::Event::kScrollPositionChanged);
}

◆ TEST() [23/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityImageAnnotationChanged
	)

Definition at line 335 of file accessibility_bridge_windows_unittests.cc.

                                                                        {
  ExpectWinEventFromAXEvent(
      1, ui::AXEventGenerator::Event::IMAGE_ANNOTATION_CHANGED,
      ax::mojom::Event::kTextChanged);
}

◆ TEST() [24/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityLiveRegionChanged
	)

Definition at line 341 of file accessibility_bridge_windows_unittests.cc.

                                                                   {
  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::LIVE_REGION_CHANGED,
                            ax::mojom::Event::kLiveRegionChanged);
}

◆ TEST() [25/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityNameChanged
	)

Definition at line 346 of file accessibility_bridge_windows_unittests.cc.

                                                             {
  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::NAME_CHANGED,
                            ax::mojom::Event::kTextChanged);
}

◆ TEST() [26/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilitySelectedChanged
	)

Definition at line 363 of file accessibility_bridge_windows_unittests.cc.

                                                                 {
  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::SELECTED_CHANGED,
                            ax::mojom::Event::kValueChanged);
}

◆ TEST() [27/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilitySelectedChildrenChanged
	)

Definition at line 368 of file accessibility_bridge_windows_unittests.cc.

                                                                         {
  ExpectWinEventFromAXEvent(
      2, ui::AXEventGenerator::Event::SELECTED_CHILDREN_CHANGED,
      ax::mojom::Event::kSelectedChildrenChanged);
}

◆ TEST() [28/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityStateChanged
	)

Definition at line 384 of file accessibility_bridge_windows_unittests.cc.

                                                              {
  ExpectWinEventFromAXEvent(
      1, ui::AXEventGenerator::Event::WIN_IACCESSIBLE_STATE_CHANGED,
      ax::mojom::Event::kStateChanged);
}

◆ TEST() [29/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilitySubtreeCreated
	)

Definition at line 374 of file accessibility_bridge_windows_unittests.cc.

                                                                {
  ExpectWinEventFromAXEvent(0, ui::AXEventGenerator::Event::SUBTREE_CREATED,
                            ax::mojom::Event::kShow);
}

◆ TEST() [30/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityValueChanged
	)

Definition at line 379 of file accessibility_bridge_windows_unittests.cc.

                                                              {
  ExpectWinEventFromAXEvent(1, ui::AXEventGenerator::Event::VALUE_CHANGED,
                            ax::mojom::Event::kValueChanged);
}

◆ TEST() [31/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnAccessibilityVScrollPosChanged
	)

Definition at line 357 of file accessibility_bridge_windows_unittests.cc.

                                                                   {
  ExpectWinEventFromAXEvent(
      1, ui::AXEventGenerator::Event::SCROLL_VERTICAL_POSITION_CHANGED,
      ax::mojom::Event::kScrollPositionChanged);
}

◆ TEST() [32/715]

flutter::testing::TEST	(	AccessibilityBridgeWindows	,
		OnDocumentSelectionChanged
	)

Definition at line 390 of file accessibility_bridge_windows_unittests.cc.

                                                             {
  ExpectWinEventFromAXEventOnFocusNode(
      1, ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED,
      ax::mojom::Event::kDocumentSelectionChanged, 2);
}

◆ TEST() [33/715]

flutter::testing::TEST	(	AndroidContextGLImpeller	,
		FallbackForEmulator
	)

Definition at line 57 of file android_context_gl_impeller_unittests.cc.

                                                    {
  auto display = std::make_unique<MockDisplay>();
  EXPECT_CALL(*display, IsValid).WillRepeatedly(Return(true));
  std::unique_ptr<Config> first_result;
  auto second_result =
      std::make_unique<Config>(ConfigDescriptor(), EGLConfig());
  auto third_result = std::make_unique<Config>(ConfigDescriptor(), EGLConfig());
  EXPECT_CALL(
      *display,
      ChooseConfig(Matcher<ConfigDescriptor>(AllOf(
          Field(&ConfigDescriptor::samples, impeller::egl::Samples::kFour),
          Field(&ConfigDescriptor::surface_type,
                impeller::egl::SurfaceType::kWindow)))))
      .WillOnce(Return(ByMove(std::move(first_result))));
  EXPECT_CALL(
      *display,
      ChooseConfig(Matcher<ConfigDescriptor>(
          AllOf(Field(&ConfigDescriptor::samples, impeller::egl::Samples::kOne),
                Field(&ConfigDescriptor::surface_type,
                      impeller::egl::SurfaceType::kWindow)))))
      .WillOnce(Return(ByMove(std::move(second_result))));
  EXPECT_CALL(*display, ChooseConfig(Matcher<ConfigDescriptor>(
                            Field(&ConfigDescriptor::surface_type,
                                  impeller::egl::SurfaceType::kPBuffer))))
      .WillOnce(Return(ByMove(std::move(third_result))));
  ON_CALL(*display, ChooseConfig(_))
      .WillByDefault(Return(ByMove(std::unique_ptr<Config>())));
  auto context =
      std::make_unique<AndroidContextGLImpeller>(std::move(display), true);
  ASSERT_TRUE(context);
}

◆ TEST() [34/715]

flutter::testing::TEST	(	AndroidContextGLImpeller	,
		MSAAFirstAttempt
	)

Definition at line 33 of file android_context_gl_impeller_unittests.cc.

                                                 {
  auto display = std::make_unique<MockDisplay>();
  EXPECT_CALL(*display, IsValid).WillRepeatedly(Return(true));
  auto first_result = std::make_unique<Config>(ConfigDescriptor(), EGLConfig());
  auto second_result =
      std::make_unique<Config>(ConfigDescriptor(), EGLConfig());
  EXPECT_CALL(
      *display,
      ChooseConfig(Matcher<ConfigDescriptor>(AllOf(
          Field(&ConfigDescriptor::samples, impeller::egl::Samples::kFour),
          Field(&ConfigDescriptor::surface_type,
                impeller::egl::SurfaceType::kWindow)))))
      .WillOnce(Return(ByMove(std::move(first_result))));
  EXPECT_CALL(*display, ChooseConfig(Matcher<ConfigDescriptor>(
                            Field(&ConfigDescriptor::surface_type,
                                  impeller::egl::SurfaceType::kPBuffer))))
      .WillOnce(Return(ByMove(std::move(second_result))));
  ON_CALL(*display, ChooseConfig(_))
      .WillByDefault(Return(ByMove(std::unique_ptr<Config>())));
  auto context =
      std::make_unique<AndroidContextGLImpeller>(std::move(display), true);
  ASSERT_TRUE(context);
}

◆ TEST() [35/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		CancelFrame
	)

Definition at line 125 of file external_view_embedder_unittests.cc.

                                               {
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, nullptr, nullptr, GetTaskRunnersForFixture());
 
  embedder->PrerollCompositeEmbeddedView(
      0, std::make_unique<EmbeddedViewParams>());
  embedder->CancelFrame();
 
  ASSERT_EQ(embedder->CompositeEmbeddedView(0), nullptr);
}

◆ TEST() [36/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		CompositeEmbeddedView
	)

Definition at line 109 of file external_view_embedder_unittests.cc.

                                                         {
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, nullptr, nullptr, GetTaskRunnersForFixture());
 
  ASSERT_EQ(nullptr, embedder->CompositeEmbeddedView(0));
  embedder->PrerollCompositeEmbeddedView(
      0, std::make_unique<EmbeddedViewParams>());
  ASSERT_NE(nullptr, embedder->CompositeEmbeddedView(0));
 
  ASSERT_EQ(nullptr, embedder->CompositeEmbeddedView(1));
  embedder->PrerollCompositeEmbeddedView(
      1, std::make_unique<EmbeddedViewParams>());
  ASSERT_NE(nullptr, embedder->CompositeEmbeddedView(1));
}

◆ TEST() [37/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		DestroyOverlayLayersOnSizeChange
	)

Definition at line 767 of file external_view_embedder_unittests.cc.

                                                                    {
  auto jni_mock = std::make_shared<JNIMock>();
 
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
 
        return android_surface_mock;
      });
 
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
 
  // ------------------ First frame ------------------ //
  {
    EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
    embedder->BeginFrame(nullptr, raster_thread_merger);
    embedder->PrepareFlutterView(frame_size, 1.5);
 
    // Add an Android view.
    MutatorsStack stack1;
    // TODO(egarciad): Investigate why Flow applies the device pixel ratio to
    // the offsetPixels, but not the sizePoints.
    auto view_params_1 = std::make_unique<EmbeddedViewParams>(
        SkMatrix(), SkSize::Make(200, 200), stack1);
 
    embedder->PrerollCompositeEmbeddedView(0, std::move(view_params_1));
 
    // This simulates Flutter UI that intersects with the Android view.
    embedder->CompositeEmbeddedView(0)->DrawRect(
        SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
 
    // Create a new overlay surface.
    EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
        .WillOnce(Return(
            ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
                0, window))));
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(0, 0, 0, 200, 200,
                                                            300, 300, stack1));
    EXPECT_CALL(*jni_mock,
                FlutterViewDisplayOverlaySurface(0, 50, 50, 150, 150));
 
    SurfaceFrame::FramebufferInfo framebuffer_info;
    auto surface_frame = std::make_unique<SurfaceFrame>(
        SkSurfaces::Null(1000, 1000), framebuffer_info,
        [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
          return true;
        },
        /*frame_size=*/SkISize::Make(800, 600));
    embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                                std::move(surface_frame));
 
    EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
    embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
  }
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces());
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  // Change the frame size.
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(30, 40), 1.0);
}

◆ TEST() [38/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		DisableThreadMerger
	)

Definition at line 956 of file external_view_embedder_unittests.cc.

                                                       {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
 
  fml::Thread platform_thread("platform");
  auto raster_thread_merger = GetThreadMergerFromRasterThread(&platform_thread);
  ASSERT_FALSE(raster_thread_merger->IsMerged());
 
  // The shell may disable the thread merger during `OnPlatformViewDestroyed`.
  raster_thread_merger->Disable();
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame()).Times(0);
 
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(10, 20), 1.0);
  // Push a platform view.
  embedder->PrerollCompositeEmbeddedView(
      0, std::make_unique<EmbeddedViewParams>());
 
  auto postpreroll_result = embedder->PostPrerollAction(raster_thread_merger);
  ASSERT_EQ(PostPrerollResult::kSkipAndRetryFrame, postpreroll_result);
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame()).Times(0);
  embedder->EndFrame(/*should_resubmit_frame=*/true, raster_thread_merger);
 
  ASSERT_FALSE(raster_thread_merger->IsMerged());
}

◆ TEST() [39/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		DoesNotCallJNIPlatformThreadOnlyMethods
	)

Definition at line 747 of file external_view_embedder_unittests.cc.

                                                                           {
  auto jni_mock = std::make_shared<JNIMock>();
 
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
 
  // While on the raster thread, don't make JNI calls as these methods can only
  // run on the platform thread.
  fml::Thread platform_thread("platform");
  auto raster_thread_merger = GetThreadMergerFromRasterThread(&platform_thread);
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame()).Times(0);
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(10, 20), 1.0);
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame()).Times(0);
  embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
}

◆ TEST() [40/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		DoesNotDestroyOverlayLayersOnSizeChange
	)

Definition at line 857 of file external_view_embedder_unittests.cc.

                                                                           {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
 
        return android_surface_mock;
      });
 
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
 
  // ------------------ First frame ------------------ //
  {
    fml::Thread rasterizer_thread("rasterizer");
    auto raster_thread_merger =
        GetThreadMergerFromPlatformThread(&rasterizer_thread);
    EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
    embedder->BeginFrame(nullptr, raster_thread_merger);
    embedder->PrepareFlutterView(frame_size, 1.5);
 
    // Add an Android view.
    MutatorsStack stack1;
    // TODO(egarciad): Investigate why Flow applies the device pixel ratio to
    // the offsetPixels, but not the sizePoints.
    auto view_params_1 = std::make_unique<EmbeddedViewParams>(
        SkMatrix(), SkSize::Make(200, 200), stack1);
 
    embedder->PrerollCompositeEmbeddedView(0, std::move(view_params_1));
 
    // This simulates Flutter UI that intersects with the Android view.
    embedder->CompositeEmbeddedView(0)->DrawRect(
        SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
 
    // Create a new overlay surface.
    EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
        .WillOnce(Return(
            ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
                0, window))));
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(0, 0, 0, 200, 200,
                                                            300, 300, stack1));
    EXPECT_CALL(*jni_mock,
                FlutterViewDisplayOverlaySurface(0, 50, 50, 150, 150));
 
    auto surface_frame = std::make_unique<SurfaceFrame>(
        SkSurfaces::Null(1000, 1000), framebuffer_info,
        [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
          return true;
        },
        /*frame_size=*/SkISize::Make(800, 600));
    embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                                std::move(surface_frame));
 
    EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
    embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
  }
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces()).Times(1);
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame()).Times(0);
 
  fml::Thread platform_thread("platform");
  embedder->BeginFrame(nullptr,
                       GetThreadMergerFromRasterThread(&platform_thread));
  embedder->PrepareFlutterView(SkISize::Make(30, 40), 1.0);
}

◆ TEST() [41/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		OverlayCoverTwoPlatformViews
	)

Definition at line 469 of file external_view_embedder_unittests.cc.

                                                                {
  // In this test we will simulate two Android views appearing on the screen
  // with a rect intersecting both of them
 
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .Times(1 /* frames */)
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        return android_surface_mock;
      });
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
 
  auto raster_thread_merger = GetThreadMergerFromPlatformThread();
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(frame_size, 1.5);
 
  {
    // Add first Android view.
    SkMatrix matrix = SkMatrix::Translate(100, 100);
    MutatorsStack stack;
    embedder->PrerollCompositeEmbeddedView(
        0, std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(100, 100),
                                                stack));
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(
                               0, 100, 100, 100, 100, 150, 150, stack));
  }
 
  {
    // Add second Android view.
    SkMatrix matrix = SkMatrix::Translate(300, 100);
    MutatorsStack stack;
    embedder->PrerollCompositeEmbeddedView(
        1, std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(100, 100),
                                                stack));
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(
                               1, 300, 100, 100, 100, 150, 150, stack));
  }
  auto rect_paint = DlPaint();
  rect_paint.setColor(DlColor::kCyan());
  rect_paint.setDrawStyle(DlDrawStyle::kFill);
 
  // This simulates Flutter UI that intersects with the two Android views.
  // Since we will compute the intersection for each android view in turn, and
  // finally merge The final size of the overlay will be smaller than the
  // width and height of the rect.
  embedder->CompositeEmbeddedView(1)->DrawRect(
      SkRect::MakeXYWH(150, 50, 200, 200), rect_paint);
 
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillRepeatedly([&]() {
        return std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
            1, window);
      });
 
  // The JNI call to display the overlay surface.
  EXPECT_CALL(*jni_mock,
              FlutterViewDisplayOverlaySurface(1, 150, 100, 200, 100))
      .Times(1);
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      SkSurfaces::Null(1000, 1000), framebuffer_info,
      [](const SurfaceFrame& surface_frame, DlCanvas* canvas) mutable {
        return true;
      },
      /*frame_size=*/SkISize::Make(800, 600));
 
  embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                              std::move(surface_frame));
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
  embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
}

◆ TEST() [42/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		PlatformViewRect
	)

Definition at line 192 of file external_view_embedder_unittests.cc.

                                                    {
  auto jni_mock = std::make_shared<JNIMock>();
 
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(100, 100), 1.5);
 
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setIdentity();
  // The framework always push a scale matrix based on the screen ratio.
  matrix.setConcat(matrix, SkMatrix::Scale(1.5, 1.5));
  matrix.setConcat(matrix, SkMatrix::Translate(10, 20));
  auto view_params =
      std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(30, 40), stack);
 
  auto view_id = 0;
  embedder->PrerollCompositeEmbeddedView(view_id, std::move(view_params));
  ASSERT_EQ(SkRect::MakeXYWH(15, 30, 45, 60), embedder->GetViewRect(view_id));
}

◆ TEST() [43/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		PlatformViewRectChangedParams
	)

Definition at line 220 of file external_view_embedder_unittests.cc.

                                                                 {
  auto jni_mock = std::make_shared<JNIMock>();
 
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(100, 100), 1.5);
 
  auto view_id = 0;
 
  MutatorsStack stack1;
  SkMatrix matrix1;
  matrix1.setIdentity();
  // The framework always push a scale matrix based on the screen ratio.
  matrix1.setConcat(SkMatrix::Scale(1.5, 1.5), SkMatrix::Translate(10, 20));
  auto view_params_1 = std::make_unique<EmbeddedViewParams>(
      matrix1, SkSize::Make(30, 40), stack1);
 
  embedder->PrerollCompositeEmbeddedView(view_id, std::move(view_params_1));
 
  MutatorsStack stack2;
  SkMatrix matrix2;
  matrix2.setIdentity();
  // The framework always push a scale matrix based on the screen ratio.
  matrix2.setConcat(matrix2, SkMatrix::Scale(1.5, 1.5));
  matrix2.setConcat(matrix2, SkMatrix::Translate(50, 60));
  auto view_params_2 = std::make_unique<EmbeddedViewParams>(
      matrix2, SkSize::Make(70, 80), stack2);
 
  embedder->PrerollCompositeEmbeddedView(view_id, std::move(view_params_2));
 
  ASSERT_EQ(SkRect::MakeXYWH(75, 90, 105, 120), embedder->GetViewRect(view_id));
}

◆ TEST() [44/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		RasterizerRunsOnPlatformThread
	)

Definition at line 137 of file external_view_embedder_unittests.cc.

                                                                  {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
 
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
  ASSERT_FALSE(raster_thread_merger->IsMerged());
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(SkISize::Make(10, 20), 1.0);
 
  // Push a platform view.
  embedder->PrerollCompositeEmbeddedView(
      0, std::make_unique<EmbeddedViewParams>());
 
  auto postpreroll_result = embedder->PostPrerollAction(raster_thread_merger);
  ASSERT_EQ(PostPrerollResult::kSkipAndRetryFrame, postpreroll_result);
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
  embedder->EndFrame(/*should_resubmit_frame=*/true, raster_thread_merger);
 
  ASSERT_TRUE(raster_thread_merger->IsMerged());
 
  int pending_frames = 0;
  while (raster_thread_merger->IsMerged()) {
    raster_thread_merger->DecrementLease();
    pending_frames++;
  }
  ASSERT_EQ(10, pending_frames);  // kDefaultMergedLeaseDuration
}

◆ TEST() [45/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		RasterizerRunsOnRasterizerThread
	)

Definition at line 172 of file external_view_embedder_unittests.cc.

                                                                    {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
 
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
  ASSERT_FALSE(raster_thread_merger->IsMerged());
 
  PostPrerollResult result = embedder->PostPrerollAction(raster_thread_merger);
  ASSERT_EQ(PostPrerollResult::kSuccess, result);
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
  embedder->EndFrame(/*should_resubmit_frame=*/true, raster_thread_merger);
 
  ASSERT_FALSE(raster_thread_merger->IsMerged());
}

◆ TEST() [46/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		SubmitFlutterView
	)

Definition at line 260 of file external_view_embedder_unittests.cc.

                                                     {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
        auto surface_frame_2 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .Times(2 /* frames */)
            .WillOnce(Return(ByMove(std::move(surface_frame_1))))
            .WillOnce(Return(ByMove(std::move(surface_frame_2))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
 
        return android_surface_mock;
      });
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
 
  auto raster_thread_merger = GetThreadMergerFromPlatformThread();
 
  // ------------------ First frame ------------------ //
  {
    auto did_submit_frame = false;
    auto surface_frame = std::make_unique<SurfaceFrame>(
        SkSurfaces::Null(1000, 1000), framebuffer_info,
        [&did_submit_frame](const SurfaceFrame& surface_frame,
                            DlCanvas* canvas) mutable {
          if (canvas != nullptr) {
            did_submit_frame = true;
          }
          return true;
        },
        /*frame_size=*/SkISize::Make(800, 600));
 
    embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                                std::move(surface_frame));
    // Submits frame if no Android view in the current frame.
    EXPECT_TRUE(did_submit_frame);
    // Doesn't resubmit frame.
    auto postpreroll_result = embedder->PostPrerollAction(raster_thread_merger);
    ASSERT_EQ(PostPrerollResult::kSuccess, postpreroll_result);
 
    EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
    embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
  }
 
  // ------------------ Second frame ------------------ //
  {
    EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
    embedder->BeginFrame(nullptr, raster_thread_merger);
    embedder->PrepareFlutterView(frame_size, 1.5);
 
    // Add an Android view.
    MutatorsStack stack1;
    SkMatrix matrix1;
    matrix1.setIdentity();
    SkMatrix scale = SkMatrix::Scale(1.5, 1.5);
    SkMatrix trans = SkMatrix::Translate(100, 100);
    matrix1.setConcat(scale, trans);
    stack1.PushTransform(scale);
    stack1.PushTransform(trans);
    // TODO(egarciad): Investigate why Flow applies the device pixel ratio to
    // the offsetPixels, but not the sizePoints.
    auto view_params_1 = std::make_unique<EmbeddedViewParams>(
        matrix1, SkSize::Make(200, 200), stack1);
 
    embedder->PrerollCompositeEmbeddedView(0, std::move(view_params_1));
    // This is the recording canvas flow writes to.
    auto canvas_1 = embedder->CompositeEmbeddedView(0);
 
    auto rect_paint = DlPaint();
    rect_paint.setColor(DlColor::kCyan());
    rect_paint.setDrawStyle(DlDrawStyle::kFill);
 
    // This simulates Flutter UI that doesn't intersect with the Android view.
    canvas_1->DrawRect(SkRect::MakeXYWH(0, 0, 50, 50), rect_paint);
    // This simulates Flutter UI that intersects with the Android view.
    canvas_1->DrawRect(SkRect::MakeXYWH(50, 50, 200, 200), rect_paint);
    canvas_1->DrawRect(SkRect::MakeXYWH(150, 150, 100, 100), rect_paint);
 
    // Create a new overlay surface.
    EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
        .WillOnce(Return(
            ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
                0, window))));
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(
                               0, 150, 150, 300, 300, 300, 300, stack1));
    // The JNI call to display the overlay surface.
    EXPECT_CALL(*jni_mock,
                FlutterViewDisplayOverlaySurface(0, 150, 150, 100, 100));
 
    auto did_submit_frame = false;
    auto surface_frame = std::make_unique<SurfaceFrame>(
        SkSurfaces::Null(1000, 1000), framebuffer_info,
        [&did_submit_frame](const SurfaceFrame& surface_frame,
                            DlCanvas* canvas) mutable {
          if (canvas != nullptr) {
            did_submit_frame = true;
          }
          return true;
        },
        /*frame_size=*/SkISize::Make(800, 600));
 
    embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                                std::move(surface_frame));
    // Doesn't submit frame if there aren't Android views in the previous frame.
    EXPECT_FALSE(did_submit_frame);
    // Resubmits frame.
    auto postpreroll_result = embedder->PostPrerollAction(raster_thread_merger);
    ASSERT_EQ(PostPrerollResult::kResubmitFrame, postpreroll_result);
 
    EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
    embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
  }
 
  // ------------------ Third frame ------------------ //
  {
    EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
    embedder->BeginFrame(nullptr, raster_thread_merger);
    embedder->PrepareFlutterView(frame_size, 1.5);
 
    // Add an Android view.
    MutatorsStack stack1;
    SkMatrix matrix1;
    matrix1.setIdentity();
    SkMatrix scale = SkMatrix::Scale(1.5, 1.5);
    SkMatrix trans = SkMatrix::Translate(100, 100);
    matrix1.setConcat(scale, trans);
    stack1.PushTransform(scale);
    stack1.PushTransform(trans);
    // TODO(egarciad): Investigate why Flow applies the device pixel ratio to
    // the offsetPixels, but not the sizePoints.
    auto view_params_1 = std::make_unique<EmbeddedViewParams>(
        matrix1, SkSize::Make(200, 200), stack1);
 
    embedder->PrerollCompositeEmbeddedView(0, std::move(view_params_1));
    // This is the recording canvas flow writes to.
    auto canvas_1 = embedder->CompositeEmbeddedView(0);
 
    auto rect_paint = DlPaint();
    rect_paint.setColor(DlColor::kCyan());
    rect_paint.setDrawStyle(DlDrawStyle::kFill);
 
    // This simulates Flutter UI that doesn't intersect with the Android view.
    canvas_1->DrawRect(SkRect::MakeXYWH(0, 0, 50, 50), rect_paint);
    // This simulates Flutter UI that intersects with the Android view.
    canvas_1->DrawRect(SkRect::MakeXYWH(50, 50, 200, 200), rect_paint);
    canvas_1->DrawRect(SkRect::MakeXYWH(150, 150, 100, 100), rect_paint);
 
    // Don't create a new overlay surface since it's recycled from the first
    // frame.
    EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface()).Times(0);
    // The JNI call to display the Android view.
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(
                               0, 150, 150, 300, 300, 300, 300, stack1));
    // The JNI call to display the overlay surface.
    EXPECT_CALL(*jni_mock,
                FlutterViewDisplayOverlaySurface(0, 150, 150, 100, 100));
 
    auto did_submit_frame = false;
    auto surface_frame = std::make_unique<SurfaceFrame>(
        SkSurfaces::Null(1000, 1000), framebuffer_info,
        [&did_submit_frame](const SurfaceFrame& surface_frame,
                            DlCanvas* canvas) mutable {
          if (canvas != nullptr) {
            did_submit_frame = true;
          }
          return true;
        },
        /*frame_size=*/SkISize::Make(800, 600));
    embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                                std::move(surface_frame));
    // Submits frame if there are Android views in the previous frame.
    EXPECT_TRUE(did_submit_frame);
    // Doesn't resubmit frame.
    auto postpreroll_result = embedder->PostPrerollAction(raster_thread_merger);
    ASSERT_EQ(PostPrerollResult::kSuccess, postpreroll_result);
 
    EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
    embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
  }
}

◆ TEST() [47/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		SubmitFrameOverlayComposition
	)

Definition at line 572 of file external_view_embedder_unittests.cc.

                                                                 {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .Times(1 /* frames */)
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        return android_surface_mock;
      });
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
 
  auto raster_thread_merger = GetThreadMergerFromPlatformThread();
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(frame_size, 1.5);
 
  {
    // Add first Android view.
    SkMatrix matrix;
    MutatorsStack stack;
    stack.PushTransform(SkMatrix::Translate(0, 0));
 
    embedder->PrerollCompositeEmbeddedView(
        0, std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(200, 200),
                                                stack));
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(0, 0, 0, 200, 200,
                                                            300, 300, stack));
  }
 
  auto rect_paint = DlPaint();
  rect_paint.setColor(DlColor::kCyan());
  rect_paint.setDrawStyle(DlDrawStyle::kFill);
 
  // This simulates Flutter UI that intersects with the first Android view.
  embedder->CompositeEmbeddedView(0)->DrawRect(
      SkRect::MakeXYWH(25, 25, 80, 150), rect_paint);
 
  {
    // Add second Android view.
    SkMatrix matrix;
    MutatorsStack stack;
    stack.PushTransform(SkMatrix::Translate(0, 100));
 
    embedder->PrerollCompositeEmbeddedView(
        1, std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(100, 100),
                                                stack));
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(1, 0, 0, 100, 100,
                                                            150, 150, stack));
  }
  // This simulates Flutter UI that intersects with the first and second Android
  // views.
  embedder->CompositeEmbeddedView(1)->DrawRect(SkRect::MakeXYWH(25, 25, 80, 50),
                                               rect_paint);
 
  embedder->CompositeEmbeddedView(1)->DrawRect(
      SkRect::MakeXYWH(75, 75, 30, 100), rect_paint);
 
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillRepeatedly([&]() {
        return std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
            1, window);
      });
 
  EXPECT_CALL(*jni_mock, FlutterViewDisplayOverlaySurface(1, 25, 25, 80, 150))
      .Times(2);
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      SkSurfaces::Null(1000, 1000), framebuffer_info,
      [](const SurfaceFrame& surface_frame, DlCanvas* canvas) mutable {
        return true;
      },
      /*frame_size=*/SkISize::Make(800, 600));
 
  embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                              std::move(surface_frame));
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
  embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
}

◆ TEST() [48/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		SubmitFramePlatformViewWithoutAnyOverlay
	)

Definition at line 677 of file external_view_embedder_unittests.cc.

                                                                            {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size, framebuffer_info]() {
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .Times(1 /* frames */)
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
 
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        return android_surface_mock;
      });
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
 
  auto raster_thread_merger = GetThreadMergerFromPlatformThread();
 
  EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(frame_size, 1.5);
 
  {
    // Add Android view.
    SkMatrix matrix;
    MutatorsStack stack;
    stack.PushTransform(SkMatrix::Translate(0, 0));
 
    embedder->PrerollCompositeEmbeddedView(
        0, std::make_unique<EmbeddedViewParams>(matrix, SkSize::Make(200, 200),
                                                stack));
    EXPECT_CALL(*jni_mock, FlutterViewOnDisplayPlatformView(0, 0, 0, 200, 200,
                                                            300, 300, stack));
  }
 
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface()).Times(0);
 
  auto surface_frame = std::make_unique<SurfaceFrame>(
      SkSurfaces::Null(1000, 1000), framebuffer_info,
      [](const SurfaceFrame& surface_frame, DlCanvas* canvas) mutable {
        return true;
      },
      /*frame_size=*/SkISize::Make(800, 600));
 
  embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                              std::move(surface_frame));
 
  EXPECT_CALL(*jni_mock, FlutterViewEndFrame());
  embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
}

◆ TEST() [49/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		SupportsDynamicThreadMerging
	)

Definition at line 948 of file external_view_embedder_unittests.cc.

                                                                {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context = AndroidContext(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
  ASSERT_TRUE(embedder->SupportsDynamicThreadMerging());
}

◆ TEST() [50/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		Teardown
	)

Definition at line 986 of file external_view_embedder_unittests.cc.

                                            {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto frame_size = SkISize::Make(1000, 1000);
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context, window, frame_size]() {
        SurfaceFrame::FramebufferInfo framebuffer_info;
        auto surface_frame_1 = std::make_unique<SurfaceFrame>(
            SkSurfaces::Null(1000, 1000), framebuffer_info,
            [](const SurfaceFrame& surface_frame, DlCanvas* canvas) {
              return true;
            },
            /*frame_size=*/SkISize::Make(800, 600));
 
        auto surface_mock = std::make_unique<SurfaceMock>();
        EXPECT_CALL(*surface_mock, AcquireFrame(frame_size))
            .WillOnce(Return(ByMove(std::move(surface_frame_1))));
 
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()))
            .WillOnce(Return(ByMove(std::move(surface_mock))));
 
        return android_surface_mock;
      });
 
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, surface_factory, GetTaskRunnersForFixture());
  fml::Thread rasterizer_thread("rasterizer");
  auto raster_thread_merger =
      GetThreadMergerFromPlatformThread(&rasterizer_thread);
 
  embedder->BeginFrame(nullptr, raster_thread_merger);
  embedder->PrepareFlutterView(frame_size, 1.5);
 
  // Add an Android view.
  MutatorsStack stack;
  auto view_params = std::make_unique<EmbeddedViewParams>(
      SkMatrix(), SkSize::Make(200, 200), stack);
 
  embedder->PrerollCompositeEmbeddedView(0, std::move(view_params));
 
  // This simulates Flutter UI that intersects with the Android view.
  embedder->CompositeEmbeddedView(0)->DrawRect(
      SkRect::MakeXYWH(50, 50, 200, 200), DlPaint());
 
  // Create a new overlay surface.
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  SurfaceFrame::FramebufferInfo framebuffer_info;
  auto surface_frame = std::make_unique<SurfaceFrame>(
      SkSurfaces::Null(1000, 1000), framebuffer_info,
      [](const SurfaceFrame& surface_frame, DlCanvas* canvas) { return true; },
      /*frame_size=*/SkISize::Make(800, 600));
  embedder->SubmitFlutterView(kImplicitViewId, gr_context.get(), nullptr,
                              std::move(surface_frame));
 
  embedder->EndFrame(/*should_resubmit_frame=*/false, raster_thread_merger);
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces());
  // Teardown.
  embedder->Teardown();
}

◆ TEST() [51/715]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		TeardownDoesNotCallJNIMethod
	)

Definition at line 1056 of file external_view_embedder_unittests.cc.

                                                                {
  auto jni_mock = std::make_shared<JNIMock>();
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
  auto embedder = std::make_unique<AndroidExternalViewEmbedder>(
      *android_context, jni_mock, nullptr, GetTaskRunnersForFixture());
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces()).Times(0);
  embedder->Teardown();
}

◆ TEST() [52/715]

flutter::testing::TEST	(	AndroidPlatformView	,
		SelectsVulkanBasedOnApiLevel
	)

Definition at line 13 of file platform_view_android_unittests.cc.

                                                        {
  Settings settings;
  settings.enable_software_rendering = false;
  settings.enable_impeller = true;
 
  int api_level = android_get_device_api_level();
  EXPECT_GT(api_level, 0);
  if (api_level >= 29) {
    EXPECT_EQ(FlutterMain::SelectedRenderingAPI(settings),
              AndroidRenderingAPI::kImpellerVulkan);
  } else {
    EXPECT_EQ(FlutterMain::SelectedRenderingAPI(settings),
              AndroidRenderingAPI::kSkiaOpenGLES);
  }
}

◆ TEST() [53/715]

flutter::testing::TEST	(	AndroidPlatformView	,
		SoftwareRenderingNotSupportedWithImpeller
	)

Definition at line 29 of file platform_view_android_unittests.cc.

                                                                     {
  Settings settings;
  settings.enable_software_rendering = true;
  settings.enable_impeller = true;
 
  ASSERT_DEATH(FlutterMain::SelectedRenderingAPI(settings), "");
}

◆ TEST() [54/715]

flutter::testing::TEST	(	AndroidShellHolder	,
		Create
	)

Definition at line 122 of file android_shell_holder_unittests.cc.

                                 {
  Settings settings;
  settings.enable_software_rendering = false;
  auto jni = std::make_shared<MockPlatformViewAndroidJNI>();
  auto holder = std::make_unique<AndroidShellHolder>(settings, jni);
  EXPECT_NE(holder.get(), nullptr);
  EXPECT_TRUE(holder->IsValid());
  EXPECT_NE(holder->GetPlatformView().get(), nullptr);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(
      nullptr, /*is_fake_window=*/true);
  holder->GetPlatformView()->NotifyCreated(window);
}

◆ TEST() [55/715]

flutter::testing::TEST	(	AndroidShellHolder	,
		HandlePlatformMessage
	)

Definition at line 135 of file android_shell_holder_unittests.cc.

                                                {
  Settings settings;
  settings.enable_software_rendering = false;
  auto jni = std::make_shared<MockPlatformViewAndroidJNI>();
  auto holder = std::make_unique<AndroidShellHolder>(settings, jni);
  EXPECT_NE(holder.get(), nullptr);
  EXPECT_TRUE(holder->IsValid());
  EXPECT_NE(holder->GetPlatformView().get(), nullptr);
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(
      nullptr, /*is_fake_window=*/true);
  holder->GetPlatformView()->NotifyCreated(window);
  EXPECT_TRUE(holder->GetPlatformMessageHandler());
  size_t data_size = 4;
  fml::MallocMapping bytes =
      fml::MallocMapping(static_cast<uint8_t*>(malloc(data_size)), data_size);
  fml::RefPtr<MockPlatformMessageResponse> response =
      MockPlatformMessageResponse::Create();
  auto message = std::make_unique<PlatformMessage>(
      /*channel=*/"foo", /*data=*/std::move(bytes), /*response=*/response);
  int response_id = 1;
  EXPECT_CALL(*jni,
              FlutterViewHandlePlatformMessage(::testing::_, response_id));
  EXPECT_CALL(*response, CompleteEmpty());
  holder->GetPlatformMessageHandler()->HandlePlatformMessage(
      std::move(message));
  holder->GetPlatformMessageHandler()
      ->InvokePlatformMessageEmptyResponseCallback(response_id);
}

◆ TEST() [56/715]

flutter::testing::TEST	(	APKAssetProvider	,
		CloneAndEquals
	)

Definition at line 19 of file apk_asset_provider_unittests.cc.

                                       {
  auto first_provider = std::make_unique<APKAssetProvider>(
      std::make_shared<MockAPKAssetProviderImpl>());
  auto second_provider = std::make_unique<APKAssetProvider>(
      std::make_shared<MockAPKAssetProviderImpl>());
  auto third_provider = first_provider->Clone();
 
  ASSERT_NE(first_provider->GetImpl(), second_provider->GetImpl());
  ASSERT_EQ(first_provider->GetImpl(), third_provider->GetImpl());
  ASSERT_FALSE(*first_provider == *second_provider);
  ASSERT_TRUE(*first_provider == *third_provider);
}

◆ TEST() [57/715]

flutter::testing::TEST	(	Base64	,
		DecodeBytes
	)

Definition at line 101 of file base64_unittests.cc.

                          {
  auto test = [](const std::string& input, const uint8_t output[], size_t num) {
    char buffer[256];
    size_t len = 0;
    auto err = Base64::Decode(input.c_str(), input.length(), &buffer, &len);
    ASSERT_EQ(err, Base64::Error::kNone);
    FML_CHECK(len <= 256);
    ASSERT_EQ(num, len) << input;
    for (int i = 0; i < int(len); i++) {
      ASSERT_EQ(uint8_t(buffer[i]), output[i]) << input << i;
    }
  };
  // Some arbitrary raw bytes, same as the byte output above
  uint8_t e[] = {0x02, 0x71, 0x82, 0x81, 0x82, 0x84, 0x59};
  test("AnGCgYKEWQ==", e, sizeof(e));
 
  uint8_t pi[] = {0x03, 0x24, 0x3F, 0x6A, 0x88, 0x85};
  test("AyQ/aoiF", pi, sizeof(pi));
}

◆ TEST() [58/715]

flutter::testing::TEST	(	Base64	,
		DecodeStringsHasErrors
	)

Definition at line 83 of file base64_unittests.cc.

                                     {
  auto test = [](const std::string& input, Base64::Error expectedError) {
    char buffer[256];
    size_t len = 0;
    auto err = Base64::Decode(input.c_str(), input.length(), &buffer, &len);
    ASSERT_EQ(err, expectedError) << input;
  };
 
  test("Nuts&Bolts", Base64::Error::kBadChar);
  test("Error!", Base64::Error::kBadChar);
  test(":", Base64::Error::kBadChar);
 
  test("RmlzaCAmIENoaXBz=", Base64::Error::kBadPadding);
  // Some cases of bad padding may be ignored due to an internal optimization
  // test("ZGF0ZQ=", Base64::Error::kBadPadding);
  // test("RWdncGxhbnQ", Base64::Error::kBadPadding);
}

◆ TEST() [59/715]

flutter::testing::TEST	(	Base64	,
		DecodeStringsSuccess
	)

Definition at line 62 of file base64_unittests.cc.

                                   {
  auto test = [](const std::string& input, const std::string& output) {
    char buffer[256];
    size_t len = 0;
    auto err = Base64::Decode(input.c_str(), input.length(), &buffer, &len);
    ASSERT_EQ(err, Base64::Error::kNone);
    FML_CHECK(len <= 256);
    std::string actual(buffer, len);
    ASSERT_STREQ(actual.c_str(), output.c_str());
  };
  // Some arbitrary strings
  test("ZGF0ZQ==", "date");
  test("RWdncGxhbnQ=", "Eggplant");
  test("RmlzaCAmIENoaXBz", "Fish & Chips");
  test("U3VQZVJjQWxJZlJhR2lMaVN0SWNFeFBpQWxJZE9jSW9Vcw==",
       "SuPeRcAlIfRaGiLiStIcExPiAlIdOcIoUs");
 
  // Spaces are ignored
  test("Y X Bwb GU=", "apple");
}

◆ TEST() [60/715]

flutter::testing::TEST	(	Base64	,
		EncodeBytes
	)

Definition at line 33 of file base64_unittests.cc.

                          {
  auto test = [](const uint8_t input[], size_t num, const std::string& output) {
    char buffer[512];
    size_t len = Base64::Encode(input, num, &buffer);
    FML_CHECK(len <= 512);
    ASSERT_EQ(len, Base64::EncodedSize(num));
    std::string actual(buffer, len);
    ASSERT_STREQ(actual.c_str(), output.c_str());
  };
  // Some arbitrary raw bytes
  uint8_t e[] = {0x02, 0x71, 0x82, 0x81, 0x82, 0x84, 0x59};
  test(e, sizeof(e), "AnGCgYKEWQ==");
 
  uint8_t pi[] = {0x03, 0x24, 0x3F, 0x6A, 0x88, 0x85};
  test(pi, sizeof(pi), "AyQ/aoiF");
 
  uint8_t bytes[256];
  for (int i = 0; i < 256; i++) {
    bytes[i] = i;
  }
  test(bytes, sizeof(bytes),
       "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gIS"
       "IjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFV"
       "WV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJ"
       "iouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8v"
       "b6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8P"
       "Hy8/T19vf4+fr7/P3+/w==");
}

◆ TEST() [61/715]

flutter::testing::TEST	(	Base64	,
		EncodeStrings
	)

Definition at line 15 of file base64_unittests.cc.

                            {
  auto test = [](const std::string& input, const std::string& output) {
    char buffer[256];
    size_t len = Base64::Encode(input.c_str(), input.length(), &buffer);
    FML_CHECK(len <= 256);
    ASSERT_EQ(len, Base64::EncodedSize(input.length()));
    std::string actual(buffer, len);
    ASSERT_STREQ(actual.c_str(), output.c_str());
  };
  // Some arbitrary strings
  test("apple", "YXBwbGU=");
  test("BANANA", "QkFOQU5B");
  test("Cherry Pie", "Q2hlcnJ5IFBpZQ==");
  test("fLoCcInAuCiNiHiLiPiLiFiCaTiOn",
       "ZkxvQ2NJbkF1Q2lOaUhpTGlQaUxpRmlDYVRpT24=");
  test("", "");
}

◆ TEST() [62/715]

flutter::testing::TEST	(	CanvasSpyTest	,
		DrawingIsTracked
	)

Definition at line 14 of file canvas_spy_unittests.cc.

                                      {
  SkPictureRecorder picture_recorder;
  SkCanvas* canvas = picture_recorder.beginRecording(100, 100);
  CanvasSpy canvas_spy = CanvasSpy(canvas);
  DlCanvas* spy = canvas_spy.GetSpyingCanvas();
 
  ASSERT_FALSE(canvas_spy.DidDrawIntoCanvas());
 
  spy->Translate(128, 128);
  spy->Clear(DlColor::kTransparent());
  ASSERT_FALSE(canvas_spy.DidDrawIntoCanvas());
 
  DlPaint paint;
  spy->DrawCircle({0, 0}, 60, paint);
  ASSERT_TRUE(canvas_spy.DidDrawIntoCanvas());
}

◆ TEST() [63/715]

flutter::testing::TEST	(	CanvasSpyTest	,
		SpiedCanvasIsDrawing
	)

Definition at line 31 of file canvas_spy_unittests.cc.

                                          {
  auto actual_surface =
      SkSurfaces::Raster(SkImageInfo::MakeN32Premul(100, 100));
  SkCanvas* actual_canvas = actual_surface->getCanvas();
 
  auto expected_surface =
      SkSurfaces::Raster(SkImageInfo::MakeN32Premul(100, 100));
  SkCanvas* expected_canvas = expected_surface->getCanvas();
 
  CanvasSpy canvas_spy = CanvasSpy(actual_canvas);
  SkCanvas* spy = canvas_spy.GetRawSpyingCanvas();
 
  SkNWayCanvas multi_canvas = SkNWayCanvas(100, 100);
  multi_canvas.addCanvas(spy);
  multi_canvas.addCanvas(expected_canvas);
 
  multi_canvas.clipRect(SkRect::MakeWH(100, 100));
  multi_canvas.clear(SK_ColorRED);
  multi_canvas.scale(.5, .5);
  multi_canvas.clipRect(SkRect::MakeWH(100, 100));
  multi_canvas.clear(SK_ColorBLUE);
 
  ASSERT_TRUE(canvas_spy.DidDrawIntoCanvas());
 
  SkPixmap actual;
  SkPixmap expected;
 
  ASSERT_TRUE(actual_surface->peekPixels(&actual));
  ASSERT_TRUE(expected_surface->peekPixels(&expected));
 
  const auto size = actual.rowBytes() * actual.height();
  ASSERT_NE(size, 0u);
 
  ASSERT_EQ(::memcmp(actual.addr(), expected.addr(), size), 0);
}

◆ TEST() [64/715]

flutter::testing::TEST	(	ContextOptionsTest	,
		OpenGLDisablesStencilBuffers
	)

Definition at line 12 of file context_options_unittests.cc.

                                                       {
  auto options = MakeDefaultContextOptions(flutter::ContextType::kRender,
                                           GrBackendApi::kOpenGL);
  EXPECT_TRUE(options.fAvoidStencilBuffers);
}

◆ TEST() [65/715]

flutter::testing::TEST	(	DirectManipulationTest	,
		TestGesture
	)

Definition at line 141 of file direct_manipulation_unittests.cc.

                                          {
  MockIDirectManipulationContent content;
  MockWindowBindingHandlerDelegate delegate;
  MockIDirectManipulationViewport viewport;
  const float scale = 1.5;
  const float pan_x = 32.0;
  const float pan_y = 16.0;
  const int DISPLAY_WIDTH = 800;
  const int DISPLAY_HEIGHT = 600;
  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
  owner->SetBindingHandlerDelegate(&delegate);
  auto handler =
      fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
  int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
      .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
        *out = &content;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
        transform[0] = 1.0f;
        transform[4] = 0.0;
        transform[5] = 0.0;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_RUNNING,
                                   DIRECTMANIPULATION_READY);
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke(
          [scale, pan_x, pan_y](float* transform, DWORD size) {
            transform[0] = scale;
            transform[4] = pan_x;
            transform[5] = pan_y;
            return S_OK;
          }));
  EXPECT_CALL(delegate,
              OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
  EXPECT_CALL(viewport, GetViewportRect(_))
      .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
        rect->left = 0;
        rect->top = 0;
        rect->right = DISPLAY_WIDTH;
        rect->bottom = DISPLAY_HEIGHT;
        return S_OK;
      }));
  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
      .WillOnce(::testing::Return(S_OK));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_INERTIA,
                                   DIRECTMANIPULATION_RUNNING);
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_READY,
                                   DIRECTMANIPULATION_INERTIA);
}

◆ TEST() [66/715]

flutter::testing::TEST	(	DirectManipulationTest	,
		TestGestureWithInitialData
	)

Definition at line 394 of file direct_manipulation_unittests.cc.

                                                         {
  MockIDirectManipulationContent content;
  MockWindowBindingHandlerDelegate delegate;
  MockIDirectManipulationViewport viewport;
  const float scale = 1.5;
  const float pan_x = 32.0;
  const float pan_y = 16.0;
  const int DISPLAY_WIDTH = 800;
  const int DISPLAY_HEIGHT = 600;
  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
  owner->SetBindingHandlerDelegate(&delegate);
  auto handler =
      fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
  int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
      .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
        *out = &content;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
        transform[0] = 2.0f;
        transform[4] = 234.0;
        transform[5] = 345.0;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_RUNNING,
                                   DIRECTMANIPULATION_READY);
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke(
          [scale, pan_x, pan_y](float* transform, DWORD size) {
            transform[0] = 2.0f * scale;
            transform[4] = 234.0 + pan_x;
            transform[5] = 345.0 + pan_y;
            return S_OK;
          }));
  EXPECT_CALL(delegate,
              OnPointerPanZoomUpdate(device_id, pan_x, pan_y, scale, 0));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
  EXPECT_CALL(viewport, GetViewportRect(_))
      .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
        rect->left = 0;
        rect->top = 0;
        rect->right = DISPLAY_WIDTH;
        rect->bottom = DISPLAY_HEIGHT;
        return S_OK;
      }));
  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
      .WillOnce(::testing::Return(S_OK));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_INERTIA,
                                   DIRECTMANIPULATION_RUNNING);
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_READY,
                                   DIRECTMANIPULATION_INERTIA);
}

◆ TEST() [67/715]

flutter::testing::TEST	(	DirectManipulationTest	,
		TestInertiaCamcelNotSentAtInertiaEnd
	)

Definition at line 340 of file direct_manipulation_unittests.cc.

                                                                   {
  MockIDirectManipulationContent content;
  MockWindowBindingHandlerDelegate delegate;
  MockIDirectManipulationViewport viewport;
  const int DISPLAY_WIDTH = 800;
  const int DISPLAY_HEIGHT = 600;
  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
  owner->SetBindingHandlerDelegate(&delegate);
  auto handler =
      fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
  int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
  // No need to mock the actual gesture, just start at the end.
  EXPECT_CALL(viewport, GetViewportRect(_))
      .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
        rect->left = 0;
        rect->top = 0;
        rect->right = DISPLAY_WIDTH;
        rect->bottom = DISPLAY_HEIGHT;
        return S_OK;
      }));
  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
      .WillOnce(::testing::Return(S_OK));
  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_INERTIA,
                                   DIRECTMANIPULATION_RUNNING);
  // Have no change in pan between events.
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
        transform[0] = 1;
        transform[4] = 0;
        transform[5] = 140;
        return S_OK;
      }));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
        transform[0] = 1;
        transform[4] = 0;
        transform[5] = 140;
        return S_OK;
      }));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  // OnScrollInertiaCancel should not be called.
  EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id)).Times(0);
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_READY,
                                   DIRECTMANIPULATION_INERTIA);
}

◆ TEST() [68/715]

flutter::testing::TEST	(	DirectManipulationTest	,
		TestInertiaCancelSentForUserCancel
	)

Definition at line 287 of file direct_manipulation_unittests.cc.

                                                                 {
  MockIDirectManipulationContent content;
  MockWindowBindingHandlerDelegate delegate;
  MockIDirectManipulationViewport viewport;
  const int DISPLAY_WIDTH = 800;
  const int DISPLAY_HEIGHT = 600;
  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
  owner->SetBindingHandlerDelegate(&delegate);
  auto handler =
      fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
  int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
  // No need to mock the actual gesture, just start at the end.
  EXPECT_CALL(viewport, GetViewportRect(_))
      .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
        rect->left = 0;
        rect->top = 0;
        rect->right = DISPLAY_WIDTH;
        rect->bottom = DISPLAY_HEIGHT;
        return S_OK;
      }));
  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
      .WillOnce(::testing::Return(S_OK));
  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_INERTIA,
                                   DIRECTMANIPULATION_RUNNING);
  // Have pan_y change by 10 between inertia updates.
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
        transform[0] = 1;
        transform[4] = 0;
        transform[5] = 100;
        return S_OK;
      }));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([](float* transform, DWORD size) {
        transform[0] = 1;
        transform[4] = 0;
        transform[5] = 110;
        return S_OK;
      }));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  // This looks like an interruption in the middle of synthetic inertia because
  // of user input.
  EXPECT_CALL(delegate, OnScrollInertiaCancel(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_READY,
                                   DIRECTMANIPULATION_INERTIA);
}

◆ TEST() [69/715]

flutter::testing::TEST	(	DirectManipulationTest	,
		TestRounding
	)

Definition at line 205 of file direct_manipulation_unittests.cc.

                                           {
  MockIDirectManipulationContent content;
  MockWindowBindingHandlerDelegate delegate;
  MockIDirectManipulationViewport viewport;
  const float scale = 1.5;
  const int DISPLAY_WIDTH = 800;
  const int DISPLAY_HEIGHT = 600;
  auto owner = std::make_unique<DirectManipulationOwner>(nullptr);
  owner->SetBindingHandlerDelegate(&delegate);
  auto handler =
      fml::MakeRefCounted<DirectManipulationEventHandler>(owner.get());
  int32_t device_id = (int32_t) reinterpret_cast<int64_t>(handler.get());
  EXPECT_CALL(viewport, GetPrimaryContent(_, _))
      .WillOnce(::testing::Invoke([&content](REFIID in, void** out) {
        *out = &content;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
        transform[0] = 1.0f;
        transform[4] = 0.0;
        transform[5] = 0.0;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(delegate, OnPointerPanZoomStart(device_id));
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_RUNNING,
                                   DIRECTMANIPULATION_READY);
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
        transform[0] = 1.5000001f;
        transform[4] = 4.0;
        transform[5] = 0.0;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(delegate,
              OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5000001f, 0))
      .Times(0);
  EXPECT_CALL(delegate, OnPointerPanZoomUpdate(device_id, 4.0, 0, 1.5f, 0))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(content, GetContentTransform(_, 6))
      .WillOnce(::testing::Invoke([scale](float* transform, DWORD size) {
        transform[0] = 1.50000065f;
        transform[4] = 2.0;
        transform[5] = 0.0;
        return S_OK;
      }))
      .RetiresOnSaturation();
  EXPECT_CALL(delegate,
              OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000065f, 0))
      .Times(0);
  EXPECT_CALL(delegate,
              OnPointerPanZoomUpdate(device_id, 2.0, 0, 1.50000047f, 0))
      .Times(1)
      .RetiresOnSaturation();
  EXPECT_CALL(delegate, OnPointerPanZoomEnd(device_id));
  EXPECT_CALL(viewport, GetViewportRect(_))
      .WillOnce(::testing::Invoke([DISPLAY_WIDTH, DISPLAY_HEIGHT](RECT* rect) {
        rect->left = 0;
        rect->top = 0;
        rect->right = DISPLAY_WIDTH;
        rect->bottom = DISPLAY_HEIGHT;
        return S_OK;
      }));
  EXPECT_CALL(viewport, ZoomToRect(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, false))
      .WillOnce(::testing::Return(S_OK));
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  handler->OnContentUpdated((IDirectManipulationViewport*)&viewport,
                            (IDirectManipulationContent*)&content);
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_INERTIA,
                                   DIRECTMANIPULATION_RUNNING);
  handler->OnViewportStatusChanged((IDirectManipulationViewport*)&viewport,
                                   DIRECTMANIPULATION_READY,
                                   DIRECTMANIPULATION_INERTIA);
}

◆ TEST() [70/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		Constructor
	)

Definition at line 12 of file dl_accumulation_rect_unittests.cc.

                                               {
  AccumulationRect accumulator;
 
  EXPECT_TRUE(accumulator.is_empty());
  EXPECT_TRUE(accumulator.bounds().isEmpty());
  EXPECT_FALSE(accumulator.overlap_detected());
}

◆ TEST() [71/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		EmptyRect
	)

Definition at line 135 of file dl_accumulation_rect_unittests.cc.

                                             {
  auto test = [](DlScalar l, DlScalar t, DlScalar r, DlScalar b,  //
                 SkRect bounds,                                   //
                 bool should_be_empty, bool should_overlap,
                 const std::string& label) {
    {
      AccumulationRect accumulator;
      accumulator.accumulate(SkRect::MakeLTRB(l, t, r, b));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(DlRect::MakeLTRB(l, t, r, b));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect content;
      content.accumulate(l, t);
      content.accumulate(r, b);
      EXPECT_EQ(content.is_empty(), should_be_empty) << label;
      EXPECT_EQ(content.bounds().isEmpty(), should_be_empty) << label;
      // bounds for an accumulation by points may be different than the
      // bounds for an accumulation by the rect they produce because
      // construction by points has no "empty rejection" case.
      if (!should_be_empty) {
        EXPECT_EQ(content.bounds(), bounds) << label;
      }
      EXPECT_EQ(content.overlap_detected(), should_overlap) << label;
 
      AccumulationRect accumulator;
      accumulator.accumulate(content);
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
  };
 
  test(10.0f, 10.0f, 10.0f, 10.0f, SkRect::MakeLTRB(0.0f, 0.0f, 0.0f, 0.0f),
       true, false, "Singular");
  test(10.0f, 10.0f, 20.0f, 10.0f, SkRect::MakeLTRB(0.0f, 0.0f, 0.0f, 0.0f),
       true, false, "Horizontal Empty");
  test(10.0f, 10.0f, 10.0f, 20.0f, SkRect::MakeLTRB(0.0f, 0.0f, 0.0f, 0.0f),
       true, false, "Vertical Empty");
  test(10.0f, 10.0f, 20.0f, 20.0f, SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),
       false, false, "Non-Empty");
}

◆ TEST() [72/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		OnePoint
	)

Definition at line 20 of file dl_accumulation_rect_unittests.cc.

                                            {
  AccumulationRect accumulator;
  accumulator.accumulate(10.0f, 10.0f);
 
  EXPECT_TRUE(accumulator.is_empty());
  EXPECT_TRUE(accumulator.bounds().isEmpty());
  EXPECT_FALSE(accumulator.overlap_detected());
}

◆ TEST() [73/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		ThreePoints
	)

Definition at line 79 of file dl_accumulation_rect_unittests.cc.

                                               {
  auto test = [](DlScalar x1, DlScalar y1,  //
                 DlScalar x2, DlScalar y2,  //
                 DlScalar x3, DlScalar y3,  //
                 SkRect bounds,             //
                 bool should_be_empty, bool should_overlap,
                 const std::string& label) {
    {
      AccumulationRect accumulator;
      accumulator.accumulate(x1, y1);
      accumulator.accumulate(x2, y2);
      accumulator.accumulate(x3, y3);
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(SkPoint::Make(x1, y1));
      accumulator.accumulate(SkPoint::Make(x2, y2));
      accumulator.accumulate(SkPoint::Make(x3, y3));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(DlPoint(x1, y1));
      accumulator.accumulate(DlPoint(x2, y2));
      accumulator.accumulate(DlPoint(x3, y3));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
  };
 
  test(10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f,
       SkRect::MakeLTRB(10.0f, 10.0f, 10.0f, 10.0f), true, false, "Same");
  test(10.0f, 10.0f, 20.0f, 10.0f, 15.0f, 10.0f,
       SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 10.0f), true, false, "Horizontal");
  test(10.0f, 10.0f, 10.0f, 20.0f, 10.0f, 15.0f,
       SkRect::MakeLTRB(10.0f, 10.0f, 10.0f, 20.0f), true, false, "Vertical");
  test(10.0f, 10.0f, 20.0f, 20.0f, 25.0f, 15.0f,
       SkRect::MakeLTRB(10.0f, 10.0f, 25.0f, 20.0f), false, false, "Disjoint");
  test(10.0f, 10.0f, 20.0f, 20.0f, 15.0f, 15.0f,
       SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), false, true, "Inside");
}

◆ TEST() [74/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		TwoPoints
	)

Definition at line 29 of file dl_accumulation_rect_unittests.cc.

                                             {
  auto test = [](DlScalar x1, DlScalar y1,  //
                 DlScalar x2, DlScalar y2,  //
                 SkRect bounds,             //
                 bool should_be_empty, bool should_overlap,
                 const std::string& label) {
    {
      AccumulationRect accumulator;
      accumulator.accumulate(x1, y1);
      accumulator.accumulate(x2, y2);
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(SkPoint::Make(x1, y1));
      accumulator.accumulate(SkPoint::Make(x2, y2));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(DlPoint(x1, y1));
      accumulator.accumulate(DlPoint(x2, y2));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
  };
 
  test(10.0f, 10.0f, 10.0f, 10.0f, SkRect::MakeLTRB(10.0f, 10.0f, 10.0f, 10.0f),
       true, false, "Same");
  test(10.0f, 10.0f, 20.0f, 10.0f, SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 10.0f),
       true, false, "Horizontal");
  test(10.0f, 10.0f, 10.0f, 20.0f, SkRect::MakeLTRB(10.0f, 10.0f, 10.0f, 20.0f),
       true, false, "Vertical");
  test(10.0f, 10.0f, 20.0f, 20.0f, SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),
       false, false, "Diagonal");
}

◆ TEST() [75/715]

flutter::testing::TEST	(	DisplayListAccumulationRect	,
		TwoRects
	)

Definition at line 194 of file dl_accumulation_rect_unittests.cc.

                                            {
  auto test = [](DlScalar l1, DlScalar t1, DlScalar r1, DlScalar b1,  //
                 DlScalar l2, DlScalar t2, DlScalar r2, DlScalar b2,  //
                 SkRect bounds,                                       //
                 bool should_be_empty, bool should_overlap,
                 const std::string& label) {
    {
      AccumulationRect accumulator;
      accumulator.accumulate(SkRect::MakeLTRB(l1, t1, r1, b1));
      accumulator.accumulate(SkRect::MakeLTRB(l2, t2, r2, b2));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect accumulator;
      accumulator.accumulate(DlRect::MakeLTRB(l1, t1, r1, b1));
      accumulator.accumulate(DlRect::MakeLTRB(l2, t2, r2, b2));
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
 
    {
      AccumulationRect content1;
      content1.accumulate(l1, t1);
      content1.accumulate(r1, b1);
 
      AccumulationRect content2;
      content2.accumulate(l2, t2);
      content2.accumulate(r2, b2);
 
      AccumulationRect accumulator;
      accumulator.accumulate(content1);
      accumulator.accumulate(content2);
 
      EXPECT_EQ(accumulator.is_empty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds().isEmpty(), should_be_empty) << label;
      EXPECT_EQ(accumulator.bounds(), bounds) << label;
      EXPECT_EQ(accumulator.overlap_detected(), should_overlap) << label;
    }
  };
 
  test(10.0f, 10.0f, 10.0f, 10.0f,                //
       20.0f, 20.0f, 20.0f, 20.0f,                //
       SkRect::MakeLTRB(0.0f, 0.0f, 0.0f, 0.0f),  //
       true, false, "Empty + Empty");
  test(10.0f, 10.0f, 20.0f, 10.0f,                //
       10.0f, 10.0f, 10.0f, 20.0f,                //
       SkRect::MakeLTRB(0.0f, 0.0f, 0.0f, 0.0f),  //
       true, false, "Horizontal + Vertical");
  test(10.0f, 10.0f, 10.0f, 10.0f,                    //
       15.0f, 15.0f, 20.0f, 20.0f,                    //
       SkRect::MakeLTRB(15.0f, 15.0f, 20.0f, 20.0f),  //
       false, false, "Empty + Non-Empty");
  test(10.0f, 10.0f, 15.0f, 15.0f,                    //
       20.0f, 20.0f, 20.0f, 20.0f,                    //
       SkRect::MakeLTRB(10.0f, 10.0f, 15.0f, 15.0f),  //
       false, false, "Non-Empty + Empty");
  test(10.0f, 10.0f, 15.0f, 15.0f,                    //
       15.0f, 15.0f, 20.0f, 20.0f,                    //
       SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),  //
       false, false, "Abutting");
  test(10.0f, 10.0f, 15.0f, 15.0f,                    //
       16.0f, 16.0f, 20.0f, 20.0f,                    //
       SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),  //
       false, false, "Disjoint");
  test(10.0f, 10.0f, 16.0f, 16.0f,                    //
       15.0f, 15.0f, 20.0f, 20.0f,                    //
       SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),  //
       false, true, "Overlapping");
}

◆ TEST() [76/715]

flutter::testing::TEST	(	DisplayListColor	,
		ArrayInterchangeableWithUint32
	)

Definition at line 21 of file dl_color_unittests.cc.

                                                       {
  uint32_t ints[5] = {
      0xFF000000,  //
      0xFFFF0000,  //
      0xFF00FF00,  //
      0xFF0000FF,  //
      0xF1F2F3F4,
  };
  DlColor colors[5] = {
      DlColor::kBlack(),  //
      DlColor::kRed(),    //
      DlColor::kGreen(),  //
      DlColor::kBlue(),   //
      DlColor(0xF1F2F3F4),
  };
  arraysEqual(ints, colors, 5);
  arraysEqual(reinterpret_cast<const uint32_t*>(colors),
              reinterpret_cast<const DlColor*>(ints), 5);
}

◆ TEST() [77/715]

flutter::testing::TEST	(	DisplayListColor	,
		DlColorDirectlyComparesToSkColor
	)

Definition at line 41 of file dl_color_unittests.cc.

                                                         {
  EXPECT_EQ(DlColor::kBlack(), SK_ColorBLACK);
  EXPECT_EQ(DlColor::kRed(), SK_ColorRED);
  EXPECT_EQ(DlColor::kGreen(), SK_ColorGREEN);
  EXPECT_EQ(DlColor::kBlue(), SK_ColorBLUE);
}

◆ TEST() [78/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendAsBlend
	)

Definition at line 28 of file dl_color_filter_unittests.cc.

                                           {
  DlBlendColorFilter filter(DlColor::kRed(), DlBlendMode::kDstATop);
  ASSERT_NE(filter.asBlend(), nullptr);
  ASSERT_EQ(filter.asBlend(), &filter);
}

◆ TEST() [79/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendConstructor
	)

Definition at line 18 of file dl_color_filter_unittests.cc.

                                               {
  DlBlendColorFilter filter(DlColor::kRed(), DlBlendMode::kDstATop);
}

◆ TEST() [80/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendContents
	)

Definition at line 34 of file dl_color_filter_unittests.cc.

                                            {
  DlBlendColorFilter filter(DlColor::kRed(), DlBlendMode::kDstATop);
  ASSERT_EQ(filter.color(), DlColor::kRed());
  ASSERT_EQ(filter.mode(), DlBlendMode::kDstATop);
}

◆ TEST() [81/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendEquals
	)

Definition at line 40 of file dl_color_filter_unittests.cc.

                                          {
  DlBlendColorFilter filter1(DlColor::kRed(), DlBlendMode::kDstATop);
  DlBlendColorFilter filter2(DlColor::kRed(), DlBlendMode::kDstATop);
  TestEquals(filter1, filter2);
}

◆ TEST() [82/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendNotEquals
	)

Definition at line 46 of file dl_color_filter_unittests.cc.

                                             {
  DlBlendColorFilter filter1(DlColor::kRed(), DlBlendMode::kDstATop);
  DlBlendColorFilter filter2(DlColor::kBlue(), DlBlendMode::kDstATop);
  DlBlendColorFilter filter3(DlColor::kRed(), DlBlendMode::kDstIn);
  TestNotEquals(filter1, filter2, "Color differs");
  TestNotEquals(filter1, filter3, "Blend mode differs");
}

◆ TEST() [83/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		BlendShared
	)

Definition at line 22 of file dl_color_filter_unittests.cc.

                                          {
  DlBlendColorFilter filter(DlColor::kRed(), DlBlendMode::kDstATop);
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [84/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		LinearToSrgbConstructor
	)

Definition at line 141 of file dl_color_filter_unittests.cc.

                                                      {
  DlLinearToSrgbGammaColorFilter filter;
}

◆ TEST() [85/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		LinearToSrgbEquals
	)

Definition at line 151 of file dl_color_filter_unittests.cc.

                                                 {
  DlLinearToSrgbGammaColorFilter filter1;
  DlLinearToSrgbGammaColorFilter filter2;
  TestEquals(filter1, filter2);
  TestEquals(filter1, *DlLinearToSrgbGammaColorFilter::kInstance);
}

◆ TEST() [86/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		LinearToSrgbShared
	)

Definition at line 145 of file dl_color_filter_unittests.cc.

                                                 {
  DlLinearToSrgbGammaColorFilter filter;
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [87/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixAsMatrix
	)

Definition at line 69 of file dl_color_filter_unittests.cc.

                                             {
  DlMatrixColorFilter filter(kMatrix);
  ASSERT_NE(filter.asMatrix(), nullptr);
  ASSERT_EQ(filter.asMatrix(), &filter);
}

◆ TEST() [88/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixConstructor
	)

Definition at line 59 of file dl_color_filter_unittests.cc.

                                                {
  DlMatrixColorFilter filter(kMatrix);
}

◆ TEST() [89/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixContents
	)

Definition at line 75 of file dl_color_filter_unittests.cc.

                                             {
  float matrix[20];
  memcpy(matrix, kMatrix, sizeof(matrix));
  DlMatrixColorFilter filter(matrix);
 
  // Test deref operator []
  for (int i = 0; i < 20; i++) {
    ASSERT_EQ(filter[i], matrix[i]);
  }
 
  // Test get_matrix
  float matrix2[20];
  filter.get_matrix(matrix2);
  for (int i = 0; i < 20; i++) {
    ASSERT_EQ(matrix2[i], matrix[i]);
  }
 
  // Test perturbing original array does not affect filter
  float original_value = matrix[4];
  matrix[4] += 101;
  ASSERT_EQ(filter[4], original_value);
}

◆ TEST() [90/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixEquals
	)

Definition at line 98 of file dl_color_filter_unittests.cc.

                                           {
  DlMatrixColorFilter filter1(kMatrix);
  DlMatrixColorFilter filter2(kMatrix);
  TestEquals(filter1, filter2);
}

◆ TEST() [91/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixNotEquals
	)

Definition at line 104 of file dl_color_filter_unittests.cc.

                                              {
  float matrix[20];
  memcpy(matrix, kMatrix, sizeof(matrix));
  DlMatrixColorFilter filter1(matrix);
  matrix[4] += 101;
  DlMatrixColorFilter filter2(matrix);
  TestNotEquals(filter1, filter2, "Matrix differs");
}

◆ TEST() [92/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		MatrixShared
	)

Definition at line 63 of file dl_color_filter_unittests.cc.

                                           {
  DlMatrixColorFilter filter(kMatrix);
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [93/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		NopBlendShouldNotCrash
	)

Definition at line 54 of file dl_color_filter_unittests.cc.

                                                     {
  DlBlendColorFilter filter(DlColor::kTransparent(), DlBlendMode::kSrcOver);
  ASSERT_FALSE(filter.modifies_transparent_black());
}

◆ TEST() [94/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		NopMatrixShouldNotCrash
	)

Definition at line 113 of file dl_color_filter_unittests.cc.

                                                      {
  float matrix[20] = {
      1, 0, 0, 0, 0,  //
      0, 1, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 1, 0,  //
  };
  DlMatrixColorFilter filter(matrix);
  ASSERT_FALSE(filter.modifies_transparent_black());
}

◆ TEST() [95/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		SrgbToLinearConstructor
	)

Definition at line 124 of file dl_color_filter_unittests.cc.

                                                      {
  DlSrgbToLinearGammaColorFilter filter;
}

◆ TEST() [96/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		SrgbToLinearEquals
	)

Definition at line 134 of file dl_color_filter_unittests.cc.

                                                 {
  DlSrgbToLinearGammaColorFilter filter1;
  DlSrgbToLinearGammaColorFilter filter2;
  TestEquals(filter1, filter2);
  TestEquals(filter1, *DlSrgbToLinearGammaColorFilter::kInstance);
}

◆ TEST() [97/715]

flutter::testing::TEST	(	DisplayListColorFilter	,
		SrgbToLinearShared
	)

Definition at line 128 of file dl_color_filter_unittests.cc.

                                                 {
  DlSrgbToLinearGammaColorFilter filter;
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [98/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		AlphaConicalGradientContents
	)

Definition at line 516 of file dl_color_source_unittests.cc.

                                                           {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount,
      kTestAlphaColors, kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asConicalGradient()->start_center(), kTestPoints[0]);
  ASSERT_EQ(source->asConicalGradient()->start_radius(), 10.0);
  ASSERT_EQ(source->asConicalGradient()->end_center(), kTestPoints[1]);
  ASSERT_EQ(source->asConicalGradient()->end_radius(), 20.0);
  ASSERT_EQ(source->asConicalGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asConicalGradient()->colors()[i], kTestAlphaColors[i]);
    ASSERT_EQ(source->asConicalGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asConicalGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asConicalGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), false);
}

◆ TEST() [99/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		AlphaImageContents
	)

Definition at line 173 of file dl_color_source_unittests.cc.

                                                 {
  DlImageColorSource source(kTestAlphaImage1, DlTileMode::kRepeat,
                            DlTileMode::kMirror, DlImageSampling::kLinear,
                            &kTestMatrix1);
  ASSERT_EQ(source.image(), kTestAlphaImage1);
  ASSERT_EQ(source.horizontal_tile_mode(), DlTileMode::kRepeat);
  ASSERT_EQ(source.vertical_tile_mode(), DlTileMode::kMirror);
  ASSERT_EQ(source.sampling(), DlImageSampling::kLinear);
  ASSERT_EQ(source.matrix(), kTestMatrix1);
  ASSERT_EQ(source.is_opaque(), false);
}

◆ TEST() [100/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		AlphaLinearGradientContents
	)

Definition at line 276 of file dl_color_source_unittests.cc.

                                                          {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestAlphaColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asLinearGradient()->start_point(), kTestPoints[0]);
  ASSERT_EQ(source->asLinearGradient()->end_point(), kTestPoints[1]);
  ASSERT_EQ(source->asLinearGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asLinearGradient()->colors()[i], kTestAlphaColors[i]);
    ASSERT_EQ(source->asLinearGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asLinearGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asLinearGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), false);
}

◆ TEST() [101/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		AlphaRadialGradientContents
	)

Definition at line 395 of file dl_color_source_unittests.cc.

                                                          {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestAlphaColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asRadialGradient()->center(), kTestPoints[0]);
  ASSERT_EQ(source->asRadialGradient()->radius(), 10.0);
  ASSERT_EQ(source->asRadialGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asRadialGradient()->colors()[i], kTestAlphaColors[i]);
    ASSERT_EQ(source->asRadialGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asRadialGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asRadialGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), false);
}

◆ TEST() [102/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		AlphaSweepGradientContents
	)

Definition at line 650 of file dl_color_source_unittests.cc.

                                                         {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestAlphaColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asSweepGradient()->center(), kTestPoints[0]);
  ASSERT_EQ(source->asSweepGradient()->start(), 10.0);
  ASSERT_EQ(source->asSweepGradient()->end(), 20.0);
  ASSERT_EQ(source->asSweepGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asSweepGradient()->colors()[i], kTestAlphaColors[i]);
    ASSERT_EQ(source->asSweepGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asSweepGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asSweepGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), false);
}

◆ TEST() [103/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorAsColor
	)

Definition at line 99 of file dl_color_source_unittests.cc.

                                           {
  DlColorColorSource source(DlColor::kRed());
  ASSERT_NE(source.asColor(), nullptr);
  ASSERT_EQ(source.asColor(), &source);
 
  ASSERT_EQ(source.asImage(), nullptr);
  ASSERT_EQ(source.asLinearGradient(), nullptr);
  ASSERT_EQ(source.asRadialGradient(), nullptr);
  ASSERT_EQ(source.asConicalGradient(), nullptr);
  ASSERT_EQ(source.asSweepGradient(), nullptr);
  ASSERT_EQ(source.asRuntimeEffect(), nullptr);
}

◆ TEST() [104/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorConstructor
	)

Definition at line 89 of file dl_color_source_unittests.cc.

                                               {
  DlColorColorSource source(DlColor::kRed());
}

◆ TEST() [105/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorContents
	)

Definition at line 112 of file dl_color_source_unittests.cc.

                                            {
  DlColorColorSource source(DlColor::kRed());
  ASSERT_EQ(source.color(), DlColor::kRed());
  ASSERT_EQ(source.is_opaque(), true);
  for (int i = 0; i < 255; i++) {
    SkColor alpha_color = SkColorSetA(SK_ColorRED, i);
    auto const alpha_source = DlColorColorSource(DlColor(alpha_color));
    ASSERT_EQ(alpha_source.color(), alpha_color);
    ASSERT_EQ(alpha_source.is_opaque(), false);
  }
}

◆ TEST() [106/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorEquals
	)

Definition at line 124 of file dl_color_source_unittests.cc.

                                          {
  DlColorColorSource source1(DlColor::kRed());
  DlColorColorSource source2(DlColor::kRed());
  TestEquals(source1, source2);
}

◆ TEST() [107/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorNotEquals
	)

Definition at line 130 of file dl_color_source_unittests.cc.

                                             {
  DlColorColorSource source1(DlColor::kRed());
  DlColorColorSource source2(DlColor::kBlue());
  TestNotEquals(source1, source2, "Color differs");
}

◆ TEST() [108/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ColorShared
	)

Definition at line 93 of file dl_color_source_unittests.cc.

                                          {
  DlColorColorSource source(DlColor::kRed());
  ASSERT_NE(source.shared().get(), &source);
  ASSERT_EQ(*source.shared(), source);
}

◆ TEST() [109/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientAsConical
	)

Definition at line 483 of file dl_color_source_unittests.cc.

                                                       {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->asConicalGradient(), nullptr);
  ASSERT_EQ(source->asConicalGradient(), source.get());
 
  ASSERT_EQ(source->asColor(), nullptr);
  ASSERT_EQ(source->asImage(), nullptr);
  ASSERT_EQ(source->asLinearGradient(), nullptr);
  ASSERT_EQ(source->asRadialGradient(), nullptr);
  ASSERT_EQ(source->asSweepGradient(), nullptr);
  ASSERT_EQ(source->asRuntimeEffect(), nullptr);
}

◆ TEST() [110/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientConstructor
	)

Definition at line 469 of file dl_color_source_unittests.cc.

                                                         {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
}

◆ TEST() [111/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientContents
	)

Definition at line 498 of file dl_color_source_unittests.cc.

                                                      {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asConicalGradient()->start_center(), kTestPoints[0]);
  ASSERT_EQ(source->asConicalGradient()->start_radius(), 10.0);
  ASSERT_EQ(source->asConicalGradient()->end_center(), kTestPoints[1]);
  ASSERT_EQ(source->asConicalGradient()->end_radius(), 20.0);
  ASSERT_EQ(source->asConicalGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asConicalGradient()->colors()[i], kTestColors[i]);
    ASSERT_EQ(source->asConicalGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asConicalGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asConicalGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), true);
}

◆ TEST() [112/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientEquals
	)

Definition at line 534 of file dl_color_source_unittests.cc.

                                                    {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  TestEquals(*source1, *source2);
}

◆ TEST() [113/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientNotEquals
	)

Definition at line 544 of file dl_color_source_unittests.cc.

                                                       {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints2[0], 10.0, kTestPoints[1], 20.0, kTestStopCount,
        kTestColors, kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Start Center differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 15.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Start Radius differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints2[1], 20.0, kTestStopCount,
        kTestColors, kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "End Center differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 25.0, kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "End Radius differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 20.0, 2, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stop count differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount,
        kTestAlphaColors, kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Colors differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
        kTestStops2, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stops differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kMirror, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Tile Mode differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeConical(
        kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix2);
    TestNotEquals(*source1, *source2, "Matrix differs");
  }
}

◆ TEST() [114/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConicalGradientShared
	)

Definition at line 475 of file dl_color_source_unittests.cc.

                                                    {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeConical(
      kTestPoints[0], 10.0, kTestPoints[1], 20.0, kTestStopCount, kTestColors,
      kTestStops, DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->shared().get(), source.get());
  ASSERT_EQ(*source->shared().get(), *source.get());
}

◆ TEST() [115/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConvertRuntimeEffect
	)

Definition at line 224 of file dl_sk_conversions_unittests.cc.

                                                   {
  const sk_sp<DlRuntimeEffect> kTestRuntimeEffect1 = DlRuntimeEffect::MakeSkia(
      SkRuntimeEffect::MakeForShader(
          SkString("vec4 main(vec2 p) { return vec4(0); }"))
          .effect);
  const sk_sp<DlRuntimeEffect> kTestRuntimeEffect2 = DlRuntimeEffect::MakeSkia(
      SkRuntimeEffect::MakeForShader(
          SkString("vec4 main(vec2 p) { return vec4(1); }"))
          .effect);
  std::shared_ptr<DlRuntimeEffectColorSource> source1 =
      DlColorSource::MakeRuntimeEffect(
          kTestRuntimeEffect1, {}, std::make_shared<std::vector<uint8_t>>());
  std::shared_ptr<DlRuntimeEffectColorSource> source2 =
      DlColorSource::MakeRuntimeEffect(
          kTestRuntimeEffect2, {}, std::make_shared<std::vector<uint8_t>>());
  std::shared_ptr<DlRuntimeEffectColorSource> source3 =
      DlColorSource::MakeRuntimeEffect(
          nullptr, {}, std::make_shared<std::vector<uint8_t>>());
 
  ASSERT_NE(ToSk(source1), nullptr);
  ASSERT_NE(ToSk(source2), nullptr);
  ASSERT_EQ(ToSk(source3), nullptr);
}

◆ TEST() [116/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ConvertRuntimeEffectWithNullSampler
	)

Definition at line 248 of file dl_sk_conversions_unittests.cc.

                                                                  {
  const sk_sp<DlRuntimeEffect> kTestRuntimeEffect1 = DlRuntimeEffect::MakeSkia(
      SkRuntimeEffect::MakeForShader(
          SkString("vec4 main(vec2 p) { return vec4(0); }"))
          .effect);
  std::shared_ptr<DlRuntimeEffectColorSource> source1 =
      DlColorSource::MakeRuntimeEffect(
          kTestRuntimeEffect1, {nullptr},
          std::make_shared<std::vector<uint8_t>>());
 
  ASSERT_EQ(ToSk(source1), nullptr);
}

◆ TEST() [117/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageAsImage
	)

Definition at line 148 of file dl_color_source_unittests.cc.

                                           {
  DlImageColorSource source(kTestImage1, DlTileMode::kClamp, DlTileMode::kClamp,
                            DlImageSampling::kLinear, &kTestMatrix1);
  ASSERT_NE(source.asImage(), nullptr);
  ASSERT_EQ(source.asImage(), &source);
 
  ASSERT_EQ(source.asColor(), nullptr);
  ASSERT_EQ(source.asLinearGradient(), nullptr);
  ASSERT_EQ(source.asRadialGradient(), nullptr);
  ASSERT_EQ(source.asConicalGradient(), nullptr);
  ASSERT_EQ(source.asSweepGradient(), nullptr);
}

◆ TEST() [118/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageConstructor
	)

Definition at line 136 of file dl_color_source_unittests.cc.

                                               {
  DlImageColorSource source(kTestImage1, DlTileMode::kClamp, DlTileMode::kClamp,
                            DlImageSampling::kLinear, &kTestMatrix1);
}

◆ TEST() [119/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageContents
	)

Definition at line 161 of file dl_color_source_unittests.cc.

                                            {
  DlImageColorSource source(kTestImage1, DlTileMode::kRepeat,
                            DlTileMode::kMirror, DlImageSampling::kLinear,
                            &kTestMatrix1);
  ASSERT_EQ(source.image(), kTestImage1);
  ASSERT_EQ(source.horizontal_tile_mode(), DlTileMode::kRepeat);
  ASSERT_EQ(source.vertical_tile_mode(), DlTileMode::kMirror);
  ASSERT_EQ(source.sampling(), DlImageSampling::kLinear);
  ASSERT_EQ(source.matrix(), kTestMatrix1);
  ASSERT_EQ(source.is_opaque(), true);
}

◆ TEST() [120/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageEquals
	)

Definition at line 185 of file dl_color_source_unittests.cc.

                                          {
  DlImageColorSource source1(kTestImage1, DlTileMode::kClamp,
                             DlTileMode::kMirror, DlImageSampling::kLinear,
                             &kTestMatrix1);
  DlImageColorSource source2(kTestImage1, DlTileMode::kClamp,
                             DlTileMode::kMirror, DlImageSampling::kLinear,
                             &kTestMatrix1);
  TestEquals(source1, source2);
}

◆ TEST() [121/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageNotEquals
	)

Definition at line 195 of file dl_color_source_unittests.cc.

                                             {
  DlImageColorSource source1(kTestImage1, DlTileMode::kClamp,
                             DlTileMode::kMirror, DlImageSampling::kLinear,
                             &kTestMatrix1);
  {
    DlImageColorSource source2(kTestAlphaImage1, DlTileMode::kClamp,
                               DlTileMode::kMirror, DlImageSampling::kLinear,
                               &kTestMatrix1);
    TestNotEquals(source1, source2, "Image differs");
  }
  {
    DlImageColorSource source2(kTestImage1, DlTileMode::kRepeat,
                               DlTileMode::kMirror, DlImageSampling::kLinear,
                               &kTestMatrix1);
    TestNotEquals(source1, source2, "hTileMode differs");
  }
  {
    DlImageColorSource source2(kTestImage1, DlTileMode::kClamp,
                               DlTileMode::kRepeat, DlImageSampling::kLinear,
                               &kTestMatrix1);
    TestNotEquals(source1, source2, "vTileMode differs");
  }
  {
    DlImageColorSource source2(kTestImage1, DlTileMode::kClamp,
                               DlTileMode::kMirror, DlImageSampling::kCubic,
                               &kTestMatrix1);
    TestNotEquals(source1, source2, "Sampling differs");
  }
  {
    DlImageColorSource source2(kTestImage1, DlTileMode::kClamp,
                               DlTileMode::kMirror, DlImageSampling::kLinear,
                               &kTestMatrix2);
    TestNotEquals(source1, source2, "Matrix differs");
  }
}

◆ TEST() [122/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		ImageShared
	)

Definition at line 141 of file dl_color_source_unittests.cc.

                                          {
  DlImageColorSource source(kTestImage1, DlTileMode::kClamp, DlTileMode::kClamp,
                            DlImageSampling::kLinear, &kTestMatrix1);
  ASSERT_NE(source.shared().get(), &source);
  ASSERT_EQ(*source.shared(), source);
}

◆ TEST() [123/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientAsLinear
	)

Definition at line 245 of file dl_color_source_unittests.cc.

                                                     {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->asLinearGradient(), nullptr);
  ASSERT_EQ(source->asLinearGradient(), source.get());
 
  ASSERT_EQ(source->asColor(), nullptr);
  ASSERT_EQ(source->asImage(), nullptr);
  ASSERT_EQ(source->asRadialGradient(), nullptr);
  ASSERT_EQ(source->asConicalGradient(), nullptr);
  ASSERT_EQ(source->asSweepGradient(), nullptr);
  ASSERT_EQ(source->asRuntimeEffect(), nullptr);
}

◆ TEST() [124/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientConstructor
	)

Definition at line 231 of file dl_color_source_unittests.cc.

                                                        {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
}

◆ TEST() [125/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientContents
	)

Definition at line 260 of file dl_color_source_unittests.cc.

                                                     {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asLinearGradient()->start_point(), kTestPoints[0]);
  ASSERT_EQ(source->asLinearGradient()->end_point(), kTestPoints[1]);
  ASSERT_EQ(source->asLinearGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asLinearGradient()->colors()[i], kTestColors[i]);
    ASSERT_EQ(source->asLinearGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asLinearGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asLinearGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), true);
}

◆ TEST() [126/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientEquals
	)

Definition at line 292 of file dl_color_source_unittests.cc.

                                                   {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  TestEquals(*source1, *source2);
}

◆ TEST() [127/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientNotEquals
	)

Definition at line 302 of file dl_color_source_unittests.cc.

                                                      {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints2[0], kTestPoints[1], kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Point 0 differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints2[1], kTestStopCount, kTestColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Point 1 differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints[1], 2, kTestColors, kTestStops,  //
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stop count differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints[1], kTestStopCount, kTestAlphaColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Colors differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors,
        kTestStops2, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stops differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kMirror, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Tile Mode differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeLinear(
        kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix2);
    TestNotEquals(*source1, *source2, "Matrix differs");
  }
}

◆ TEST() [128/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		LinearGradientShared
	)

Definition at line 237 of file dl_color_source_unittests.cc.

                                                   {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeLinear(
      kTestPoints[0], kTestPoints[1], kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->shared().get(), source.get());
  ASSERT_EQ(*source->shared().get(), *source.get());
}

◆ TEST() [129/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientAsRadial
	)

Definition at line 364 of file dl_color_source_unittests.cc.

                                                     {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->asRadialGradient(), nullptr);
  ASSERT_EQ(source->asRadialGradient(), source.get());
 
  ASSERT_EQ(source->asColor(), nullptr);
  ASSERT_EQ(source->asImage(), nullptr);
  ASSERT_EQ(source->asLinearGradient(), nullptr);
  ASSERT_EQ(source->asConicalGradient(), nullptr);
  ASSERT_EQ(source->asSweepGradient(), nullptr);
  ASSERT_EQ(source->asRuntimeEffect(), nullptr);
}

◆ TEST() [130/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientConstructor
	)

Definition at line 350 of file dl_color_source_unittests.cc.

                                                        {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
}

◆ TEST() [131/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientContents
	)

Definition at line 379 of file dl_color_source_unittests.cc.

                                                     {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asRadialGradient()->center(), kTestPoints[0]);
  ASSERT_EQ(source->asRadialGradient()->radius(), 10.0);
  ASSERT_EQ(source->asRadialGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asRadialGradient()->colors()[i], kTestColors[i]);
    ASSERT_EQ(source->asRadialGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asRadialGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asRadialGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), true);
}

◆ TEST() [132/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientEquals
	)

Definition at line 411 of file dl_color_source_unittests.cc.

                                                   {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  TestEquals(*source1, *source2);
}

◆ TEST() [133/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientNotEquals
	)

Definition at line 421 of file dl_color_source_unittests.cc.

                                                      {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints2[0], 10.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Center differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 20.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Radius differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 10.0, 2, kTestColors, kTestStops,  //
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stop count differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 10.0, kTestStopCount, kTestAlphaColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Colors differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops2,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stops differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kMirror, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Tile Mode differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeRadial(
        kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix2);
    TestNotEquals(*source1, *source2, "Matrix differs");
  }
}

◆ TEST() [134/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RadialGradientShared
	)

Definition at line 356 of file dl_color_source_unittests.cc.

                                                   {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeRadial(
      kTestPoints[0], 10.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->shared().get(), source.get());
  ASSERT_EQ(*source->shared().get(), *source.get());
}

◆ TEST() [135/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		RuntimeEffect
	)

Definition at line 731 of file dl_color_source_unittests.cc.

                                            {
  std::shared_ptr<DlRuntimeEffectColorSource> source1 =
      DlColorSource::MakeRuntimeEffect(
          kTestRuntimeEffect1, {}, std::make_shared<std::vector<uint8_t>>());
  std::shared_ptr<DlRuntimeEffectColorSource> source2 =
      DlColorSource::MakeRuntimeEffect(
          kTestRuntimeEffect2, {}, std::make_shared<std::vector<uint8_t>>());
  std::shared_ptr<DlRuntimeEffectColorSource> source3 =
      DlColorSource::MakeRuntimeEffect(
          nullptr, {}, std::make_shared<std::vector<uint8_t>>());
 
  ASSERT_EQ(source1->type(), DlColorSourceType::kRuntimeEffect);
  ASSERT_EQ(source1->asRuntimeEffect(), source1.get());
  ASSERT_NE(source2->asRuntimeEffect(), source1.get());
 
  ASSERT_EQ(source1->asImage(), nullptr);
  ASSERT_EQ(source1->asColor(), nullptr);
  ASSERT_EQ(source1->asLinearGradient(), nullptr);
  ASSERT_EQ(source1->asRadialGradient(), nullptr);
  ASSERT_EQ(source1->asConicalGradient(), nullptr);
  ASSERT_EQ(source1->asSweepGradient(), nullptr);
 
  TestEquals(source1, source1);
  TestEquals(source3, source3);
  TestNotEquals(source1, source2, "SkRuntimeEffect differs");
  TestNotEquals(source2, source3, "SkRuntimeEffect differs");
}

◆ TEST() [136/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientAsSweep
	)

Definition at line 618 of file dl_color_source_unittests.cc.

                                                   {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->asSweepGradient(), nullptr);
  ASSERT_EQ(source->asSweepGradient(), source.get());
 
  ASSERT_EQ(source->asColor(), nullptr);
  ASSERT_EQ(source->asImage(), nullptr);
  ASSERT_EQ(source->asLinearGradient(), nullptr);
  ASSERT_EQ(source->asRadialGradient(), nullptr);
  ASSERT_EQ(source->asConicalGradient(), nullptr);
  ASSERT_EQ(source->asRuntimeEffect(), nullptr);
}

◆ TEST() [137/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientConstructor
	)

Definition at line 604 of file dl_color_source_unittests.cc.

                                                       {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
}

◆ TEST() [138/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientContents
	)

Definition at line 633 of file dl_color_source_unittests.cc.

                                                    {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_EQ(source->asSweepGradient()->center(), kTestPoints[0]);
  ASSERT_EQ(source->asSweepGradient()->start(), 10.0);
  ASSERT_EQ(source->asSweepGradient()->end(), 20.0);
  ASSERT_EQ(source->asSweepGradient()->stop_count(), kTestStopCount);
  for (int i = 0; i < kTestStopCount; i++) {
    ASSERT_EQ(source->asSweepGradient()->colors()[i], kTestColors[i]);
    ASSERT_EQ(source->asSweepGradient()->stops()[i], kTestStops[i]);
  }
  ASSERT_EQ(source->asSweepGradient()->tile_mode(), DlTileMode::kClamp);
  ASSERT_EQ(source->asSweepGradient()->matrix(), kTestMatrix1);
  ASSERT_EQ(source->is_opaque(), true);
}

◆ TEST() [139/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientEquals
	)

Definition at line 667 of file dl_color_source_unittests.cc.

                                                  {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  TestEquals(*source1, *source2);
}

◆ TEST() [140/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientNotEquals
	)

Definition at line 677 of file dl_color_source_unittests.cc.

                                                     {
  std::shared_ptr<DlColorSource> source1 = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints2[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Center differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 15.0, 20.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Start Angle differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 25.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "End Angle differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 20.0, 2, kTestColors, kTestStops,  //
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stop count differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestAlphaColors,
        kTestStops, DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Colors differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops2,
        DlTileMode::kClamp, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Stops differ");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kMirror, &kTestMatrix1);
    TestNotEquals(*source1, *source2, "Tile Mode differs");
  }
  {
    std::shared_ptr<DlColorSource> source2 = DlColorSource::MakeSweep(
        kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
        DlTileMode::kClamp, &kTestMatrix2);
    TestNotEquals(*source1, *source2, "Matrix differs");
  }
}

◆ TEST() [141/715]

flutter::testing::TEST	(	DisplayListColorSource	,
		SweepGradientShared
	)

Definition at line 610 of file dl_color_source_unittests.cc.

                                                  {
  std::shared_ptr<DlColorSource> source = DlColorSource::MakeSweep(
      kTestPoints[0], 10.0, 20.0, kTestStopCount, kTestColors, kTestStops,
      DlTileMode::kClamp, &kTestMatrix1);
  ASSERT_NE(source->shared().get(), source.get());
  ASSERT_EQ(*source->shared().get(), *source.get());
}

◆ TEST() [142/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		AntiAliasing
	)

Definition at line 80 of file dl_complexity_unittests.cc.

                                          {
  DisplayListBuilder builder_no_aa;
  builder_no_aa.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
                         DlPaint());
  auto display_list_no_aa = builder_no_aa.Build();
 
  DisplayListBuilder builder_aa;
  builder_aa.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
                      DlPaint().setAntiAlias(true));
  auto display_list_aa = builder_aa.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_no_aa.get()),
              calculator->Compute(display_list_aa.get()));
  }
}

◆ TEST() [143/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DisplayListCeiling
	)

Definition at line 56 of file dl_complexity_unittests.cc.

                                                {
  auto display_list = GetSampleDisplayList();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    calculator->SetComplexityCeiling(10u);
    ASSERT_EQ(calculator->Compute(display_list.get()), 10u);
    calculator->SetComplexityCeiling(std::numeric_limits<unsigned int>::max());
  }
}

◆ TEST() [144/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawArc
	)

Definition at line 281 of file dl_complexity_unittests.cc.

                                     {
  DisplayListBuilder builder;
  builder.DrawArc(SkRect::MakeXYWH(10, 10, 100, 80), 0.0f, 10.0f, true,
                  DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [145/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawAtlas
	)

Definition at line 416 of file dl_complexity_unittests.cc.

                                       {
  SkImageInfo info =
      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                        SkAlphaType::kPremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 0);
  auto image = SkImages::RasterFromBitmap(bitmap);
 
  std::vector<SkRect> rects;
  std::vector<SkRSXform> xforms;
  for (int i = 0; i < 10; i++) {
    rects.push_back(SkRect::MakeXYWH(0, 0, 10, 10));
    xforms.push_back(SkRSXform::Make(1, 0, 0, 0));
  }
 
  DisplayListBuilder builder;
  builder.DrawAtlas(DlImage::Make(image), xforms.data(), rects.data(), nullptr,
                    10, DlBlendMode::kSrc, DlImageSampling::kNearestNeighbor,
                    nullptr, nullptr);
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [146/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawCircle
	)

Definition at line 242 of file dl_complexity_unittests.cc.

                                        {
  DisplayListBuilder builder;
  builder.DrawCircle(SkPoint::Make(50, 50), 10.0f, DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [147/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawDRRect
	)

Definition at line 266 of file dl_complexity_unittests.cc.

                                        {
  DisplayListBuilder builder;
  SkRRect outer =
      SkRRect::MakeRectXY(SkRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f);
  SkRRect inner =
      SkRRect::MakeRectXY(SkRect::MakeXYWH(15, 15, 70, 70), 1.5f, 1.5f);
  builder.DrawDRRect(outer, inner, DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [148/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawImage
	)

Definition at line 353 of file dl_complexity_unittests.cc.

                                       {
  SkImageInfo info =
      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                        SkAlphaType::kPremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 0);
  auto image = SkImages::RasterFromBitmap(bitmap);
 
  DisplayListBuilder builder;
  builder.DrawImage(DlImage::Make(image), SkPoint::Make(0, 0),
                    DlImageSampling::kNearestNeighbor, nullptr);
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [149/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawImageNine
	)

Definition at line 372 of file dl_complexity_unittests.cc.

                                           {
  SkImageInfo info =
      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                        SkAlphaType::kPremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 0);
  auto image = SkImages::RasterFromBitmap(bitmap);
 
  SkIRect center = SkIRect::MakeXYWH(5, 5, 20, 20);
  SkRect dest = SkRect::MakeXYWH(0, 0, 50, 50);
 
  DisplayListBuilder builder;
  builder.DrawImageNine(DlImage::Make(image), center, dest,
                        DlFilterMode::kNearest, nullptr);
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [150/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawImageRect
	)

Definition at line 394 of file dl_complexity_unittests.cc.

                                           {
  SkImageInfo info =
      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                        SkAlphaType::kPremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 0);
  auto image = SkImages::RasterFromBitmap(bitmap);
 
  SkRect src = SkRect::MakeXYWH(0, 0, 50, 50);
  SkRect dest = SkRect::MakeXYWH(0, 0, 50, 50);
 
  DisplayListBuilder builder;
  builder.DrawImageRect(DlImage::Make(image), src, dest,
                        DlImageSampling::kNearestNeighbor, nullptr);
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [151/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawOval
	)

Definition at line 231 of file dl_complexity_unittests.cc.

                                      {
  DisplayListBuilder builder;
  builder.DrawOval(SkRect::MakeXYWH(10, 10, 100, 80), DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [152/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawPath
	)

Definition at line 145 of file dl_complexity_unittests.cc.

                                      {
  DisplayListBuilder builder_line;
  SkPath line_path;
  line_path.moveTo(SkPoint::Make(0, 0));
  line_path.lineTo(SkPoint::Make(10, 10));
  line_path.close();
  builder_line.DrawPath(line_path, DlPaint());
  auto display_list_line = builder_line.Build();
 
  DisplayListBuilder builder_quad;
  SkPath quad_path;
  quad_path.moveTo(SkPoint::Make(0, 0));
  quad_path.quadTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20));
  quad_path.close();
  builder_quad.DrawPath(quad_path, DlPaint());
  auto display_list_quad = builder_quad.Build();
 
  DisplayListBuilder builder_conic;
  SkPath conic_path;
  conic_path.moveTo(SkPoint::Make(0, 0));
  conic_path.conicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20), 1.5f);
  conic_path.close();
  builder_conic.DrawPath(conic_path, DlPaint());
  auto display_list_conic = builder_conic.Build();
 
  DisplayListBuilder builder_cubic;
  SkPath cubic_path;
  cubic_path.moveTo(SkPoint::Make(0, 0));
  cubic_path.cubicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20),
                     SkPoint::Make(20, 20));
  builder_cubic.DrawPath(cubic_path, DlPaint());
  auto display_list_cubic = builder_cubic.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_line.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_quad.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_conic.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_cubic.get()), 0u);
  }
}

◆ TEST() [153/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawPoints
	)

Definition at line 328 of file dl_complexity_unittests.cc.

                                        {
  auto points = GetTestPoints();
  DisplayListBuilder builder_lines;
  builder_lines.DrawPoints(DlCanvas::PointMode::kLines, points.size(),
                           points.data(), DlPaint());
  auto display_list_lines = builder_lines.Build();
 
  DisplayListBuilder builder_points;
  builder_points.DrawPoints(DlCanvas::PointMode::kPoints, points.size(),
                            points.data(), DlPaint());
  auto display_list_points = builder_points.Build();
 
  DisplayListBuilder builder_polygon;
  builder_polygon.DrawPoints(DlCanvas::PointMode::kPolygon, points.size(),
                             points.data(), DlPaint());
  auto display_list_polygon = builder_polygon.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_lines.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_points.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_polygon.get()), 0u);
  }
}

◆ TEST() [154/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawRRect
	)

Definition at line 253 of file dl_complexity_unittests.cc.

                                       {
  DisplayListBuilder builder;
  builder.DrawRRect(
      SkRRect::MakeRectXY(SkRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f),
      DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [155/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawShadow
	)

Definition at line 187 of file dl_complexity_unittests.cc.

                                        {
  DisplayListBuilder builder_line;
  SkPath line_path;
  line_path.moveTo(SkPoint::Make(0, 0));
  line_path.lineTo(SkPoint::Make(10, 10));
  line_path.close();
  builder_line.DrawShadow(line_path, DlColor(SK_ColorRED), 10.0f, false, 1.0f);
  auto display_list_line = builder_line.Build();
 
  DisplayListBuilder builder_quad;
  SkPath quad_path;
  quad_path.moveTo(SkPoint::Make(0, 0));
  quad_path.quadTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20));
  quad_path.close();
  builder_quad.DrawShadow(quad_path, DlColor(SK_ColorRED), 10.0f, false, 1.0f);
  auto display_list_quad = builder_quad.Build();
 
  DisplayListBuilder builder_conic;
  SkPath conic_path;
  conic_path.moveTo(SkPoint::Make(0, 0));
  conic_path.conicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20), 1.5f);
  conic_path.close();
  builder_conic.DrawShadow(conic_path, DlColor(SK_ColorRED), 10.0f, false,
                           1.0f);
  auto display_list_conic = builder_conic.Build();
 
  DisplayListBuilder builder_cubic;
  SkPath cubic_path;
  cubic_path.moveTo(SkPoint::Make(0, 0));
  cubic_path.cubicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20),
                     SkPoint::Make(20, 20));
  builder_cubic.DrawShadow(cubic_path, DlColor(SK_ColorRED), 10.0f, false,
                           1.0f);
  auto display_list_cubic = builder_cubic.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_line.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_quad.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_conic.get()), 0u);
    ASSERT_NE(calculator->Compute(display_list_cubic.get()), 0u);
  }
}

◆ TEST() [156/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawTextBlob
	)

Definition at line 307 of file dl_complexity_unittests.cc.

                                          {
  auto text_blob = SkTextBlob::MakeFromString(
      "The quick brown fox jumps over the lazy dog.", CreateTestFontOfSize(20));
 
  DisplayListBuilder builder;
  builder.DrawTextBlob(text_blob, 0.0f, 0.0f, DlPaint());
  auto display_list = builder.Build();
 
  DisplayListBuilder builder_multiple;
  builder_multiple.DrawTextBlob(text_blob, 0.0f, 0.0f, DlPaint());
  builder_multiple.DrawTextBlob(text_blob, 0.0f, 0.0f, DlPaint());
  auto display_list_multiple = builder_multiple.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
    ASSERT_GT(calculator->Compute(display_list_multiple.get()),
              calculator->Compute(display_list.get()));
  }
}

◆ TEST() [157/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		DrawVertices
	)

Definition at line 293 of file dl_complexity_unittests.cc.

                                          {
  auto points = GetTestPoints();
  auto vertices = DlVertices::Make(DlVertexMode::kTriangles, points.size(),
                                   points.data(), nullptr, nullptr);
  DisplayListBuilder builder;
  builder.DrawVertices(vertices.get(), DlBlendMode::kSrc, DlPaint());
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [158/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		EmptyDisplayList
	)

Definition at line 47 of file dl_complexity_unittests.cc.

                                              {
  auto display_list = GetSampleDisplayList(0);
 
  auto calculators = Calculators();
  for (auto calculator : calculators) {
    ASSERT_EQ(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [159/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		NestedDisplayList
	)

Definition at line 67 of file dl_complexity_unittests.cc.

                                               {
  auto display_list = GetSampleNestedDisplayList();
 
  auto calculators = Calculators();
  for (auto calculator : calculators) {
    // There's only one draw call in the "outer" DisplayList, which calls
    // drawDisplayList with the "inner" DisplayList. To ensure we are
    // recursing correctly into the inner DisplayList, check that we aren't
    // returning 0 (if the function is a no-op) or 1 (as the op_count is 1)
    ASSERT_GT(calculator->Compute(display_list.get()), 1u);
  }
}

◆ TEST() [160/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		SaveLayers
	)

Definition at line 134 of file dl_complexity_unittests.cc.

                                        {
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  auto display_list = builder.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list.get()), 0u);
  }
}

◆ TEST() [161/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		StrokeWidth
	)

Definition at line 98 of file dl_complexity_unittests.cc.

                                         {
  DisplayListBuilder builder_stroke_0;
  builder_stroke_0.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
                            DlPaint().setStrokeWidth(0.0f));
  auto display_list_stroke_0 = builder_stroke_0.Build();
 
  DisplayListBuilder builder_stroke_1;
  builder_stroke_1.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
                            DlPaint().setStrokeWidth(1.0f));
  auto display_list_stroke_1 = builder_stroke_1.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_stroke_0.get()),
              calculator->Compute(display_list_stroke_1.get()));
  }
}

◆ TEST() [162/715]

flutter::testing::TEST	(	DisplayListComplexity	,
		Style
	)

Definition at line 116 of file dl_complexity_unittests.cc.

                                   {
  DisplayListBuilder builder_filled;
  builder_filled.DrawRect(SkRect::MakeXYWH(10, 10, 80, 80),
                          DlPaint().setDrawStyle(DlDrawStyle::kFill));
  auto display_list_filled = builder_filled.Build();
 
  DisplayListBuilder builder_stroked;
  builder_stroked.DrawRect(SkRect::MakeXYWH(10, 10, 80, 80),
                           DlPaint().setDrawStyle(DlDrawStyle::kStroke));
  auto display_list_stroked = builder_stroked.Build();
 
  auto calculators = AccumulatorCalculators();
  for (auto calculator : calculators) {
    ASSERT_NE(calculator->Compute(display_list_filled.get()),
              calculator->Compute(display_list_stroked.get()));
  }
}

◆ TEST() [163/715]

flutter::testing::TEST	(	DisplayListGeometryTypes	,
		ISizeConversion
	)

Definition at line 39 of file dl_geometry_types_unittests.cc.

                                                {
  SkISize sk_s = SkISize::Make(1.0f, 2.0f);
  DlISize dl_s = DlISize(1.0f, 2.0f);
 
  EXPECT_EQ(sk_s, ToSkISize(dl_s));
  EXPECT_EQ(ToDlISize(sk_s), dl_s);
 
  sk_s = SkISize::Make(1.0f, 2.0f);
  dl_s = DlISize(1.0f, 3.0f);
 
  EXPECT_NE(sk_s, ToSkISize(dl_s));
  EXPECT_NE(ToDlISize(sk_s), dl_s);
}

◆ TEST() [164/715]

flutter::testing::TEST	(	DisplayListGeometryTypes	,
		PointConversion
	)

Definition at line 11 of file dl_geometry_types_unittests.cc.

                                                {
  SkPoint sk_p = SkPoint::Make(1.0f, 2.0f);
  DlPoint dl_p = DlPoint(1.0f, 2.0f);
 
  EXPECT_EQ(sk_p, ToSkPoint(dl_p));
  EXPECT_EQ(ToDlPoint(sk_p), dl_p);
 
  sk_p = SkPoint::Make(1.0f, 2.0f);
  dl_p = DlPoint(1.0f, 3.0f);
 
  EXPECT_NE(sk_p, ToSkPoint(dl_p));
  EXPECT_NE(ToDlPoint(sk_p), dl_p);
}

◆ TEST() [165/715]

flutter::testing::TEST	(	DisplayListGeometryTypes	,
		RectConversion
	)

Definition at line 25 of file dl_geometry_types_unittests.cc.

                                               {
  SkRect sk_r = SkRect::MakeLTRB(1.0f, 2.0f, 3.0f, 4.0f);
  DlRect dl_r = DlRect::MakeLTRB(1.0f, 2.0f, 3.0f, 4.0f);
 
  EXPECT_EQ(sk_r, ToSkRect(dl_r));
  EXPECT_EQ(ToDlRect(sk_r), dl_r);
 
  sk_r = SkRect::MakeLTRB(1.0f, 2.0f, 3.0f, 4.0f);
  dl_r = DlRect::MakeLTRB(1.0f, 2.0f, 3.0f, 5.0f);
 
  EXPECT_NE(sk_r, ToSkRect(dl_r));
  EXPECT_NE(ToDlRect(sk_r), dl_r);
}

◆ TEST() [166/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurAsBlur
	)

Definition at line 163 of file dl_image_filter_unittests.cc.

                                         {
  DlBlurImageFilter filter(5.0, 6.0, DlTileMode::kMirror);
 
  ASSERT_NE(filter.asBlur(), nullptr);
  ASSERT_EQ(filter.asBlur(), &filter);
}

◆ TEST() [167/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurBounds
	)

Definition at line 205 of file dl_image_filter_unittests.cc.

                                         {
  DlBlurImageFilter filter = DlBlurImageFilter(5, 10, DlTileMode::kDecal);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  SkRect expected_output_bounds = input_bounds.makeOutset(15, 30);
  TestBounds(filter, input_bounds, expected_output_bounds);
}

◆ TEST() [168/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurConstructor
	)

Definition at line 152 of file dl_image_filter_unittests.cc.

                                              {
  DlBlurImageFilter filter(5.0, 6.0, DlTileMode::kMirror);
}

◆ TEST() [169/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurContents
	)

Definition at line 170 of file dl_image_filter_unittests.cc.

                                           {
  DlBlurImageFilter filter(5.0, 6.0, DlTileMode::kMirror);
 
  ASSERT_EQ(filter.sigma_x(), 5.0);
  ASSERT_EQ(filter.sigma_y(), 6.0);
  ASSERT_EQ(filter.tile_mode(), DlTileMode::kMirror);
}

◆ TEST() [170/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurEquals
	)

Definition at line 178 of file dl_image_filter_unittests.cc.

                                         {
  DlBlurImageFilter filter1(5.0, 6.0, DlTileMode::kMirror);
  DlBlurImageFilter filter2(5.0, 6.0, DlTileMode::kMirror);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [171/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurNotEquals
	)

Definition at line 194 of file dl_image_filter_unittests.cc.

                                            {
  DlBlurImageFilter filter1(5.0, 6.0, DlTileMode::kMirror);
  DlBlurImageFilter filter2(7.0, 6.0, DlTileMode::kMirror);
  DlBlurImageFilter filter3(5.0, 8.0, DlTileMode::kMirror);
  DlBlurImageFilter filter4(5.0, 6.0, DlTileMode::kRepeat);
 
  TestNotEquals(filter1, filter2, "Sigma X differs");
  TestNotEquals(filter1, filter3, "Sigma Y differs");
  TestNotEquals(filter1, filter4, "Tile Mode differs");
}

◆ TEST() [172/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurShared
	)

Definition at line 156 of file dl_image_filter_unittests.cc.

                                         {
  DlBlurImageFilter filter(5.0, 6.0, DlTileMode::kMirror);
 
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [173/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurWithLocalMatrixEquals
	)

Definition at line 185 of file dl_image_filter_unittests.cc.

                                                        {
  DlBlurImageFilter filter1(5.0, 6.0, DlTileMode::kMirror);
  DlBlurImageFilter filter2(5.0, 6.0, DlTileMode::kMirror);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [174/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		BlurZeroSigma
	)

Definition at line 212 of file dl_image_filter_unittests.cc.

                                            {
  std::shared_ptr<DlImageFilter> filter =
      DlBlurImageFilter::Make(0, 0, DlTileMode::kMirror);
  ASSERT_EQ(filter, nullptr);
  filter = DlBlurImageFilter::Make(3, SK_ScalarNaN, DlTileMode::kMirror);
  ASSERT_EQ(filter, nullptr);
  filter = DlBlurImageFilter::Make(SK_ScalarNaN, 3, DlTileMode::kMirror);
  ASSERT_EQ(filter, nullptr);
  filter =
      DlBlurImageFilter::Make(SK_ScalarNaN, SK_ScalarNaN, DlTileMode::kMirror);
  ASSERT_EQ(filter, nullptr);
  filter = DlBlurImageFilter::Make(3, 0, DlTileMode::kMirror);
  ASSERT_NE(filter, nullptr);
  filter = DlBlurImageFilter::Make(0, 3, DlTileMode::kMirror);
  ASSERT_NE(filter, nullptr);
}

◆ TEST() [175/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterAsColorFilter
	)

Definition at line 634 of file dl_image_filter_unittests.cc.

                                                       {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter(dl_color_filter);
 
  ASSERT_NE(filter.asColorFilter(), nullptr);
  ASSERT_EQ(filter.asColorFilter(), &filter);
}

◆ TEST() [176/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterBounds
	)

Definition at line 685 of file dl_image_filter_unittests.cc.

                                                {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kSrcIn);
  DlColorFilterImageFilter filter(dl_color_filter);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  TestBounds(filter, input_bounds, input_bounds);
}

◆ TEST() [177/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterConstructor
	)

Definition at line 622 of file dl_image_filter_unittests.cc.

                                                     {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter(dl_color_filter);
}

◆ TEST() [178/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterContents
	)

Definition at line 642 of file dl_image_filter_unittests.cc.

                                                  {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter(dl_color_filter);
 
  ASSERT_EQ(*filter.color_filter().get(), dl_color_filter);
}

◆ TEST() [179/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterEquals
	)

Definition at line 649 of file dl_image_filter_unittests.cc.

                                                {
  DlBlendColorFilter dl_color_filter1(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter1(dl_color_filter1);
 
  DlBlendColorFilter dl_color_filter2(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter2(dl_color_filter2);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [180/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterModifiesTransparencyBounds
	)

Definition at line 692 of file dl_image_filter_unittests.cc.

                                                                    {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kSrcOver);
  DlColorFilterImageFilter filter(dl_color_filter);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  TestInvalidBounds(filter, SkMatrix::I(), input_bounds);
}

◆ TEST() [181/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterNotEquals
	)

Definition at line 671 of file dl_image_filter_unittests.cc.

                                                   {
  DlBlendColorFilter dl_color_filter1(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter1(dl_color_filter1);
 
  DlBlendColorFilter dl_color_filter2(DlColor::kBlue(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter2(dl_color_filter2);
 
  DlBlendColorFilter dl_color_filter3(DlColor::kRed(), DlBlendMode::kDarken);
  DlColorFilterImageFilter filter3(dl_color_filter3);
 
  TestNotEquals(filter1, filter2, "Color differs");
  TestNotEquals(filter1, filter3, "Blend Mode differs");
}

◆ TEST() [182/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterShared
	)

Definition at line 627 of file dl_image_filter_unittests.cc.

                                                {
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter(dl_color_filter);
 
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [183/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ColorFilterWithLocalMatrixEquals
	)

Definition at line 659 of file dl_image_filter_unittests.cc.

                                                               {
  DlBlendColorFilter dl_color_filter1(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter1(dl_color_filter1);
 
  DlBlendColorFilter dl_color_filter2(DlColor::kRed(), DlBlendMode::kLighten);
  DlColorFilterImageFilter filter2(dl_color_filter2);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [184/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeAsCompose
	)

Definition at line 455 of file dl_image_filter_unittests.cc.

                                               {
  DlMatrixImageFilter outer(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                              0.5, 3.0, 15,  //
                                              0.0, 0.0, 1),
                            DlImageSampling::kLinear);
  DlBlurImageFilter inner(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter(outer, inner);
 
  ASSERT_NE(filter.asCompose(), nullptr);
  ASSERT_EQ(filter.asCompose(), &filter);
}

◆ TEST() [185/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeBounds
	)

Definition at line 538 of file dl_image_filter_unittests.cc.

                                            {
  DlDilateImageFilter outer = DlDilateImageFilter(5, 10);
  DlBlurImageFilter inner = DlBlurImageFilter(12, 5, DlTileMode::kDecal);
  DlComposeImageFilter filter = DlComposeImageFilter(outer, inner);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  SkRect expected_output_bounds =
      input_bounds.makeOutset(36, 15).makeOutset(5, 10);
  TestBounds(filter, input_bounds, expected_output_bounds);
}

◆ TEST() [186/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeBoundsWithUnboundedInner
	)

Definition at line 568 of file dl_image_filter_unittests.cc.

                                                              {
  auto input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  auto expected_bounds = SkRect::MakeLTRB(5, 2, 95, 98);
 
  DlBlendColorFilter color_filter(DlColor::kRed(), DlBlendMode::kSrcOver);
  auto outer = DlBlurImageFilter(5.0, 6.0, DlTileMode::kRepeat);
  auto inner = DlColorFilterImageFilter(color_filter.shared());
  auto composed = DlComposeImageFilter(outer.shared(), inner.shared());
 
  TestUnboundedBounds(composed, input_bounds, expected_bounds, expected_bounds);
}

◆ TEST() [187/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeBoundsWithUnboundedInnerAndOuter
	)

Definition at line 592 of file dl_image_filter_unittests.cc.

                                                                      {
  auto input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  auto expected_bounds = input_bounds;
 
  DlBlendColorFilter color_filter1(DlColor::kRed(), DlBlendMode::kSrcOver);
  DlBlendColorFilter color_filter2(DlColor::kBlue(), DlBlendMode::kSrcOver);
  auto outer = DlColorFilterImageFilter(color_filter1.shared());
  auto inner = DlColorFilterImageFilter(color_filter2.shared());
  auto composed = DlComposeImageFilter(outer.shared(), inner.shared());
 
  TestUnboundedBounds(composed, input_bounds, expected_bounds, expected_bounds);
}

◆ TEST() [188/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeBoundsWithUnboundedOuter
	)

Definition at line 580 of file dl_image_filter_unittests.cc.

                                                              {
  auto input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  auto expected_bounds = SkRect::MakeLTRB(5, 2, 95, 98);
 
  DlBlendColorFilter color_filter(DlColor::kRed(), DlBlendMode::kSrcOver);
  auto outer = DlColorFilterImageFilter(color_filter.shared());
  auto inner = DlBlurImageFilter(5.0, 6.0, DlTileMode::kRepeat);
  auto composed = DlComposeImageFilter(outer.shared(), inner.shared());
 
  TestUnboundedBounds(composed, input_bounds, expected_bounds, expected_bounds);
}

◆ TEST() [189/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeConstructor
	)

Definition at line 434 of file dl_image_filter_unittests.cc.

                                                 {
  DlMatrixImageFilter outer(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                              0.5, 3.0, 15,  //
                                              0.0, 0.0, 1),
                            DlImageSampling::kLinear);
  DlBlurImageFilter inner(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter(outer, inner);
}

◆ TEST() [190/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeContents
	)

Definition at line 467 of file dl_image_filter_unittests.cc.

                                              {
  DlMatrixImageFilter outer(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                              0.5, 3.0, 15,  //
                                              0.0, 0.0, 1),
                            DlImageSampling::kLinear);
  DlBlurImageFilter inner(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter(outer, inner);
 
  ASSERT_EQ(*filter.outer().get(), outer);
  ASSERT_EQ(*filter.inner().get(), inner);
}

◆ TEST() [191/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeEquals
	)

Definition at line 479 of file dl_image_filter_unittests.cc.

                                            {
  DlMatrixImageFilter outer1(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner1(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter1(outer1, inner1);
 
  DlMatrixImageFilter outer2(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner2(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter2(outer1, inner1);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [192/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeNotEquals
	)

Definition at line 517 of file dl_image_filter_unittests.cc.

                                               {
  DlMatrixImageFilter outer1(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner1(5.0, 6.0, DlTileMode::kMirror);
 
  DlMatrixImageFilter outer2(SkMatrix::MakeAll(5.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner2(7.0, 6.0, DlTileMode::kMirror);
 
  DlComposeImageFilter filter1(outer1, inner1);
  DlComposeImageFilter filter2(outer2, inner1);
  DlComposeImageFilter filter3(outer1, inner2);
 
  TestNotEquals(filter1, filter2, "Outer differs");
  TestNotEquals(filter1, filter3, "Inner differs");
}

◆ TEST() [193/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeShared
	)

Definition at line 443 of file dl_image_filter_unittests.cc.

                                            {
  DlMatrixImageFilter outer(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                              0.5, 3.0, 15,  //
                                              0.0, 0.0, 1),
                            DlImageSampling::kLinear);
  DlBlurImageFilter inner(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter(outer, inner);
 
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [194/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ComposeWithLocalMatrixEquals
	)

Definition at line 497 of file dl_image_filter_unittests.cc.

                                                           {
  DlMatrixImageFilter outer1(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner1(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter1(outer1, inner1);
 
  DlMatrixImageFilter outer2(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
  DlBlurImageFilter inner2(5.0, 6.0, DlTileMode::kMirror);
  DlComposeImageFilter filter2(outer1, inner1);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [195/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateAsDilate
	)

Definition at line 240 of file dl_image_filter_unittests.cc.

                                             {
  DlDilateImageFilter filter(5.0, 6.0);
 
  ASSERT_NE(filter.asDilate(), nullptr);
  ASSERT_EQ(filter.asDilate(), &filter);
}

◆ TEST() [196/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateBounds
	)

Definition at line 279 of file dl_image_filter_unittests.cc.

                                           {
  DlDilateImageFilter filter = DlDilateImageFilter(5, 10);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  SkRect expected_output_bounds = input_bounds.makeOutset(5, 10);
  TestBounds(filter, input_bounds, expected_output_bounds);
}

◆ TEST() [197/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateConstructor
	)

Definition at line 229 of file dl_image_filter_unittests.cc.

                                                {
  DlDilateImageFilter filter(5.0, 6.0);
}

◆ TEST() [198/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateContents
	)

Definition at line 247 of file dl_image_filter_unittests.cc.

                                             {
  DlDilateImageFilter filter(5.0, 6.0);
 
  ASSERT_EQ(filter.radius_x(), 5.0);
  ASSERT_EQ(filter.radius_y(), 6.0);
}

◆ TEST() [199/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateEquals
	)

Definition at line 254 of file dl_image_filter_unittests.cc.

                                           {
  DlDilateImageFilter filter1(5.0, 6.0);
  DlDilateImageFilter filter2(5.0, 6.0);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [200/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateNotEquals
	)

Definition at line 270 of file dl_image_filter_unittests.cc.

                                              {
  DlDilateImageFilter filter1(5.0, 6.0);
  DlDilateImageFilter filter2(7.0, 6.0);
  DlDilateImageFilter filter3(5.0, 8.0);
 
  TestNotEquals(filter1, filter2, "Radius X differs");
  TestNotEquals(filter1, filter3, "Radius Y differs");
}

◆ TEST() [201/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateShared
	)

Definition at line 233 of file dl_image_filter_unittests.cc.

                                           {
  DlDilateImageFilter filter(5.0, 6.0);
 
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [202/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		DilateWithLocalMatrixEquals
	)

Definition at line 261 of file dl_image_filter_unittests.cc.

                                                          {
  DlDilateImageFilter filter1(5.0, 6.0);
  DlDilateImageFilter filter2(5.0, 6.0);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [203/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeAsErode
	)

Definition at line 297 of file dl_image_filter_unittests.cc.

                                           {
  DlErodeImageFilter filter(5.0, 6.0);
 
  ASSERT_NE(filter.asErode(), nullptr);
  ASSERT_EQ(filter.asErode(), &filter);
}

◆ TEST() [204/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeBounds
	)

Definition at line 336 of file dl_image_filter_unittests.cc.

                                          {
  DlErodeImageFilter filter = DlErodeImageFilter(5, 10);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  SkRect expected_output_bounds = input_bounds.makeInset(5, 10);
  TestBounds(filter, input_bounds, expected_output_bounds);
}

◆ TEST() [205/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeConstructor
	)

Definition at line 286 of file dl_image_filter_unittests.cc.

                                               {
  DlErodeImageFilter filter(5.0, 6.0);
}

◆ TEST() [206/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeContents
	)

Definition at line 304 of file dl_image_filter_unittests.cc.

                                            {
  DlErodeImageFilter filter(5.0, 6.0);
 
  ASSERT_EQ(filter.radius_x(), 5.0);
  ASSERT_EQ(filter.radius_y(), 6.0);
}

◆ TEST() [207/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeEquals
	)

Definition at line 311 of file dl_image_filter_unittests.cc.

                                          {
  DlErodeImageFilter filter1(5.0, 6.0);
  DlErodeImageFilter filter2(5.0, 6.0);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [208/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeNotEquals
	)

Definition at line 327 of file dl_image_filter_unittests.cc.

                                             {
  DlErodeImageFilter filter1(5.0, 6.0);
  DlErodeImageFilter filter2(7.0, 6.0);
  DlErodeImageFilter filter3(5.0, 8.0);
 
  TestNotEquals(filter1, filter2, "Radius X differs");
  TestNotEquals(filter1, filter3, "Radius Y differs");
}

◆ TEST() [209/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeShared
	)

Definition at line 290 of file dl_image_filter_unittests.cc.

                                          {
  DlErodeImageFilter filter(5.0, 6.0);
 
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [210/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		ErodeWithLocalMatrixEquals
	)

Definition at line 318 of file dl_image_filter_unittests.cc.

                                                         {
  DlErodeImageFilter filter1(5.0, 6.0);
  DlErodeImageFilter filter2(5.0, 6.0);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [211/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		Issue108433
	)

Definition at line 606 of file dl_image_filter_unittests.cc.

                                          {
  auto input_bounds = SkIRect::MakeLTRB(20, 20, 80, 80);
  auto expected_bounds = SkIRect::MakeLTRB(5, 2, 95, 98);
 
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kSrcOver);
  auto dl_outer = DlBlurImageFilter(5.0, 6.0, DlTileMode::kRepeat);
  auto dl_inner = DlColorFilterImageFilter(dl_color_filter.shared());
  auto dl_compose = DlComposeImageFilter(dl_outer, dl_inner);
 
  SkIRect dl_bounds;
  ASSERT_EQ(
      dl_compose.map_device_bounds(input_bounds, SkMatrix::I(), dl_bounds),
      nullptr);
  ASSERT_EQ(dl_bounds, expected_bounds);
}

◆ TEST() [212/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		LocalImageFilterBounds
	)

Definition at line 699 of file dl_image_filter_unittests.cc.

                                                     {
  auto filter_matrix = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                         0.5, 3.0, 15,  //
                                         0.0, 0.0, 1);
  std::vector<sk_sp<SkImageFilter>> sk_filters{
      SkImageFilters::Blur(5.0, 6.0, SkTileMode::kRepeat, nullptr),
      SkImageFilters::ColorFilter(
          SkColorFilters::Blend(SK_ColorRED, SkBlendMode::kSrcOver), nullptr),
      SkImageFilters::Dilate(5.0, 10.0, nullptr),
      SkImageFilters::MatrixTransform(
          filter_matrix, SkSamplingOptions(SkFilterMode::kLinear), nullptr),
      SkImageFilters::Compose(
          SkImageFilters::Blur(5.0, 6.0, SkTileMode::kRepeat, nullptr),
          SkImageFilters::ColorFilter(
              SkColorFilters::Blend(SK_ColorRED, SkBlendMode::kSrcOver),
              nullptr))};
 
  DlBlendColorFilter dl_color_filter(DlColor::kRed(), DlBlendMode::kSrcOver);
  std::vector<std::shared_ptr<DlImageFilter>> dl_filters{
      std::make_shared<DlBlurImageFilter>(5.0, 6.0, DlTileMode::kRepeat),
      std::make_shared<DlColorFilterImageFilter>(dl_color_filter.shared()),
      std::make_shared<DlDilateImageFilter>(5, 10),
      std::make_shared<DlMatrixImageFilter>(filter_matrix,
                                            DlImageSampling::kLinear),
      std::make_shared<DlComposeImageFilter>(
          std::make_shared<DlBlurImageFilter>(5.0, 6.0, DlTileMode::kRepeat),
          std::make_shared<DlColorFilterImageFilter>(
              dl_color_filter.shared()))};
 
  auto persp = SkMatrix::I();
  persp.setPerspY(0.001);
  std::vector<SkMatrix> matrices = {
      SkMatrix::Translate(10.0, 10.0),
      SkMatrix::Scale(2.0, 2.0).preTranslate(10.0, 10.0),
      SkMatrix::RotateDeg(45).preTranslate(5.0, 5.0), persp};
  std::vector<SkMatrix> bounds_matrices{SkMatrix::Translate(5.0, 10.0),
                                        SkMatrix::Scale(2.0, 2.0)};
 
  for (unsigned j = 0; j < matrices.size(); j++) {
    DlLocalMatrixImageFilter filter(matrices[j], nullptr);
    {
      const auto input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
      SkRect output_bounds;
      EXPECT_EQ(filter.map_local_bounds(input_bounds, output_bounds),
                &output_bounds);
      EXPECT_EQ(input_bounds, output_bounds);
    }
    for (unsigned k = 0; k < bounds_matrices.size(); k++) {
      auto& bounds_matrix = bounds_matrices[k];
      {
        const auto input_bounds = SkIRect::MakeLTRB(20, 20, 80, 80);
        SkIRect output_bounds;
        EXPECT_EQ(filter.map_device_bounds(input_bounds, bounds_matrix,
                                           output_bounds),
                  &output_bounds);
        EXPECT_EQ(input_bounds, output_bounds);
      }
      {
        const auto output_bounds = SkIRect::MakeLTRB(20, 20, 80, 80);
        SkIRect input_bounds;
        EXPECT_EQ(filter.get_input_device_bounds(output_bounds, bounds_matrix,
                                                 input_bounds),
                  &input_bounds);
        EXPECT_EQ(input_bounds, output_bounds);
      }
    }
  }
 
  for (unsigned i = 0; i < sk_filters.size(); i++) {
    for (unsigned j = 0; j < matrices.size(); j++) {
      for (unsigned k = 0; k < bounds_matrices.size(); k++) {
        auto desc = "filter " + std::to_string(i + 1)             //
                    + ", filter matrix " + std::to_string(j + 1)  //
                    + ", bounds matrix " + std::to_string(k + 1);
        auto& m = matrices[j];
        auto& bounds_matrix = bounds_matrices[k];
        auto sk_local_filter = sk_filters[i]->makeWithLocalMatrix(m);
        auto dl_local_filter = dl_filters[i]->makeWithLocalMatrix(m);
        if (!sk_local_filter || !dl_local_filter) {
          // Temporarily relax the equivalence testing to allow Skia to expand
          // their behavior. Once the Skia fixes are rolled in, the
          // DlImageFilter should adapt  to the new rules.
          // See https://github.com/flutter/flutter/issues/114723
          ASSERT_TRUE(sk_local_filter || !dl_local_filter) << desc;
          continue;
        }
        {
          auto input_bounds = SkIRect::MakeLTRB(20, 20, 80, 80);
          SkIRect sk_rect, dl_rect;
          sk_rect = sk_local_filter->filterBounds(
              input_bounds, bounds_matrix,
              SkImageFilter::MapDirection::kForward_MapDirection);
          if (dl_local_filter->map_device_bounds(input_bounds, bounds_matrix,
                                                 dl_rect)) {
            ASSERT_EQ(sk_rect, dl_rect) << desc;
          } else {
            ASSERT_TRUE(dl_local_filter->modifies_transparent_black()) << desc;
            ASSERT_FALSE(sk_local_filter->canComputeFastBounds()) << desc;
          }
        }
        {
          // Test for: Know the outset bounds to get the inset bounds
          // Skia have some bounds calculate error of DilateFilter and
          // MatrixFilter
          // Skia issue: https://bugs.chromium.org/p/skia/issues/detail?id=13444
          // flutter issue: https://github.com/flutter/flutter/issues/108693
          if (i == 2 || i == 3) {
            continue;
          }
          auto outset_bounds = SkIRect::MakeLTRB(20, 20, 80, 80);
          SkIRect sk_rect, dl_rect;
          sk_rect = sk_local_filter->filterBounds(
              outset_bounds, bounds_matrix,
              SkImageFilter::MapDirection::kReverse_MapDirection);
          if (dl_local_filter->get_input_device_bounds(
                  outset_bounds, bounds_matrix, dl_rect)) {
            ASSERT_EQ(sk_rect, dl_rect) << desc;
          } else {
            ASSERT_TRUE(dl_local_filter->modifies_transparent_black());
            ASSERT_FALSE(sk_local_filter->canComputeFastBounds());
          }
        }
      }
    }
  }
}

◆ TEST() [213/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		LocalImageSkiaNull
	)

Definition at line 20 of file dl_sk_conversions_unittests.cc.

                                                 {
  auto blur_filter =
      std::make_shared<DlBlurImageFilter>(0, 0, DlTileMode::kClamp);
  DlLocalMatrixImageFilter dl_local_matrix_filter(SkMatrix::RotateDeg(45),
                                                  blur_filter);
  // With sigmas set to zero on the blur filter, Skia will return a null filter.
  // The local matrix filter should return nullptr instead of crashing.
  ASSERT_EQ(ToSk(dl_local_matrix_filter), nullptr);
}

◆ TEST() [214/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixAsMatrix
	)

Definition at line 360 of file dl_image_filter_unittests.cc.

                                             {
  DlMatrixImageFilter filter(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
 
  ASSERT_NE(filter.asMatrix(), nullptr);
  ASSERT_EQ(filter.asMatrix(), &filter);
}

◆ TEST() [215/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixBounds
	)

Definition at line 417 of file dl_image_filter_unittests.cc.

                                           {
  SkMatrix matrix = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                      0.5, 3.0, 7,   //
                                      0.0, 0.0, 1);
  SkMatrix inverse;
  ASSERT_TRUE(matrix.invert(&inverse));
  DlMatrixImageFilter filter(matrix, DlImageSampling::kLinear);
  SkRect input_bounds = SkRect::MakeLTRB(20, 20, 80, 80);
  SkPoint expectedOutputQuad[4] = {
      {50, 77},    // (20,20) => (20*2 + 10, 20/2 + 20*3 + 7) == (50, 77)
      {50, 257},   // (20,80) => (20*2 + 10, 20/2 + 80*3 + 7) == (50, 257)
      {170, 287},  // (80,80) => (80*2 + 10, 80/2 + 80*3 + 7) == (170, 287)
      {170, 107},  // (80,20) => (80*2 + 10, 80/2 + 20*3 + 7) == (170, 107)
  };
  TestBounds(filter, input_bounds, expectedOutputQuad);
}

◆ TEST() [216/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixConstructor
	)

Definition at line 343 of file dl_image_filter_unittests.cc.

                                                {
  DlMatrixImageFilter filter(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
}

◆ TEST() [217/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixContents
	)

Definition at line 370 of file dl_image_filter_unittests.cc.

                                             {
  SkMatrix matrix = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                      0.5, 3.0, 15,  //
                                      0.0, 0.0, 1);
  DlMatrixImageFilter filter(matrix, DlImageSampling::kLinear);
 
  ASSERT_EQ(filter.matrix(), matrix);
  ASSERT_EQ(filter.sampling(), DlImageSampling::kLinear);
}

◆ TEST() [218/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixEquals
	)

Definition at line 380 of file dl_image_filter_unittests.cc.

                                           {
  SkMatrix matrix = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                      0.5, 3.0, 15,  //
                                      0.0, 0.0, 1);
  DlMatrixImageFilter filter1(matrix, DlImageSampling::kLinear);
  DlMatrixImageFilter filter2(matrix, DlImageSampling::kLinear);
 
  TestEquals(filter1, filter2);
}

◆ TEST() [219/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixNotEquals
	)

Definition at line 402 of file dl_image_filter_unittests.cc.

                                              {
  SkMatrix matrix1 = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                       0.5, 3.0, 15,  //
                                       0.0, 0.0, 1);
  SkMatrix matrix2 = SkMatrix::MakeAll(5.0, 0.0, 10,  //
                                       0.5, 3.0, 15,  //
                                       0.0, 0.0, 1);
  DlMatrixImageFilter filter1(matrix1, DlImageSampling::kLinear);
  DlMatrixImageFilter filter2(matrix2, DlImageSampling::kLinear);
  DlMatrixImageFilter filter3(matrix1, DlImageSampling::kNearestNeighbor);
 
  TestNotEquals(filter1, filter2, "Matrix differs");
  TestNotEquals(filter1, filter3, "Sampling differs");
}

◆ TEST() [220/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixShared
	)

Definition at line 350 of file dl_image_filter_unittests.cc.

                                           {
  DlMatrixImageFilter filter(SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                               0.5, 3.0, 15,  //
                                               0.0, 0.0, 1),
                             DlImageSampling::kLinear);
 
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [221/715]

flutter::testing::TEST	(	DisplayListImageFilter	,
		MatrixWithLocalMatrixEquals
	)

Definition at line 390 of file dl_image_filter_unittests.cc.

                                                          {
  SkMatrix matrix = SkMatrix::MakeAll(2.0, 0.0, 10,  //
                                      0.5, 3.0, 15,  //
                                      0.0, 0.0, 1);
  DlMatrixImageFilter filter1(matrix, DlImageSampling::kLinear);
  DlMatrixImageFilter filter2(matrix, DlImageSampling::kLinear);
 
  SkMatrix local_matrix = SkMatrix::Translate(10, 10);
  TestEquals(*filter1.makeWithLocalMatrix(local_matrix),
             *filter2.makeWithLocalMatrix(local_matrix));
}

◆ TEST() [222/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurAsBlur
	)

Definition at line 23 of file dl_mask_filter_unittests.cc.

                                        {
  DlBlurMaskFilter filter(DlBlurStyle::kNormal, 5.0);
  ASSERT_NE(filter.asBlur(), nullptr);
  ASSERT_EQ(filter.asBlur(), &filter);
}

◆ TEST() [223/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurConstructor
	)

Definition at line 13 of file dl_mask_filter_unittests.cc.

                                             {
  DlBlurMaskFilter filter(DlBlurStyle::kNormal, 5.0);
}

◆ TEST() [224/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurContents
	)

Definition at line 29 of file dl_mask_filter_unittests.cc.

                                          {
  DlBlurMaskFilter filter(DlBlurStyle::kNormal, 5.0);
  ASSERT_EQ(filter.style(), DlBlurStyle::kNormal);
  ASSERT_EQ(filter.sigma(), 5.0);
}

◆ TEST() [225/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurEquals
	)

Definition at line 35 of file dl_mask_filter_unittests.cc.

                                        {
  DlBlurMaskFilter filter1(DlBlurStyle::kNormal, 5.0);
  DlBlurMaskFilter filter2(DlBlurStyle::kNormal, 5.0);
  TestEquals(filter1, filter2);
}

◆ TEST() [226/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurNotEquals
	)

Definition at line 41 of file dl_mask_filter_unittests.cc.

                                           {
  DlBlurMaskFilter filter1(DlBlurStyle::kNormal, 5.0);
  DlBlurMaskFilter filter2(DlBlurStyle::kInner, 5.0);
  DlBlurMaskFilter filter3(DlBlurStyle::kNormal, 6.0);
  TestNotEquals(filter1, filter2, "Blur style differs");
  TestNotEquals(filter1, filter3, "blur radius differs");
}

◆ TEST() [227/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		BlurShared
	)

Definition at line 17 of file dl_mask_filter_unittests.cc.

                                        {
  DlBlurMaskFilter filter(DlBlurStyle::kNormal, 5.0);
  ASSERT_NE(filter.shared().get(), &filter);
  ASSERT_EQ(*filter.shared(), filter);
}

◆ TEST() [228/715]

flutter::testing::TEST	(	DisplayListMaskFilter	,
		ComparableTemplates
	)

Definition at line 100 of file dl_mask_filter_unittests.cc.

                                                 {
  DlBlurMaskFilter filter1a(DlBlurStyle::kNormal, 3.0);
  DlBlurMaskFilter filter1b(DlBlurStyle::kNormal, 3.0);
  DlBlurMaskFilter filter2(DlBlurStyle::kNormal, 5.0);
  std::shared_ptr<DlMaskFilter> shared_null;
 
  // null to null
  testEquals(nullptr, nullptr);
  testEquals(shared_null, nullptr);
  testEquals(shared_null, shared_null);
 
  // ptr to null
  testNotEquals(&filter1a, nullptr);
  testNotEquals(&filter1b, nullptr);
  testNotEquals(&filter2, nullptr);
 
  // shared_ptr to null and shared_null to ptr
  testNotEquals(filter1a.shared(), nullptr);
  testNotEquals(filter1b.shared(), nullptr);
  testNotEquals(filter2.shared(), nullptr);
  testNotEquals(shared_null, &filter1a);
  testNotEquals(shared_null, &filter1b);
  testNotEquals(shared_null, &filter2);
 
  // ptr to ptr
  testEquals(&filter1a, &filter1a);
  testEquals(&filter1a, &filter1b);
  testEquals(&filter1b, &filter1b);
  testEquals(&filter2, &filter2);
  testNotEquals(&filter1a, &filter2);
 
  // shared_ptr to ptr
  testEquals(filter1a.shared(), &filter1a);
  testEquals(filter1a.shared(), &filter1b);
  testEquals(filter1b.shared(), &filter1b);
  testEquals(filter2.shared(), &filter2);
  testNotEquals(filter1a.shared(), &filter2);
  testNotEquals(filter1b.shared(), &filter2);
  testNotEquals(filter2.shared(), &filter1a);
  testNotEquals(filter2.shared(), &filter1b);
 
  // shared_ptr to shared_ptr
  testEquals(filter1a.shared(), filter1a.shared());
  testEquals(filter1a.shared(), filter1b.shared());
  testEquals(filter1b.shared(), filter1b.shared());
  testEquals(filter2.shared(), filter2.shared());
  testNotEquals(filter1a.shared(), filter2.shared());
  testNotEquals(filter1b.shared(), filter2.shared());
  testNotEquals(filter2.shared(), filter1a.shared());
  testNotEquals(filter2.shared(), filter1b.shared());
}

◆ TEST() [229/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		ClipDifference
	)

Definition at line 476 of file dl_matrix_clip_tracker_unittests.cc.

                                                 {
  SkRect cull_rect = SkRect::MakeLTRB(20, 20, 40, 40);
 
  auto non_reducing = [&cull_rect](const SkRect& diff_rect,
                                   const std::string& label) {
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      state.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), cull_rect) << label;
    }
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
      state.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), cull_rect) << label << " (RRect)";
    }
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      const SkPath diff_path = SkPath().addRect(diff_rect);
      state.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), cull_rect) << label << " (RRect)";
    }
  };
 
  auto reducing = [&cull_rect](const SkRect& diff_rect,
                               const SkRect& result_rect,
                               const std::string& label) {
    EXPECT_TRUE(result_rect.isEmpty() || cull_rect.contains(result_rect));
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      state.clipRect(diff_rect, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), result_rect) << label;
    }
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      const SkRRect diff_rrect = SkRRect::MakeRect(diff_rect);
      state.clipRRect(diff_rrect, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), result_rect) << label << " (RRect)";
    }
    {
      DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
      const SkPath diff_path = SkPath().addRect(diff_rect);
      state.clipPath(diff_path, DlCanvas::ClipOp::kDifference, false);
      EXPECT_EQ(state.device_cull_rect(), result_rect) << label << " (RRect)";
    }
  };
 
  // Skim the corners and edge
  non_reducing(SkRect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
  non_reducing(SkRect::MakeLTRB(20, 10, 40, 20), "Above");
  non_reducing(SkRect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
  non_reducing(SkRect::MakeLTRB(40, 20, 50, 40), "Right");
  non_reducing(SkRect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
  non_reducing(SkRect::MakeLTRB(20, 40, 40, 50), "Below");
  non_reducing(SkRect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
  non_reducing(SkRect::MakeLTRB(10, 20, 20, 40), "Left");
 
  // Overlap corners
  non_reducing(SkRect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
  non_reducing(SkRect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
  non_reducing(SkRect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
  non_reducing(SkRect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
 
  // Overlap edges, but not across an entire side
  non_reducing(SkRect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
  non_reducing(SkRect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
  non_reducing(SkRect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
  non_reducing(SkRect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
  non_reducing(SkRect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
  non_reducing(SkRect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
  non_reducing(SkRect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
  non_reducing(SkRect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
 
  // Slice all the way through the middle
  non_reducing(SkRect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
  non_reducing(SkRect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
 
  // Slice off each edge
  reducing(SkRect::MakeLTRB(20, 15, 40, 25),  //
           SkRect::MakeLTRB(20, 25, 40, 40),  //
           "Slice off top");
  reducing(SkRect::MakeLTRB(35, 20, 45, 40),  //
           SkRect::MakeLTRB(20, 20, 35, 40),  //
           "Slice off right");
  reducing(SkRect::MakeLTRB(20, 35, 40, 45),  //
           SkRect::MakeLTRB(20, 20, 40, 35),  //
           "Slice off bottom");
  reducing(SkRect::MakeLTRB(15, 20, 25, 40),  //
           SkRect::MakeLTRB(25, 20, 40, 40),  //
           "Slice off left");
 
  // cull rect contains diff rect
  non_reducing(SkRect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
 
  // cull rect equals diff rect
  reducing(cull_rect, SkRect::MakeEmpty(), "Perfectly covering");
 
  // diff rect contains cull rect
  reducing(SkRect::MakeLTRB(15, 15, 45, 45), SkRect::MakeEmpty(), "Smothering");
}

◆ TEST() [230/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		ClipPathWithInvertFillType
	)

Definition at line 577 of file dl_matrix_clip_tracker_unittests.cc.

                                                             {
  SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
  DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  clip.setFillType(SkPathFillType::kInverseWinding);
  state.clipPath(clip, DlCanvas::ClipOp::kIntersect, false);
 
  EXPECT_EQ(state.local_cull_rect(), cull_rect);
  EXPECT_EQ(state.device_cull_rect(), cull_rect);
}

◆ TEST() [231/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Constructor
	)

Definition at line 12 of file dl_matrix_clip_tracker_unittests.cc.

                                              {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
  const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), matrix);
  EXPECT_EQ(state1.matrix_4x4(), m44);
  EXPECT_EQ(state1.matrix(), dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), matrix);
  EXPECT_EQ(state2.matrix_4x4(), m44);
  EXPECT_EQ(state2.matrix(), dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), matrix);
  EXPECT_EQ(state3.matrix_4x4(), m44);
  EXPECT_EQ(state3.matrix(), dl_matrix);
}

◆ TEST() [232/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Constructor4x4
	)

Definition at line 46 of file dl_matrix_clip_tracker_unittests.cc.

                                                 {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  // clang-format off
  const SkM44 m44 = SkM44(4, 0, 0.5, 0,
                          0, 4, 0.5, 0,
                          0, 0, 4.0, 0,
                          0, 0, 0.0, 1);
  const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
                                               0, 4, 0.5, 0,
                                               0, 0, 4.0, 0,
                                               0, 0, 0.0, 1);
  // clang-format on
  const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
 
  DisplayListMatrixClipState state1(cull_rect, m44);
  DisplayListMatrixClipState state2(dl_cull_rect, dl_matrix);
 
  EXPECT_TRUE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_4x4(), m44);
  EXPECT_EQ(state1.matrix(), dl_matrix);
 
  EXPECT_TRUE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_4x4(), m44);
  EXPECT_EQ(state2.matrix(), dl_matrix);
}

◆ TEST() [233/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		DiffClipPathWithInvertFillType
	)

Definition at line 588 of file dl_matrix_clip_tracker_unittests.cc.

                                                                 {
  SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
  DisplayListMatrixClipState state(cull_rect, SkMatrix::I());
 
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  clip.setFillType(SkPathFillType::kInverseWinding);
  SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
  state.clipPath(clip, DlCanvas::ClipOp::kDifference, false);
 
  EXPECT_EQ(state.local_cull_rect(), clip_bounds);
  EXPECT_EQ(state.device_cull_rect(), clip_bounds);
}

◆ TEST() [234/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		MapAndClipRectScale
	)

Definition at line 684 of file dl_matrix_clip_tracker_unittests.cc.

                                                      {
  DlRect cull_rect = DlRect::MakeLTRB(100.0f, 100.0f, 500.0f, 500.0f);
  DlMatrix matrix = DlMatrix::MakeScale({2.0f, 4.0f, 1.0f});
  DisplayListMatrixClipState state(cull_rect, matrix);
 
  {
    // Empty width in src rect (before and after scaling)
    SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 100.0f, 110.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Empty height in src rect (before and after scaling)
    SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 110.0f, 100.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // rect far outside of clip, even after scaling
    SkRect rect = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect abuts clip left side after scaling
    SkRect rect = SkRect::MakeLTRB(40.0f, 100.0f, 50.0f, 110.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip left side after scaling
    SkRect rect = SkRect::MakeLTRB(40.0f, 100.0f, 51.0f, 110.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(100.0f, 400.0f, 102.0f, 440.0f));
  }
 
  {
    // Rect abuts clip top after scaling
    SkRect rect = SkRect::MakeLTRB(100.0f, 15.0f, 110.0f, 25.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip top after scaling
    SkRect rect = SkRect::MakeLTRB(100.0f, 15.0f, 110.0f, 26.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(200.0f, 100.0f, 220.0f, 104.0f));
  }
 
  {
    // Rect abuts clip right side after scaling
    SkRect rect = SkRect::MakeLTRB(250.0f, 100.0f, 260.0f, 110.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip right side after scaling
    SkRect rect = SkRect::MakeLTRB(249.0f, 100.0f, 260.0f, 110.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(498.0f, 400.0f, 500.0f, 440.0f));
  }
 
  {
    // Rect abuts clip bottom after scaling
    SkRect rect = SkRect::MakeLTRB(100.0f, 125.0f, 110.0f, 135.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip bottom after scaling
    SkRect rect = SkRect::MakeLTRB(100.0f, 124.0f, 110.0f, 135.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(200.0f, 496.0f, 220.0f, 500.0f));
  }
}

◆ TEST() [235/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		MapAndClipRectTranslation
	)

Definition at line 601 of file dl_matrix_clip_tracker_unittests.cc.

                                                            {
  DlRect cull_rect = DlRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlMatrix matrix = DlMatrix::MakeTranslation({10.0f, 20.0f, 1.0f});
  DisplayListMatrixClipState state(cull_rect, matrix);
 
  {
    // Empty width in src rect (before and after translation)
    SkRect rect = SkRect::MakeLTRB(150.0f, 150.0f, 150.0f, 160.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Empty height in src rect (before and after translation)
    SkRect rect = SkRect::MakeLTRB(150.0f, 150.0f, 160.0f, 150.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // rect far outside of clip, even after translation
    SkRect rect = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect abuts clip left side after translation
    SkRect rect = SkRect::MakeLTRB(80.0f, 100.0f, 90.0f, 110.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip left side after translation
    SkRect rect = SkRect::MakeLTRB(80.0f, 100.0f, 91.0f, 110.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(100.0f, 120.0f, 101.0f, 130.0f));
  }
 
  {
    // Rect abuts clip top after translation
    SkRect rect = SkRect::MakeLTRB(100.0f, 70.0f, 110.0f, 80.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip top after translation
    SkRect rect = SkRect::MakeLTRB(100.0f, 70.0f, 110.0f, 81.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(110.0f, 100.0f, 120.0f, 101.0f));
  }
 
  {
    // Rect abuts clip right side after translation
    SkRect rect = SkRect::MakeLTRB(190.0f, 100.0f, 200.0f, 110.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip right side after translation
    SkRect rect = SkRect::MakeLTRB(189.0f, 100.0f, 200.0f, 110.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(199.0f, 120.0f, 200.0f, 130.0f));
  }
 
  {
    // Rect abuts clip bottom after translation
    SkRect rect = SkRect::MakeLTRB(100.0f, 180.0f, 110.0f, 190.0f);
    EXPECT_FALSE(state.mapAndClipRect(&rect));
    EXPECT_TRUE(rect.isEmpty());
  }
 
  {
    // Rect barely grazes clip bottom after translation
    SkRect rect = SkRect::MakeLTRB(100.0f, 179.0f, 110.0f, 190.0f);
    EXPECT_TRUE(state.mapAndClipRect(&rect));
    EXPECT_EQ(rect, SkRect::MakeLTRB(110.0f, 199.0f, 120.0f, 200.0f));
  }
}

◆ TEST() [236/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		OvalCoverage
	)

Definition at line 858 of file dl_matrix_clip_tracker_unittests.cc.

                                               {
  DlRect cull = DlRect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  DisplayListMatrixClipState state(cull);
  // The cull rect corners will be at (50, 50) so the oval needs to have
  // a radius large enough to cover that - sqrt(2*50*50) == sqrt(2) * 50
  // We pad by an ever so slight 0.02f to account for round off error and
  // then use larger expansion/contractions of 0.1f to cover/not-cover it.
  DlRect test = cull.Scale(impeller::kSqrt2).Expand(0.02f);
 
  EXPECT_TRUE(state.oval_covers_cull(test));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.1f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.1f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.0f, 0.1f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(-0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, -0.1f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, -0.1f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.0f, -0.1f)));
}

◆ TEST() [237/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		OvalCoverageUnderRotation
	)

Definition at line 901 of file dl_matrix_clip_tracker_unittests.cc.

                                                            {
  DlRect unit = DlRect::MakeLTRB(-1.0f, -1.0f, 1.0f, 1.0f);
  DlRect cull = unit.Scale(50.0f);
  // See above, test bounds need to be sqrt(2) larger for the inscribed
  // oval to contain the cull rect. These tests are simpler than the scaled
  // rectangle coverage tests because this expanded test oval will
  // precisely cover the cull rect at all angles.
  DlRect test = cull.Scale(impeller::kSqrt2);
  DlRect test_true = test.Expand(0.002f);
  DlRect test_false = test.Expand(-0.002f);
 
  for (int i = 0; i <= 360; i++) {
    DisplayListMatrixClipState state(cull);
    state.rotate(i);
    EXPECT_TRUE(state.oval_covers_cull(test_true))
        << "  testing " << test_true << std::endl
        << "    contains " << state.local_cull_rect() << std::endl
        << "    at " << i << " degrees";
    EXPECT_FALSE(state.oval_covers_cull(test_false))
        << "  testing " << test_false << std::endl
        << "    contains " << state.local_cull_rect() << std::endl
        << "    at " << i << " degrees";
  }
}

◆ TEST() [238/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		OvalCoverageUnderScale
	)

Definition at line 878 of file dl_matrix_clip_tracker_unittests.cc.

                                                         {
  DlRect cull = DlRect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  DisplayListMatrixClipState state(cull);
  state.scale(2.0f, 2.0f);
  // The cull rect corners will be at (50, 50) so the oval needs to have
  // a radius large enough to cover that - sqrt(2*50*50) == sqrt(2) * 50
  // We pad by an ever so slight 0.02f to account for round off error and
  // then use larger expansion/contractions of 0.1f to cover/not-cover it.
  // We combine that with an additional scale 0.5f since we are viewing
  // the cull rect under a 2.0 scale.
  DlRect test = cull.Scale(0.5f * impeller::kSqrt2).Expand(0.02f);
 
  EXPECT_TRUE(state.oval_covers_cull(test));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.1f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.1f, 0.0f)));
  EXPECT_TRUE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.0f, 0.1f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(-0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, -0.1f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, -0.1f, 0.0f)));
  EXPECT_FALSE(state.oval_covers_cull(test.Expand(0.0f, 0.0f, 0.0f, -0.1f)));
}

◆ TEST() [239/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		RectCoverage
	)

Definition at line 767 of file dl_matrix_clip_tracker_unittests.cc.

                                               {
  DlRect rect = DlRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DisplayListMatrixClipState state(rect);
 
  EXPECT_TRUE(state.rect_covers_cull(rect));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.1f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.1f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.0f, 0.1f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(-0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, -0.1f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, -0.1f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.0f, -0.1f)));
}

◆ TEST() [240/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		RectCoverageAccuracy
	)

Definition at line 782 of file dl_matrix_clip_tracker_unittests.cc.

                                                       {
  // These particular values create bit errors if we use the path that
  // tests for inclusion in local space, but work OK if we use a forward
  // path that tests for inclusion in device space, due to the fact that
  // the extra matrix inversion is just enough math to cause the transform
  // to place the local space cull corners just outside the original rect.
  // The test in device space only works under a simple scale, such as we
  // use for DPR adjustments (and which are not always inversion friendly).
 
  DlRect cull = DlRect::MakeLTRB(0.0f, 0.0f, 1080.0f, 2400.0f);
  DlScalar DPR = 2.625;
  DlRect rect = DlRect::MakeLTRB(0.0f, 0.0f, 1080.0f / DPR, 2400.0f / DPR);
 
  DisplayListMatrixClipState state(cull);
  state.scale(DPR, DPR);
 
  EXPECT_TRUE(state.rect_covers_cull(rect));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.1f, 0.0f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.1f, 0.0f)));
  EXPECT_TRUE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.0f, 0.1f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(-0.1f, 0.0f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, -0.1f, 0.0f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, -0.1f, 0.0f)));
  EXPECT_FALSE(state.rect_covers_cull(rect.Expand(0.0f, 0.0f, 0.0f, -0.1f)));
}

◆ TEST() [241/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		RectCoverageUnderRotation
	)

Definition at line 826 of file dl_matrix_clip_tracker_unittests.cc.

                                                            {
  DlRect rect = DlRect::MakeLTRB(-1.0f, -1.0f, 1.0f, 1.0f);
  DlRect cull = rect.Scale(impeller::kSqrt2 * 25);
  DlRect test = rect.Scale(50.0f);
  DlRect test_true = test.Expand(0.002f);
  DlRect test_false = test.Expand(-0.002f);
 
  for (int i = 0; i <= 360; i++) {
    DisplayListMatrixClipState state(cull);
    state.rotate(i);
    EXPECT_TRUE(state.rect_covers_cull(test_true))
        << "  testing " << test_true << std::endl
        << "    contains " << state.local_cull_rect() << std::endl
        << "    at " << i << " degrees";
    if ((i % 90) == 45) {
      // The cull rect is largest when viewed at multiples of 45
      // degrees so we will fail to contain it at those angles
      EXPECT_FALSE(state.rect_covers_cull(test_false))
          << "  testing " << test_false << std::endl
          << "    contains " << state.local_cull_rect() << std::endl
          << "    at " << i << " degrees";
    } else {
      // At other angles, the cull rect is not quite so big as to encroach
      // upon the expanded test rectangle.
      EXPECT_TRUE(state.rect_covers_cull(test_false))
          << "  testing " << test_false << std::endl
          << "    contains " << state.local_cull_rect() << std::endl
          << "    at " << i << " degrees";
    }
  }
}

◆ TEST() [242/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		RectCoverageUnderScale
	)

Definition at line 809 of file dl_matrix_clip_tracker_unittests.cc.

                                                         {
  DlRect rect = DlRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DisplayListMatrixClipState state(rect);
  state.scale(2.0f, 2.0f);
 
  EXPECT_FALSE(state.rect_covers_cull(DlRect::MakeLTRB(100, 100, 200, 200)));
  EXPECT_TRUE(state.rect_covers_cull(DlRect::MakeLTRB(50, 50, 100, 100)));
  EXPECT_TRUE(state.rect_covers_cull(DlRect::MakeLTRB(49, 50, 100, 100)));
  EXPECT_TRUE(state.rect_covers_cull(DlRect::MakeLTRB(50, 49, 100, 100)));
  EXPECT_TRUE(state.rect_covers_cull(DlRect::MakeLTRB(50, 50, 101, 100)));
  EXPECT_TRUE(state.rect_covers_cull(DlRect::MakeLTRB(50, 50, 100, 101)));
  EXPECT_FALSE(state.rect_covers_cull(DlRect::MakeLTRB(51, 50, 100, 100)));
  EXPECT_FALSE(state.rect_covers_cull(DlRect::MakeLTRB(50, 51, 100, 100)));
  EXPECT_FALSE(state.rect_covers_cull(DlRect::MakeLTRB(50, 50, 99, 100)));
  EXPECT_FALSE(state.rect_covers_cull(DlRect::MakeLTRB(50, 50, 100, 99)));
}

◆ TEST() [243/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Rotate
	)

Definition at line 273 of file dl_matrix_clip_tracker_unittests.cc.

                                         {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
  const SkMatrix rotated_matrix =
      SkMatrix::Concat(matrix, SkMatrix::RotateDeg(90));
  const SkM44 rotated_m44 = SkM44(rotated_matrix);
  const DlMatrix rotated_dl_matrix =
      dl_matrix * DlMatrix::MakeRotationZ(DlDegrees(90));
  const SkRect local_cull_rect = SkRect::MakeLTRB(10, -15, 20, -5);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.rotate(90);
  state2.rotate(90);
  state3.rotate(90);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), rotated_matrix);
  EXPECT_EQ(state1.matrix_4x4(), rotated_m44);
  EXPECT_EQ(state1.matrix(), rotated_dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), rotated_matrix);
  EXPECT_EQ(state2.matrix_4x4(), rotated_m44);
  EXPECT_EQ(state2.matrix(), rotated_dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), rotated_matrix);
  EXPECT_EQ(state3.matrix_4x4(), rotated_m44);
  EXPECT_EQ(state3.matrix(), rotated_dl_matrix);
}

◆ TEST() [244/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		RRectCoverage
	)

Definition at line 926 of file dl_matrix_clip_tracker_unittests.cc.

                                                {
  SkRect cull = SkRect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  DisplayListMatrixClipState state(cull);
  // test_bounds need to contain
  SkRect test = cull.makeOutset(2.0f, 2.0f);
 
  // RRect of cull with no corners covers
  EXPECT_TRUE(state.rrect_covers_cull(SkRRect::MakeRectXY(cull, 0.0f, 0.0f)));
  // RRect of cull with even the tiniest corners does not cover
  EXPECT_FALSE(
      state.rrect_covers_cull(SkRRect::MakeRectXY(cull, 0.01f, 0.01f)));
 
  // Expanded by 2.0 and then with a corner of 2.0 obviously still covers
  EXPECT_TRUE(state.rrect_covers_cull(SkRRect::MakeRectXY(test, 2.0f, 2.0f)));
  // The corner point of the cull rect is at (c-2, c-2) relative to the
  // corner of the rrect bounds so we compute its disance to the center
  // of the circular part and compare it to the radius of the corner (c)
  // to find the corner radius where it will start to leave the rounded
  // rectangle:
  //
  //     +-----------      +
  //     |    __---^^      |
  //     |  +/-------  +   |
  //     |  / \        |   c
  //     | /|   \     c-2  |
  //     |/ |     \    |   |
  //     || |       *  +   +
  //
  // sqrt(2*(c-2)*(c-2)) > c
  // 2*(c-2)*(c-2) > c*c
  // 2*(cc - 4c + 4) > cc
  // 2cc - 8c + 8 > cc
  // cc - 8c + 8 > 0
  // c > 8 +/- sqrt(64 - 32) / 2
  // c > ~6.828
  // corners set to 6.82 should still cover the cull rect
  EXPECT_TRUE(state.rrect_covers_cull(SkRRect::MakeRectXY(test, 6.82f, 6.82f)));
  // but corners set to 6.83 should not cover the cull rect
  EXPECT_FALSE(
      state.rrect_covers_cull(SkRRect::MakeRectXY(test, 6.84f, 6.84f)));
}

◆ TEST() [245/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Scale
	)

Definition at line 189 of file dl_matrix_clip_tracker_unittests.cc.

                                        {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
  // Scale factor carefully chosen to multiply cleanly and invert
  // without any non-binary-power-of-2 approximation errors.
  const SkMatrix scaled_matrix =
      SkMatrix::Concat(matrix, SkMatrix::Scale(0.5, 2));
  const SkM44 scaled_m44 = SkM44(scaled_matrix);
  const DlMatrix scaled_dl_matrix = dl_matrix.Scale({0.5, 2, 1});
  const SkRect local_cull_rect = SkRect::MakeLTRB(10, 5, 30, 10);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.scale(0.5, 2);
  state2.scale(0.5, 2);
  state3.scale(0.5, 2);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), scaled_matrix);
  EXPECT_EQ(state1.matrix_4x4(), scaled_m44);
  EXPECT_EQ(state1.matrix(), scaled_dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), scaled_matrix);
  EXPECT_EQ(state2.matrix_4x4(), scaled_m44);
  EXPECT_EQ(state2.matrix(), scaled_dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), scaled_matrix);
  EXPECT_EQ(state3.matrix_4x4(), scaled_m44);
  EXPECT_EQ(state3.matrix(), scaled_dl_matrix);
}

◆ TEST() [246/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		SetTo4x4
	)

Definition at line 112 of file dl_matrix_clip_tracker_unittests.cc.

                                           {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  // clang-format off
  const SkM44 m44 = SkM44(4, 0, 0.5, 0,
                          0, 4, 0.5, 0,
                          0, 0, 4.0, 0,
                          0, 0, 0.0, 1);
  const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
                                               0, 4, 0.5, 0,
                                               0, 0, 4.0, 0,
                                               0, 0, 0.0, 1);
  // clang-format on
  const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
 
  DisplayListMatrixClipState state1(cull_rect, SkMatrix::I());
  DisplayListMatrixClipState state2(dl_cull_rect, DlMatrix());
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_FALSE(state2.using_4x4_matrix());
 
  state1.setTransform(m44);
  EXPECT_TRUE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_4x4(), m44);
  EXPECT_EQ(state1.matrix(), dl_matrix);
 
  state2.setTransform(dl_matrix);
  EXPECT_TRUE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_4x4(), m44);
  EXPECT_EQ(state2.matrix(), dl_matrix);
}

◆ TEST() [247/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Skew
	)

Definition at line 232 of file dl_matrix_clip_tracker_unittests.cc.

                                       {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
  const SkMatrix skewed_matrix =
      SkMatrix::Concat(matrix, SkMatrix::Skew(.25, 0));
  const SkM44 skewed_m44 = SkM44(skewed_matrix);
  const DlMatrix skewed_dl_matrix = dl_matrix * DlMatrix::MakeSkew(0.25, 0);
  const SkRect local_cull_rect = SkRect::MakeLTRB(0, 10, 12.5, 20);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.skew(.25, 0);
  state2.skew(.25, 0);
  state3.skew(.25, 0);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), skewed_matrix);
  EXPECT_EQ(state1.matrix_4x4(), skewed_m44);
  EXPECT_EQ(state1.matrix(), skewed_dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), skewed_matrix);
  EXPECT_EQ(state2.matrix_4x4(), skewed_m44);
  EXPECT_EQ(state2.matrix(), skewed_dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), skewed_matrix);
  EXPECT_EQ(state3.matrix_4x4(), skewed_m44);
  EXPECT_EQ(state3.matrix(), skewed_dl_matrix);
}

◆ TEST() [248/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Transform2DAffine
	)

Definition at line 315 of file dl_matrix_clip_tracker_unittests.cc.

                                                    {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
 
  const SkMatrix transformed_matrix =
      SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5,  //
                                                 0, 2, 6,  //
                                                 0, 0, 1));
  const SkM44 transformed_m44 = SkM44(transformed_matrix);
  const DlMatrix transformed_dl_matrix =
      dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5,  //
                                    0, 2, 0, 6,  //
                                    0, 0, 1, 0,  //
                                    0, 0, 0, 1);
  const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.transform2DAffine(2, 0, 5,  //
                           0, 2, 6);
  state2.transform2DAffine(2, 0, 5,  //
                           0, 2, 6);
  state3.transform2DAffine(2, 0, 5,  //
                           0, 2, 6);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
}

◆ TEST() [249/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		TransformFullPerspectiveUsing3x3Matrix
	)

Definition at line 366 of file dl_matrix_clip_tracker_unittests.cc.

                                                                         {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
 
  const SkMatrix transformed_matrix =
      SkMatrix::Concat(matrix, SkMatrix::MakeAll(2, 0, 5,  //
                                                 0, 2, 6,  //
                                                 0, 0, 1));
  const SkM44 transformed_m44 = SkM44(transformed_matrix);
  const DlMatrix transformed_dl_matrix =
      dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5,  //
                                    0, 2, 0, 6,  //
                                    0, 0, 1, 0,  //
                                    0, 0, 0, 1);
  const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 0,  //
                                  0, 0, 0, 1);
  state2.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 0,  //
                                  0, 0, 0, 1);
  state3.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 0,  //
                                  0, 0, 0, 1);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), transformed_matrix);
  EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
}

◆ TEST() [250/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		TransformFullPerspectiveUsing4x4Matrix
	)

Definition at line 423 of file dl_matrix_clip_tracker_unittests.cc.

                                                                         {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4, 4, 1});
 
  const SkM44 transformed_m44 = SkM44(m44, SkM44(2, 0, 0, 5,  //
                                                 0, 2, 0, 6,  //
                                                 0, 0, 1, 7,  //
                                                 0, 0, 0, 1));
  const DlMatrix transformed_dl_matrix =
      dl_matrix * DlMatrix::MakeRow(2, 0, 0, 5,  //
                                    0, 2, 0, 6,  //
                                    0, 0, 1, 7,  //
                                    0, 0, 0, 1);
  const SkRect local_cull_rect = SkRect::MakeLTRB(0, 2, 5, 7);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 7,  //
                                  0, 0, 0, 1);
  state2.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 7,  //
                                  0, 0, 0, 1);
  state3.transformFullPerspective(2, 0, 0, 5,  //
                                  0, 2, 0, 6,  //
                                  0, 0, 1, 7,  //
                                  0, 0, 0, 1);
 
  EXPECT_TRUE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state1.matrix(), transformed_dl_matrix);
 
  EXPECT_TRUE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state2.matrix(), transformed_dl_matrix);
 
  EXPECT_TRUE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_4x4(), transformed_m44);
  EXPECT_EQ(state3.matrix(), transformed_dl_matrix);
}

◆ TEST() [251/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		TransformTo4x4
	)

Definition at line 77 of file dl_matrix_clip_tracker_unittests.cc.

                                                 {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  // clang-format off
  const SkM44 m44 = SkM44(4, 0, 0.5, 0,
                          0, 4, 0.5, 0,
                          0, 0, 4.0, 0,
                          0, 0, 0.0, 1);
  const DlMatrix dl_matrix = DlMatrix::MakeRow(4, 0, 0.5, 0,
                                               0, 4, 0.5, 0,
                                               0, 0, 4.0, 0,
                                               0, 0, 0.0, 1);
  // clang-format on
  const SkRect local_cull_rect = SkRect::MakeLTRB(5, 10, 15, 20);
 
  DisplayListMatrixClipState state1(cull_rect, SkMatrix::I());
  DisplayListMatrixClipState state2(dl_cull_rect, DlMatrix());
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_FALSE(state2.using_4x4_matrix());
 
  state1.transform(m44);
  EXPECT_TRUE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_4x4(), m44);
  EXPECT_EQ(state1.matrix(), dl_matrix);
 
  state2.transform(dl_matrix);
  EXPECT_TRUE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_4x4(), m44);
  EXPECT_EQ(state2.matrix(), dl_matrix);
}

◆ TEST() [252/715]

flutter::testing::TEST	(	DisplayListMatrixClipState	,
		Translate
	)

Definition at line 147 of file dl_matrix_clip_tracker_unittests.cc.

                                            {
  const SkRect cull_rect = SkRect::MakeLTRB(20, 40, 60, 80);
  const DlRect dl_cull_rect = DlRect::MakeLTRB(20, 40, 60, 80);
  const SkMatrix matrix = SkMatrix::Scale(4, 4);
  const SkM44 m44 = SkM44::Scale(4, 4);
  const DlMatrix dl_matrix = DlMatrix::MakeScale({4.0, 4.0, 1.0});
  const SkMatrix translated_matrix =
      SkMatrix::Concat(matrix, SkMatrix::Translate(5, 1));
  const SkM44 translated_m44 = SkM44(translated_matrix);
  const DlMatrix dl_translated_matrix =
      dl_matrix * DlMatrix::MakeTranslation({5.0, 1.0});
  const SkRect local_cull_rect = SkRect::MakeLTRB(0, 9, 10, 19);
 
  DisplayListMatrixClipState state1(cull_rect, matrix);
  DisplayListMatrixClipState state2(cull_rect, m44);
  DisplayListMatrixClipState state3(dl_cull_rect, dl_matrix);
  state1.translate(5, 1);
  state2.translate(5, 1);
  state3.translate(5, 1);
 
  EXPECT_FALSE(state1.using_4x4_matrix());
  EXPECT_EQ(state1.device_cull_rect(), cull_rect);
  EXPECT_EQ(state1.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state1.matrix_3x3(), translated_matrix);
  EXPECT_EQ(state1.matrix_4x4(), translated_m44);
  EXPECT_EQ(state1.matrix(), dl_translated_matrix);
 
  EXPECT_FALSE(state2.using_4x4_matrix());
  EXPECT_EQ(state2.device_cull_rect(), cull_rect);
  EXPECT_EQ(state2.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state2.matrix_3x3(), translated_matrix);
  EXPECT_EQ(state2.matrix_4x4(), translated_m44);
  EXPECT_EQ(state2.matrix(), dl_translated_matrix);
 
  EXPECT_FALSE(state3.using_4x4_matrix());
  EXPECT_EQ(state3.device_cull_rect(), cull_rect);
  EXPECT_EQ(state3.local_cull_rect(), local_cull_rect);
  EXPECT_EQ(state3.matrix_3x3(), translated_matrix);
  EXPECT_EQ(state3.matrix_4x4(), translated_m44);
  EXPECT_EQ(state3.matrix(), dl_translated_matrix);
}

◆ TEST() [253/715]

flutter::testing::TEST	(	DisplayListPaint	,
		ChainingConstructor
	)

Definition at line 95 of file dl_paint_unittests.cc.

                                            {
  DlPaint paint =
      DlPaint()                                                              //
          .setAntiAlias(true)                                                //
          .setInvertColors(true)                                             //
          .setColor(DlColor::kGreen())                                       //
          .setAlpha(0x7F)                                                    //
          .setBlendMode(DlBlendMode::kLuminosity)                            //
          .setDrawStyle(DlDrawStyle::kStrokeAndFill)                         //
          .setStrokeCap(DlStrokeCap::kSquare)                                //
          .setStrokeJoin(DlStrokeJoin::kBevel)                               //
          .setStrokeWidth(42)                                                //
          .setStrokeMiter(1.5)                                               //
          .setColorSource(DlColorColorSource(DlColor::kMagenta()).shared())  //
          .setColorFilter(
              DlBlendColorFilter(DlColor::kYellow(), DlBlendMode::kDstIn)
                  .shared())
          .setImageFilter(
              DlBlurImageFilter(1.3, 4.7, DlTileMode::kClamp).shared())
          .setMaskFilter(DlBlurMaskFilter(DlBlurStyle::kInner, 3.14).shared());
  EXPECT_TRUE(paint.isAntiAlias());
  EXPECT_TRUE(paint.isInvertColors());
  EXPECT_EQ(paint.getColor(), DlColor::kGreen().withAlpha(0x7F));
  EXPECT_EQ(paint.getAlpha(), 0x7F);
  EXPECT_EQ(paint.getBlendMode(), DlBlendMode::kLuminosity);
  EXPECT_EQ(paint.getDrawStyle(), DlDrawStyle::kStrokeAndFill);
  EXPECT_EQ(paint.getStrokeCap(), DlStrokeCap::kSquare);
  EXPECT_EQ(paint.getStrokeJoin(), DlStrokeJoin::kBevel);
  EXPECT_EQ(paint.getStrokeWidth(), 42);
  EXPECT_EQ(paint.getStrokeMiter(), 1.5);
  EXPECT_EQ(*paint.getColorSource(), DlColorColorSource(DlColor::kMagenta()));
  EXPECT_EQ(*paint.getColorFilter(),
            DlBlendColorFilter(DlColor::kYellow(), DlBlendMode::kDstIn));
  EXPECT_EQ(*paint.getImageFilter(),
            DlBlurImageFilter(1.3, 4.7, DlTileMode::kClamp));
  EXPECT_EQ(*paint.getMaskFilter(),
            DlBlurMaskFilter(DlBlurStyle::kInner, 3.14));
 
  EXPECT_NE(paint, DlPaint());
}

◆ TEST() [254/715]

flutter::testing::TEST	(	DisplayListPaint	,
		ConstructorDefaults
	)

Definition at line 13 of file dl_paint_unittests.cc.

                                            {
  DlPaint paint;
  EXPECT_FALSE(paint.isAntiAlias());
  EXPECT_FALSE(paint.isInvertColors());
  EXPECT_EQ(paint.getColor(), DlPaint::kDefaultColor);
  EXPECT_EQ(paint.getAlpha(), 0xFF);
  EXPECT_EQ(paint.getBlendMode(), DlBlendMode::kDefaultMode);
  EXPECT_EQ(paint.getDrawStyle(), DlDrawStyle::kDefaultStyle);
  EXPECT_EQ(paint.getStrokeCap(), DlStrokeCap::kDefaultCap);
  EXPECT_EQ(paint.getStrokeJoin(), DlStrokeJoin::kDefaultJoin);
  EXPECT_EQ(paint.getStrokeWidth(), DlPaint::kDefaultWidth);
  EXPECT_EQ(paint.getStrokeMiter(), DlPaint::kDefaultMiter);
  EXPECT_EQ(paint.getColorSource(), nullptr);
  EXPECT_EQ(paint.getColorFilter(), nullptr);
  EXPECT_EQ(paint.getImageFilter(), nullptr);
  EXPECT_EQ(paint.getMaskFilter(), nullptr);
  EXPECT_TRUE(paint.isDefault());
  EXPECT_EQ(paint, DlPaint::kDefault);
 
  EXPECT_EQ(DlBlendMode::kDefaultMode, DlBlendMode::kSrcOver);
  EXPECT_EQ(DlDrawStyle::kDefaultStyle, DlDrawStyle::kFill);
  EXPECT_EQ(DlStrokeCap::kDefaultCap, DlStrokeCap::kButt);
  EXPECT_EQ(DlStrokeJoin::kDefaultJoin, DlStrokeJoin::kMiter);
 
  EXPECT_EQ(DlPaint::kDefaultColor, DlColor::kBlack());
  EXPECT_EQ(DlPaint::kDefaultWidth, 0.0);
  EXPECT_EQ(DlPaint::kDefaultMiter, 4.0);
 
  EXPECT_EQ(paint, DlPaint());
  EXPECT_EQ(paint, DlPaint(DlColor::kBlack()));
  EXPECT_EQ(paint, DlPaint(DlColor(0xFF000000)));
 
  EXPECT_NE(paint, DlPaint().setAntiAlias(true));
  EXPECT_NE(paint, DlPaint().setInvertColors(true));
  EXPECT_NE(paint, DlPaint().setColor(DlColor::kGreen()));
  EXPECT_NE(paint, DlPaint(DlColor::kGreen()));
  EXPECT_NE(paint, DlPaint(DlColor(0xFF00FF00)));
  EXPECT_NE(paint, DlPaint().setAlpha(0x7f));
  EXPECT_NE(paint, DlPaint().setBlendMode(DlBlendMode::kDstIn));
  EXPECT_NE(paint, DlPaint().setDrawStyle(DlDrawStyle::kStrokeAndFill));
  EXPECT_NE(paint, DlPaint().setStrokeCap(DlStrokeCap::kRound));
  EXPECT_NE(paint, DlPaint().setStrokeJoin(DlStrokeJoin::kRound));
  EXPECT_NE(paint, DlPaint().setStrokeWidth(6));
  EXPECT_NE(paint, DlPaint().setStrokeMiter(7));
 
  DlColorColorSource color_source(DlColor::kMagenta());
  EXPECT_NE(paint, DlPaint().setColorSource(color_source.shared()));
 
  DlBlendColorFilter color_filter(DlColor::kYellow(), DlBlendMode::kDstIn);
  EXPECT_NE(paint, DlPaint().setColorFilter(color_filter.shared()));
 
  DlBlurImageFilter image_filter(1.3, 4.7, DlTileMode::kClamp);
  EXPECT_NE(paint, DlPaint().setImageFilter(image_filter.shared()));
 
  DlBlurMaskFilter mask_filter(DlBlurStyle::kInner, 3.14);
  EXPECT_NE(paint, DlPaint().setMaskFilter(mask_filter.shared()));
}

◆ TEST() [255/715]

flutter::testing::TEST	(	DisplayListPaint	,
		NullPointerSetGet
	)

Definition at line 71 of file dl_paint_unittests.cc.

                                          {
  DlColorSource* null_color_source = nullptr;
  DlColorFilter* null_color_filter = nullptr;
  DlImageFilter* null_image_filter = nullptr;
  DlMaskFilter* null_mask_filter = nullptr;
  DlPaint paint;
  EXPECT_EQ(paint.setColorSource(null_color_source).getColorSource(), nullptr);
  EXPECT_EQ(paint.setColorFilter(null_color_filter).getColorFilter(), nullptr);
  EXPECT_EQ(paint.setImageFilter(null_image_filter).getImageFilter(), nullptr);
  EXPECT_EQ(paint.setMaskFilter(null_mask_filter).getMaskFilter(), nullptr);
}

◆ TEST() [256/715]

flutter::testing::TEST	(	DisplayListPaint	,
		NullSharedPointerSetGet
	)

Definition at line 83 of file dl_paint_unittests.cc.

                                                {
  std::shared_ptr<DlColorSource> null_color_source;
  std::shared_ptr<DlColorFilter> null_color_filter;
  std::shared_ptr<DlImageFilter> null_image_filter;
  std::shared_ptr<DlMaskFilter> null_mask_filter;
  DlPaint paint;
  EXPECT_EQ(paint.setColorSource(null_color_source).getColorSource(), nullptr);
  EXPECT_EQ(paint.setColorFilter(null_color_filter).getColorFilter(), nullptr);
  EXPECT_EQ(paint.setImageFilter(null_image_filter).getImageFilter(), nullptr);
  EXPECT_EQ(paint.setMaskFilter(null_mask_filter).getMaskFilter(), nullptr);
}

◆ TEST() [257/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Deband
	)

Definition at line 128 of file dl_region_unittests.cc.

                                {
  DlRegion region({
      SkIRect::MakeXYWH(0, 0, 50, 50),
      SkIRect::MakeXYWH(60, 0, 20, 20),
      SkIRect::MakeXYWH(90, 0, 50, 50),
  });
 
  auto rects_with_deband = region.getRects(true);
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(60, 0, 20, 20),
      SkIRect::MakeXYWH(0, 0, 50, 50),
      SkIRect::MakeXYWH(90, 0, 50, 50),
  };
  EXPECT_EQ(rects_with_deband, expected);
 
  auto rects_without_deband = region.getRects(false);
  std::vector<SkIRect> expected_without_deband{
      SkIRect::MakeXYWH(0, 0, 50, 20),   //
      SkIRect::MakeXYWH(60, 0, 20, 20),  //
      SkIRect::MakeXYWH(90, 0, 50, 20),  //
      SkIRect::MakeXYWH(0, 20, 50, 30),  //
      SkIRect::MakeXYWH(90, 20, 50, 30),
  };
  EXPECT_EQ(rects_without_deband, expected_without_deband);
}

◆ TEST() [258/715]

flutter::testing::TEST	(	DisplayListRegion	,
		EmptyRegion
	)

Definition at line 15 of file dl_region_unittests.cc.

                                     {
  DlRegion region;
  EXPECT_TRUE(region.isEmpty());
  EXPECT_TRUE(region.getRects().empty());
}

◆ TEST() [259/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Intersection1
	)

Definition at line 197 of file dl_region_unittests.cc.

                                       {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(20, 0, 20, 20),
      SkIRect::MakeXYWH(0, 20, 20, 20),
  });
  DlRegion i = DlRegion::MakeIntersection(region1, region2);
  EXPECT_EQ(i.bounds(), SkIRect::MakeEmpty());
  EXPECT_TRUE(i.isEmpty());
  auto rects = i.getRects();
  EXPECT_TRUE(rects.empty());
}

◆ TEST() [260/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Intersection2
	)

Definition at line 213 of file dl_region_unittests.cc.

                                       {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  });
  DlRegion i = DlRegion::MakeIntersection(region1, region2);
  EXPECT_EQ(i.bounds(), SkIRect::MakeXYWH(0, 0, 40, 40));
  auto rects = i.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [261/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Intersection3
	)

Definition at line 232 of file dl_region_unittests.cc.

                                       {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(-10, -10, 20, 20),
      SkIRect::MakeXYWH(10, 10, 20, 20),
  });
  DlRegion i = DlRegion::MakeIntersection(region1, region2);
  EXPECT_EQ(i.bounds(), SkIRect::MakeXYWH(0, 0, 20, 20));
  auto rects = i.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(0, 0, 10, 10),
      SkIRect::MakeXYWH(10, 10, 10, 10),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [262/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Intersects1
	)

Definition at line 154 of file dl_region_unittests.cc.

                                     {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(20, 0, 20, 20),
      SkIRect::MakeXYWH(0, 20, 20, 20),
  });
  EXPECT_FALSE(region1.intersects(region2));
  EXPECT_FALSE(region2.intersects(region1));
 
  EXPECT_TRUE(region1.intersects(region2.bounds()));
  EXPECT_TRUE(region2.intersects(region1.bounds()));
 
  EXPECT_TRUE(region1.intersects(SkIRect::MakeXYWH(0, 0, 20, 20)));
  EXPECT_FALSE(region1.intersects(SkIRect::MakeXYWH(20, 0, 20, 20)));
 
  EXPECT_TRUE(region1.intersects(
      DlRegion(std::vector<SkIRect>{SkIRect::MakeXYWH(0, 0, 20, 20)})));
  EXPECT_FALSE(region1.intersects(
      DlRegion(std::vector<SkIRect>{SkIRect::MakeXYWH(20, 0, 20, 20)})));
 
  EXPECT_FALSE(region1.intersects(SkIRect::MakeXYWH(-1, -1, 1, 1)));
  EXPECT_TRUE(region1.intersects(SkIRect::MakeXYWH(0, 0, 1, 1)));
 
  EXPECT_FALSE(region1.intersects(SkIRect::MakeXYWH(40, 40, 1, 1)));
  EXPECT_TRUE(region1.intersects(SkIRect::MakeXYWH(39, 39, 1, 1)));
}

◆ TEST() [263/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Intersects2
	)

Definition at line 184 of file dl_region_unittests.cc.

                                     {
  DlRegion region1({
      SkIRect::MakeXYWH(-10, -10, 20, 20),
      SkIRect::MakeXYWH(-30, -30, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(20, 20, 5, 5),
      SkIRect::MakeXYWH(0, 0, 20, 20),
  });
  EXPECT_TRUE(region1.intersects(region2));
  EXPECT_TRUE(region2.intersects(region1));
}

◆ TEST() [264/715]

flutter::testing::TEST	(	DisplayListRegion	,
		MergeTouchingRectangles
	)

Definition at line 89 of file dl_region_unittests.cc.

                                                 {
  DlRegion region({
      SkIRect::MakeXYWH(0, 0, 10, 10),
      SkIRect::MakeXYWH(-10, -10, 10, 10),
      SkIRect::MakeXYWH(10, 10, 10, 10),
      SkIRect::MakeXYWH(-10, 0, 10, 10),
      SkIRect::MakeXYWH(0, 10, 10, 10),
      SkIRect::MakeXYWH(0, -10, 10, 10),
      SkIRect::MakeXYWH(10, 0, 10, 10),
      SkIRect::MakeXYWH(10, -10, 10, 10),
      SkIRect::MakeXYWH(-10, 10, 10, 10),
  });
 
  auto rects = region.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(-10, -10, 30, 30),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [265/715]

flutter::testing::TEST	(	DisplayListRegion	,
		NonOverlappingRectangles1
	)

Definition at line 28 of file dl_region_unittests.cc.

                                                   {
  std::vector<SkIRect> rects_in;
  for (int i = 0; i < 10; ++i) {
    SkIRect rect = SkIRect::MakeXYWH(50 * i, 50 * i, 50, 50);
    rects_in.push_back(rect);
  }
  DlRegion region(rects_in);
  auto rects = region.getRects();
  std::vector<SkIRect> expected{
      {0, 0, 50, 50},       {50, 50, 100, 100},   {100, 100, 150, 150},
      {150, 150, 200, 200}, {200, 200, 250, 250}, {250, 250, 300, 300},
      {300, 300, 350, 350}, {350, 350, 400, 400}, {400, 400, 450, 450},
      {450, 450, 500, 500},
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [266/715]

flutter::testing::TEST	(	DisplayListRegion	,
		NonOverlappingRectangles2
	)

Definition at line 45 of file dl_region_unittests.cc.

                                                   {
  DlRegion region({
      SkIRect::MakeXYWH(5, 5, 10, 10),
      SkIRect::MakeXYWH(25, 5, 10, 10),
      SkIRect::MakeXYWH(5, 25, 10, 10),
      SkIRect::MakeXYWH(25, 25, 10, 10),
  });
  auto rects = region.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(5, 5, 10, 10),
      SkIRect::MakeXYWH(25, 5, 10, 10),
      SkIRect::MakeXYWH(5, 25, 10, 10),
      SkIRect::MakeXYWH(25, 25, 10, 10),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [267/715]

flutter::testing::TEST	(	DisplayListRegion	,
		NonOverlappingRectangles3
	)

Definition at line 62 of file dl_region_unittests.cc.

                                                   {
  DlRegion region({
      SkIRect::MakeXYWH(0, 0, 10, 10),
      SkIRect::MakeXYWH(-11, -11, 10, 10),
      SkIRect::MakeXYWH(11, 11, 10, 10),
      SkIRect::MakeXYWH(-11, 0, 10, 10),
      SkIRect::MakeXYWH(0, 11, 10, 10),
      SkIRect::MakeXYWH(0, -11, 10, 10),
      SkIRect::MakeXYWH(11, 0, 10, 10),
      SkIRect::MakeXYWH(11, -11, 10, 10),
      SkIRect::MakeXYWH(-11, 11, 10, 10),
  });
  auto rects = region.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(-11, -11, 10, 10),  //
      SkIRect::MakeXYWH(0, -11, 10, 10),    //
      SkIRect::MakeXYWH(11, -11, 10, 10),   //
      SkIRect::MakeXYWH(-11, 0, 10, 10),    //
      SkIRect::MakeXYWH(0, 0, 10, 10),      //
      SkIRect::MakeXYWH(11, 0, 10, 10),     //
      SkIRect::MakeXYWH(-11, 11, 10, 10),   //
      SkIRect::MakeXYWH(0, 11, 10, 10),     //
      SkIRect::MakeXYWH(11, 11, 10, 10),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [268/715]

flutter::testing::TEST	(	DisplayListRegion	,
		OverlappingRectangles
	)

Definition at line 109 of file dl_region_unittests.cc.

                                               {
  std::vector<SkIRect> rects_in;
  for (int i = 0; i < 10; ++i) {
    SkIRect rect = SkIRect::MakeXYWH(10 * i, 10 * i, 50, 50);
    rects_in.push_back(rect);
  }
  DlRegion region(rects_in);
  auto rects = region.getRects();
  std::vector<SkIRect> expected{
      {0, 0, 50, 10},      {0, 10, 60, 20},     {0, 20, 70, 30},
      {0, 30, 80, 40},     {0, 40, 90, 50},     {10, 50, 100, 60},
      {20, 60, 110, 70},   {30, 70, 120, 80},   {40, 80, 130, 90},
      {50, 90, 140, 100},  {60, 100, 140, 110}, {70, 110, 140, 120},
      {80, 120, 140, 130}, {90, 130, 140, 140},
  };
 
  EXPECT_EQ(rects, expected);
}

◆ TEST() [269/715]

flutter::testing::TEST	(	DisplayListRegion	,
		SingleRectangle
	)

Definition at line 21 of file dl_region_unittests.cc.

                                         {
  DlRegion region({SkIRect::MakeLTRB(10, 10, 50, 50)});
  auto rects = region.getRects();
  ASSERT_EQ(rects.size(), 1u);
  EXPECT_EQ(rects.front(), SkIRect::MakeLTRB(10, 10, 50, 50));
}

◆ TEST() [270/715]

flutter::testing::TEST	(	DisplayListRegion	,
		TestAgainstSkRegion
	)

Definition at line 361 of file dl_region_unittests.cc.

                                             {
  struct Settings {
    int max_size;
  };
  std::vector<Settings> all_settings{{100}, {400}, {800}};
 
  std::vector<size_t> iterations{1, 10, 100, 1000};
 
  for (const auto& settings : all_settings) {
    for (const auto iterations_1 : iterations) {
      for (const auto iterations_2 : iterations) {
        std::random_device d;
        std::seed_seq seed{::testing::UnitTest::GetInstance()->random_seed()};
        std::mt19937 rng(seed);
 
        SkRegion sk_region1;
        SkRegion sk_region2;
 
        std::uniform_int_distribution pos(0, 4000);
        std::uniform_int_distribution size(1, settings.max_size);
 
        std::vector<SkIRect> rects_in1;
        std::vector<SkIRect> rects_in2;
 
        for (size_t i = 0; i < iterations_1; ++i) {
          SkIRect rect =
              SkIRect::MakeXYWH(pos(rng), pos(rng), size(rng), size(rng));
          rects_in1.push_back(rect);
        }
 
        for (size_t i = 0; i < iterations_2; ++i) {
          SkIRect rect =
              SkIRect::MakeXYWH(pos(rng), pos(rng), size(rng), size(rng));
          rects_in2.push_back(rect);
        }
 
        DlRegion region1(rects_in1);
        sk_region1.setRects(rects_in1.data(), rects_in1.size());
        CheckEquality(region1, sk_region1);
 
        DlRegion region2(rects_in2);
        sk_region2.setRects(rects_in2.data(), rects_in2.size());
        CheckEquality(region2, sk_region2);
 
        auto intersects_1 = region1.intersects(region2);
        auto intersects_2 = region2.intersects(region1);
        auto sk_intesects = sk_region1.intersects(sk_region2);
        EXPECT_EQ(intersects_1, intersects_2);
        EXPECT_EQ(intersects_1, sk_intesects);
 
        {
          auto rects = region2.getRects(true);
          for (const auto& r : rects) {
            EXPECT_EQ(region1.intersects(r), sk_region1.intersects(r));
          }
        }
 
        DlRegion dl_union = DlRegion::MakeUnion(region1, region2);
        SkRegion sk_union(sk_region1);
        sk_union.op(sk_region2, SkRegion::kUnion_Op);
        CheckEquality(dl_union, sk_union);
 
        DlRegion dl_intersection = DlRegion::MakeIntersection(region1, region2);
        SkRegion sk_intersection(sk_region1);
        sk_intersection.op(sk_region2, SkRegion::kIntersect_Op);
        CheckEquality(dl_intersection, sk_intersection);
      }
    }
  }
}

◆ TEST() [271/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Union1
	)

Definition at line 250 of file dl_region_unittests.cc.

                                {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(20, 20, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(20, 0, 20, 20),
      SkIRect::MakeXYWH(0, 20, 20, 20),
  });
  DlRegion u = DlRegion::MakeUnion(region1, region2);
  EXPECT_EQ(u.bounds(), SkIRect::MakeXYWH(0, 0, 40, 40));
  EXPECT_TRUE(u.isSimple());
  auto rects = u.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(0, 0, 40, 40),  //
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [272/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Union2
	)

Definition at line 269 of file dl_region_unittests.cc.

                                {
  DlRegion region1({
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(21, 21, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(21, 0, 20, 20),
      SkIRect::MakeXYWH(0, 21, 20, 20),
  });
  DlRegion u = DlRegion::MakeUnion(region1, region2);
  EXPECT_EQ(u.bounds(), SkIRect::MakeXYWH(0, 0, 41, 41));
  auto rects = u.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(0, 0, 20, 20),
      SkIRect::MakeXYWH(21, 0, 20, 20),
      SkIRect::MakeXYWH(0, 21, 20, 20),
      SkIRect::MakeXYWH(21, 21, 20, 20),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [273/715]

flutter::testing::TEST	(	DisplayListRegion	,
		Union3
	)

Definition at line 290 of file dl_region_unittests.cc.

                                {
  DlRegion region1({
      SkIRect::MakeXYWH(-10, -10, 20, 20),
  });
  DlRegion region2({
      SkIRect::MakeXYWH(0, 0, 20, 20),
  });
  DlRegion u = DlRegion::MakeUnion(region1, region2);
  EXPECT_EQ(u.bounds(), SkIRect::MakeXYWH(-10, -10, 30, 30));
  auto rects = u.getRects();
  std::vector<SkIRect> expected{
      SkIRect::MakeXYWH(-10, -10, 20, 10),
      SkIRect::MakeXYWH(-10, 0, 30, 10),
      SkIRect::MakeXYWH(0, 10, 20, 10),
  };
  EXPECT_EQ(rects, expected);
}

◆ TEST() [274/715]

flutter::testing::TEST	(	DisplayListRegion	,
		UnionEmpty
	)

Definition at line 308 of file dl_region_unittests.cc.

                                    {
  {
    DlRegion region1(std::vector<SkIRect>{});
    DlRegion region2(std::vector<SkIRect>{});
    DlRegion u = DlRegion::MakeUnion(region1, region2);
    EXPECT_EQ(u.bounds(), SkIRect::MakeEmpty());
    EXPECT_TRUE(u.isEmpty());
    auto rects = u.getRects();
    EXPECT_TRUE(rects.empty());
  }
  {
    DlRegion region1(std::vector<SkIRect>{});
    DlRegion region2({
        SkIRect::MakeXYWH(0, 0, 20, 20),
    });
    DlRegion u = DlRegion::MakeUnion(region1, region2);
    EXPECT_EQ(u.bounds(), SkIRect::MakeXYWH(0, 0, 20, 20));
    auto rects = u.getRects();
    std::vector<SkIRect> expected{
        SkIRect::MakeXYWH(0, 0, 20, 20),
    };
  }
  {
    DlRegion region1({
        SkIRect::MakeXYWH(0, 0, 20, 20),
    });
    DlRegion region2(std::vector<SkIRect>{});
    DlRegion u = DlRegion::MakeUnion(region1, region2);
    EXPECT_EQ(u.bounds(), SkIRect::MakeXYWH(0, 0, 20, 20));
    auto rects = u.getRects();
    std::vector<SkIRect> expected{
        SkIRect::MakeXYWH(0, 0, 20, 20),
    };
  }
}

◆ TEST() [275/715]

flutter::testing::TEST	(	DisplayListRTree	,
		Grid
	)

Definition at line 125 of file dl_rtree_unittests.cc.

                             {
  // Non-overlapping 10 x 10 rectangles starting at 5, 5 with
  // 10 pixels between them.
  // Rect 1 goes from  5 to 15
  // Rect 2 goes from 25 to 35
  // etc. in both dimensions
  const int ROWS = 10;
  const int COLS = 10;
  const int N = ROWS * COLS;
  SkRect rects[N];
  int ids[N];
  for (int r = 0; r < ROWS; r++) {
    int y = r * 20 + 5;
    for (int c = 0; c < COLS; c++) {
      int x = c * 20 + 5;
      int i = r * COLS + c;
      rects[i] = SkRect::MakeXYWH(x, y, 10, 10);
      ids[i] = i + 42;
    }
  }
  DlRTree tree(rects, N, ids);
  EXPECT_EQ(tree.leaf_count(), N);
  EXPECT_GE(tree.node_count(), N);
  EXPECT_EQ(tree.id(-1), -1);
  EXPECT_EQ(tree.bounds(-1), SkRect::MakeEmpty());
  EXPECT_EQ(tree.id(N), -1);
  EXPECT_EQ(tree.bounds(N), SkRect::MakeEmpty());
  std::vector<int> results;
  tree.search(SkRect::MakeEmpty(), &results);
  EXPECT_EQ(results.size(), 0u);
  // Testing eqch rect for a single hit
  for (int r = 0; r < ROWS; r++) {
    int y = r * 20 + 5;
    for (int c = 0; c < COLS; c++) {
      int x = c * 20 + 5;
      int i = r * COLS + c;
      auto desc =
          "row " + std::to_string(r + 1) + ", col " + std::to_string(c + 1);
      results.clear();
      auto query = SkRect::MakeXYWH(x + 2, y + 2, 6, 6);
      tree.search(query, &results);
      EXPECT_EQ(results.size(), 1u) << desc;
      EXPECT_EQ(results[0], i) << desc;
      EXPECT_EQ(tree.id(results[0]), ids[i]) << desc;
      EXPECT_EQ(tree.bounds(results[0]), rects[i]) << desc;
      auto list = tree.searchAndConsolidateRects(query);
      EXPECT_EQ(list.size(), 1u);
      EXPECT_EQ(list.front(), rects[i]);
    }
  }
  // Testing inside each gap for no hits
  for (int r = 1; r < ROWS; r++) {
    int y = r * 20 + 5;
    for (int c = 1; c < COLS; c++) {
      int x = c * 20 + 5;
      auto desc =
          "row " + std::to_string(r + 1) + ", col " + std::to_string(c + 1);
      results.clear();
      auto query = SkRect::MakeXYWH(x - 8, y - 8, 6, 6);
      tree.search(query, &results);
      EXPECT_EQ(results.size(), 0u) << desc;
      auto list = tree.searchAndConsolidateRects(query);
      EXPECT_EQ(list.size(), 0u) << desc;
    }
  }
  // Spanning each gap for a quad of hits
  for (int r = 1; r < ROWS; r++) {
    int y = r * 20 + 5;
    for (int c = 1; c < COLS; c++) {
      int x = c * 20 + 5;
      // We will hit this rect and the ones above/left of us
      int i = r * COLS + c;
      auto desc =
          "row " + std::to_string(r + 1) + ", col " + std::to_string(c + 1);
      results.clear();
      auto query = SkRect::MakeXYWH(x - 11, y - 11, 12, 12);
      tree.search(query, &results);
      EXPECT_EQ(results.size(), 4u) << desc;
 
      // First rect is above and to the left
      EXPECT_EQ(results[0], i - COLS - 1) << desc;
      EXPECT_EQ(tree.id(results[0]), ids[i - COLS - 1]) << desc;
      EXPECT_EQ(tree.bounds(results[0]), rects[i - COLS - 1]) << desc;
 
      // Second rect is above
      EXPECT_EQ(results[1], i - COLS) << desc;
      EXPECT_EQ(tree.id(results[1]), ids[i - COLS]) << desc;
      EXPECT_EQ(tree.bounds(results[1]), rects[i - COLS]) << desc;
 
      // Third rect is left
      EXPECT_EQ(results[2], i - 1) << desc;
      EXPECT_EQ(tree.id(results[2]), ids[i - 1]) << desc;
      EXPECT_EQ(tree.bounds(results[2]), rects[i - 1]) << desc;
 
      // Fourth rect is us
      EXPECT_EQ(results[3], i) << desc;
      EXPECT_EQ(tree.id(results[3]), ids[i]) << desc;
      EXPECT_EQ(tree.bounds(results[3]), rects[i]) << desc;
 
      auto list = tree.searchAndConsolidateRects(query);
      EXPECT_EQ(list.size(), 4u);
      list.remove(rects[i - COLS - 1]);
      list.remove(rects[i - COLS]);
      list.remove(rects[i - 1]);
      list.remove(rects[i]);
      EXPECT_EQ(list.size(), 0u);
    }
  }
}

◆ TEST() [276/715]

flutter::testing::TEST	(	DisplayListRTree	,
		HugeSize
	)

Definition at line 92 of file dl_rtree_unittests.cc.

                                 {
  // A diagonal of non-overlapping 10x10 rectangles spaced 20
  // pixels apart.
  // Rect 1 goes from  0 to 10
  // Rect 2 goes from 20 to 30
  // etc. in both dimensions
  const int N = 10000;
  SkRect rects[N];
  int ids[N];
  for (int i = 0; i < N; i++) {
    rects[i].setXYWH(i * 20, i * 20, 10, 10);
    ids[i] = i + 42;
  }
  DlRTree tree(rects, N, ids);
  EXPECT_EQ(tree.leaf_count(), N);
  EXPECT_GE(tree.node_count(), N);
  EXPECT_EQ(tree.id(-1), -1);
  EXPECT_EQ(tree.bounds(-1), SkRect::MakeEmpty());
  EXPECT_EQ(tree.id(N), -1);
  EXPECT_EQ(tree.bounds(N), SkRect::MakeEmpty());
  std::vector<int> results;
  tree.search(SkRect::MakeEmpty(), &results);
  EXPECT_EQ(results.size(), 0u);
  for (int i = 0; i < N; i++) {
    results.clear();
    tree.search(SkRect::MakeXYWH(i * 20 + 2, i * 20 + 2, 6, 6), &results);
    EXPECT_EQ(results.size(), 1u);
    EXPECT_EQ(results[0], i);
    EXPECT_EQ(tree.id(results[0]), ids[i]);
    EXPECT_EQ(tree.bounds(results[0]), rects[i]);
  }
}

◆ TEST() [277/715]

flutter::testing::TEST	(	DisplayListRTree	,
		ManySizes
	)

Definition at line 41 of file dl_rtree_unittests.cc.

                                  {
  // A diagonal of non-overlapping 10x10 rectangles spaced 20
  // pixels apart.
  // Rect 1 goes from  0 to 10
  // Rect 2 goes from 20 to 30
  // etc. in both dimensions
  const int kMaxN = 250;
  SkRect rects[kMaxN + 1];
  int ids[kMaxN + 1];
  for (int i = 0; i <= kMaxN; i++) {
    rects[i].setXYWH(i * 20, i * 20, 10, 10);
    ids[i] = i + 42;
  }
  std::vector<int> results;
  for (int N = 0; N <= kMaxN; N++) {
    DlRTree tree(rects, N, ids);
    auto desc = "node count = " + std::to_string(N);
    EXPECT_EQ(tree.leaf_count(), N) << desc;
    EXPECT_GE(tree.node_count(), N) << desc;
    EXPECT_EQ(tree.id(-1), -1) << desc;
    EXPECT_EQ(tree.bounds(-1), SkRect::MakeEmpty()) << desc;
    EXPECT_EQ(tree.id(N), -1) << desc;
    EXPECT_EQ(tree.bounds(N), SkRect::MakeEmpty()) << desc;
    results.clear();
    tree.search(SkRect::MakeEmpty(), &results);
    EXPECT_EQ(results.size(), 0u) << desc;
    results.clear();
    tree.search(SkRect::MakeLTRB(2, 2, 8, 8), &results);
    if (N == 0) {
      EXPECT_EQ(results.size(), 0u) << desc;
    } else {
      EXPECT_EQ(results.size(), 1u) << desc;
      EXPECT_EQ(results[0], 0) << desc;
      EXPECT_EQ(tree.id(results[0]), ids[0]) << desc;
      EXPECT_EQ(tree.bounds(results[0]), rects[0]) << desc;
      for (int i = 1; i < N; i++) {
        results.clear();
        auto query = SkRect::MakeXYWH(i * 20 + 2, i * 20 + 2, 6, 6);
        tree.search(query, &results);
        EXPECT_EQ(results.size(), 1u) << desc;
        EXPECT_EQ(results[0], i) << desc;
        EXPECT_EQ(tree.id(results[0]), ids[i]) << desc;
        EXPECT_EQ(tree.bounds(results[0]), rects[i]) << desc;
        auto list = tree.searchAndConsolidateRects(query);
        EXPECT_EQ(list.size(), 1u);
        EXPECT_EQ(list.front(), rects[i]);
      }
    }
  }
}

◆ TEST() [278/715]

flutter::testing::TEST	(	DisplayListRTree	,
		NegativeCount
	)

Definition at line 18 of file dl_rtree_unittests.cc.

                                      {
  EXPECT_DEATH_IF_SUPPORTED(new DlRTree(nullptr, -1), "N >= 0");
}

◆ TEST() [279/715]

flutter::testing::TEST	(	DisplayListRTree	,
		NullRectListNonZeroCount
	)

Definition at line 14 of file dl_rtree_unittests.cc.

                                                 {
  EXPECT_DEATH_IF_SUPPORTED(new DlRTree(nullptr, 1), "rects != nullptr");
}

◆ TEST() [280/715]

flutter::testing::TEST	(	DisplayListRTree	,
		NullRectListZeroCount
	)

Definition at line 29 of file dl_rtree_unittests.cc.

                                              {
  DlRTree tree(nullptr, 0);
  EXPECT_EQ(tree.leaf_count(), 0);
  EXPECT_EQ(tree.node_count(), 0);
  std::vector<int> results;
  auto huge = SkRect::MakeLTRB(-1e6, -1e6, 1e6, 1e6);
  tree.search(huge, &results);
  EXPECT_EQ(results.size(), 0u);
  auto list = tree.searchAndConsolidateRects(huge);
  EXPECT_EQ(list.size(), 0u);
}

◆ TEST() [281/715]

flutter::testing::TEST	(	DisplayListRTree	,
		NullSearchResultVector
	)

Definition at line 22 of file dl_rtree_unittests.cc.

                                               {
  DlRTree tree(nullptr, 0);
  EXPECT_DEATH_IF_SUPPORTED(tree.search(SkRect::MakeLTRB(0, 0, 1, 1), nullptr),
                            "results != nullptr");
}

◆ TEST() [282/715]

flutter::testing::TEST	(	DisplayListRTree	,
		OverlappingRects
	)

Definition at line 235 of file dl_rtree_unittests.cc.

                                         {
  // Rectangles are centered at coordinates 15, 35, and 55 and are 15 wide
  // This gives them 10 pixels of overlap with the rectangles on either
  // side of them and the 10 pixels around their center coordinate are
  // exclusive to themselves.
  // So, horizontally and vertically, they cover the following ranges:
  // First  row/col:  0 to 30
  // Second row/col: 20 to 50
  // Third  row/col: 40 to 70
  // Coords  0 to 20 are only the first row/col
  // Coords 20 to 30 are both first and second row/col
  // Coords 30 to 40 are only the second row/col
  // Coords 40 to 50 are both second and third row/col
  // Coords 50 to 70 are only the third row/col
  //
  // In either dimension:
  // 0------------------20--------30--------40--------50------------------70
  // |         rect1               |
  //                     |  1 & 2  |
  //                     |            rect2            |
  //                                         |  2 & 3  |
  //                                         |                rect3        |
  SkRect rects[9];
  for (int r = 0; r < 3; r++) {
    int y = 15 + 20 * r;
    for (int c = 0; c < 3; c++) {
      int x = 15 + 20 * c;
      rects[r * 3 + c].setLTRB(x - 15, y - 15, x + 15, y + 15);
    }
  }
  DlRTree tree(rects, 9);
  // Tiny rects only intersecting a single source rect
  for (int r = 0; r < 3; r++) {
    int y = 15 + 20 * r;
    for (int c = 0; c < 3; c++) {
      int x = 15 + 20 * c;
      auto query = SkRect::MakeLTRB(x - 1, y - 1, x + 1, y + 1);
      auto list = tree.searchAndConsolidateRects(query);
      EXPECT_EQ(list.size(), 1u);
      EXPECT_EQ(list.front(), rects[r * 3 + c]);
    }
  }
  // Wide rects intersecting 3 source rects horizontally
  for (int r = 0; r < 3; r++) {
    int c = 1;
    int y = 15 + 20 * r;
    int x = 15 + 20 * c;
    auto query = SkRect::MakeLTRB(x - 6, y - 1, x + 6, y + 1);
    auto list = tree.searchAndConsolidateRects(query);
    EXPECT_EQ(list.size(), 1u);
    EXPECT_EQ(list.front(), SkRect::MakeLTRB(x - 35, y - 15, x + 35, y + 15));
  }
  // Tall rects intersecting 3 source rects vertically
  for (int c = 0; c < 3; c++) {
    int r = 1;
    int x = 15 + 20 * c;
    int y = 15 + 20 * r;
    auto query = SkRect::MakeLTRB(x - 1, y - 6, x + 1, y + 6);
    auto list = tree.searchAndConsolidateRects(query);
    EXPECT_EQ(list.size(), 1u);
    EXPECT_EQ(list.front(), SkRect::MakeLTRB(x - 15, y - 35, x + 15, y + 35));
  }
  // Finally intersecting all 9 rects
  auto query = SkRect::MakeLTRB(35 - 6, 35 - 6, 35 + 6, 35 + 6);
  auto list = tree.searchAndConsolidateRects(query);
  EXPECT_EQ(list.size(), 1u);
  EXPECT_EQ(list.front(), SkRect::MakeLTRB(0, 0, 70, 70));
}

◆ TEST() [283/715]

flutter::testing::TEST	(	DisplayListRTree	,
		Region
	)

Definition at line 304 of file dl_rtree_unittests.cc.

                               {
  SkRect rect[9];
  for (int i = 0; i < 9; i++) {
    rect[i] = SkRect::MakeXYWH(i * 10, i * 10, 20, 20);
  }
  DlRTree rtree(rect, 9);
  const auto& region = rtree.region();
  auto rects = region.getRects(true);
  std::vector<SkIRect> expected_rects{
      SkIRect::MakeLTRB(0, 0, 20, 10),    SkIRect::MakeLTRB(0, 10, 30, 20),
      SkIRect::MakeLTRB(10, 20, 40, 30),  SkIRect::MakeLTRB(20, 30, 50, 40),
      SkIRect::MakeLTRB(30, 40, 60, 50),  SkIRect::MakeLTRB(40, 50, 70, 60),
      SkIRect::MakeLTRB(50, 60, 80, 70),  SkIRect::MakeLTRB(60, 70, 90, 80),
      SkIRect::MakeLTRB(70, 80, 100, 90), SkIRect::MakeLTRB(80, 90, 100, 100),
  };
  EXPECT_EQ(rects.size(), expected_rects.size());
}

◆ TEST() [284/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		BlendColorFilterModifiesTransparency
	)

Definition at line 152 of file dl_sk_conversions_unittests.cc.

                                                                     {
  auto test_mode_color = [](DlBlendMode mode, DlColor color) {
    std::stringstream desc_str;
    desc_str << "blend[" << static_cast<int>(mode) << ", " << color.argb()
             << "]";
    std::string desc = desc_str.str();
    DlBlendColorFilter filter(color, mode);
    auto srgb = SkColorSpace::MakeSRGB();
    if (filter.modifies_transparent_black()) {
      auto dl_filter = DlBlendColorFilter::Make(color, mode);
      auto sk_filter = ToSk(filter);
      ASSERT_NE(dl_filter, nullptr) << desc;
      ASSERT_NE(sk_filter, nullptr) << desc;
      ASSERT_TRUE(sk_filter->filterColor4f(SkColors::kTransparent, srgb.get(),
                                           srgb.get()) !=
                  SkColors::kTransparent)
          << desc;
    } else {
      auto dl_filter = DlBlendColorFilter::Make(color, mode);
      auto sk_filter = ToSk(filter);
      EXPECT_EQ(dl_filter == nullptr, sk_filter == nullptr) << desc;
      ASSERT_TRUE(sk_filter == nullptr ||
                  sk_filter->filterColor4f(SkColors::kTransparent, srgb.get(),
                                           srgb.get()) ==
                      SkColors::kTransparent)
          << desc;
    }
  };
 
  auto test_mode = [&test_mode_color](DlBlendMode mode) {
    test_mode_color(mode, DlColor::kTransparent());
    test_mode_color(mode, DlColor::kWhite());
    test_mode_color(mode, DlColor::kWhite().modulateOpacity(0.5));
    test_mode_color(mode, DlColor::kBlack());
    test_mode_color(mode, DlColor::kBlack().modulateOpacity(0.5));
  };
 
#define TEST_MODE(V) test_mode(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST() [285/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ConvertWithZeroAndNegativeVerticesAndIndices
	)

Definition at line 196 of file dl_sk_conversions_unittests.cc.

                                                                             {
  std::shared_ptr<const DlVertices> vertices1 = DlVertices::Make(
      DlVertexMode::kTriangles, 0, nullptr, nullptr, nullptr, 0, nullptr);
  EXPECT_NE(vertices1, nullptr);
  EXPECT_NE(ToSk(vertices1), nullptr);
 
  std::shared_ptr<const DlVertices> vertices2 = DlVertices::Make(
      DlVertexMode::kTriangles, -1, nullptr, nullptr, nullptr, -1, nullptr);
  EXPECT_NE(vertices2, nullptr);
  EXPECT_NE(ToSk(vertices2), nullptr);
}

◆ TEST() [286/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		MatrixColorFilterModifiesTransparency
	)

Definition at line 261 of file dl_sk_conversions_unittests.cc.

                                                                      {
  auto test_matrix = [](int element, SkScalar value) {
    // clang-format off
    float matrix[] = {
        1, 0, 0, 0, 0,
        0, 1, 0, 0, 0,
        0, 0, 1, 0, 0,
        0, 0, 0, 1, 0,
    };
    // clang-format on
    std::string desc =
        "matrix[" + std::to_string(element) + "] = " + std::to_string(value);
    matrix[element] = value;
    DlMatrixColorFilter filter(matrix);
    auto dl_filter = DlMatrixColorFilter::Make(matrix);
    auto sk_filter = ToSk(filter);
    auto srgb = SkColorSpace::MakeSRGB();
    EXPECT_EQ(dl_filter == nullptr, sk_filter == nullptr);
    EXPECT_EQ(filter.modifies_transparent_black(),
              sk_filter && sk_filter->filterColor4f(SkColors::kTransparent,
                                                    srgb.get(), srgb.get()) !=
                               SkColors::kTransparent);
  };
 
  // Tests identity (matrix[0] already == 1 in an identity filter)
  test_matrix(0, 1);
  // test_matrix(19, 1);
  for (int i = 0; i < 20; i++) {
    test_matrix(i, -0.25);
    test_matrix(i, 0);
    test_matrix(i, 0.25);
    test_matrix(i, 1);
    test_matrix(i, 1.25);
    test_matrix(i, SK_ScalarNaN);
    test_matrix(i, SK_ScalarInfinity);
    test_matrix(i, -SK_ScalarInfinity);
  }
}

◆ TEST() [287/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkBlendMode
	)

Definition at line 146 of file dl_sk_conversions_unittests.cc.

                                             {
#define CHECK_TO_SKENUM(V) ASSERT_EQ(ToSk(DlBlendMode::V), SkBlendMode::V);
    FOR_EACH_BLEND_MODE_ENUM(CHECK_TO_SKENUM)
#undef CHECK_TO_SKENUM
}

◆ TEST() [288/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkBlurStyle
	)

Definition at line 52 of file dl_sk_conversions_unittests.cc.

                                              {
  ASSERT_EQ(ToSk(DlBlurStyle::kInner), SkBlurStyle::kInner_SkBlurStyle);
  ASSERT_EQ(ToSk(DlBlurStyle::kOuter), SkBlurStyle::kOuter_SkBlurStyle);
  ASSERT_EQ(ToSk(DlBlurStyle::kSolid), SkBlurStyle::kSolid_SkBlurStyle);
  ASSERT_EQ(ToSk(DlBlurStyle::kNormal), SkBlurStyle::kNormal_SkBlurStyle);
}

◆ TEST() [289/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkColor
	)

Definition at line 30 of file dl_sk_conversions_unittests.cc.

                                          {
  // Red
  ASSERT_EQ(ToSk(DlColor::kRed()), SK_ColorRED);
 
  // Green
  ASSERT_EQ(ToSk(DlColor::kGreen()), SK_ColorGREEN);
 
  // Blue
  ASSERT_EQ(ToSk(DlColor::kBlue()), SK_ColorBLUE);
 
  // Half transparent grey
  auto const grey_hex_half_opaque = 0x7F999999;
  ASSERT_EQ(ToSk(DlColor(grey_hex_half_opaque)), SkColor(grey_hex_half_opaque));
}

◆ TEST() [290/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkDitheringEnabledForGradients
	)

Definition at line 300 of file dl_sk_conversions_unittests.cc.

                                                                 {
  // Test that when using the utility method "ToSk", the resulting SkPaint
  // has "isDither" set to true, if the paint is a gradient, because it's
  // a supported feature in the Impeller backend.
 
  DlPaint dl_paint;
 
  // Set the paint to be a gradient.
  dl_paint.setColorSource(DlColorSource::MakeLinear(SkPoint::Make(0, 0),
                                                    SkPoint::Make(100, 100), 0,
                                                    0, 0, DlTileMode::kClamp));
 
  {
    SkPaint sk_paint = ToSk(dl_paint);
    EXPECT_TRUE(sk_paint.isDither());
  }
 
  {
    SkPaint sk_paint = ToStrokedSk(dl_paint);
    EXPECT_TRUE(sk_paint.isDither());
  }
 
  {
    SkPaint sk_paint = ToNonShaderSk(dl_paint);
    EXPECT_FALSE(sk_paint.isDither());
  }
}

◆ TEST() [291/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkDrawStyle
	)

Definition at line 59 of file dl_sk_conversions_unittests.cc.

                                              {
  ASSERT_EQ(ToSk(DlDrawStyle::kFill), SkPaint::Style::kFill_Style);
  ASSERT_EQ(ToSk(DlDrawStyle::kStroke), SkPaint::Style::kStroke_Style);
  ASSERT_EQ(ToSk(DlDrawStyle::kStrokeAndFill),
            SkPaint::Style::kStrokeAndFill_Style);
}

◆ TEST() [292/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkFilterMode
	)

Definition at line 87 of file dl_sk_conversions_unittests.cc.

                                               {
  ASSERT_EQ(ToSk(DlFilterMode::kLinear), SkFilterMode::kLinear);
  ASSERT_EQ(ToSk(DlFilterMode::kNearest), SkFilterMode::kNearest);
  ASSERT_EQ(ToSk(DlFilterMode::kLast), SkFilterMode::kLast);
}

◆ TEST() [293/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkSamplingOptions
	)

Definition at line 100 of file dl_sk_conversions_unittests.cc.

                                                    {
  ASSERT_EQ(ToSk(DlImageSampling::kLinear),
            SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone));
  ASSERT_EQ(ToSk(DlImageSampling::kMipmapLinear),
            SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kLinear));
  ASSERT_EQ(ToSk(DlImageSampling::kNearestNeighbor),
            SkSamplingOptions(SkFilterMode::kNearest, SkMipmapMode::kNone));
  ASSERT_EQ(ToSk(DlImageSampling::kCubic),
            SkSamplingOptions(SkCubicResampler{1 / 3.0f, 1 / 3.0f}));
}

◆ TEST() [294/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkSrcRectConstraint
	)

Definition at line 93 of file dl_sk_conversions_unittests.cc.

                                                      {
  ASSERT_EQ(ToSk(DlCanvas::SrcRectConstraint::kFast),
            SkCanvas::SrcRectConstraint::kFast_SrcRectConstraint);
  ASSERT_EQ(ToSk(DlCanvas::SrcRectConstraint::kStrict),
            SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint);
}

◆ TEST() [295/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkStrokeCap
	)

Definition at line 66 of file dl_sk_conversions_unittests.cc.

                                              {
  ASSERT_EQ(ToSk(DlStrokeCap::kButt), SkPaint::Cap::kButt_Cap);
  ASSERT_EQ(ToSk(DlStrokeCap::kRound), SkPaint::Cap::kRound_Cap);
  ASSERT_EQ(ToSk(DlStrokeCap::kSquare), SkPaint::Cap::kSquare_Cap);
}

◆ TEST() [296/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkStrokeJoin
	)

Definition at line 72 of file dl_sk_conversions_unittests.cc.

                                               {
  ASSERT_EQ(ToSk(DlStrokeJoin::kMiter), SkPaint::Join::kMiter_Join);
  ASSERT_EQ(ToSk(DlStrokeJoin::kRound), SkPaint::Join::kRound_Join);
  ASSERT_EQ(ToSk(DlStrokeJoin::kBevel), SkPaint::Join::kBevel_Join);
}

◆ TEST() [297/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkTileMode
	)

Definition at line 45 of file dl_sk_conversions_unittests.cc.

                                             {
  ASSERT_EQ(ToSk(DlTileMode::kClamp), SkTileMode::kClamp);
  ASSERT_EQ(ToSk(DlTileMode::kRepeat), SkTileMode::kRepeat);
  ASSERT_EQ(ToSk(DlTileMode::kMirror), SkTileMode::kMirror);
  ASSERT_EQ(ToSk(DlTileMode::kDecal), SkTileMode::kDecal);
}

◆ TEST() [298/715]

flutter::testing::TEST	(	DisplayListSkConversions	,
		ToSkVertexMode
	)

Definition at line 78 of file dl_sk_conversions_unittests.cc.

                                               {
  ASSERT_EQ(ToSk(DlVertexMode::kTriangles),
            SkVertices::VertexMode::kTriangles_VertexMode);
  ASSERT_EQ(ToSk(DlVertexMode::kTriangleStrip),
            SkVertices::VertexMode::kTriangleStrip_VertexMode);
  ASSERT_EQ(ToSk(DlVertexMode::kTriangleFan),
            SkVertices::VertexMode::kTriangleFan_VertexMode);
}

◆ TEST() [299/715]

flutter::testing::TEST	(	DisplayListUtils	,
		OverRestore
	)

Definition at line 40 of file dl_sk_paint_dispatcher_unittests.cc.

                                    {
  MockDispatchHelper helper;
  helper.save();
  helper.restore();
  // There should be a protection here for over-restore to keep the program from
  // crashing.
  helper.restore();
}

◆ TEST() [300/715]

flutter::testing::TEST	(	DisplayListUtils	,
		SetColorSourceDithersIfGradient
	)

Definition at line 50 of file dl_sk_paint_dispatcher_unittests.cc.

                                                        {
  MockDispatchHelper helper;
 
  helper.setColorSource(kTestLinearGradient.get());
  EXPECT_TRUE(helper.paint(true).isDither());
  EXPECT_FALSE(helper.paint(false).isDither());
}

◆ TEST() [301/715]

flutter::testing::TEST	(	DisplayListUtils	,
		SetColorSourceDoesNotDitherIfNotGradient
	)

Definition at line 59 of file dl_sk_paint_dispatcher_unittests.cc.

                                                                 {
  MockDispatchHelper helper;
 
  helper.setColorSource(kTestLinearGradient.get());
  helper.setColorSource(nullptr);
  EXPECT_FALSE(helper.paint(true).isDither());
  EXPECT_FALSE(helper.paint(false).isDither());
 
  DlColorColorSource color_color_source(DlColor::kBlue());
  helper.setColorSource(&color_color_source);
  EXPECT_FALSE(helper.paint(true).isDither());
  EXPECT_FALSE(helper.paint(false).isDither());
 
  helper.setColorSource(&kTestSource1);
  EXPECT_FALSE(helper.paint(true).isDither());
  EXPECT_FALSE(helper.paint(false).isDither());
}

◆ TEST() [302/715]

flutter::testing::TEST	(	DisplayListUtils	,
		SkDispatcherSetColorSourceDithersIfGradient
	)

Definition at line 78 of file dl_sk_paint_dispatcher_unittests.cc.

                                                                    {
  SkCanvas canvas;
  DlSkCanvasDispatcher dispatcher(&canvas);
 
  dispatcher.setColorSource(kTestLinearGradient.get());
  EXPECT_TRUE(dispatcher.paint(true).isDither());
  EXPECT_FALSE(dispatcher.paint(false).isDither());
  EXPECT_FALSE(dispatcher.safe_paint(true)->isDither());
  // Calling safe_paint(false) returns a nullptr
}

◆ TEST() [303/715]

flutter::testing::TEST	(	DisplayListUtils	,
		SkDispatcherSetColorSourceDoesNotDitherIfNotGradient
	)

Definition at line 90 of file dl_sk_paint_dispatcher_unittests.cc.

                                                                             {
  SkCanvas canvas;
  DlSkCanvasDispatcher dispatcher(&canvas);
 
  dispatcher.setColorSource(kTestLinearGradient.get());
  dispatcher.setColorSource(nullptr);
  EXPECT_FALSE(dispatcher.paint(true).isDither());
  EXPECT_FALSE(dispatcher.paint(false).isDither());
  EXPECT_FALSE(dispatcher.safe_paint(true)->isDither());
  // Calling safe_paint(false) returns a nullptr
 
  DlColorColorSource color_color_source(DlColor::kBlue());
  dispatcher.setColorSource(&color_color_source);
  EXPECT_FALSE(dispatcher.paint(true).isDither());
  EXPECT_FALSE(dispatcher.paint(false).isDither());
  EXPECT_FALSE(dispatcher.safe_paint(true)->isDither());
  // Calling safe_paint(false) returns a nullptr
 
  dispatcher.setColorSource(&kTestSource1);
  EXPECT_FALSE(dispatcher.paint(true).isDither());
  EXPECT_FALSE(dispatcher.paint(false).isDither());
  EXPECT_FALSE(dispatcher.safe_paint(true)->isDither());
  // Calling safe_paint(false) returns a nullptr
}

◆ TEST() [304/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuilderFlags
	)

Definition at line 374 of file dl_vertices_unittests.cc.

                                        {
  Builder::Flags flags;
  EXPECT_FALSE(flags.has_texture_coordinates);
  EXPECT_FALSE(flags.has_colors);
 
  flags |= Builder::kHasTextureCoordinates;
  EXPECT_TRUE(flags.has_texture_coordinates);
  EXPECT_FALSE(flags.has_colors);
 
  flags |= Builder::kHasColors;
  EXPECT_TRUE(flags.has_texture_coordinates);
  EXPECT_TRUE(flags.has_colors);
 
  flags = Builder::Flags();
  EXPECT_FALSE(flags.has_texture_coordinates);
  EXPECT_FALSE(flags.has_colors);
 
  flags |= Builder::kHasColors;
  EXPECT_FALSE(flags.has_texture_coordinates);
  EXPECT_TRUE(flags.has_colors);
 
  flags |= Builder::kHasTextureCoordinates;
  EXPECT_TRUE(flags.has_texture_coordinates);
  EXPECT_TRUE(flags.has_colors);
 
  EXPECT_FALSE(Builder::kNone.has_texture_coordinates);
  EXPECT_FALSE(Builder::kNone.has_colors);
 
  EXPECT_TRUE(Builder::kHasTextureCoordinates.has_texture_coordinates);
  EXPECT_FALSE(Builder::kHasTextureCoordinates.has_colors);
 
  EXPECT_FALSE(Builder::kHasColors.has_texture_coordinates);
  EXPECT_TRUE(Builder::kHasColors.has_colors);
 
  EXPECT_TRUE((Builder::kHasTextureCoordinates | Builder::kHasColors)  //
                  .has_texture_coordinates);
  EXPECT_TRUE((Builder::kHasTextureCoordinates | Builder::kHasColors)  //
                  .has_colors);
}

◆ TEST() [305/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildUsingFloatsSameAsPoints
	)

Definition at line 699 of file dl_vertices_unittests.cc.

                                                        {
  SkPoint coord_points[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coord_points[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
 
  float coord_floats[6] = {
      2,  3,  //
      5,  6,  //
      15, 20,
  };
  float texture_coord_floats[6] = {
      102, 103,  //
      105, 106,  //
      115, 120,
  };
 
  Builder builder_points(DlVertexMode::kTriangles, 3,  //
                         Builder::kHasTextureCoordinates, 0);
  builder_points.store_vertices(coord_points);
  builder_points.store_texture_coordinates(texture_coord_points);
  std::shared_ptr<const DlVertices> vertices_points = builder_points.build();
 
  Builder builder_floats(DlVertexMode::kTriangles, 3,  //
                         Builder::kHasTextureCoordinates, 0);
  builder_floats.store_vertices(coord_floats);
  builder_floats.store_texture_coordinates(texture_coord_floats);
  std::shared_ptr<const DlVertices> vertices_floats = builder_floats.build();
 
  TestEquals(*vertices_points, *vertices_floats);
}

◆ TEST() [306/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithColor
	)

Definition at line 737 of file dl_vertices_unittests.cc.

                                          {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkColor colors[3] = {
      SK_ColorRED,
      SK_ColorCYAN,
      SK_ColorGREEN,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasColors, 0);
  builder.store_vertices(coords);
  builder.store_colors(colors);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [307/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithColorAndIndices
	)

Definition at line 587 of file dl_vertices_unittests.cc.

                                                    {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkColor colors[3] = {
      SK_ColorRED,
      SK_ColorCYAN,
      SK_ColorGREEN,
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasColors, 6);
  builder.store_vertices(coords);
  builder.store_colors(colors);
  builder.store_indices(indices);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [308/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithIndices
	)

Definition at line 771 of file dl_vertices_unittests.cc.

                                            {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3, Builder::kNone, 6);
  builder.store_vertices(coords);
  builder.store_indices(indices);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [309/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithNegativeIndexCount
	)

Definition at line 831 of file dl_vertices_unittests.cc.

                                                       {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
 
  Builder builder(DlVertexMode::kTriangles, 3, Builder::kNone, -5);
  builder.store_vertices(coords);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [310/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithNoOptionalData
	)

Definition at line 805 of file dl_vertices_unittests.cc.

                                                   {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
 
  Builder builder(DlVertexMode::kTriangles, 3, Builder::kNone, 0);
  builder.store_vertices(coords);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [311/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithTexAndColor
	)

Definition at line 504 of file dl_vertices_unittests.cc.

                                                {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasTextureCoordinates | Builder::kHasColors, 0);
  builder.store_vertices(coords);
  builder.store_texture_coordinates(texture_coords);
  builder.store_colors(colors);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [312/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithTexAndColorAndIndices
	)

Definition at line 440 of file dl_vertices_unittests.cc.

                                                          {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasTextureCoordinates | Builder::kHasColors, 6);
  builder.store_vertices(coords);
  builder.store_texture_coordinates(texture_coords);
  builder.store_colors(colors);
  builder.store_indices(indices);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
 
  Builder builder2(DlVertexMode::kTriangles, 3,  //
                   Builder::kHasTextureCoordinates | Builder::kHasColors, 6);
  builder2.store_vertices(coords);
  builder2.store_texture_coordinates(texture_coords);
  builder2.store_colors(colors);
  builder2.store_indices(indices);
  std::shared_ptr<const DlVertices> vertices2 = builder2.build();
 
  TestEquals(*vertices, *vertices2);
 
  std::shared_ptr<const DlVertices> vertices3 = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, colors, 6, indices);
 
  TestEquals(*vertices, *vertices3);
}

◆ TEST() [313/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithTexAndIndices
	)

Definition at line 545 of file dl_vertices_unittests.cc.

                                                  {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasTextureCoordinates, 6);
  builder.store_vertices(coords);
  builder.store_texture_coordinates(texture_coords);
  builder.store_indices(indices);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [314/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithTexUsingFloats
	)

Definition at line 663 of file dl_vertices_unittests.cc.

                                                   {
  float coords[6] = {
      2,  3,  //
      5,  6,  //
      15, 20,
  };
  float texture_coords[6] = {
      102, 103,  //
      105, 106,  //
      115, 120,
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasTextureCoordinates, 0);
  builder.store_vertices(coords);
  builder.store_texture_coordinates(texture_coords);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i].fX, coords[i * 2 + 0]);
    ASSERT_EQ(vertices->vertices()[i].fY, coords[i * 2 + 1]);
    ASSERT_EQ(vertices->texture_coordinates()[i].fX, texture_coords[i * 2 + 0]);
    ASSERT_EQ(vertices->texture_coordinates()[i].fY, texture_coords[i * 2 + 1]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [315/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithTexUsingPoints
	)

Definition at line 629 of file dl_vertices_unittests.cc.

                                                   {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
 
  Builder builder(DlVertexMode::kTriangles, 3,  //
                  Builder::kHasTextureCoordinates, 0);
  builder.store_vertices(coords);
  builder.store_texture_coordinates(texture_coords);
  std::shared_ptr<const DlVertices> vertices = builder.build();
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [316/715]

flutter::testing::TEST	(	DisplayListVertices	,
		BuildWithZeroAndNegativeVerticesAndIndices
	)

Definition at line 414 of file dl_vertices_unittests.cc.

                                                                      {
  Builder builder1(DlVertexMode::kTriangles, 0, Builder::kNone, 0);
  EXPECT_TRUE(builder1.is_valid());
  std::shared_ptr<DlVertices> vertices1 = builder1.build();
  EXPECT_NE(vertices1, nullptr);
  EXPECT_EQ(vertices1->vertex_count(), 0);
  EXPECT_EQ(vertices1->vertices(), nullptr);
  EXPECT_EQ(vertices1->texture_coordinates(), nullptr);
  EXPECT_EQ(vertices1->colors(), nullptr);
  EXPECT_EQ(vertices1->index_count(), 0);
  EXPECT_EQ(vertices1->indices(), nullptr);
 
  Builder builder2(DlVertexMode::kTriangles, -1, Builder::kNone, -1);
  EXPECT_TRUE(builder2.is_valid());
  std::shared_ptr<DlVertices> vertices2 = builder2.build();
  EXPECT_NE(vertices2, nullptr);
  EXPECT_EQ(vertices2->vertex_count(), 0);
  EXPECT_EQ(vertices2->vertices(), nullptr);
  EXPECT_EQ(vertices2->texture_coordinates(), nullptr);
  EXPECT_EQ(vertices2->colors(), nullptr);
  EXPECT_EQ(vertices2->index_count(), 0);
  EXPECT_EQ(vertices2->indices(), nullptr);
 
  TestEquals(*vertices1, *vertices2);
}

◆ TEST() [317/715]

flutter::testing::TEST	(	DisplayListVertices	,
		ConvertWithZeroAndNegativeVerticesAndIndices
	)

Definition at line 208 of file dl_sk_conversions_unittests.cc.

                                                                        {
  DlVertices::Builder builder1(DlVertexMode::kTriangles, 0,
                               DlVertices::Builder::kNone, 0);
  EXPECT_TRUE(builder1.is_valid());
  std::shared_ptr<DlVertices> vertices1 = builder1.build();
  EXPECT_NE(vertices1, nullptr);
  EXPECT_NE(ToSk(vertices1), nullptr);
 
  DlVertices::Builder builder2(DlVertexMode::kTriangles, -1,
                               DlVertices::Builder::kNone, -1);
  EXPECT_TRUE(builder2.is_valid());
  std::shared_ptr<DlVertices> vertices2 = builder2.build();
  EXPECT_NE(vertices2, nullptr);
  EXPECT_NE(ToSk(vertices2), nullptr);
}

◆ TEST() [318/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithColor
	)

Definition at line 226 of file dl_vertices_unittests.cc.

                                         {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, colors, 6, nullptr);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [319/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithColorAndIndices
	)

Definition at line 157 of file dl_vertices_unittests.cc.

                                                   {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, colors, 6, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [320/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithIndices
	)

Definition at line 257 of file dl_vertices_unittests.cc.

                                           {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, nullptr, 6, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [321/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithIndicesButNegativeIndexCount
	)

Definition at line 343 of file dl_vertices_unittests.cc.

                                                                {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, nullptr, -5, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [322/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithIndicesButZeroIndexCount
	)

Definition at line 314 of file dl_vertices_unittests.cc.

                                                            {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, nullptr, 0, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [323/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithNoOptionalData
	)

Definition at line 289 of file dl_vertices_unittests.cc.

                                                  {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, nullptr, nullptr, 6, nullptr);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_EQ(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [324/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithTex
	)

Definition at line 195 of file dl_vertices_unittests.cc.

                                       {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, nullptr, 6, nullptr);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [325/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithTexAndColor
	)

Definition at line 82 of file dl_vertices_unittests.cc.

                                               {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, colors, 6, nullptr);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_EQ(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 0);
}

◆ TEST() [326/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithTexAndColorAndIndices
	)

Definition at line 38 of file dl_vertices_unittests.cc.

                                                         {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, colors, 6, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_NE(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
    ASSERT_EQ(vertices->colors()[i], colors[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [327/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithTexAndIndices
	)

Definition at line 119 of file dl_vertices_unittests.cc.

                                                 {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, nullptr, 6, indices);
 
  ASSERT_NE(vertices, nullptr);
  ASSERT_NE(vertices->vertices(), nullptr);
  ASSERT_NE(vertices->texture_coordinates(), nullptr);
  ASSERT_EQ(vertices->colors(), nullptr);
  ASSERT_NE(vertices->indices(), nullptr);
 
  ASSERT_EQ(vertices->bounds(), SkRect::MakeLTRB(2, 3, 15, 20));
  ASSERT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  ASSERT_EQ(vertices->vertex_count(), 3);
  for (int i = 0; i < 3; i++) {
    ASSERT_EQ(vertices->vertices()[i], coords[i]);
    ASSERT_EQ(vertices->texture_coordinates()[i], texture_coords[i]);
  }
  ASSERT_EQ(vertices->index_count(), 6);
  for (int i = 0; i < 6; i++) {
    ASSERT_EQ(vertices->indices()[i], indices[i]);
  }
}

◆ TEST() [328/715]

flutter::testing::TEST	(	DisplayListVertices	,
		MakeWithZeroAndNegativeVerticesAndIndices
	)

Definition at line 14 of file dl_vertices_unittests.cc.

                                                                     {
  std::shared_ptr<const DlVertices> vertices1 = DlVertices::Make(
      DlVertexMode::kTriangles, 0, nullptr, nullptr, nullptr, 0, nullptr);
  EXPECT_NE(vertices1, nullptr);
  EXPECT_EQ(vertices1->vertex_count(), 0);
  EXPECT_EQ(vertices1->vertices(), nullptr);
  EXPECT_EQ(vertices1->texture_coordinates(), nullptr);
  EXPECT_EQ(vertices1->colors(), nullptr);
  EXPECT_EQ(vertices1->index_count(), 0);
  EXPECT_EQ(vertices1->indices(), nullptr);
 
  std::shared_ptr<const DlVertices> vertices2 = DlVertices::Make(
      DlVertexMode::kTriangles, -1, nullptr, nullptr, nullptr, -1, nullptr);
  EXPECT_NE(vertices2, nullptr);
  EXPECT_EQ(vertices2->vertex_count(), 0);
  EXPECT_EQ(vertices2->vertices(), nullptr);
  EXPECT_EQ(vertices2->texture_coordinates(), nullptr);
  EXPECT_EQ(vertices2->colors(), nullptr);
  EXPECT_EQ(vertices2->index_count(), 0);
  EXPECT_EQ(vertices2->indices(), nullptr);
 
  TestEquals(*vertices1, *vertices2);
}

◆ TEST() [329/715]

flutter::testing::TEST	(	DisplayListVertices	,
		TestEquals
	)

Definition at line 857 of file dl_vertices_unittests.cc.

                                      {
  SkPoint coords[3] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
  };
  SkPoint texture_coords[3] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
  };
  DlColor colors[3] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
  };
  uint16_t indices[6] = {
      2, 1, 0,  //
      1, 2, 0,
  };
 
  std::shared_ptr<const DlVertices> vertices1 = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, colors, 6, indices);
  std::shared_ptr<const DlVertices> vertices2 = DlVertices::Make(
      DlVertexMode::kTriangles, 3, coords, texture_coords, colors, 6, indices);
  TestEquals(*vertices1, *vertices2);
}

◆ TEST() [330/715]

flutter::testing::TEST	(	DisplayListVertices	,
		TestNotEquals
	)

Definition at line 885 of file dl_vertices_unittests.cc.

                                         {
  SkPoint coords[4] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
      SkPoint::Make(53, 62),
  };
  SkPoint wrong_coords[4] = {
      SkPoint::Make(2, 3),
      SkPoint::Make(5, 6),
      SkPoint::Make(15, 20),
      SkPoint::Make(57, 62),
  };
  SkPoint texture_coords[4] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 120),
      SkPoint::Make(153, 162),
  };
  SkPoint wrong_texture_coords[4] = {
      SkPoint::Make(102, 103),
      SkPoint::Make(105, 106),
      SkPoint::Make(115, 121),
      SkPoint::Make(153, 162),
  };
  DlColor colors[4] = {
      DlColor::kRed(),
      DlColor::kCyan(),
      DlColor::kGreen(),
      DlColor::kMagenta(),
  };
  DlColor wrong_colors[4] = {
      DlColor::kRed(),
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::kMagenta(),
  };
  uint16_t indices[9] = {
      2, 1, 0,  //
      1, 2, 0,  //
      1, 2, 3,
  };
  uint16_t wrong_indices[9] = {
      2, 1, 0,  //
      1, 2, 0,  //
      2, 3, 1,
  };
 
  std::shared_ptr<const DlVertices> vertices1 = DlVertices::Make(
      DlVertexMode::kTriangles, 4, coords, texture_coords, colors, 9, indices);
 
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangleFan, 4, coords,  //
                         texture_coords, colors, 9, indices);
    TestNotEquals(*vertices1, *vertices2, "vertex mode differs");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 3, coords,  //
                         texture_coords, colors, 9, indices);
    TestNotEquals(*vertices1, *vertices2, "vertex count differs");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 4, wrong_coords,  //
                         texture_coords, colors, 9, indices);
    TestNotEquals(*vertices1, *vertices2, "vertex coordinates differ");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 4, coords,  //
                         wrong_texture_coords, colors, 9, indices);
    TestNotEquals(*vertices1, *vertices2, "texture coordinates differ");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 4, coords,  //
                         texture_coords, wrong_colors, 9, indices);
    TestNotEquals(*vertices1, *vertices2, "colors differ");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 4, coords,  //
                         texture_coords, colors, 6, indices);
    TestNotEquals(*vertices1, *vertices2, "index count differs");
  }
  {
    std::shared_ptr<const DlVertices> vertices2 =
        DlVertices::Make(DlVertexMode::kTriangles, 4, coords,  //
                         texture_coords, colors, 9, wrong_indices);
    TestNotEquals(*vertices1, *vertices2, "indices differ");
  }
}

◆ TEST() [331/715]

flutter::testing::TEST	(	DlOpSpy	,
		DidDrawIsFalseByDefault
	)

Definition at line 33 of file dl_op_spy_unittests.cc.

                                       {
  DlOpSpy dl_op_spy;
  ASSERT_FALSE(dl_op_spy.did_draw());
}

◆ TEST() [332/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawArc
	)

Definition at line 328 of file dl_op_spy_unittests.cc.

                       {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawArc(SkRect::MakeWH(5, 5), 0, 1, true, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawArc(SkRect::MakeWH(5, 5), 0, 1, true, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [333/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawCircle
	)

Definition at line 248 of file dl_op_spy_unittests.cc.

                          {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawCircle(SkPoint::Make(5, 5), 1.0, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawCircle(SkPoint::Make(5, 5), 1.0, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [334/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawColor
	)

Definition at line 113 of file dl_op_spy_unittests.cc.

                         {
  {  // Black color source.
    DisplayListBuilder builder;
    auto color = DlColor::kBlack();
    builder.DrawColor(color, DlBlendMode::kSrc);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // Transparent color with kSrc.
    DisplayListBuilder builder;
    auto color = DlColor::kTransparent();
    builder.DrawColor(color, DlBlendMode::kSrc);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
  {  // Transparent color with kSrcOver.
    DisplayListBuilder builder;
    auto color = DlColor::kTransparent();
    builder.DrawColor(color, DlBlendMode::kSrcOver);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [335/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawDashedLine
	)

Definition at line 185 of file dl_op_spy_unittests.cc.

                              {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawDashedLine(DlPoint(0, 1), DlPoint(1, 2), 1.0f, 1.0f, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawDashedLine(DlPoint(0, 1), DlPoint(1, 2), 1.0f, 1.0f, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [336/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawDisplayList
	)

Definition at line 497 of file dl_op_spy_unittests.cc.

                               {
  {  // Recursive Transparent DisplayList
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
 
    DisplayListBuilder builder_parent;
    DlPaint paint_parent(DlColor::kTransparent());
    builder_parent.DrawPaint(paint_parent);
    builder_parent.DrawDisplayList(dl, 1);
    sk_sp<DisplayList> dl2 = builder_parent.Build();
 
    DlOpSpy dl_op_spy;
    dl2->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl2);
  }
  {  // Sub non-transparent DisplayList,
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
 
    DisplayListBuilder builder_parent;
    DlPaint paint_parent(DlColor::kTransparent());
    builder_parent.DrawPaint(paint_parent);
    builder_parent.DrawDisplayList(dl, 1);
    sk_sp<DisplayList> dl2 = builder_parent.Build();
 
    DlOpSpy dl_op_spy;
    dl2->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl2);
  }
 
  {  // Sub non-transparent DisplayList, 0 opacity
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
 
    DisplayListBuilder builder_parent;
    DlPaint paint_parent(DlColor::kTransparent());
    builder_parent.DrawPaint(paint_parent);
    builder_parent.DrawDisplayList(dl, 0);
    sk_sp<DisplayList> dl2 = builder_parent.Build();
 
    DlOpSpy dl_op_spy;
    dl2->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl2);
  }
 
  {  // Parent non-transparent DisplayList
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
 
    DisplayListBuilder builder_parent;
    DlPaint paint_parent(DlColor::kBlack());
    builder_parent.DrawPaint(paint_parent);
    builder_parent.DrawDisplayList(dl, 0);
    sk_sp<DisplayList> dl2 = builder_parent.Build();
 
    DlOpSpy dl_op_spy;
    dl2->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl2);
  }
}

◆ TEST() [337/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawLine
	)

Definition at line 164 of file dl_op_spy_unittests.cc.

                        {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawLine(SkPoint::Make(0, 1), SkPoint::Make(1, 2), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawLine(SkPoint::Make(0, 1), SkPoint::Make(1, 2), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [338/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawOval
	)

Definition at line 227 of file dl_op_spy_unittests.cc.

                        {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawOval(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawOval(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [339/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawPaint
	)

Definition at line 143 of file dl_op_spy_unittests.cc.

                         {
  {  // Transparent color in paint.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
  {  // black color in paint.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawPaint(paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [340/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawPath
	)

Definition at line 290 of file dl_op_spy_unittests.cc.

                        {
  {  // black line
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    paint.setDrawStyle(DlDrawStyle::kStroke);
    builder.DrawPath(SkPath::Line(SkPoint::Make(0, 1), SkPoint::Make(1, 1)),
                     paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // triangle
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    SkPath path;
    path.moveTo({0, 0});
    path.lineTo({1, 0});
    path.lineTo({0, 1});
    builder.DrawPath(path, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent line
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    paint.setDrawStyle(DlDrawStyle::kStroke);
    builder.DrawPath(SkPath::Line(SkPoint::Make(0, 1), SkPoint::Make(1, 1)),
                     paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [341/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawPoints
	)

Definition at line 349 of file dl_op_spy_unittests.cc.

                          {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    const SkPoint points[] = {SkPoint::Make(5, 4)};
    builder.DrawPoints(DlCanvas::PointMode::kPoints, 1, points, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    const SkPoint points[] = {SkPoint::Make(5, 4)};
    builder.DrawPoints(DlCanvas::PointMode::kPoints, 1, points, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [342/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawRect
	)

Definition at line 206 of file dl_op_spy_unittests.cc.

                        {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [343/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawRRect
	)

Definition at line 269 of file dl_op_spy_unittests.cc.

                         {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawRRect(SkRRect::MakeRect(SkRect::MakeWH(5, 5)), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawRRect(SkRRect::MakeRect(SkRect::MakeWH(5, 5)), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [344/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawShadow
	)

Definition at line 593 of file dl_op_spy_unittests.cc.

                          {
  {  // valid shadow
    DisplayListBuilder builder;
    DlPaint paint;
    DlColor color = DlColor::kBlack();
    SkPath path = SkPath::Line(SkPoint::Make(0, 1), SkPoint::Make(1, 1));
    builder.DrawShadow(path, color, 1, false, 1);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent color
    DisplayListBuilder builder;
    DlPaint paint;
    DlColor color = DlColor::kTransparent();
    SkPath path = SkPath::Line(SkPoint::Make(0, 1), SkPoint::Make(1, 1));
    builder.DrawShadow(path, color, 1, false, 1);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [345/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawTextBlob
	)

Definition at line 566 of file dl_op_spy_unittests.cc.

                            {
  {  // Non-transparent color.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    std::string string = "xx";
    SkFont font = CreateTestFontOfSize(12);
    auto text_blob = SkTextBlob::MakeFromString(string.c_str(), font);
    builder.DrawTextBlob(text_blob, 1, 1, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent color.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    std::string string = "xx";
    SkFont font = CreateTestFontOfSize(12);
    auto text_blob = SkTextBlob::MakeFromString(string.c_str(), font);
    builder.DrawTextBlob(text_blob, 1, 1, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [346/715]

flutter::testing::TEST	(	DlOpSpy	,
		DrawVertices
	)

Definition at line 372 of file dl_op_spy_unittests.cc.

                            {
  {  // black
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    const SkPoint vertices[] = {
        SkPoint::Make(5, 5),
        SkPoint::Make(5, 15),
        SkPoint::Make(15, 5),
    };
    const SkPoint texture_coordinates[] = {
        SkPoint::Make(5, 5),
        SkPoint::Make(15, 5),
        SkPoint::Make(5, 15),
    };
    const DlColor colors[] = {
        DlColor::kBlack(),
        DlColor::kRed(),
        DlColor::kGreen(),
    };
    auto dl_vertices = DlVertices::Make(DlVertexMode::kTriangles, 3, vertices,
                                        texture_coordinates, colors, 0);
    builder.DrawVertices(dl_vertices.get(), DlBlendMode::kSrc, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // transparent
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    const SkPoint vertices[] = {
        SkPoint::Make(5, 5),
        SkPoint::Make(5, 15),
        SkPoint::Make(15, 5),
    };
    const SkPoint texture_coordinates[] = {
        SkPoint::Make(5, 5),
        SkPoint::Make(15, 5),
        SkPoint::Make(5, 15),
    };
    const DlColor colors[] = {
        DlColor::kBlack(),
        DlColor::kRed(),
        DlColor::kGreen(),
    };
    auto dl_vertices = DlVertices::Make(DlVertexMode::kTriangles, 3, vertices,
                                        texture_coordinates, colors, 0);
    builder.DrawVertices(dl_vertices.get(), DlBlendMode::kSrc, paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [347/715]

flutter::testing::TEST	(	DlOpSpy	,
		EmptyDisplayList
	)

Definition at line 38 of file dl_op_spy_unittests.cc.

                                {
  DisplayListBuilder builder;
  sk_sp<DisplayList> dl = builder.Build();
  DlOpSpy dl_op_spy;
  dl->Dispatch(dl_op_spy);
  ASSERT_NO_DRAW(dl_op_spy, dl);
}

◆ TEST() [348/715]

flutter::testing::TEST	(	DlOpSpy	,
		Images
	)

Definition at line 427 of file dl_op_spy_unittests.cc.

                      {
  {  // DrawImage
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    SkImageInfo info =
        SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                          SkAlphaType::kPremul_SkAlphaType);
    SkBitmap bitmap;
    bitmap.allocPixels(info, 0);
    auto sk_image = SkImages::RasterFromBitmap(bitmap);
    builder.DrawImage(DlImage::Make(sk_image), SkPoint::Make(5, 5),
                      DlImageSampling::kLinear);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // DrawImageRect
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    SkImageInfo info =
        SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                          SkAlphaType::kPremul_SkAlphaType);
    SkBitmap bitmap;
    bitmap.allocPixels(info, 0);
    auto sk_image = SkImages::RasterFromBitmap(bitmap);
    builder.DrawImageRect(DlImage::Make(sk_image), SkRect::MakeWH(5, 5),
                          SkRect::MakeWH(5, 5), DlImageSampling::kLinear);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // DrawImageNine
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    SkImageInfo info =
        SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                          SkAlphaType::kPremul_SkAlphaType);
    SkBitmap bitmap;
    bitmap.allocPixels(info, 0);
    auto sk_image = SkImages::RasterFromBitmap(bitmap);
    builder.DrawImageNine(DlImage::Make(sk_image), SkIRect::MakeWH(5, 5),
                          SkRect::MakeWH(5, 5), DlFilterMode::kLinear);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // DrawAtlas
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    SkImageInfo info =
        SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
                          SkAlphaType::kPremul_SkAlphaType);
    SkBitmap bitmap;
    bitmap.allocPixels(info, 0);
    auto sk_image = SkImages::RasterFromBitmap(bitmap);
    const SkRSXform xform[] = {SkRSXform::Make(1, 0, 0, 0)};
    const SkRect tex[] = {SkRect::MakeXYWH(10, 10, 10, 10)};
    SkRect cull_rect = SkRect::MakeWH(5, 5);
    builder.DrawAtlas(DlImage::Make(sk_image), xform, tex, nullptr, 1,
                      DlBlendMode::kSrc, DlImageSampling::kLinear, &cull_rect);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [349/715]

flutter::testing::TEST	(	DlOpSpy	,
		SetColor
	)

Definition at line 46 of file dl_op_spy_unittests.cc.

                        {
  {  // No Color set.
    DisplayListBuilder builder;
    DlPaint paint;
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // Set transparent color.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kTransparent());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
  {  // Set black color.
    DisplayListBuilder builder;
    DlPaint paint(DlColor::kBlack());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [350/715]

flutter::testing::TEST	(	DlOpSpy	,
		SetColorSource
	)

Definition at line 76 of file dl_op_spy_unittests.cc.

                              {
  {  // Set null source
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColorSource(nullptr);
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
  {  // Set transparent color.
    DisplayListBuilder builder;
    DlPaint paint;
    auto color = DlColor::kTransparent();
    DlColorColorSource color_source_transparent(color);
    paint.setColorSource(color_source_transparent.shared());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_NO_DRAW(dl_op_spy, dl);
  }
  {  // Set black color.
    DisplayListBuilder builder;
    DlPaint paint;
    auto color = DlColor::kBlack();
    DlColorColorSource color_source_transparent(color);
    paint.setColorSource(color_source_transparent.shared());
    builder.DrawRect(SkRect::MakeWH(5, 5), paint);
    sk_sp<DisplayList> dl = builder.Build();
    DlOpSpy dl_op_spy;
    dl->Dispatch(dl_op_spy);
    ASSERT_DID_DRAW(dl_op_spy, dl);
  }
}

◆ TEST() [351/715]

flutter::testing::TEST	(	DlVertexPainter	,
		DrawRectIntoVertices
	)

Definition at line 21 of file stopwatch_dl_unittests.cc.

                                            {
  auto painter = DlVertexPainter();
 
  // Paint a red rectangle.
  painter.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10), DlColor::kRed());
 
  // Paint a blue rectangle.
  painter.DrawRect(SkRect::MakeLTRB(10, 10, 20, 20), DlColor::kBlue());
 
  // Convert the buffered vertices into a |DlVertices| object.
  auto vertices = painter.IntoVertices();
 
  // Verify the vertices.
  EXPECT_EQ(vertices->mode(), DlVertexMode::kTriangles);
  EXPECT_EQ(vertices->vertex_count(), 3 * 2 * 2);
 
  auto const points = vertices->vertices();
 
  {
    // Extract the first 6 vertices (first rectangle).
    SkPoint first_rect_vertices[6];
    std::copy(points, points + 6, first_rect_vertices);
    EXPECT_EQ(MakeRectFromVertices(first_rect_vertices),
              SkRect::MakeLTRB(0, 0, 10, 10));
  }
 
  {
    // Extract the next 6 vertices (second rectangle).
    SkPoint second_rect_vertices[6];
    std::copy(points + 6, points + 12, second_rect_vertices);
    EXPECT_EQ(MakeRectFromVertices(second_rect_vertices),
              SkRect::MakeLTRB(10, 10, 20, 20));
  }
 
  // Verify the colors (first 6 vertices are red, next 6 are blue).
  auto const colors = vertices->colors();
  EXPECT_EQ(colors[0], DlColor::kRed());
  EXPECT_EQ(colors[1], DlColor::kRed());
  EXPECT_EQ(colors[2], DlColor::kRed());
  EXPECT_EQ(colors[3], DlColor::kRed());
  EXPECT_EQ(colors[4], DlColor::kRed());
  EXPECT_EQ(colors[5], DlColor::kRed());
 
  EXPECT_EQ(colors[6], DlColor::kBlue());
  EXPECT_EQ(colors[7], DlColor::kBlue());
  EXPECT_EQ(colors[8], DlColor::kBlue());
  EXPECT_EQ(colors[9], DlColor::kBlue());
  EXPECT_EQ(colors[10], DlColor::kBlue());
  EXPECT_EQ(colors[11], DlColor::kBlue());
}

◆ TEST() [352/715]

flutter::testing::TEST	(	DpiUtilsTest	,
		NonZero
	)

Definition at line 13 of file dpi_utils_unittests.cc.

                            {
  ASSERT_GT(GetDpiForHWND(nullptr), 0);
  ASSERT_GT(GetDpiForMonitor(nullptr), 0);
};

◆ TEST() [353/715]

flutter::testing::TEST	(	DpiUtilsTest	,
		NullHwndUsesPrimaryMonitor
	)

Definition at line 18 of file dpi_utils_unittests.cc.

                                               {
  const POINT target_point = {0, 0};
  HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTOPRIMARY);
  ASSERT_EQ(GetDpiForHWND(nullptr), GetDpiForMonitor(monitor));
};

◆ TEST() [354/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithNoMutations
	)

Definition at line 12 of file embedded_view_params_unittests.cc.

                                                                       {
  MutatorsStack stack;
  SkMatrix matrix;
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), 1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), 1));
}

◆ TEST() [355/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithRotation45
	)

Definition at line 65 of file embedded_view_params_unittests.cc.

                                                                      {
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setRotate(45);
  stack.PushTransform(matrix);
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), -sqrt(2) / 2));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), sqrt(2)));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), sqrt(2)));
}

◆ TEST() [356/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithRotation90
	)

Definition at line 50 of file embedded_view_params_unittests.cc.

                                                                      {
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setRotate(90);
  stack.PushTransform(matrix);
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
 
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), -1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), 1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), 1));
}

◆ TEST() [357/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithScale
	)

Definition at line 24 of file embedded_view_params_unittests.cc.

                                                                 {
  MutatorsStack stack;
  SkMatrix matrix = SkMatrix::Scale(2, 2);
  stack.PushTransform(matrix);
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 0));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), 2));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), 2));
}

◆ TEST() [358/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithTranslate
	)

Definition at line 37 of file embedded_view_params_unittests.cc.

                                                                     {
  MutatorsStack stack;
  SkMatrix matrix = SkMatrix::Translate(1, 1);
  stack.PushTransform(matrix);
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), 1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), 1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), 1));
}

◆ TEST() [359/715]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithTranslateScaleAndRotation
	)

Definition at line 79 of file embedded_view_params_unittests.cc.

                                                                 {
  SkMatrix matrix = SkMatrix::Translate(2, 2);
  matrix.preScale(3, 3);
  matrix.preRotate(90);
 
  MutatorsStack stack;
  stack.PushTransform(matrix);
 
  EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
  const SkRect& rect = params.finalBoundingRect();
  ASSERT_TRUE(SkScalarNearlyEqual(rect.x(), -1));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.y(), 2));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.width(), 3));
  ASSERT_TRUE(SkScalarNearlyEqual(rect.height(), 3));
}

◆ TEST() [360/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterDamageIsFrozen
	)

Definition at line 52 of file embedder_frozen_unittests.cc.

                                            {
  ASSERT_EQ_OFFSET(FlutterDamage, FrozenFlutterDamage, struct_size);
  ASSERT_EQ_OFFSET(FlutterDamage, FrozenFlutterDamage, num_rects);
  ASSERT_EQ_OFFSET(FlutterDamage, FrozenFlutterDamage, damage);
}

◆ TEST() [361/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterPointIsFrozen
	)

Definition at line 45 of file embedder_frozen_unittests.cc.

                                           {
  ASSERT_EQ_OFFSET(FlutterPoint, FrozenFlutterPoint, x);
  ASSERT_EQ_OFFSET(FlutterPoint, FrozenFlutterPoint, y);
}

◆ TEST() [362/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterRectIsFrozen
	)

Definition at line 36 of file embedder_frozen_unittests.cc.

                                          {
  ASSERT_EQ_OFFSET(FlutterRect, FrozenFlutterRect, left);
  ASSERT_EQ_OFFSET(FlutterRect, FrozenFlutterRect, top);
  ASSERT_EQ_OFFSET(FlutterRect, FrozenFlutterRect, right);
  ASSERT_EQ_OFFSET(FlutterRect, FrozenFlutterRect, bottom);
}

◆ TEST() [363/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterSemanticsCustomActionIsFrozen
	)

Definition at line 114 of file embedder_frozen_unittests.cc.

                                                           {
  ASSERT_EQ(sizeof(FlutterSemanticsCustomAction),
            sizeof(FrozenFlutterSemanticsCustomAction));
 
  ASSERT_EQ_OFFSET(FlutterSemanticsCustomAction,
                   FrozenFlutterSemanticsCustomAction, struct_size);
  ASSERT_EQ_OFFSET(FlutterSemanticsCustomAction,
                   FrozenFlutterSemanticsCustomAction, id);
  ASSERT_EQ_OFFSET(FlutterSemanticsCustomAction,
                   FrozenFlutterSemanticsCustomAction, override_action);
  ASSERT_EQ_OFFSET(FlutterSemanticsCustomAction,
                   FrozenFlutterSemanticsCustomAction, label);
  ASSERT_EQ_OFFSET(FlutterSemanticsCustomAction,
                   FrozenFlutterSemanticsCustomAction, hint);
}

◆ TEST() [364/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterSemanticsNodeIsFrozen
	)

Definition at line 61 of file embedder_frozen_unittests.cc.

                                                   {
  ASSERT_EQ(sizeof(FlutterSemanticsNode), sizeof(FrozenFlutterSemanticsNode));
 
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   struct_size);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, id);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, flags);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, actions);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   text_selection_base);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   text_selection_extent);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   scroll_child_count);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   scroll_index);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   scroll_position);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   scroll_extent_max);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   scroll_extent_min);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, elevation);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, thickness);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, label);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, hint);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, value);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   increased_value);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   decreased_value);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   text_direction);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, rect);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, transform);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   child_count);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   children_in_traversal_order);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   children_in_hit_test_order);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   custom_accessibility_actions_count);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   custom_accessibility_actions);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode,
                   platform_view_id);
  ASSERT_EQ_OFFSET(FlutterSemanticsNode, FrozenFlutterSemanticsNode, tooltip);
}

◆ TEST() [365/715]

flutter::testing::TEST	(	EmbedderFrozen	,
		FlutterTransformationIsFrozen
	)

Definition at line 20 of file embedder_frozen_unittests.cc.

                                                    {
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, scaleX);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, skewX);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, transX);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, skewY);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, scaleY);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, transY);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, pers0);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, pers1);
  ASSERT_EQ_OFFSET(FlutterTransformation, FrozenFlutterTransformation, pers2);
}

◆ TEST() [366/715]

flutter::testing::TEST	(	EmbedderProcTable	,
		AllPointersProvided
	)

Definition at line 20 of file embedder_unittests_proctable.cc.

                                             {
  FlutterEngineProcTable procs = {};
  procs.struct_size = sizeof(FlutterEngineProcTable);
  ASSERT_EQ(FlutterEngineGetProcAddresses(&procs), kSuccess);
 
  void (**proc)() = reinterpret_cast<void (**)()>(&procs.CreateAOTData);
  const uintptr_t end_address =
      reinterpret_cast<uintptr_t>(&procs) + procs.struct_size;
  while (reinterpret_cast<uintptr_t>(proc) < end_address) {
    EXPECT_NE(*proc, nullptr);
    ++proc;
  }
}

◆ TEST() [367/715]

flutter::testing::TEST	(	EmbedderProcTable	,
		CallProc
	)

Definition at line 53 of file embedder_unittests_proctable.cc.

                                  {
  FlutterEngineProcTable procs = {};
  procs.struct_size = sizeof(FlutterEngineProcTable);
  ASSERT_EQ(FlutterEngineGetProcAddresses(&procs), kSuccess);
 
  EXPECT_NE(procs.GetCurrentTime(), 0ULL);
}

◆ TEST() [368/715]

flutter::testing::TEST	(	EmbedderProcTable	,
		NoDuplicatePointers
	)

Definition at line 36 of file embedder_unittests_proctable.cc.

                                             {
  FlutterEngineProcTable procs = {};
  procs.struct_size = sizeof(FlutterEngineProcTable);
  ASSERT_EQ(FlutterEngineGetProcAddresses(&procs), kSuccess);
 
  void (**proc)() = reinterpret_cast<void (**)()>(&procs.CreateAOTData);
  const uintptr_t end_address =
      reinterpret_cast<uintptr_t>(&procs) + procs.struct_size;
  std::set<void (*)()> seen_procs;
  while (reinterpret_cast<uintptr_t>(proc) < end_address) {
    auto result = seen_procs.insert(*proc);
    EXPECT_TRUE(result.second);
    ++proc;
  }
}

◆ TEST() [369/715]

flutter::testing::TEST	(	EmbedderTestNoFixture	,
		CanGetCurrentTimeInNanoseconds
	)

Definition at line 268 of file embedder_unittests.cc.

                                                            {
  auto point1 = fml::TimePoint::FromEpochDelta(
      fml::TimeDelta::FromNanoseconds(FlutterEngineGetCurrentTime()));
  auto point2 = fml::TimePoint::Now();
 
  ASSERT_LT((point2 - point1), fml::TimeDelta::FromMilliseconds(1));
}

◆ TEST() [370/715]

flutter::testing::TEST	(	EmbedderTestNoFixture	,
		MustNotRunWithInvalidArgs
	)

Definition at line 58 of file embedder_unittests.cc.

                                                       {
  EmbedderTestContextSoftware context;
  EmbedderConfigBuilder builder(
      context, EmbedderConfigBuilder::InitializationPreference::kNoInitialize);
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST() [371/715]

flutter::testing::TEST	(	FlutterAppDelegateTest	,
		DoesNotCallDelegatesWithoutHandler
	)

Definition at line 32 of file FlutterAppDelegateTest.mm.

                                                                 {
  FlutterAppDelegate* appDelegate = [[FlutterAppDelegate alloc] init];
  AppDelegateNoopFlutterAppLifecycleDelegate* noopDelegate =
      [[AppDelegateNoopFlutterAppLifecycleDelegate alloc] init];
  [appDelegate addApplicationLifecycleDelegate:noopDelegate];
 
  [appDelegate application:NSApplication.sharedApplication openURLs:@[]];
  // No EXPECT, since the test is that the call doesn't throw due to calling without checking that
  // the method is implemented.
}

◆ TEST() [372/715]

flutter::testing::TEST	(	FlutterAppDelegateTest	,
		OperURLsStopsAfterHandled
	)

Definition at line 57 of file FlutterAppDelegateTest.mm.

                                                        {
  FlutterAppDelegate* appDelegate = [[FlutterAppDelegate alloc] init];
  AppDelegateTestFlutterAppLifecycleDelegate* firstDelegate =
      [[AppDelegateTestFlutterAppLifecycleDelegate alloc] init];
  AppDelegateTestFlutterAppLifecycleDelegate* secondDelegate =
      [[AppDelegateTestFlutterAppLifecycleDelegate alloc] init];
  [appDelegate addApplicationLifecycleDelegate:firstDelegate];
  [appDelegate addApplicationLifecycleDelegate:secondDelegate];
 
  NSURL* URL = [NSURL URLWithString:@"https://flutter.dev"];
  EXPECT_NE(URL, nil);
  NSArray<NSURL*>* URLs = @[ URL ];
  [appDelegate application:NSApplication.sharedApplication openURLs:URLs];
 
  EXPECT_EQ([firstDelegate receivedURLs], URLs);
  EXPECT_EQ([secondDelegate receivedURLs], nil);
}

◆ TEST() [373/715]

flutter::testing::TEST	(	FlutterAppDelegateTest	,
		ReceivesOpenURLs
	)

Definition at line 43 of file FlutterAppDelegateTest.mm.

                                               {
  FlutterAppDelegate* appDelegate = [[FlutterAppDelegate alloc] init];
  AppDelegateTestFlutterAppLifecycleDelegate* delegate =
      [[AppDelegateTestFlutterAppLifecycleDelegate alloc] init];
  [appDelegate addApplicationLifecycleDelegate:delegate];
 
  NSURL* URL = [NSURL URLWithString:@"https://flutter.dev"];
  EXPECT_NE(URL, nil);
  NSArray<NSURL*>* URLs = @[ URL ];
  [appDelegate application:NSApplication.sharedApplication openURLs:URLs];
 
  EXPECT_EQ([delegate receivedURLs], URLs);
}

◆ TEST() [374/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		ReleasesDelegateOnDealloc
	)

Definition at line 223 of file FlutterAppLifecycleDelegateTest.mm.

                                                                 {
  __weak FlutterAppLifecycleRegistrar* weakRegistrar;
  __weak TestFlutterAppLifecycleDelegate* weakDelegate;
  @autoreleasepool {
    FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
    weakRegistrar = registrar;
    TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
    weakDelegate = delegate;
    [registrar addDelegate:delegate];
  }
  EXPECT_EQ(weakRegistrar, nil);
  EXPECT_EQ(weakDelegate, nil);
}

◆ TEST() [375/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidBecomeActive
	)

Definition at line 109 of file FlutterAppLifecycleDelegateTest.mm.

                                                                 {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didBecomeActive =
      [NSNotification notificationWithName:NSApplicationDidBecomeActiveNotification object:nil];
  [registrar handleDidBecomeActive:didBecomeActive];
  EXPECT_EQ([delegate lastNotification], didBecomeActive);
}

◆ TEST() [376/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidChangeOcclusionState
	)

Definition at line 209 of file FlutterAppLifecycleDelegateTest.mm.

                                                                         {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didChangeOcclusionState =
      [NSNotification notificationWithName:NSApplicationDidChangeOcclusionStateNotification
                                    object:nil];
  if ([registrar respondsToSelector:@selector(handleDidChangeOcclusionState:)]) {
    [registrar handleDidChangeOcclusionState:didChangeOcclusionState];
    EXPECT_EQ([delegate lastNotification], didChangeOcclusionState);
  }
}

◆ TEST() [377/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidChangeScreenParameters
	)

Definition at line 197 of file FlutterAppLifecycleDelegateTest.mm.

                                                                           {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didChangeScreenParameters =
      [NSNotification notificationWithName:NSApplicationDidChangeScreenParametersNotification
                                    object:nil];
  [registrar handleDidChangeScreenParameters:didChangeScreenParameters];
  EXPECT_EQ([delegate lastNotification], didChangeScreenParameters);
}

◆ TEST() [378/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidFinishLaunching
	)

Definition at line 87 of file FlutterAppLifecycleDelegateTest.mm.

                                                                    {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didFinishLaunching =
      [NSNotification notificationWithName:NSApplicationDidFinishLaunchingNotification object:nil];
  [registrar handleDidFinishLaunching:didFinishLaunching];
  EXPECT_EQ([delegate lastNotification], didFinishLaunching);
}

◆ TEST() [379/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidHide
	)

Definition at line 175 of file FlutterAppLifecycleDelegateTest.mm.

                                                         {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didHide = [NSNotification notificationWithName:NSApplicationDidHideNotification
                                                          object:nil];
  [registrar handleDidHide:didHide];
  EXPECT_EQ([delegate lastNotification], didHide);
}

◆ TEST() [380/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidResignActive
	)

Definition at line 131 of file FlutterAppLifecycleDelegateTest.mm.

                                                                 {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didResignActive =
      [NSNotification notificationWithName:NSApplicationDidResignActiveNotification object:nil];
  [registrar handleDidResignActive:didResignActive];
  EXPECT_EQ([delegate lastNotification], didResignActive);
}

◆ TEST() [381/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToDidUnhide
	)

Definition at line 186 of file FlutterAppLifecycleDelegateTest.mm.

                                                           {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* didUnhide =
      [NSNotification notificationWithName:NSApplicationDidUnhideNotification object:nil];
  [registrar handleDidUnhide:didUnhide];
  EXPECT_EQ([delegate lastNotification], didUnhide);
}

◆ TEST() [382/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillBecomeActive
	)

Definition at line 98 of file FlutterAppLifecycleDelegateTest.mm.

                                                                  {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* willBecomeActive =
      [NSNotification notificationWithName:NSApplicationWillBecomeActiveNotification object:nil];
  [registrar handleWillBecomeActive:willBecomeActive];
  EXPECT_EQ([delegate lastNotification], willBecomeActive);
}

◆ TEST() [383/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillFinishLaunching
	)

Definition at line 76 of file FlutterAppLifecycleDelegateTest.mm.

                                                                     {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* willFinishLaunching =
      [NSNotification notificationWithName:NSApplicationWillFinishLaunchingNotification object:nil];
  [registrar handleWillFinishLaunching:willFinishLaunching];
  EXPECT_EQ([delegate lastNotification], willFinishLaunching);
}

◆ TEST() [384/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillHide
	)

Definition at line 153 of file FlutterAppLifecycleDelegateTest.mm.

                                                          {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* willHide = [NSNotification notificationWithName:NSApplicationWillHideNotification
                                                           object:nil];
  [registrar handleWillHide:willHide];
  EXPECT_EQ([delegate lastNotification], willHide);
}

◆ TEST() [385/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillResignActive
	)

Definition at line 120 of file FlutterAppLifecycleDelegateTest.mm.

                                                                  {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* willResignActive =
      [NSNotification notificationWithName:NSApplicationWillResignActiveNotification object:nil];
  [registrar handleWillResignActive:willResignActive];
  EXPECT_EQ([delegate lastNotification], willResignActive);
}

◆ TEST() [386/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillTerminate
	)

Definition at line 142 of file FlutterAppLifecycleDelegateTest.mm.

                                                               {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* applicationWillTerminate =
      [NSNotification notificationWithName:NSApplicationWillTerminateNotification object:nil];
  [registrar handleWillTerminate:applicationWillTerminate];
  EXPECT_EQ([delegate lastNotification], applicationWillTerminate);
}

◆ TEST() [387/715]

flutter::testing::TEST	(	FlutterAppLifecycleDelegateTest	,
		RespondsToWillUnhide
	)

Definition at line 164 of file FlutterAppLifecycleDelegateTest.mm.

                                                            {
  FlutterAppLifecycleRegistrar* registrar = [[FlutterAppLifecycleRegistrar alloc] init];
  TestFlutterAppLifecycleDelegate* delegate = [[TestFlutterAppLifecycleDelegate alloc] init];
  [registrar addDelegate:delegate];
 
  NSNotification* willUnhide =
      [NSNotification notificationWithName:NSApplicationWillUnhideNotification object:nil];
  [registrar handleWillUnhide:willUnhide];
  EXPECT_EQ([delegate lastNotification], willUnhide);
}

◆ TEST() [388/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		BasicKeyEvent
	)

Definition at line 118 of file FlutterEmbedderKeyResponderTest.mm.

                                                          {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 123.0f, 0x100, @"a", @"a", FALSE, 0)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->timestamp, 123000000.0f);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", TRUE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = TRUE;
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 124.0f, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->timestamp, 124000000.0f);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_EQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, TRUE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:FALSE];  // Check if responding FALSE works
  EXPECT_EQ(last_handled, FALSE);
 
  [events removeAllObjects];
}

◆ TEST() [389/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		ConvertAbruptRepeatEventsToDown
	)

Definition at line 410 of file FlutterEmbedderKeyResponderTest.mm.

                                                                            {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  last_handled = TRUE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", TRUE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
  EXPECT_EQ(last_handled, TRUE);
  [[events lastObject] respond:FALSE];
  EXPECT_EQ(last_handled, FALSE);
 
  [events removeAllObjects];
}

◆ TEST() [390/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		ConvertCapsLockEvents
	)

Definition at line 1100 of file FlutterEmbedderKeyResponderTest.mm.

                                                                  {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  id keyEventCallback = ^(BOOL handled) {
    last_handled = handled;
  };
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  // In:  CapsLock down
  // Out: CapsLock down & *CapsLock Up
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x10100, @"", @"", FALSE, kKeyCodeCapsLock)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 2u);
 
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  EXPECT_TRUE([[events firstObject] hasCallback]);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([[events lastObject] hasCallback]);
 
  EXPECT_EQ(last_handled, FALSE);
  [[events firstObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  // In:  CapsLock up
  // Out: CapsLock down & *CapsLock Up
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeCapsLock)
                callback:keyEventCallback];
 
  EXPECT_EQ([events count], 2u);
 
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  EXPECT_TRUE([[events firstObject] hasCallback]);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([[events lastObject] hasCallback]);
 
  EXPECT_EQ(last_handled, FALSE);
  [[events firstObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [391/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		IdentifyLeftAndRightModifiers
	)

Definition at line 720 of file FlutterEmbedderKeyResponderTest.mm.

                                                                          {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20106, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20104, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
}

◆ TEST() [392/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		IgnoreDuplicateUpEvent
	)

Definition at line 379 of file FlutterEmbedderKeyResponderTest.mm.

                                                                   {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
  __block BOOL last_handled = TRUE;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  EXPECT_EQ(last_handled, TRUE);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->physical, 0ull);
  EXPECT_EQ(event->logical, 0ull);
  EXPECT_FALSE([[events lastObject] hasCallback]);
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [393/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		MultipleCharacters
	)

Definition at line 274 of file FlutterEmbedderKeyResponderTest.mm.

                                                               {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0, @"àn", @"àn", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, 0x1400000000ull);
  EXPECT_STREQ(event->character, "àn");
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, 0x1400000000ull);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
}

◆ TEST() [394/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		NonAsciiCharacters
	)

Definition at line 200 of file FlutterEmbedderKeyResponderTest.mm.

                                                               {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x80140, @"", @"", FALSE, kKeyCodeAltRight)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalAltRight);
  EXPECT_EQ(event->logical, kLogicalAltRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x80140, @"∑", @"w", FALSE, kKeyCodeKeyW)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyW);
  EXPECT_EQ(event->logical, kLogicalKeyW);
  EXPECT_STREQ(event->character, "∑");
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeAltRight)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalAltRight);
  EXPECT_EQ(event->logical, kLogicalAltRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x100, @"w", @"w", FALSE, kKeyCodeKeyW)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyW);
  EXPECT_EQ(event->logical, kLogicalKeyW);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
}

◆ TEST() [395/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SpecialModiferFlags
	)

Definition at line 564 of file FlutterEmbedderKeyResponderTest.mm.

                                                                {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  // Keydown:    Numpad1, F1, KeyA, ShiftLeft
  // Then KeyUp: Numpad1, F1, KeyA, ShiftLeft
 
  // Numpad 1
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x200100, @"1", @"1", FALSE, kKeyCodeNumpad1)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumpad1);
  EXPECT_EQ(event->logical, kLogicalNumpad1);
  EXPECT_STREQ(event->character, "1");
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // F1
  [responder
      handleEvent:keyEvent(NSEventTypeKeyDown, 0x800100, @"\uf704", @"\uf704", FALSE, kKeyCodeF1)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalF1);
  EXPECT_EQ(event->logical, kLogicalF1);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // KeyA
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // ShiftLeft
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // Numpad 1
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x220102, @"1", @"1", FALSE, kKeyCodeNumpad1)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumpad1);
  EXPECT_EQ(event->logical, kLogicalNumpad1);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // F1
  [responder
      handleEvent:keyEvent(NSEventTypeKeyUp, 0x820102, @"\uF704", @"\uF704", FALSE, kKeyCodeF1)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalF1);
  EXPECT_EQ(event->logical, kLogicalF1);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // KeyA
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x20102, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  // ShiftLeft
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
}

◆ TEST() [396/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SynchronizeCapsLockStateOnCapsLock
	)

Definition at line 1183 of file FlutterEmbedderKeyResponderTest.mm.

                                                                               {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
  __block BOOL last_handled = TRUE;
  id keyEventCallback = ^(BOOL handled) {
    last_handled = handled;
  };
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  // In:  CapsLock down
  // Out: (empty)
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeCapsLock)
                callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  EXPECT_EQ(last_handled, TRUE);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->physical, 0ull);
  EXPECT_EQ(event->logical, 0ull);
  EXPECT_FALSE([[events lastObject] hasCallback]);
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [397/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SynchronizeCapsLockStateOnNormalKey
	)

Definition at line 1218 of file FlutterEmbedderKeyResponderTest.mm.

                                                                                {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  id keyEventCallback = ^(BOOL handled) {
    last_handled = handled;
  };
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x10100, @"A", @"a", FALSE, kKeyCodeKeyA)
                callback:keyEventCallback];
 
  EXPECT_EQ([events count], 3u);
 
  event = events[0].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([events[0] hasCallback]);
 
  event = events[1].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalCapsLock);
  EXPECT_EQ(event->logical, kLogicalCapsLock);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([events[1] hasCallback]);
 
  event = events[2].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "A");
  EXPECT_EQ(event->synthesized, false);
  EXPECT_TRUE([events[2] hasCallback]);
 
  EXPECT_EQ(last_handled, FALSE);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [398/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SynthesizeForDuplicateDownEvent
	)

Definition at line 317 of file FlutterEmbedderKeyResponderTest.mm.

                                                                            {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  last_handled = TRUE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
  EXPECT_EQ(last_handled, TRUE);
  [[events lastObject] respond:FALSE];
  EXPECT_EQ(last_handled, FALSE);
 
  [events removeAllObjects];
 
  last_handled = TRUE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"à", @"à", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled) {
                  last_handled = handled;
                }];
 
  EXPECT_EQ([events count], 2u);
 
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, NULL);
  EXPECT_EQ(event->synthesized, true);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, 0xE0ull /* à */);
  EXPECT_STREQ(event->character, "à");
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:FALSE];
  EXPECT_EQ(last_handled, FALSE);
 
  [events removeAllObjects];
}

◆ TEST() [399/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SynthesizeMissedModifierEvents
	)

Definition at line 806 of file FlutterEmbedderKeyResponderTest.mm.

                                                                           {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  id keyEventCallback = ^(BOOL handled) {
    last_handled = handled;
  };
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  // Case 1:
  // In:  L down, (L up), L down, L up
  // Out: L down,                 L up
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->physical, 0u);
  EXPECT_EQ(event->logical, 0u);
  EXPECT_FALSE([[events lastObject] hasCallback]);
  EXPECT_EQ(last_handled, TRUE);
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  // Case 2:
  // In:  (L down), L up
  // Out:
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->physical, 0u);
  EXPECT_EQ(event->logical, 0u);
  EXPECT_FALSE([[events lastObject] hasCallback]);
  EXPECT_EQ(last_handled, TRUE);
  [events removeAllObjects];
 
  // Case 3:
  // In:  L down, (L up), (R down), R up
  // Out: L down,                   *L up
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
 
  // The primary event is automatically replied with TRUE, unrelated to the received event.
  EXPECT_EQ(last_handled, TRUE);
  EXPECT_FALSE([[events lastObject] hasCallback]);
 
  [events removeAllObjects];
 
  // Case 4:
  // In:  L down, R down, (L up), R up
  // Out: L down, R down          *L up & R up
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", FALSE, kKeyCodeShiftLeft)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x20106, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:keyEventCallback];
 
  EXPECT_EQ([events count], 2u);
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
 
  EXPECT_FALSE([[events firstObject] hasCallback]);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
 
  EXPECT_EQ(last_handled, FALSE);
  EXPECT_TRUE([[events lastObject] hasCallback]);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [400/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		SynthesizeMissedModifierEventsInNormalEvents
	)

Definition at line 1022 of file FlutterEmbedderKeyResponderTest.mm.

                                                                                         {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  __block BOOL last_handled = TRUE;
  id keyEventCallback = ^(BOOL handled) {
    last_handled = handled;
  };
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  // In:  (LShift down), A down,           (LShift up), A up
  // Out:               *LS down & A down,              *LS up & A up
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x20102, @"A", @"A", FALSE, kKeyCodeKeyA)
                callback:keyEventCallback];
 
  EXPECT_EQ([events count], 2u);
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([[events firstObject] hasCallback]);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "A");
  EXPECT_EQ(event->synthesized, false);
  EXPECT_TRUE([[events lastObject] hasCallback]);
 
  EXPECT_EQ(last_handled, FALSE);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
 
  last_handled = FALSE;
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:keyEventCallback];
 
  EXPECT_EQ([events count], 2u);
  event = [events firstObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, true);
  EXPECT_FALSE([[events firstObject] hasCallback]);
 
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  EXPECT_TRUE([[events lastObject] hasCallback]);
 
  EXPECT_EQ(last_handled, FALSE);
  [[events lastObject] respond:TRUE];
  EXPECT_EQ(last_handled, TRUE);
 
  [events removeAllObjects];
}

◆ TEST() [401/715]

flutter::testing::TEST	(	FlutterEmbedderKeyResponderUnittests	,
		ToggleModifiersDuringKeyTap
	)

Definition at line 448 of file FlutterEmbedderKeyResponderTest.mm.

                                                                        {
  __block NSMutableArray<TestKeyEvent*>* events = [[NSMutableArray<TestKeyEvent*> alloc] init];
  FlutterKeyEvent* event;
 
  FlutterEmbedderKeyResponder* responder = [[FlutterEmbedderKeyResponder alloc]
      initWithSendEvent:^(const FlutterKeyEvent& event, _Nullable FlutterKeyEventCallback callback,
                          void* _Nullable user_data) {
        [events addObject:[[TestKeyEvent alloc] initWithEvent:&event
                                                     callback:callback
                                                     userData:user_data]];
      }];
 
  [responder handleEvent:keyEvent(NSEventTypeFlagsChanged, 123.0f, 0x20104, @"", @"", FALSE,
                                  kKeyCodeShiftRight)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->timestamp, 123000000.0f);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x20104, @"A", @"A", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "A");
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x20104, @"A", @"A", TRUE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "A");
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder
      handleEvent:keyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", FALSE, kKeyCodeShiftRight)
         callback:^(BOOL handled){
         }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", TRUE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  [events removeAllObjects];
 
  [responder handleEvent:keyEvent(NSEventTypeKeyUp, 0x100, @"a", @"a", FALSE, kKeyCodeKeyA)
                callback:^(BOOL handled){
                }];
 
  EXPECT_EQ([events count], 1u);
  event = [events lastObject].data;
  ASSERT_NE(event, nullptr);
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, nullptr);
  EXPECT_EQ(event->synthesized, false);
  [[events lastObject] respond:TRUE];
 
  [events removeAllObjects];
}

◆ TEST() [402/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		CorrectLogicalKeyForLayouts
	)

Definition at line 462 of file FlutterKeyboardManagerTest.mm.

                                                                   {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] correctLogicalKeyForLayouts]);
}

◆ TEST() [403/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		DoublePrimaryResponder
	)

Definition at line 438 of file FlutterKeyboardManagerTest.mm.

                                                              {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] doublePrimaryResponder]);
}

◆ TEST() [404/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		EmptyNextResponder
	)

Definition at line 446 of file FlutterKeyboardManagerTest.mm.

                                                          {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] emptyNextResponder]);
}

◆ TEST() [405/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		GetPressedState
	)

Definition at line 450 of file FlutterKeyboardManagerTest.mm.

                                                       {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] getPressedState]);
}

◆ TEST() [406/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		KeyboardChannelGetPressedState
	)

Definition at line 454 of file FlutterKeyboardManagerTest.mm.

                                                                      {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] keyboardChannelGetPressedState]);
}

◆ TEST() [407/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		RacingConditionBetweenKeyAndText
	)

Definition at line 458 of file FlutterKeyboardManagerTest.mm.

                                                                        {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] racingConditionBetweenKeyAndText]);
}

◆ TEST() [408/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		ShouldNotHoldStrongReferenceToViewDelegate
	)

Definition at line 466 of file FlutterKeyboardManagerTest.mm.

                                                                                  {
  ASSERT_TRUE(
      [[FlutterKeyboardManagerUnittestsObjC alloc] shouldNotHoldStrongReferenceToViewDelegate]);
}

◆ TEST() [409/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		SingleFinalResponder
	)

Definition at line 442 of file FlutterKeyboardManagerTest.mm.

                                                            {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] textInputPlugin]);
}

◆ TEST() [410/715]

flutter::testing::TEST	(	FlutterKeyboardManagerUnittests	,
		SinglePrimaryResponder
	)

Definition at line 434 of file FlutterKeyboardManagerTest.mm.

                                                              {
  ASSERT_TRUE([[FlutterKeyboardManagerUnittestsObjC alloc] singlePrimaryResponder]);
}

◆ TEST() [411/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateMac	,
		Basics
	)

Definition at line 32 of file FlutterPlatformNodeDelegateMacTest.mm.

                                             {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  engine.semanticsEnabled = YES;
  auto bridge = viewController.accessibilityBridge.lock();
  // Initialize ax node data.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  ;
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "accessibility";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  auto root_platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  // Verify the accessibility attribute matches.
  NSAccessibilityElement* native_accessibility =
      root_platform_node_delegate->GetNativeViewAccessible();
  std::string value = [native_accessibility.accessibilityValue UTF8String];
  EXPECT_TRUE(value == "accessibility");
  EXPECT_EQ(native_accessibility.accessibilityRole, NSAccessibilityStaticTextRole);
  EXPECT_EQ([native_accessibility.accessibilityChildren count], 0u);
  [engine shutDownEngine];
}

◆ TEST() [412/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateMac	,
		CanPerformAction
	)

Definition at line 149 of file FlutterPlatformNodeDelegateMacTest.mm.

                                                       {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
 
  // Attach the view to a NSWindow.
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
 
  engine.semanticsEnabled = YES;
  auto bridge = viewController.accessibilityBridge.lock();
  // Initialize ax node data.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
 
  auto root_platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
 
  // Set up embedder API mock.
  FlutterSemanticsAction called_action;
  uint64_t called_id;
 
  engine.embedderAPI.DispatchSemanticsAction = MOCK_ENGINE_PROC(
      DispatchSemanticsAction,
      ([&called_id, &called_action](auto engine, uint64_t id, FlutterSemanticsAction action,
                                    const uint8_t* data, size_t data_length) {
        called_id = id;
        called_action = action;
        return kSuccess;
      }));
 
  // Performs an AXAction.
  ui::AXActionData action_data;
  action_data.action = ax::mojom::Action::kDoDefault;
  root_platform_node_delegate->AccessibilityPerformAction(action_data);
 
  EXPECT_EQ(called_action, FlutterSemanticsAction::kFlutterSemanticsActionTap);
  EXPECT_EQ(called_id, 1u);
 
  [engine setViewController:nil];
  [engine shutDownEngine];
}

◆ TEST() [413/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateMac	,
		SelectableTextHasCorrectSemantics
	)

Definition at line 68 of file FlutterPlatformNodeDelegateMacTest.mm.

                                                                        {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  engine.semanticsEnabled = YES;
  auto bridge = viewController.accessibilityBridge.lock();
  // Initialize ax node data.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags =
      static_cast<FlutterSemanticsFlag>(FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
                                        FlutterSemanticsFlag::kFlutterSemanticsFlagIsReadOnly);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = 1;
  root.text_selection_extent = 3;
  root.label = "";
  root.hint = "";
  // Selectable text store its text in value
  root.value = "selectable text";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  auto root_platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  // Verify the accessibility attribute matches.
  NSAccessibilityElement* native_accessibility =
      root_platform_node_delegate->GetNativeViewAccessible();
  std::string value = [native_accessibility.accessibilityValue UTF8String];
  EXPECT_EQ(value, "selectable text");
  EXPECT_EQ(native_accessibility.accessibilityRole, NSAccessibilityStaticTextRole);
  EXPECT_EQ([native_accessibility.accessibilityChildren count], 0u);
  NSRange selection = native_accessibility.accessibilitySelectedTextRange;
  EXPECT_EQ(selection.location, 1u);
  EXPECT_EQ(selection.length, 2u);
  std::string selected_text = [native_accessibility.accessibilitySelectedText UTF8String];
  EXPECT_EQ(selected_text, "el");
}

◆ TEST() [414/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateMac	,
		SelectableTextWithoutSelectionReturnZeroRange
	)

Definition at line 110 of file FlutterPlatformNodeDelegateMacTest.mm.

                                                                                    {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  engine.semanticsEnabled = YES;
  auto bridge = viewController.accessibilityBridge.lock();
  // Initialize ax node data.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags =
      static_cast<FlutterSemanticsFlag>(FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField |
                                        FlutterSemanticsFlag::kFlutterSemanticsFlagIsReadOnly);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "";
  root.hint = "";
  // Selectable text store its text in value
  root.value = "selectable text";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  auto root_platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  // Verify the accessibility attribute matches.
  NSAccessibilityElement* native_accessibility =
      root_platform_node_delegate->GetNativeViewAccessible();
  NSRange selection = native_accessibility.accessibilitySelectedTextRange;
  EXPECT_TRUE(selection.location == NSNotFound);
  EXPECT_EQ(selection.length, 0u);
}

◆ TEST() [415/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateMac	,
		TextFieldUsesFlutterTextField
	)

Definition at line 220 of file FlutterPlatformNodeDelegateMacTest.mm.

                                                                    {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  [viewController loadView];
 
  // Unit test localization is unnecessary.
  // NOLINTNEXTLINE(clang-analyzer-optin.osx.cocoa.localizability.NonLocalizedStringChecker)
  viewController.textInputPlugin.string = @"textfield";
  // Creates a NSWindow so that the native text field can become first responder.
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
  engine.semanticsEnabled = YES;
 
  auto bridge = viewController.accessibilityBridge.lock();
  // Initialize ax node data.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  root.rect = {0, 0, 100, 100};  // LTRB
  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  double rectSize = 50;
  double transformFactor = 0.5;
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.flags = FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField;
  child1.actions = static_cast<FlutterSemanticsAction>(0);
  child1.label = "";
  child1.hint = "";
  child1.value = "textfield";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.text_selection_base = -1;
  child1.text_selection_extent = -1;
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  child1.rect = {0, 0, rectSize, rectSize};  // LTRB
  child1.transform = {transformFactor, 0, 0, 0, transformFactor, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
 
  auto child_platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  // Verify the accessibility attribute matches.
  id native_accessibility = child_platform_node_delegate->GetNativeViewAccessible();
  EXPECT_EQ([native_accessibility isKindOfClass:[FlutterTextField class]], YES);
  FlutterTextField* native_text_field = (FlutterTextField*)native_accessibility;
 
  NSView* view = viewController.flutterView;
  CGRect scaledBounds = [view convertRectToBacking:view.bounds];
  CGSize scaledSize = scaledBounds.size;
  double pixelRatio = view.bounds.size.width == 0 ? 1 : scaledSize.width / view.bounds.size.width;
 
  double expectedFrameSize = rectSize * transformFactor / pixelRatio;
  EXPECT_EQ(NSEqualRects(native_text_field.frame, NSMakeRect(0, 600 - expectedFrameSize,
                                                             expectedFrameSize, expectedFrameSize)),
            YES);
 
  [native_text_field startEditing];
  EXPECT_EQ([native_text_field.stringValue isEqualToString:@"textfield"], YES);
}

◆ TEST() [416/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canCalculateBoundsCorrectly
	)

Definition at line 110 of file flutter_platform_node_delegate_unittests.cc.

                                                                   {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  root.rect = {0, 0, 100, 100};  // LTRB
  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  child1.rect = {0, 0, 50, 50};  // LTRB
  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  ui::AXOffscreenResult result;
  gfx::Rect bounds =
      child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
                                 ui::AXClippingBehavior::kClipped, &result);
  EXPECT_EQ(bounds.x(), 0);
  EXPECT_EQ(bounds.y(), 0);
  EXPECT_EQ(bounds.width(), 25);
  EXPECT_EQ(bounds.height(), 25);
  EXPECT_EQ(result, ui::AXOffscreenResult::kOnscreen);
}

◆ TEST() [417/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canCalculateOffScreenBoundsCorrectly
	)

Definition at line 156 of file flutter_platform_node_delegate_unittests.cc.

                                                                            {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  root.rect = {0, 0, 100, 100};  // LTRB
  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  child1.rect = {90, 90, 100, 100};  // LTRB
  child1.transform = {2, 0, 0, 0, 2, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  ui::AXOffscreenResult result;
  gfx::Rect bounds =
      child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
                                 ui::AXClippingBehavior::kUnclipped, &result);
  EXPECT_EQ(bounds.x(), 180);
  EXPECT_EQ(bounds.y(), 180);
  EXPECT_EQ(bounds.width(), 20);
  EXPECT_EQ(bounds.height(), 20);
  EXPECT_EQ(result, ui::AXOffscreenResult::kOffscreen);
}

◆ TEST() [418/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canGetAXNode
	)

Definition at line 84 of file flutter_platform_node_delegate_unittests.cc.

                                                    {
  // Set up a flutter accessibility node.
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField;
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  EXPECT_EQ(accessibility->GetData().id, 0);
}

◆ TEST() [419/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canGetFromNodeID
	)

Definition at line 271 of file flutter_platform_node_delegate_unittests.cc.

                                                        {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  auto node_by_id = root_node->GetFromNodeID(1);
  EXPECT_EQ(child1_node->GetPlatformNode(), node_by_id);
}

◆ TEST() [420/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canPerfomActions
	)

Definition at line 40 of file flutter_platform_node_delegate_unittests.cc.

                                                        {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField;
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  // Performs an AXAction.
  ui::AXActionData action_data;
  action_data.action = ax::mojom::Action::kDoDefault;
  accessibility->AccessibilityPerformAction(action_data);
  EXPECT_EQ(bridge->performed_actions.size(), size_t{1});
  EXPECT_EQ(bridge->performed_actions[0],
            FlutterSemanticsAction::kFlutterSemanticsActionTap);
 
  action_data.action = ax::mojom::Action::kFocus;
  accessibility->AccessibilityPerformAction(action_data);
  EXPECT_EQ(bridge->performed_actions.size(), size_t{2});
  EXPECT_EQ(
      bridge->performed_actions[1],
      FlutterSemanticsAction::kFlutterSemanticsActionDidGainAccessibilityFocus);
 
  action_data.action = ax::mojom::Action::kScrollToMakeVisible;
  accessibility->AccessibilityPerformAction(action_data);
  EXPECT_EQ(bridge->performed_actions.size(), size_t{3});
  EXPECT_EQ(bridge->performed_actions[2],
            FlutterSemanticsAction::kFlutterSemanticsActionShowOnScreen);
}

◆ TEST() [421/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		canUseOwnerBridge
	)

Definition at line 202 of file flutter_platform_node_delegate_unittests.cc.

                                                         {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
  root.rect = {0, 0, 100, 100};  // LTRB
  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
  child1.rect = {0, 0, 50, 50};  // LTRB
  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
  bridge->AddFlutterSemanticsNodeUpdate(child1);
 
  bridge->CommitUpdates();
  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  auto owner_bridge = child1_node->GetOwnerBridge().lock();
 
  bool result;
  gfx::RectF bounds = owner_bridge->RelativeToGlobalBounds(
      child1_node->GetAXNode(), result, true);
  EXPECT_EQ(bounds.x(), 0);
  EXPECT_EQ(bounds.y(), 0);
  EXPECT_EQ(bounds.width(), 25);
  EXPECT_EQ(bounds.height(), 25);
  EXPECT_EQ(result, false);
}

◆ TEST() [422/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		NodeDelegateHasUniqueId
	)

Definition at line 15 of file flutter_platform_node_delegate_unittests.cc.

                                                               {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
 
  // Add node 0: root.
  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
  std::vector<int32_t> node0_children{1};
  node0.child_count = node0_children.size();
  node0.children_in_traversal_order = node0_children.data();
  node0.children_in_hit_test_order = node0_children.data();
 
  // Add node 1: text child of node 0.
  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
  node1.label = "prefecture";
  node1.value = "Kyoto";
 
  bridge->AddFlutterSemanticsNodeUpdate(node0);
  bridge->AddFlutterSemanticsNodeUpdate(node1);
  bridge->CommitUpdates();
 
  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  EXPECT_TRUE(node0_delegate->GetUniqueId() != node1_delegate->GetUniqueId());
}

◆ TEST() [423/715]

flutter::testing::TEST	(	FlutterPlatformNodeDelegateTest	,
		selfIsLowestPlatformAncestor
	)

Definition at line 249 of file flutter_platform_node_delegate_unittests.cc.

                                                                    {
  std::shared_ptr<TestAccessibilityBridge> bridge =
      std::make_shared<TestAccessibilityBridge>();
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.children_in_traversal_order = nullptr;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  auto lowest_platform_ancestor = root_node->GetLowestPlatformAncestor();
  EXPECT_EQ(root_node->GetNativeViewAccessible(), lowest_platform_ancestor);
}

◆ TEST() [424/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestAcceptGesture
	)

Definition at line 164 of file FlutterPlatformViewControllerTest.mm.

                                                       {
  FlutterPlatformViewController* platformViewController =
      [[FlutterPlatformViewController alloc] init];
  [platformViewController registerViewFactory:[TestFlutterPlatformViewFactory alloc]
                                       withId:@"MockPlatformView"];
 
  // Create the PlatformView.
  const NSNumber* viewId = [NSNumber numberWithLongLong:2];
  FlutterMethodCall* methodCallOnCreate = [FlutterMethodCall
      methodCallWithMethodName:@"create"
                     arguments:@{@"id" : viewId, @"viewType" : @"MockPlatformView"}];
  __block bool created = false;
  FlutterResult resultOnCreate = ^(id result) {
    // If a platform view is successfully created, the result is nil.
    if (result == nil) {
      created = true;
    }
  };
  [platformViewController handleMethodCall:methodCallOnCreate result:resultOnCreate];
 
  // Call acceptGesture.
  FlutterMethodCall* methodCallAcceptGesture =
      [FlutterMethodCall methodCallWithMethodName:@"acceptGesture" arguments:@{@"id" : viewId}];
  __block bool acceptGestureCalled = false;
  FlutterResult resultAcceptGesture = ^(id result) {
    // If a acceptGesture is successful, the result is nil.
    if (result == nil) {
      acceptGestureCalled = true;
    }
  };
  [platformViewController handleMethodCall:methodCallAcceptGesture result:resultAcceptGesture];
 
  EXPECT_TRUE(created);
  EXPECT_TRUE(acceptGestureCalled);
}

◆ TEST() [425/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestAcceptGestureOnMissingViewId
	)

Definition at line 200 of file FlutterPlatformViewControllerTest.mm.

                                                                      {
  FlutterPlatformViewController* platformViewController =
      [[FlutterPlatformViewController alloc] init];
  [platformViewController registerViewFactory:[TestFlutterPlatformViewFactory alloc]
                                       withId:@"MockPlatformView"];
 
  // Call rejectGesture.
  FlutterMethodCall* methodCallAcceptGesture =
      [FlutterMethodCall methodCallWithMethodName:@"acceptGesture" arguments:@{
        @"id" : @20
      }];
  __block bool errored = false;
  FlutterResult result = ^(id result) {
    if ([result isKindOfClass:[FlutterError class]]) {
      errored = true;
    }
  };
  [platformViewController handleMethodCall:methodCallAcceptGesture result:result];
 
  EXPECT_TRUE(errored);
}

◆ TEST() [426/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestCreateAndDispose
	)

Definition at line 101 of file FlutterPlatformViewControllerTest.mm.

                                                          {
  // Use id so we can access handleMethodCall method.
  id platformViewController = [[FlutterPlatformViewController alloc] init];
 
  TestFlutterPlatformViewFactory* factory = [TestFlutterPlatformViewFactory alloc];
 
  [platformViewController registerViewFactory:factory withId:@"MockPlatformView"];
 
  FlutterMethodCall* methodCallOnCreate =
      [FlutterMethodCall methodCallWithMethodName:@"create"
                                        arguments:@{
                                          @"id" : @2,
                                          @"viewType" : @"MockPlatformView"
                                        }];
 
  __block bool created = false;
  FlutterResult resultOnCreate = ^(id result) {
    // If a platform view is successfully created, the result is nil.
    if (result == nil) {
      created = true;
    }
  };
 
  [platformViewController handleMethodCall:methodCallOnCreate result:resultOnCreate];
 
  FlutterMethodCall* methodCallOnDispose =
      [FlutterMethodCall methodCallWithMethodName:@"dispose"
                                        arguments:[NSNumber numberWithLongLong:2]];
 
  __block bool disposed = false;
  FlutterResult resultOnDispose = ^(id result) {
    // If a platform view is successfully created, the result is nil.
    if (result == nil) {
      disposed = true;
    }
  };
 
  [platformViewController handleMethodCall:methodCallOnDispose result:resultOnDispose];
 
  EXPECT_TRUE(created);
  EXPECT_TRUE(disposed);
}

◆ TEST() [427/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestCreatePlatformViewNoMatchingViewType
	)

Definition at line 14 of file FlutterPlatformViewControllerTest.mm.

                                                                              {
  // Use id so we can access handleMethodCall method.
  id platformViewController = [[FlutterPlatformViewController alloc] init];
 
  FlutterMethodCall* methodCall =
      [FlutterMethodCall methodCallWithMethodName:@"create"
                                        arguments:@{
                                          @"id" : @2,
                                          @"viewType" : @"FlutterPlatformViewMock"
                                        }];
 
  __block bool errored = false;
  FlutterResult result = ^(id result) {
    if ([result isKindOfClass:[FlutterError class]]) {
      errored = true;
    }
  };
 
  [platformViewController handleMethodCall:methodCall result:result];
 
  // We expect the call to error since no factories are registered.
  EXPECT_TRUE(errored);
}

◆ TEST() [428/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestDisposeOnMissingViewId
	)

Definition at line 144 of file FlutterPlatformViewControllerTest.mm.

                                                                {
  // Use id so we can access handleMethodCall method.
  id platformViewController = [[FlutterPlatformViewController alloc] init];
 
  FlutterMethodCall* methodCall =
      [FlutterMethodCall methodCallWithMethodName:@"dispose"
                                        arguments:[NSNumber numberWithLongLong:20]];
 
  __block bool errored = false;
  FlutterResult result = ^(id result) {
    if ([result isKindOfClass:[FlutterError class]]) {
      errored = true;
    }
  };
 
  [platformViewController handleMethodCall:methodCall result:result];
 
  EXPECT_TRUE(errored);
}

◆ TEST() [429/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestRegisterPlatformViewFactoryAndCreate
	)

Definition at line 38 of file FlutterPlatformViewControllerTest.mm.

                                                                              {
  // Use id so we can access handleMethodCall method.
  id platformViewController = [[FlutterPlatformViewController alloc] init];
 
  TestFlutterPlatformViewFactory* factory = [TestFlutterPlatformViewFactory alloc];
 
  [platformViewController registerViewFactory:factory withId:@"MockPlatformView"];
 
  NSDictionary* creationArgs = @{
    @"album" : @"スコットとリバース",
    @"releaseYear" : @2013,
    @"artists" : @[ @"Scott Murphy", @"Rivers Cuomo" ],
    @"playlist" : @[ @"おかしいやつ", @"ほどけていたんだ" ],
  };
  NSObject<FlutterMessageCodec>* codec = [factory createArgsCodec];
  FlutterStandardTypedData* creationArgsData =
      [FlutterStandardTypedData typedDataWithBytes:[codec encode:creationArgs]];
 
  FlutterMethodCall* methodCall =
      [FlutterMethodCall methodCallWithMethodName:@"create"
                                        arguments:@{
                                          @"id" : @2,
                                          @"viewType" : @"MockPlatformView",
                                          @"params" : creationArgsData,
                                        }];
 
  __block bool success = false;
  FlutterResult result = ^(id result) {
    // If a platform view is successfully created, the result is nil.
    if (result == nil) {
      success = true;
    }
  };
  [platformViewController handleMethodCall:methodCall result:result];
  EXPECT_TRUE(success);
 
  // Verify PlatformView parameters are decoded correctly.
  TestFlutterPlatformView* view =
      (TestFlutterPlatformView*)[platformViewController platformViewWithID:2];
  ASSERT_TRUE(view != nil);
  ASSERT_TRUE(view.args != nil);
 
  // Verify string type.
  NSString* album = [view.args objectForKey:@"album"];
  EXPECT_TRUE([album isEqualToString:@"スコットとリバース"]);
 
  // Verify int type.
  NSNumber* releaseYear = [view.args objectForKey:@"releaseYear"];
  EXPECT_EQ(releaseYear.intValue, 2013);
 
  // Verify list/array types.
  NSArray* artists = [view.args objectForKey:@"artists"];
  ASSERT_TRUE(artists != nil);
  ASSERT_EQ(artists.count, 2ul);
  EXPECT_TRUE([artists[0] isEqualToString:@"Scott Murphy"]);
  EXPECT_TRUE([artists[1] isEqualToString:@"Rivers Cuomo"]);
 
  NSArray* playlist = [view.args objectForKey:@"playlist"];
  ASSERT_EQ(playlist.count, 2ul);
  EXPECT_TRUE([playlist[0] isEqualToString:@"おかしいやつ"]);
  EXPECT_TRUE([playlist[1] isEqualToString:@"ほどけていたんだ"]);
}

◆ TEST() [430/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestRejectGesture
	)

Definition at line 222 of file FlutterPlatformViewControllerTest.mm.

                                                       {
  FlutterPlatformViewController* platformViewController =
      [[FlutterPlatformViewController alloc] init];
  [platformViewController registerViewFactory:[TestFlutterPlatformViewFactory alloc]
                                       withId:@"MockPlatformView"];
 
  // Create the PlatformView.
  const NSNumber* viewId = [NSNumber numberWithLongLong:2];
  FlutterMethodCall* methodCallOnCreate = [FlutterMethodCall
      methodCallWithMethodName:@"create"
                     arguments:@{@"id" : viewId, @"viewType" : @"MockPlatformView"}];
  __block bool created = false;
  FlutterResult resultOnCreate = ^(id result) {
    // If a platform view is successfully created, the result is nil.
    if (result == nil) {
      created = true;
    }
  };
  [platformViewController handleMethodCall:methodCallOnCreate result:resultOnCreate];
 
  // Call rejectGesture.
  FlutterMethodCall* methodCallRejectGesture =
      [FlutterMethodCall methodCallWithMethodName:@"rejectGesture" arguments:@{@"id" : viewId}];
  __block bool rejectGestureCalled = false;
  FlutterResult resultRejectGesture = ^(id result) {
    // If a rejectGesture is successful, the result is nil.
    if (result == nil) {
      rejectGestureCalled = true;
    }
  };
  [platformViewController handleMethodCall:methodCallRejectGesture result:resultRejectGesture];
 
  EXPECT_TRUE(created);
  EXPECT_TRUE(rejectGestureCalled);
}

◆ TEST() [431/715]

flutter::testing::TEST	(	FlutterPlatformViewController	,
		TestRejectGestureOnMissingViewId
	)

Definition at line 258 of file FlutterPlatformViewControllerTest.mm.

                                                                      {
  FlutterPlatformViewController* platformViewController =
      [[FlutterPlatformViewController alloc] init];
  [platformViewController registerViewFactory:[TestFlutterPlatformViewFactory alloc]
                                       withId:@"MockPlatformView"];
 
  // Call rejectGesture.
  FlutterMethodCall* methodCallRejectGesture =
      [FlutterMethodCall methodCallWithMethodName:@"rejectGesture" arguments:@{
        @"id" : @20
      }];
  __block bool errored = false;
  FlutterResult result = ^(id result) {
    if ([result isKindOfClass:[FlutterError class]]) {
      errored = true;
    }
  };
  [platformViewController handleMethodCall:methodCallRejectGesture result:result];
 
  EXPECT_TRUE(errored);
}

◆ TEST() [432/715]

flutter::testing::TEST	(	FlutterProjectBundle	,
		BasicPropertiesAbsolutePaths
	)

Definition at line 11 of file flutter_project_bundle_unittests.cc.

                                                         {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"C:\\foo\\flutter_assets";
  properties.icu_data_path = L"C:\\foo\\icudtl.dat";
 
  FlutterProjectBundle project(properties);
 
  EXPECT_TRUE(project.HasValidPaths());
  EXPECT_EQ(project.assets_path().string(), "C:\\foo\\flutter_assets");
  EXPECT_EQ(project.icu_path().string(), "C:\\foo\\icudtl.dat");
}

◆ TEST() [433/715]

flutter::testing::TEST	(	FlutterProjectBundle	,
		BasicPropertiesRelativePaths
	)

Definition at line 23 of file flutter_project_bundle_unittests.cc.

                                                         {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"foo\\flutter_assets";
  properties.icu_data_path = L"foo\\icudtl.dat";
 
  FlutterProjectBundle project(properties);
 
  EXPECT_TRUE(project.HasValidPaths());
  EXPECT_TRUE(project.assets_path().is_absolute());
  EXPECT_EQ(project.assets_path().filename().string(), "flutter_assets");
  EXPECT_TRUE(project.icu_path().is_absolute());
  EXPECT_EQ(project.icu_path().filename().string(), "icudtl.dat");
}

◆ TEST() [434/715]

flutter::testing::TEST	(	FlutterProjectBundle	,
		DartEntrypointArguments
	)

Definition at line 50 of file flutter_project_bundle_unittests.cc.

                                                    {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"foo\\flutter_assets";
  properties.icu_data_path = L"foo\\icudtl.dat";
 
  std::vector<const char*> test_arguments = {"arg1", "arg2"};
  properties.dart_entrypoint_argc = test_arguments.size();
  properties.dart_entrypoint_argv = test_arguments.data();
 
  FlutterProjectBundle project(properties);
 
  std::vector<std::string> retrieved_arguments =
      project.dart_entrypoint_arguments();
  EXPECT_EQ(retrieved_arguments.size(), 2U);
  EXPECT_EQ(retrieved_arguments[0], "arg1");
  EXPECT_EQ(retrieved_arguments[1], "arg2");
}

◆ TEST() [435/715]

flutter::testing::TEST	(	FlutterProjectBundle	,
		Switches
	)

Definition at line 69 of file flutter_project_bundle_unittests.cc.

                                     {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"foo\\flutter_assets";
  properties.icu_data_path = L"foo\\icudtl.dat";
 
  _putenv_s("FLUTTER_ENGINE_SWITCHES", "2");
  _putenv_s("FLUTTER_ENGINE_SWITCH_1", "abc");
  _putenv_s("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"");
 
  FlutterProjectBundle project(properties);
 
  std::vector<std::string> switches = project.GetSwitches();
  EXPECT_EQ(switches.size(), 2);
  EXPECT_EQ(switches[0], "--abc");
  EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
}

◆ TEST() [436/715]

flutter::testing::TEST	(	FlutterProjectBundle	,
		SwitchesEmpty
	)

Definition at line 37 of file flutter_project_bundle_unittests.cc.

                                          {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"foo\\flutter_assets";
  properties.icu_data_path = L"foo\\icudtl.dat";
 
  // Clear the main environment variable, since test order is not guaranteed.
  _putenv_s("FLUTTER_ENGINE_SWITCHES", "");
 
  FlutterProjectBundle project(properties);
 
  EXPECT_EQ(project.GetSwitches().size(), 0);
}

◆ TEST() [437/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		BackBufferCacheDoesNotLeak
	)

Definition at line 96 of file FlutterSurfaceManagerTest.mm.

                                                        {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
 
  auto surface1 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface1) ] atTime:0 notify:nil];
 
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
 
  auto surface2 = [surfaceManager surfaceForSize:CGSizeMake(110, 110)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface2) ] atTime:0 notify:nil];
 
  EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
 
  auto surface3 = [surfaceManager surfaceForSize:CGSizeMake(120, 120)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface3) ] atTime:0 notify:nil];
 
  // Cache should be cleaned during present and only contain the last visible
  // surface(s).
  EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
  auto surfaceFromCache = [surfaceManager surfaceForSize:CGSizeMake(110, 110)];
  EXPECT_EQ(surfaceFromCache, surface2);
 
  // Submit empty surfaces until the one in cache gets to age >= kSurfaceEvictionAge, in which case
  // it should be removed.
 
  for (int i = 0; i < 30 /* kSurfaceEvictionAge */; ++i) {
    [surfaceManager presentSurfaces:@[] atTime:0 notify:nil];
    EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
  }
 
  [surfaceManager presentSurfaces:@[] atTime:0 notify:nil];
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
}

◆ TEST() [438/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		BackingStoreCacheSurfaceStuckInUse
	)

Definition at line 171 of file FlutterSurfaceManagerTest.mm.

                                                                {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
 
  auto surface1 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
 
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface1) ] atTime:0 notify:nil];
  // Pretend that compositor is holding on to the surface. The surface will be kept
  // in cache until the age of kSurfaceEvictionAge is reached, and then evicted.
  surface1.isInUseOverride = YES;
 
  auto surface2 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface2) ] atTime:0 notify:nil];
  EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
 
  for (int i = 0; i < 30 /* kSurfaceEvictionAge */ - 1; ++i) {
    auto surface3 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
    [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface3) ] atTime:0 notify:nil];
    EXPECT_EQ(surfaceManager.backBufferCache.count, 2ul);
  }
 
  auto surface4 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface4) ] atTime:0 notify:nil];
  // Surface in use should bet old enough at this point to be evicted.
  EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
}

◆ TEST() [439/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		LayerManagement
	)

Definition at line 202 of file FlutterSurfaceManagerTest.mm.

                                             {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
 
  EXPECT_EQ(testView.layer.sublayers.count, 0ul);
 
  auto surface1_1 = [surfaceManager surfaceForSize:CGSizeMake(50, 30)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface1_1, CGPointMake(20, 10)) ]
                           atTime:0
                           notify:nil];
 
  EXPECT_EQ(testView.layer.sublayers.count, 1ul);
  EXPECT_TRUE(CGSizeEqualToSize(testView.presentedFrameSize, CGSizeMake(70, 40)));
 
  auto surface2_1 = [surfaceManager surfaceForSize:CGSizeMake(50, 30)];
  auto surface2_2 = [surfaceManager surfaceForSize:CGSizeMake(20, 20)];
  [surfaceManager presentSurfaces:@[
    CreatePresentInfo(surface2_1, CGPointMake(20, 10), 1),
    CreatePresentInfo(surface2_2, CGPointMake(40, 50), 2,
                      {
                          FlutterRect{0, 0, 20, 20},
                          FlutterRect{40, 0, 60, 20},
                      })
  ]
                           atTime:0
                           notify:nil];
 
  EXPECT_EQ(testView.layer.sublayers.count, 2ul);
  EXPECT_EQ(testView.layer.sublayers[0].zPosition, 1.0);
  EXPECT_EQ(testView.layer.sublayers[1].zPosition, 2.0);
  CALayer* firstOverlaySublayer;
  {
    NSArray<CALayer*>* sublayers = testView.layer.sublayers[1].sublayers;
    EXPECT_EQ(sublayers.count, 2ul);
    EXPECT_TRUE(CGRectEqualToRect(sublayers[0].frame, CGRectMake(0, 0, 10, 10)));
    EXPECT_TRUE(CGRectEqualToRect(sublayers[1].frame, CGRectMake(20, 0, 10, 10)));
    EXPECT_TRUE(CGRectEqualToRect(sublayers[0].contentsRect, CGRectMake(0, 0, 1, 1)));
    EXPECT_TRUE(CGRectEqualToRect(sublayers[1].contentsRect, CGRectMake(2, 0, 1, 1)));
    EXPECT_EQ(sublayers[0].contents, sublayers[1].contents);
    firstOverlaySublayer = sublayers[0];
  }
  EXPECT_TRUE(CGSizeEqualToSize(testView.presentedFrameSize, CGSizeMake(70, 70)));
 
  // Check second overlay sublayer is removed while first is reused and updated
  [surfaceManager presentSurfaces:@[
    CreatePresentInfo(surface2_1, CGPointMake(20, 10), 1),
    CreatePresentInfo(surface2_2, CGPointMake(40, 50), 2,
                      {
                          FlutterRect{0, 10, 20, 20},
                      })
  ]
                           atTime:0
                           notify:nil];
  EXPECT_EQ(testView.layer.sublayers.count, 2ul);
  {
    NSArray<CALayer*>* sublayers = testView.layer.sublayers[1].sublayers;
    EXPECT_EQ(sublayers.count, 1ul);
    EXPECT_EQ(sublayers[0], firstOverlaySublayer);
    EXPECT_TRUE(CGRectEqualToRect(sublayers[0].frame, CGRectMake(0, 5, 10, 5)));
  }
 
  // Check that second overlay sublayer is added back while first is reused and updated
  [surfaceManager presentSurfaces:@[
    CreatePresentInfo(surface2_1, CGPointMake(20, 10), 1),
    CreatePresentInfo(surface2_2, CGPointMake(40, 50), 2,
                      {
                          FlutterRect{0, 0, 20, 20},
                          FlutterRect{40, 0, 60, 20},
                      })
  ]
                           atTime:0
                           notify:nil];
 
  EXPECT_EQ(testView.layer.sublayers.count, 2ul);
  {
    NSArray<CALayer*>* sublayers = testView.layer.sublayers[1].sublayers;
    EXPECT_EQ(sublayers.count, 2ul);
    EXPECT_EQ(sublayers[0], firstOverlaySublayer);
    EXPECT_TRUE(CGRectEqualToRect(sublayers[0].frame, CGRectMake(0, 0, 10, 10)));
    EXPECT_TRUE(CGRectEqualToRect(sublayers[1].frame, CGRectMake(20, 0, 10, 10)));
    EXPECT_EQ(sublayers[0].contents, sublayers[1].contents);
  }
 
  auto surface3_1 = [surfaceManager surfaceForSize:CGSizeMake(50, 30)];
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface3_1, CGPointMake(20, 10)) ]
                           atTime:0
                           notify:nil];
 
  EXPECT_EQ(testView.layer.sublayers.count, 1ul);
  EXPECT_TRUE(CGSizeEqualToSize(testView.presentedFrameSize, CGSizeMake(70, 40)));
 
  // Check removal of all surfaces.
  [surfaceManager presentSurfaces:@[] atTime:0 notify:nil];
  EXPECT_EQ(testView.layer.sublayers.count, 0ul);
  EXPECT_TRUE(CGSizeEqualToSize(testView.presentedFrameSize, CGSizeMake(0, 0)));
}

◆ TEST() [440/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		MetalTextureSizeMatchesSurfaceSize
	)

Definition at line 64 of file FlutterSurfaceManagerTest.mm.

                                                                {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
 
  // Get back buffer, lookup should work for borrowed surfaces util present.
  auto surface = [surfaceManager surfaceForSize:CGSizeMake(100, 50)];
  auto texture = surface.asFlutterMetalTexture;
  id<MTLTexture> metalTexture = (__bridge id)texture.texture;
  EXPECT_EQ(metalTexture.width, 100ul);
  EXPECT_EQ(metalTexture.height, 50ul);
  texture.destruction_callback(texture.user_data);
}

◆ TEST() [441/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		SurfacesAreRecycled
	)

Definition at line 132 of file FlutterSurfaceManagerTest.mm.

                                                 {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
 
  EXPECT_EQ(surfaceManager.frontSurfaces.count, 0ul);
 
  // Get first surface and present it.
 
  auto surface1 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  EXPECT_TRUE(CGSizeEqualToSize(surface1.size, CGSizeMake(100, 100)));
 
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
  EXPECT_EQ(surfaceManager.frontSurfaces.count, 0ul);
 
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface1) ] atTime:0 notify:nil];
 
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
  EXPECT_EQ(surfaceManager.frontSurfaces.count, 1ul);
  EXPECT_EQ(testView.layer.sublayers.count, 1ul);
 
  // Get second surface and present it.
 
  auto surface2 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  EXPECT_TRUE(CGSizeEqualToSize(surface2.size, CGSizeMake(100, 100)));
 
  EXPECT_EQ(surfaceManager.backBufferCache.count, 0ul);
 
  [surfaceManager presentSurfaces:@[ CreatePresentInfo(surface2) ] atTime:0 notify:nil];
 
  // Check that current front surface returns to cache.
  EXPECT_EQ(surfaceManager.backBufferCache.count, 1ul);
  EXPECT_EQ(surfaceManager.frontSurfaces.count, 1ul);
  EXPECT_EQ(testView.layer.sublayers.count, 1ull);
 
  // Check that surface is properly reused.
  auto surface3 = [surfaceManager surfaceForSize:CGSizeMake(100, 100)];
  EXPECT_EQ(surface3, surface1);
}

◆ TEST() [442/715]

flutter::testing::TEST	(	FlutterSurfaceManager	,
		TestSurfaceLookupFromTexture
	)

Definition at line 77 of file FlutterSurfaceManagerTest.mm.

                                                          {
  TestView* testView = [[TestView alloc] init];
  FlutterSurfaceManager* surfaceManager = CreateSurfaceManager(testView);
 
  // Get back buffer, lookup should work for borrowed surfaces util present.
  auto surface = [surfaceManager surfaceForSize:CGSizeMake(100, 50)];
 
  // SurfaceManager should keep texture alive while borrowed.
  auto texture = surface.asFlutterMetalTexture;
  texture.destruction_callback(texture.user_data);
 
  FlutterMetalTexture dummyTexture{.texture_id = 1, .texture = nullptr, .user_data = nullptr};
  auto surface1 = [FlutterSurface fromFlutterMetalTexture:&dummyTexture];
  EXPECT_EQ(surface1, nil);
 
  auto surface2 = [FlutterSurface fromFlutterMetalTexture:&texture];
  EXPECT_EQ(surface2, surface);
}

◆ TEST() [443/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		CanNotBecomeResponderIfNoViewController
	)

Definition at line 2026 of file FlutterTextInputPluginTest.mm.

                                                                          {
  FlutterEngine* engine = CreateTestEngine();
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  // Creates a NSWindow so that the native text field can become first responder.
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
 
  engine.semanticsEnabled = YES;
 
  auto bridge = viewController.accessibilityBridge.lock();
  FlutterPlatformNodeDelegateMac delegate(bridge, viewController);
  ui::AXTree tree;
  ui::AXNode ax_node(&tree, nullptr, 0, 0);
  ui::AXNodeData node_data;
  node_data.SetValue("initial text");
  ax_node.SetData(node_data);
  delegate.Init(viewController.accessibilityBridge, &ax_node);
  FlutterTextPlatformNode text_platform_node(&delegate, viewController);
 
  FlutterTextField* textField = text_platform_node.GetNativeViewAccessible();
  EXPECT_EQ([textField becomeFirstResponder], YES);
  // Removes view controller.
  [engine setViewController:nil];
  FlutterTextPlatformNode text_platform_node_no_controller(&delegate, nil);
  textField = text_platform_node_no_controller.GetNativeViewAccessible();
  EXPECT_EQ([textField becomeFirstResponder], NO);
}

◆ TEST() [444/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		CanWorkWithFlutterTextField
	)

Definition at line 1961 of file FlutterTextInputPluginTest.mm.

                                                              {
  FlutterEngine* engine = CreateTestEngine();
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  // Create a NSWindow so that the native text field can become first responder.
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
 
  engine.semanticsEnabled = YES;
 
  auto bridge = viewController.accessibilityBridge.lock();
  FlutterPlatformNodeDelegateMac delegate(bridge, viewController);
  ui::AXTree tree;
  ui::AXNode ax_node(&tree, nullptr, 0, 0);
  ui::AXNodeData node_data;
  node_data.SetValue("initial text");
  ax_node.SetData(node_data);
  delegate.Init(viewController.accessibilityBridge, &ax_node);
  {
    FlutterTextPlatformNode text_platform_node(&delegate, viewController);
 
    FlutterTextFieldMock* mockTextField =
        [[FlutterTextFieldMock alloc] initWithPlatformNode:&text_platform_node
                                               fieldEditor:viewController.textInputPlugin];
    [viewController.view addSubview:mockTextField];
    [mockTextField startEditing];
 
    NSDictionary* setClientConfig = @{
      @"inputAction" : @"action",
      @"inputType" : @{@"name" : @"inputName"},
    };
    FlutterMethodCall* methodCall =
        [FlutterMethodCall methodCallWithMethodName:@"TextInput.setClient"
                                          arguments:@[ @(1), setClientConfig ]];
    FlutterResult result = ^(id result) {
    };
    [viewController.textInputPlugin handleMethodCall:methodCall result:result];
 
    NSDictionary* arguments = @{
      @"text" : @"new text",
      @"selectionBase" : @(1),
      @"selectionExtent" : @(2),
      @"composingBase" : @(-1),
      @"composingExtent" : @(-1),
    };
    methodCall = [FlutterMethodCall methodCallWithMethodName:@"TextInput.setEditingState"
                                                   arguments:arguments];
    [viewController.textInputPlugin handleMethodCall:methodCall result:result];
    EXPECT_EQ([mockTextField.lastUpdatedString isEqualToString:@"new text"], YES);
    EXPECT_EQ(NSEqualRanges(mockTextField.lastUpdatedSelection, NSMakeRange(1, 1)), YES);
 
    // This blocks the FlutterTextFieldMock, which is held onto by the main event
    // loop, from crashing.
    [mockTextField setPlatformNode:nil];
  }
 
  // This verifies that clearing the platform node works.
  [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
}

◆ TEST() [445/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		FirstResponderIsCorrect
	)

Definition at line 2093 of file FlutterTextInputPluginTest.mm.

                                                          {
  FlutterEngine* engine = CreateTestEngine();
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
 
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
 
  ASSERT_TRUE(viewController.flutterView.acceptsFirstResponder);
 
  [window makeFirstResponder:viewController.flutterView];
 
  [viewController.textInputPlugin
      handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.show" arguments:@[]]
                result:^(id){
                }];
 
  ASSERT_TRUE(window.firstResponder == viewController.textInputPlugin);
 
  ASSERT_FALSE(viewController.flutterView.acceptsFirstResponder);
 
  [viewController.textInputPlugin
      handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.hide" arguments:@[]]
                result:^(id){
                }];
 
  ASSERT_TRUE(viewController.flutterView.acceptsFirstResponder);
  ASSERT_TRUE(window.firstResponder == viewController.flutterView);
}

◆ TEST() [446/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		HandleArrowKeyWhenImePopoverIsActive
	)

Definition at line 1937 of file FlutterTextInputPluginTest.mm.

                                                                       {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] handleArrowKeyWhenImePopoverIsActive]);
}

◆ TEST() [447/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		HasZeroSizeAndClipsToBounds
	)

Definition at line 2128 of file FlutterTextInputPluginTest.mm.

                                                              {
  id engineMock = flutter::testing::CreateMockFlutterEngine(@"");
  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
  OCMStub(  // NOLINT(google-objc-avoid-throwing-exception)
      [engineMock binaryMessenger])
      .andReturn(binaryMessengerMock);
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engineMock
                                                                                nibName:@""
                                                                                 bundle:nil];
 
  FlutterTextInputPlugin* plugin =
      [[FlutterTextInputPlugin alloc] initWithViewController:viewController];
 
  ASSERT_TRUE(NSIsEmptyRect(plugin.frame));
  ASSERT_TRUE(plugin.clipsToBounds);
}

◆ TEST() [448/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		IsAddedAndRemovedFromViewHierarchy
	)

Definition at line 2060 of file FlutterTextInputPluginTest.mm.

                                                                     {
  FlutterEngine* engine = CreateTestEngine();
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
 
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
 
  ASSERT_EQ(viewController.textInputPlugin.superview, nil);
  ASSERT_FALSE(window.firstResponder == viewController.textInputPlugin);
 
  [viewController.textInputPlugin
      handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.show" arguments:@[]]
                result:^(id){
                }];
 
  ASSERT_EQ(viewController.textInputPlugin.superview, viewController.view);
  ASSERT_TRUE(window.firstResponder == viewController.textInputPlugin);
 
  [viewController.textInputPlugin
      handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"TextInput.hide" arguments:@[]]
                result:^(id){
                }];
 
  ASSERT_EQ(viewController.textInputPlugin.superview, nil);
  ASSERT_FALSE(window.firstResponder == viewController.textInputPlugin);
}

◆ TEST() [449/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteDisabledWhenAutofillGroupIncludesPassword
	)

Definition at line 1895 of file FlutterTextInputPluginTest.mm.

                                                                                            {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc]
      testAutocompleteDisabledWhenAutofillGroupIncludesPassword]);
}

◆ TEST() [450/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteDisabledWhenAutofillNotSet
	)

Definition at line 1875 of file FlutterTextInputPluginTest.mm.

                                                                             {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testAutocompleteDisabledWhenAutofillNotSet]);
}

◆ TEST() [451/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteDisabledWhenObscureTextSet
	)

Definition at line 1887 of file FlutterTextInputPluginTest.mm.

                                                                             {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testAutocompleteDisabledWhenObscureTextSet]);
}

◆ TEST() [452/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteDisabledWhenPasswordAutofillSet
	)

Definition at line 1891 of file FlutterTextInputPluginTest.mm.

                                                                                  {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testAutocompleteDisabledWhenPasswordAutofillSet]);
}

◆ TEST() [453/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteEnabledWhenAutofillSet
	)

Definition at line 1879 of file FlutterTextInputPluginTest.mm.

                                                                         {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testAutocompleteEnabledWhenAutofillSet]);
}

◆ TEST() [454/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestAutocompleteEnabledWhenAutofillSetNoHint
	)

Definition at line 1883 of file FlutterTextInputPluginTest.mm.

                                                                               {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testAutocompleteEnabledWhenAutofillSetNoHint]);
}

◆ TEST() [455/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestClearClientDuringComposing
	)

Definition at line 1871 of file FlutterTextInputPluginTest.mm.

                                                                 {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testClearClientDuringComposing]);
}

◆ TEST() [456/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestComposingRegionRemovedByFramework
	)

Definition at line 1867 of file FlutterTextInputPluginTest.mm.

                                                                        {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testComposingRegionRemovedByFramework]);
}

◆ TEST() [457/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestComposingWithDelta
	)

Definition at line 1921 of file FlutterTextInputPluginTest.mm.

                                                         {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testComposingWithDelta]);
}

◆ TEST() [458/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestComposingWithDeltasWhenSelectionIsActive
	)

Definition at line 1925 of file FlutterTextInputPluginTest.mm.

                                                                               {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testComposingWithDeltasWhenSelectionIsActive]);
}

◆ TEST() [459/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestEmptyCompositionRange
	)

Definition at line 1855 of file FlutterTextInputPluginTest.mm.

                                                            {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testEmptyCompositionRange]);
}

◆ TEST() [460/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestFirstRectForCharacterRange
	)

Definition at line 1900 of file FlutterTextInputPluginTest.mm.

                                                                 {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testFirstRectForCharacterRange]);
}

◆ TEST() [461/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestFirstRectForCharacterRangeAtInfinity
	)

Definition at line 1904 of file FlutterTextInputPluginTest.mm.

                                                                           {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testFirstRectForCharacterRangeAtInfinity]);
}

◆ TEST() [462/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestFirstRectForCharacterRangeWithEsotericAffineTransform
	)

Definition at line 1908 of file FlutterTextInputPluginTest.mm.

                                                                                            {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc]
      testFirstRectForCharacterRangeWithEsotericAffineTransform]);
}

◆ TEST() [463/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestInsertNewLine
	)

Definition at line 1953 of file FlutterTextInputPluginTest.mm.

                                                    {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testInsertNewLine]);
}

◆ TEST() [464/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestLocalTextAndSelectionUpdateAfterDelta
	)

Definition at line 1929 of file FlutterTextInputPluginTest.mm.

                                                                            {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testLocalTextAndSelectionUpdateAfterDelta]);
}

◆ TEST() [465/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestOperationsThatTriggerDelta
	)

Definition at line 1917 of file FlutterTextInputPluginTest.mm.

                                                                 {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testOperationsThatTriggerDelta]);
}

◆ TEST() [466/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestPerformKeyEquivalent
	)

Definition at line 1933 of file FlutterTextInputPluginTest.mm.

                                                           {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testPerformKeyEquivalent]);
}

◆ TEST() [467/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSelectorsAreForwardedToFramework
	)

Definition at line 1945 of file FlutterTextInputPluginTest.mm.

                                                                       {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSelectorsAreForwardedToFramework]);
}

◆ TEST() [468/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSelectorsNotForwardedToFrameworkIfNoClient
	)

Definition at line 1949 of file FlutterTextInputPluginTest.mm.

                                                                                 {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSelectorsNotForwardedToFrameworkIfNoClient]);
}

◆ TEST() [469/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSendActionDoNotInsertNewLine
	)

Definition at line 1957 of file FlutterTextInputPluginTest.mm.

                                                                   {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSendActionDoNotInsertNewLine]);
}

◆ TEST() [470/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSetEditingStateWithTextEditingDelta
	)

Definition at line 1913 of file FlutterTextInputPluginTest.mm.

                                                                          {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSetEditingStateWithTextEditingDelta]);
}

◆ TEST() [471/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSetMarkedTextWithReplacementRange
	)

Definition at line 1863 of file FlutterTextInputPluginTest.mm.

                                                                        {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSetMarkedTextWithReplacementRange]);
}

◆ TEST() [472/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		TestSetMarkedTextWithSelectionChange
	)

Definition at line 1859 of file FlutterTextInputPluginTest.mm.

                                                                       {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] testSetMarkedTextWithSelectionChange]);
}

◆ TEST() [473/715]

flutter::testing::TEST	(	FlutterTextInputPluginTest	,
		UnhandledKeyEquivalent
	)

Definition at line 1941 of file FlutterTextInputPluginTest.mm.

                                                         {
  ASSERT_TRUE([[FlutterInputPluginTestObjc alloc] unhandledKeyEquivalent]);
}

◆ TEST() [474/715]

flutter::testing::TEST	(	FlutterTextInputSemanticsObjectTest	,
		DoesInitialize
	)

Definition at line 27 of file FlutterTextInputSemanticsObjectTest.mm.

                                                          {
  FlutterEngine* engine = CreateTestEngine();
  {
    FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                  nibName:nil
                                                                                   bundle:nil];
    [viewController loadView];
    // Create a NSWindow so that the native text field can become first responder.
    NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                   styleMask:NSBorderlessWindowMask
                                                     backing:NSBackingStoreBuffered
                                                       defer:NO];
    window.contentView = viewController.view;
 
    engine.semanticsEnabled = YES;
 
    auto bridge = viewController.accessibilityBridge.lock();
    FlutterPlatformNodeDelegateMac delegate(bridge, viewController);
    ui::AXTree tree;
    ui::AXNode ax_node(&tree, nullptr, 0, 0);
    ui::AXNodeData node_data;
    node_data.SetValue("initial text");
    ax_node.SetData(node_data);
    delegate.Init(viewController.accessibilityBridge, &ax_node);
    // Verify that a FlutterTextField is attached to the view.
    FlutterTextPlatformNode text_platform_node(&delegate, viewController);
    id native_accessibility = text_platform_node.GetNativeViewAccessible();
    EXPECT_TRUE([native_accessibility isKindOfClass:[FlutterTextField class]]);
    auto subviews = [viewController.view subviews];
    EXPECT_EQ([subviews count], 2u);
    EXPECT_TRUE([subviews[0] isKindOfClass:[FlutterTextField class]]);
    FlutterTextField* nativeTextField = subviews[0];
    EXPECT_EQ(text_platform_node.GetNativeViewAccessible(), nativeTextField);
  }
 
  [engine shutDownEngine];
  engine = nil;
  // Pump the event loop to make sure no stray nodes cause crashes after the
  // engine has been destroyed.
  // From issue: https://github.com/flutter/flutter/issues/115599
  [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
}

◆ TEST() [475/715]

flutter::testing::TEST	(	FlutterViewEngineProviderUnittests	,
		GetViewReturnsTheCorrectView
	)

Definition at line 19 of file FlutterViewEngineProviderTest.mm.

                                                                       {
  FlutterViewEngineProvider* viewProvider;
  id mockEngine = CreateMockFlutterEngine(@"");
  __block id mockFlutterViewController;
  OCMStub([mockEngine viewControllerForIdentifier:0])
      .ignoringNonObjectArgs()
      .andDo(^(NSInvocation* invocation) {
        FlutterViewIdentifier viewIdentifier;
        [invocation getArgument:&viewIdentifier atIndex:2];
        if (viewIdentifier == kFlutterImplicitViewId) {
          if (mockFlutterViewController != nil) {
            [invocation setReturnValue:&mockFlutterViewController];
          }
        }
      });
  viewProvider = [[FlutterViewEngineProvider alloc] initWithEngine:mockEngine];
 
  // When the view controller is not set, the returned view is nil.
  EXPECT_EQ([viewProvider viewForIdentifier:0], nil);
 
  // When the view controller is set, the returned view is the controller's view.
  mockFlutterViewController = OCMStrictClassMock([FlutterViewController class]);
  id mockView = OCMStrictClassMock([FlutterView class]);
  OCMStub([mockFlutterViewController flutterView]).andReturn(mockView);
  EXPECT_EQ([viewProvider viewForIdentifier:0], mockView);
}

◆ TEST() [476/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		CreateDestroy
	)

Definition at line 67 of file flutter_windows_texture_registrar_unittests.cc.

                                                        {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  EXPECT_TRUE(true);
}

◆ TEST() [477/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		PopulateD3dTexture
	)

Definition at line 267 of file flutter_windows_texture_registrar_unittests.cc.

                                                             {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  UINT width = 100;
  UINT height = 100;
  auto d3d_texture = CreateD3dTexture(engine.get(), width, height);
  EXPECT_TRUE(d3d_texture);
 
  bool release_callback_called = false;
  FlutterDesktopGpuSurfaceDescriptor surface_descriptor = {};
  surface_descriptor.struct_size = sizeof(FlutterDesktopGpuSurfaceDescriptor);
  surface_descriptor.handle = d3d_texture.Get();
  surface_descriptor.width = surface_descriptor.visible_width = width;
  surface_descriptor.height = surface_descriptor.visible_height = height;
  surface_descriptor.release_context = &release_callback_called;
  surface_descriptor.release_callback = [](void* release_context) {
    bool* called = reinterpret_cast<bool*>(release_context);
    *called = true;
  };
 
  FlutterDesktopTextureInfo texture_info = {};
  texture_info.type = kFlutterDesktopGpuSurfaceTexture;
  texture_info.gpu_surface_config.struct_size =
      sizeof(FlutterDesktopGpuSurfaceTextureConfig);
  texture_info.gpu_surface_config.type =
      kFlutterDesktopGpuSurfaceTypeD3d11Texture2D;
  texture_info.gpu_surface_config.user_data = &surface_descriptor;
  texture_info.gpu_surface_config.callback =
      [](size_t width, size_t height,
         void* user_data) -> const FlutterDesktopGpuSurfaceDescriptor* {
    return reinterpret_cast<const FlutterDesktopGpuSurfaceDescriptor*>(
        user_data);
  };
 
  FlutterOpenGLTexture flutter_texture = {};
  auto texture_id = registrar.RegisterTexture(&texture_info);
  EXPECT_NE(texture_id, -1);
 
  EXPECT_CALL(*gl.get(), GenTextures(1, _))
      .Times(1)
      .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
 
  auto result =
      registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
  EXPECT_TRUE(result);
  EXPECT_EQ(flutter_texture.width, width);
  EXPECT_EQ(flutter_texture.height, height);
  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
  EXPECT_TRUE(release_callback_called);
}

◆ TEST() [478/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		PopulateD3dTextureWithHandle
	)

Definition at line 205 of file flutter_windows_texture_registrar_unittests.cc.

                                                                       {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  UINT width = 100;
  UINT height = 100;
  auto d3d_texture = CreateD3dTexture(engine.get(), width, height);
  EXPECT_TRUE(d3d_texture);
 
  ComPtr<IDXGIResource> shared_resource;
  EXPECT_TRUE(SUCCEEDED(d3d_texture.As(&shared_resource)));
 
  HANDLE shared_handle;
  EXPECT_TRUE(SUCCEEDED(shared_resource->GetSharedHandle(&shared_handle)));
 
  bool release_callback_called = false;
  FlutterDesktopGpuSurfaceDescriptor surface_descriptor = {};
  surface_descriptor.struct_size = sizeof(FlutterDesktopGpuSurfaceDescriptor);
  surface_descriptor.handle = shared_handle;
  surface_descriptor.width = surface_descriptor.visible_width = width;
  surface_descriptor.height = surface_descriptor.visible_height = height;
  surface_descriptor.release_context = &release_callback_called;
  surface_descriptor.release_callback = [](void* release_context) {
    bool* called = reinterpret_cast<bool*>(release_context);
    *called = true;
  };
 
  FlutterDesktopTextureInfo texture_info = {};
  texture_info.type = kFlutterDesktopGpuSurfaceTexture;
  texture_info.gpu_surface_config.struct_size =
      sizeof(FlutterDesktopGpuSurfaceTextureConfig);
  texture_info.gpu_surface_config.type =
      kFlutterDesktopGpuSurfaceTypeDxgiSharedHandle;
  texture_info.gpu_surface_config.user_data = &surface_descriptor;
  texture_info.gpu_surface_config.callback =
      [](size_t width, size_t height,
         void* user_data) -> const FlutterDesktopGpuSurfaceDescriptor* {
    return reinterpret_cast<const FlutterDesktopGpuSurfaceDescriptor*>(
        user_data);
  };
 
  FlutterOpenGLTexture flutter_texture = {};
  auto texture_id = registrar.RegisterTexture(&texture_info);
  EXPECT_NE(texture_id, -1);
 
  EXPECT_CALL(*gl.get(), GenTextures(1, _))
      .Times(1)
      .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
 
  auto result =
      registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
  EXPECT_TRUE(result);
  EXPECT_EQ(flutter_texture.width, width);
  EXPECT_EQ(flutter_texture.height, height);
  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
  EXPECT_TRUE(release_callback_called);
}

◆ TEST() [479/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		PopulateInvalidTexture
	)

Definition at line 323 of file flutter_windows_texture_registrar_unittests.cc.

                                                                 {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
 
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  auto result = registrar.PopulateTexture(1, 640, 480, nullptr);
  EXPECT_FALSE(result);
}

◆ TEST() [480/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		PopulatePixelBufferTexture
	)

Definition at line 154 of file flutter_windows_texture_registrar_unittests.cc.

                                                                     {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
 
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  bool release_callback_called = false;
  size_t width = 100;
  size_t height = 100;
  std::unique_ptr<uint8_t[]> pixels =
      std::make_unique<uint8_t[]>(width * height * 4);
  FlutterDesktopPixelBuffer pixel_buffer = {};
  pixel_buffer.width = width;
  pixel_buffer.height = height;
  pixel_buffer.buffer = pixels.get();
  pixel_buffer.release_context = &release_callback_called;
  pixel_buffer.release_callback = [](void* release_context) {
    bool* called = reinterpret_cast<bool*>(release_context);
    *called = true;
  };
 
  FlutterDesktopTextureInfo texture_info = {};
  texture_info.type = kFlutterDesktopPixelBufferTexture;
  texture_info.pixel_buffer_config.user_data = &pixel_buffer;
  texture_info.pixel_buffer_config.callback =
      [](size_t width, size_t height,
         void* user_data) -> const FlutterDesktopPixelBuffer* {
    return reinterpret_cast<const FlutterDesktopPixelBuffer*>(user_data);
  };
 
  FlutterOpenGLTexture flutter_texture = {};
  auto texture_id = registrar.RegisterTexture(&texture_info);
  EXPECT_NE(texture_id, -1);
 
  EXPECT_CALL(*gl.get(), GenTextures(1, _))
      .Times(1)
      .WillOnce([](GLsizei n, GLuint* textures) { textures[0] = 1; });
  EXPECT_CALL(*gl.get(), BindTexture).Times(1);
  EXPECT_CALL(*gl.get(), TexParameteri).Times(AtLeast(1));
  EXPECT_CALL(*gl.get(), TexImage2D).Times(1);
  EXPECT_CALL(*gl.get(), DeleteTextures(1, _)).Times(1);
 
  auto result =
      registrar.PopulateTexture(texture_id, 640, 480, &flutter_texture);
  EXPECT_TRUE(result);
  EXPECT_EQ(flutter_texture.width, width);
  EXPECT_EQ(flutter_texture.height, height);
  EXPECT_EQ(flutter_texture.target, GL_TEXTURE_2D);
  EXPECT_TRUE(release_callback_called);
}

◆ TEST() [481/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		RegisterUnknownTextureType
	)

Definition at line 140 of file flutter_windows_texture_registrar_unittests.cc.

                                                                     {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
 
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  FlutterDesktopTextureInfo texture_info = {};
  texture_info.type = static_cast<FlutterDesktopTextureType>(1234);
 
  auto texture_id = registrar.RegisterTexture(&texture_info);
 
  EXPECT_EQ(texture_id, -1);
}

◆ TEST() [482/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		RegisterUnregisterTexture
	)

Definition at line 75 of file flutter_windows_texture_registrar_unittests.cc.

                                                                    {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  auto gl = std::make_shared<egl::MockProcTable>();
 
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  FlutterDesktopTextureInfo texture_info = {};
  texture_info.type = kFlutterDesktopPixelBufferTexture;
  texture_info.pixel_buffer_config.callback =
      [](size_t width, size_t height,
         void* user_data) -> const FlutterDesktopPixelBuffer* {
    return nullptr;
  };
 
  int64_t registered_texture_id = 0;
  bool register_called = false;
  modifier.embedder_api().RegisterExternalTexture = MOCK_ENGINE_PROC(
      RegisterExternalTexture, ([&register_called, &registered_texture_id](
                                    auto engine, auto texture_id) {
        register_called = true;
        registered_texture_id = texture_id;
        return kSuccess;
      }));
 
  bool unregister_called = false;
  modifier.embedder_api().UnregisterExternalTexture = MOCK_ENGINE_PROC(
      UnregisterExternalTexture, ([&unregister_called, &registered_texture_id](
                                      auto engine, auto texture_id) {
        unregister_called = true;
        EXPECT_EQ(registered_texture_id, texture_id);
        return kSuccess;
      }));
 
  bool mark_frame_available_called = false;
  modifier.embedder_api().MarkExternalTextureFrameAvailable =
      MOCK_ENGINE_PROC(MarkExternalTextureFrameAvailable,
                       ([&mark_frame_available_called, &registered_texture_id](
                            auto engine, auto texture_id) {
                         mark_frame_available_called = true;
                         EXPECT_EQ(registered_texture_id, texture_id);
                         return kSuccess;
                       }));
 
  modifier.embedder_api().PostRenderThreadTask =
      MOCK_ENGINE_PROC(PostRenderThreadTask,
                       [](auto engine, auto callback, void* callback_data) {
                         callback(callback_data);
                         return kSuccess;
                       });
 
  auto texture_id = registrar.RegisterTexture(&texture_info);
  EXPECT_TRUE(register_called);
  EXPECT_NE(texture_id, -1);
  EXPECT_EQ(texture_id, registered_texture_id);
 
  EXPECT_TRUE(registrar.MarkTextureFrameAvailable(texture_id));
  EXPECT_TRUE(mark_frame_available_called);
 
  fml::AutoResetWaitableEvent latch;
  registrar.UnregisterTexture(texture_id, [&]() { latch.Signal(); });
  latch.Wait();
  ASSERT_TRUE(unregister_called);
}

◆ TEST() [483/715]

flutter::testing::TEST	(	FlutterWindowsTextureRegistrarTest	,
		UnregisterTextureWithEngineDownInvokesCallback
	)

Definition at line 333 of file flutter_windows_texture_registrar_unittests.cc.

                                                     {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  auto gl = std::make_shared<egl::MockProcTable>();
 
  FlutterWindowsTextureRegistrar registrar(engine.get(), gl);
 
  fml::AutoResetWaitableEvent latch;
  registrar.UnregisterTexture(1234, [&]() { latch.Signal(); });
  latch.Wait();
}

◆ TEST() [484/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		AccessibilityHitTesting
	)

Definition at line 752 of file flutter_windows_view_unittests.cc.

                                                      {
  constexpr FlutterTransformation kIdentityTransform = {1, 0, 0,  //
                                                        0, 1, 0,  //
                                                        0, 0, 1};
 
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  // Add root node at origin. Size 500x500.
  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
  std::vector<int32_t> node0_children{1, 2};
  node0.rect = {0, 0, 500, 500};
  node0.transform = kIdentityTransform;
  node0.child_count = node0_children.size();
  node0.children_in_traversal_order = node0_children.data();
  node0.children_in_hit_test_order = node0_children.data();
 
  // Add node 1 located at 0,0 relative to node 0. Size 250x500.
  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
  node1.rect = {0, 0, 250, 500};
  node1.transform = kIdentityTransform;
  node1.label = "prefecture";
  node1.value = "Kyoto";
 
  // Add node 2 located at 250,0 relative to node 0. Size 250x500.
  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
  std::vector<int32_t> node2_children{3};
  node2.rect = {0, 0, 250, 500};
  node2.transform = {1, 0, 250, 0, 1, 0, 0, 0, 1};
  node2.child_count = node2_children.size();
  node2.children_in_traversal_order = node2_children.data();
  node2.children_in_hit_test_order = node2_children.data();
 
  // Add node 3 located at 0,250 relative to node 2. Size 250, 250.
  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
  node3.rect = {0, 0, 250, 250};
  node3.transform = {1, 0, 0, 0, 1, 250, 0, 0, 1};
  node3.label = "city";
  node3.value = "Uji";
 
  bridge->AddFlutterSemanticsNodeUpdate(node0);
  bridge->AddFlutterSemanticsNodeUpdate(node1);
  bridge->AddFlutterSemanticsNodeUpdate(node2);
  bridge->AddFlutterSemanticsNodeUpdate(node3);
  bridge->CommitUpdates();
 
  // Look up the root windows node delegate.
  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_TRUE(node0_delegate);
  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  ASSERT_TRUE(node1_delegate);
  auto node2_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
  ASSERT_TRUE(node2_delegate);
  auto node3_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(3).lock();
  ASSERT_TRUE(node3_delegate);
 
  // Get the native IAccessible root object.
  IAccessible* node0_accessible = node0_delegate->GetNativeViewAccessible();
  ASSERT_TRUE(node0_accessible != nullptr);
 
  // Perform a hit test that should hit node 1.
  VARIANT varchild{};
  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(150, 150, &varchild)));
  EXPECT_EQ(varchild.vt, VT_DISPATCH);
  EXPECT_EQ(varchild.pdispVal, node1_delegate->GetNativeViewAccessible());
 
  // Perform a hit test that should hit node 2.
  varchild = {};
  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 150, &varchild)));
  EXPECT_EQ(varchild.vt, VT_DISPATCH);
  EXPECT_EQ(varchild.pdispVal, node2_delegate->GetNativeViewAccessible());
 
  // Perform a hit test that should hit node 3.
  varchild = {};
  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 450, &varchild)));
  EXPECT_EQ(varchild.vt, VT_DISPATCH);
  EXPECT_EQ(varchild.pdispVal, node3_delegate->GetNativeViewAccessible());
}

◆ TEST() [485/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		AddSemanticsNodeUpdate
	)

Definition at line 331 of file flutter_windows_view_unittests.cc.

                                                     {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  auto window_binding_handler =
      std::make_unique<NiceMock<MockWindowBindingHandler>>();
  std::unique_ptr<FlutterWindowsView> view =
      engine->CreateView(std::move(window_binding_handler));
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  // Add root node.
  FlutterSemanticsNode2 node{sizeof(FlutterSemanticsNode2), 0};
  node.label = "name";
  node.value = "value";
  node.platform_view_id = -1;
  bridge->AddFlutterSemanticsNodeUpdate(node);
  bridge->CommitUpdates();
 
  // Look up the root windows node delegate.
  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_TRUE(node_delegate);
  EXPECT_EQ(node_delegate->GetChildCount(), 0);
 
  // Get the native IAccessible object.
  IAccessible* native_view = node_delegate->GetNativeViewAccessible();
  ASSERT_TRUE(native_view != nullptr);
 
  // Property lookups will be made against this node itself.
  VARIANT varchild{};
  varchild.vt = VT_I4;
  varchild.lVal = CHILDID_SELF;
 
  // Verify node name matches our label.
  BSTR bname = nullptr;
  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
  std::string name(_com_util::ConvertBSTRToString(bname));
  EXPECT_EQ(name, "name");
 
  // Verify node value matches.
  BSTR bvalue = nullptr;
  ASSERT_EQ(native_view->get_accValue(varchild, &bvalue), S_OK);
  std::string value(_com_util::ConvertBSTRToString(bvalue));
  EXPECT_EQ(value, "value");
 
  // Verify node type is static text.
  VARIANT varrole{};
  varrole.vt = VT_I4;
  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
 
  // Get the IRawElementProviderFragment object.
  IRawElementProviderSimple* uia_view;
  native_view->QueryInterface(IID_PPV_ARGS(&uia_view));
  ASSERT_TRUE(uia_view != nullptr);
 
  // Verify name property matches our label.
  VARIANT varname{};
  ASSERT_EQ(uia_view->GetPropertyValue(UIA_NamePropertyId, &varname), S_OK);
  EXPECT_EQ(varname.vt, VT_BSTR);
  name = _com_util::ConvertBSTRToString(varname.bstrVal);
  EXPECT_EQ(name, "name");
 
  // Verify value property matches our label.
  VARIANT varvalue{};
  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ValueValuePropertyId, &varvalue),
            S_OK);
  EXPECT_EQ(varvalue.vt, VT_BSTR);
  value = _com_util::ConvertBSTRToString(varvalue.bstrVal);
  EXPECT_EQ(value, "value");
 
  // Verify node control type is text.
  varrole = {};
  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
            S_OK);
  EXPECT_EQ(varrole.vt, VT_I4);
  EXPECT_EQ(varrole.lVal, UIA_TextControlTypeId);
}

◆ TEST() [486/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		AddSemanticsNodeUpdateWithChildren
	)

Definition at line 430 of file flutter_windows_view_unittests.cc.

                                                                 {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  // Add root node.
  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
  std::vector<int32_t> node0_children{1, 2};
  node0.child_count = node0_children.size();
  node0.children_in_traversal_order = node0_children.data();
  node0.children_in_hit_test_order = node0_children.data();
 
  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
  node1.label = "prefecture";
  node1.value = "Kyoto";
  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
  std::vector<int32_t> node2_children{3};
  node2.child_count = node2_children.size();
  node2.children_in_traversal_order = node2_children.data();
  node2.children_in_hit_test_order = node2_children.data();
  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
  node3.label = "city";
  node3.value = "Uji";
 
  bridge->AddFlutterSemanticsNodeUpdate(node0);
  bridge->AddFlutterSemanticsNodeUpdate(node1);
  bridge->AddFlutterSemanticsNodeUpdate(node2);
  bridge->AddFlutterSemanticsNodeUpdate(node3);
  bridge->CommitUpdates();
 
  // Look up the root windows node delegate.
  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_TRUE(node_delegate);
  EXPECT_EQ(node_delegate->GetChildCount(), 2);
 
  // Get the native IAccessible object.
  IAccessible* node0_accessible = node_delegate->GetNativeViewAccessible();
  ASSERT_TRUE(node0_accessible != nullptr);
 
  // Property lookups will be made against this node itself.
  VARIANT varchild{};
  varchild.vt = VT_I4;
  varchild.lVal = CHILDID_SELF;
 
  // Verify node type is a group.
  VARIANT varrole{};
  varrole.vt = VT_I4;
  ASSERT_EQ(node0_accessible->get_accRole(varchild, &varrole), S_OK);
  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
 
  // Verify child count.
  long node0_child_count = 0;
  ASSERT_EQ(node0_accessible->get_accChildCount(&node0_child_count), S_OK);
  EXPECT_EQ(node0_child_count, 2);
 
  {
    // Look up first child of node0 (node1), a static text node.
    varchild.lVal = 1;
    IDispatch* node1_dispatch = nullptr;
    ASSERT_EQ(node0_accessible->get_accChild(varchild, &node1_dispatch), S_OK);
    ASSERT_TRUE(node1_dispatch != nullptr);
    IAccessible* node1_accessible = nullptr;
    ASSERT_EQ(node1_dispatch->QueryInterface(
                  IID_IAccessible, reinterpret_cast<void**>(&node1_accessible)),
              S_OK);
    ASSERT_TRUE(node1_accessible != nullptr);
 
    // Verify node name matches our label.
    varchild.lVal = CHILDID_SELF;
    BSTR bname = nullptr;
    ASSERT_EQ(node1_accessible->get_accName(varchild, &bname), S_OK);
    std::string name(_com_util::ConvertBSTRToString(bname));
    EXPECT_EQ(name, "prefecture");
 
    // Verify node value matches.
    BSTR bvalue = nullptr;
    ASSERT_EQ(node1_accessible->get_accValue(varchild, &bvalue), S_OK);
    std::string value(_com_util::ConvertBSTRToString(bvalue));
    EXPECT_EQ(value, "Kyoto");
 
    // Verify node type is static text.
    VARIANT varrole{};
    varrole.vt = VT_I4;
    ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
    EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
 
    // Verify the parent node is the root.
    IDispatch* parent_dispatch;
    node1_accessible->get_accParent(&parent_dispatch);
    IAccessible* parent_accessible;
    ASSERT_EQ(
        parent_dispatch->QueryInterface(
            IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
        S_OK);
    EXPECT_EQ(parent_accessible, node0_accessible);
  }
 
  // Look up second child of node0 (node2), a parent group for node3.
  varchild.lVal = 2;
  IDispatch* node2_dispatch = nullptr;
  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
  ASSERT_TRUE(node2_dispatch != nullptr);
  IAccessible* node2_accessible = nullptr;
  ASSERT_EQ(node2_dispatch->QueryInterface(
                IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
            S_OK);
  ASSERT_TRUE(node2_accessible != nullptr);
 
  {
    // Verify child count.
    long node2_child_count = 0;
    ASSERT_EQ(node2_accessible->get_accChildCount(&node2_child_count), S_OK);
    EXPECT_EQ(node2_child_count, 1);
 
    // Verify node type is static text.
    varchild.lVal = CHILDID_SELF;
    VARIANT varrole{};
    varrole.vt = VT_I4;
    ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
    EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
 
    // Verify the parent node is the root.
    IDispatch* parent_dispatch;
    node2_accessible->get_accParent(&parent_dispatch);
    IAccessible* parent_accessible;
    ASSERT_EQ(
        parent_dispatch->QueryInterface(
            IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
        S_OK);
    EXPECT_EQ(parent_accessible, node0_accessible);
  }
 
  {
    // Look up only child of node2 (node3), a static text node.
    varchild.lVal = 1;
    IDispatch* node3_dispatch = nullptr;
    ASSERT_EQ(node2_accessible->get_accChild(varchild, &node3_dispatch), S_OK);
    ASSERT_TRUE(node3_dispatch != nullptr);
    IAccessible* node3_accessible = nullptr;
    ASSERT_EQ(node3_dispatch->QueryInterface(
                  IID_IAccessible, reinterpret_cast<void**>(&node3_accessible)),
              S_OK);
    ASSERT_TRUE(node3_accessible != nullptr);
 
    // Verify node name matches our label.
    varchild.lVal = CHILDID_SELF;
    BSTR bname = nullptr;
    ASSERT_EQ(node3_accessible->get_accName(varchild, &bname), S_OK);
    std::string name(_com_util::ConvertBSTRToString(bname));
    EXPECT_EQ(name, "city");
 
    // Verify node value matches.
    BSTR bvalue = nullptr;
    ASSERT_EQ(node3_accessible->get_accValue(varchild, &bvalue), S_OK);
    std::string value(_com_util::ConvertBSTRToString(bvalue));
    EXPECT_EQ(value, "Uji");
 
    // Verify node type is static text.
    VARIANT varrole{};
    varrole.vt = VT_I4;
    ASSERT_EQ(node3_accessible->get_accRole(varchild, &varrole), S_OK);
    EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
 
    // Verify the parent node is node2.
    IDispatch* parent_dispatch;
    node3_accessible->get_accParent(&parent_dispatch);
    IAccessible* parent_accessible;
    ASSERT_EQ(
        parent_dispatch->QueryInterface(
            IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
        S_OK);
    EXPECT_EQ(parent_accessible, node2_accessible);
  }
}

◆ TEST() [487/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		CheckboxNativeState
	)

Definition at line 1116 of file flutter_windows_view_unittests.cc.

                                                  {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsChecked);
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
    EXPECT_EQ(root_node->GetData().GetCheckedState(),
              ax::mojom::CheckedState::kTrue);
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the checkbox is checked.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
 
    // Perform similar tests for UIA value;
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_ToggleToggleStatePropertyId, &native_state)));
    EXPECT_EQ(native_state.lVal, ToggleState_On);
 
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_AriaPropertiesPropertyId, &native_state)));
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=true"), nullptr);
  }
 
  // Test unchecked too.
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
    EXPECT_EQ(root_node->GetData().GetCheckedState(),
              ax::mojom::CheckedState::kFalse);
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the checkbox is unchecked.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
 
    // Perform similar tests for UIA value;
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_ToggleToggleStatePropertyId, &native_state)));
    EXPECT_EQ(native_state.lVal, ToggleState_Off);
 
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_AriaPropertiesPropertyId, &native_state)));
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=false"), nullptr);
  }
 
  // Now check mixed state.
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasCheckedState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsCheckStateMixed);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
    EXPECT_EQ(root_node->GetData().GetCheckedState(),
              ax::mojom::CheckedState::kMixed);
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the checkbox is mixed.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_MIXED);
 
    // Perform similar tests for UIA value;
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_ToggleToggleStatePropertyId, &native_state)));
    EXPECT_EQ(native_state.lVal, ToggleState_Indeterminate);
 
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_AriaPropertiesPropertyId, &native_state)));
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=mixed"), nullptr);
  }
}

◆ TEST() [488/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		DisablesVSyncAfterStartup
	)

Definition at line 1505 of file flutter_windows_view_unittests.cc.

                                                        {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
  auto egl_manager = std::make_unique<egl::MockManager>();
  egl::MockContext render_context;
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto surface_ptr = surface.get();
 
  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
      .WillOnce(Return(true));
 
  EXPECT_CALL(*egl_manager.get(), render_context)
      .WillOnce(Return(&render_context));
  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
 
  InSequence s;
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
      .WillOnce(Return(std::move(surface)));
  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
      .WillOnce([](fml::closure callback) {
        callback();
        return true;
      });
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
      .WillOnce([](fml::closure callback) {
        callback();
        return true;
      });
  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
 
  EngineModifier modifier{engine.get()};
  modifier.SetEGLManager(std::move(egl_manager));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
}

◆ TEST() [489/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		DisablesVSyncAtStartup
	)

Definition at line 1434 of file flutter_windows_view_unittests.cc.

                                                     {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
  auto egl_manager = std::make_unique<egl::MockManager>();
  egl::MockContext render_context;
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto surface_ptr = surface.get();
 
  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
 
  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
      .WillOnce(Return(true));
 
  EXPECT_CALL(*egl_manager.get(), render_context)
      .WillOnce(Return(&render_context));
  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
 
  InSequence s;
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
      .WillOnce(Return(std::move(surface)));
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
 
  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
 
  EngineModifier modifier{engine.get()};
  modifier.SetEGLManager(std::move(egl_manager));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
}

◆ TEST() [490/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		EnableSemantics
	)

Definition at line 309 of file flutter_windows_view_unittests.cc.

                                              {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
 
  bool semantics_enabled = false;
  modifier.embedder_api().UpdateSemanticsEnabled = MOCK_ENGINE_PROC(
      UpdateSemanticsEnabled,
      [&semantics_enabled](FLUTTER_API_SYMBOL(FlutterEngine) engine,
                           bool enabled) {
        semantics_enabled = enabled;
        return kSuccess;
      });
 
  auto window_binding_handler =
      std::make_unique<NiceMock<MockWindowBindingHandler>>();
  std::unique_ptr<FlutterWindowsView> view =
      engine->CreateView(std::move(window_binding_handler));
 
  view->OnUpdateSemanticsEnabled(true);
  EXPECT_TRUE(semantics_enabled);
}

◆ TEST() [491/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		EnablesVSyncAfterStartup
	)

Definition at line 1548 of file flutter_windows_view_unittests.cc.

                                                       {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
  auto egl_manager = std::make_unique<egl::MockManager>();
  egl::MockContext render_context;
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto surface_ptr = surface.get();
 
  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
 
  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
      .WillOnce(Return(false));
 
  EXPECT_CALL(*egl_manager.get(), render_context)
      .WillOnce(Return(&render_context));
  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
 
  InSequence s;
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
      .WillOnce(Return(std::move(surface)));
  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
      .WillOnce([](fml::closure callback) {
        callback();
        return true;
      });
 
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
 
  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
      .WillOnce([](fml::closure callback) {
        callback();
        return true;
      });
  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
 
  EngineModifier modifier{engine.get()};
  modifier.SetEGLManager(std::move(egl_manager));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
}

◆ TEST() [492/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		EnablesVSyncAtStartup
	)

Definition at line 1470 of file flutter_windows_view_unittests.cc.

                                                    {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
  auto egl_manager = std::make_unique<egl::MockManager>();
  egl::MockContext render_context;
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto surface_ptr = surface.get();
 
  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
      .WillOnce(Return(false));
 
  EXPECT_CALL(*egl_manager.get(), render_context)
      .WillOnce(Return(&render_context));
  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
 
  InSequence s;
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
      .WillOnce(Return(std::move(surface)));
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
 
  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
 
  EngineModifier modifier{engine.get()};
  modifier.SetEGLManager(std::move(egl_manager));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
}

◆ TEST() [493/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		KeySequence
	)

Definition at line 291 of file flutter_windows_view_unittests.cc.

                                          {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
 
  test_response = false;
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
              [](bool handled) {});
 
  EXPECT_EQ(key_event_logs.size(), 2);
  EXPECT_EQ(key_event_logs[0], kKeyEventFromEmbedder);
  EXPECT_EQ(key_event_logs[1], kKeyEventFromChannel);
 
  key_event_logs.clear();
}

◆ TEST() [494/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		NonZeroSemanticsRoot
	)

Definition at line 626 of file flutter_windows_view_unittests.cc.

                                                   {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  // Add root node.
  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
  std::vector<int32_t> node1_children{2};
  node1.child_count = node1_children.size();
  node1.children_in_traversal_order = node1_children.data();
  node1.children_in_hit_test_order = node1_children.data();
 
  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
  node2.label = "prefecture";
  node2.value = "Kyoto";
 
  bridge->AddFlutterSemanticsNodeUpdate(node1);
  bridge->AddFlutterSemanticsNodeUpdate(node2);
  bridge->CommitUpdates();
 
  // Look up the root windows node delegate.
  auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  ASSERT_TRUE(root_delegate);
  EXPECT_EQ(root_delegate->GetChildCount(), 1);
 
  // Look up the child node delegate
  auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
  ASSERT_TRUE(child_delegate);
  EXPECT_EQ(child_delegate->GetChildCount(), 0);
 
  // Ensure a node with ID 0 does not exist.
  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_FALSE(fake_delegate);
 
  // Get the root's native IAccessible object.
  IAccessible* node1_accessible = root_delegate->GetNativeViewAccessible();
  ASSERT_TRUE(node1_accessible != nullptr);
 
  // Property lookups will be made against this node itself.
  VARIANT varchild{};
  varchild.vt = VT_I4;
  varchild.lVal = CHILDID_SELF;
 
  // Verify node type is a group.
  VARIANT varrole{};
  varrole.vt = VT_I4;
  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
 
  // Verify child count.
  long node1_child_count = 0;
  ASSERT_EQ(node1_accessible->get_accChildCount(&node1_child_count), S_OK);
  EXPECT_EQ(node1_child_count, 1);
 
  {
    // Look up first child of node1 (node0), a static text node.
    varchild.lVal = 1;
    IDispatch* node2_dispatch = nullptr;
    ASSERT_EQ(node1_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
    ASSERT_TRUE(node2_dispatch != nullptr);
    IAccessible* node2_accessible = nullptr;
    ASSERT_EQ(node2_dispatch->QueryInterface(
                  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
              S_OK);
    ASSERT_TRUE(node2_accessible != nullptr);
 
    // Verify node name matches our label.
    varchild.lVal = CHILDID_SELF;
    BSTR bname = nullptr;
    ASSERT_EQ(node2_accessible->get_accName(varchild, &bname), S_OK);
    std::string name(_com_util::ConvertBSTRToString(bname));
    EXPECT_EQ(name, "prefecture");
 
    // Verify node value matches.
    BSTR bvalue = nullptr;
    ASSERT_EQ(node2_accessible->get_accValue(varchild, &bvalue), S_OK);
    std::string value(_com_util::ConvertBSTRToString(bvalue));
    EXPECT_EQ(value, "Kyoto");
 
    // Verify node type is static text.
    VARIANT varrole{};
    varrole.vt = VT_I4;
    ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
    EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
 
    // Verify the parent node is the root.
    IDispatch* parent_dispatch;
    node2_accessible->get_accParent(&parent_dispatch);
    IAccessible* parent_accessible;
    ASSERT_EQ(
        parent_dispatch->QueryInterface(
            IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
        S_OK);
    EXPECT_EQ(parent_accessible, node1_accessible);
  }
}

◆ TEST() [495/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		Shutdown
	)

Definition at line 241 of file flutter_windows_view_unittests.cc.

                                       {
  auto engine = std::make_unique<MockFlutterWindowsEngine>();
  auto window_binding_handler =
      std::make_unique<NiceMock<MockWindowBindingHandler>>();
  auto egl_manager = std::make_unique<egl::MockManager>();
  auto surface = std::make_unique<egl::MockWindowSurface>();
  egl::MockContext render_context;
 
  auto engine_ptr = engine.get();
  auto surface_ptr = surface.get();
  auto egl_manager_ptr = egl_manager.get();
 
  EngineModifier modifier{engine.get()};
  modifier.SetEGLManager(std::move(egl_manager));
 
  InSequence s;
  std::unique_ptr<FlutterWindowsView> view;
 
  // Mock render surface initialization.
  {
    EXPECT_CALL(*egl_manager_ptr, CreateWindowSurface)
        .WillOnce(Return(std::move(surface)));
    EXPECT_CALL(*engine_ptr, running).WillOnce(Return(false));
    EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
    EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
    EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
    EXPECT_CALL(*egl_manager_ptr, render_context)
        .WillOnce(Return(&render_context));
    EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
 
    view = engine->CreateView(std::move(window_binding_handler));
  }
 
  // The view must be removed before the surface can be destroyed.
  {
    auto view_id = view->view_id();
    FlutterWindowsViewController controller{std::move(engine), std::move(view)};
 
    EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
    EXPECT_CALL(*engine_ptr, RemoveView(view_id)).Times(1);
    EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
    EXPECT_CALL(*engine_ptr, PostRasterThreadTask)
        .WillOnce([](fml::closure callback) {
          callback();
          return true;
        });
    EXPECT_CALL(*surface_ptr, Destroy).Times(1);
  }
}

◆ TEST() [496/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		SubMenuExpandedState
	)

Definition at line 137 of file flutter_windows_view_unittests.cc.

                                                   {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  auto window_binding_handler =
      std::make_unique<NiceMock<MockWindowBindingHandler>>();
  std::unique_ptr<FlutterWindowsView> view =
      engine->CreateView(std::move(window_binding_handler));
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasExpandedState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsExpanded);
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kExpanded));
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the submenu is expanded.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_EXPANDED);
 
    // Perform similar tests for UIA value;
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
    EXPECT_EQ(native_state.lVal, ExpandCollapseState_Expanded);
 
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_AriaPropertiesPropertyId, &native_state)));
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=true"), nullptr);
  }
 
  // Test collapsed too.
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasExpandedState);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kCollapsed));
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the submenu is collapsed.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_COLLAPSED);
 
    // Perform similar tests for UIA value;
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
    EXPECT_EQ(native_state.lVal, ExpandCollapseState_Collapsed);
 
    ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
        UIA_AriaPropertiesPropertyId, &native_state)));
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=false"), nullptr);
  }
}

◆ TEST() [497/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		SwitchNativeState
	)

Definition at line 1260 of file flutter_windows_view_unittests.cc.

                                                {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState |
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsToggled);
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
    EXPECT_EQ(root_node->GetData().GetCheckedState(),
              ax::mojom::CheckedState::kTrue);
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    varchild.lVal = CHILDID_SELF;
    VARIANT varrole = {};
 
    // Verify the role of the switch is CHECKBUTTON
    ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
    ASSERT_EQ(varrole.lVal, ROLE_SYSTEM_CHECKBUTTON);
 
    // Verify the switch is pressed.
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_PRESSED);
    EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
 
    // Test similarly on UIA node.
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_EQ(uia_node->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
              S_OK);
    EXPECT_EQ(varrole.lVal, UIA_ButtonControlTypeId);
    ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
                                         &native_state),
              S_OK);
    EXPECT_EQ(native_state.lVal, ToggleState_On);
    ASSERT_EQ(
        uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
        S_OK);
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=true"), nullptr);
  }
 
  // Test unpressed too.
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagHasToggledState);
  bridge->AddFlutterSemanticsNodeUpdate(root);
  bridge->CommitUpdates();
 
  {
    auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
    EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
    EXPECT_EQ(root_node->GetData().GetCheckedState(),
              ax::mojom::CheckedState::kFalse);
 
    // Get the IAccessible for the root node.
    IAccessible* native_view = root_node->GetNativeViewAccessible();
    ASSERT_TRUE(native_view != nullptr);
 
    // Look up against the node itself (not one of its children).
    VARIANT varchild = {};
    varchild.vt = VT_I4;
 
    // Verify the switch is not pressed.
    varchild.lVal = CHILDID_SELF;
    VARIANT native_state = {};
    ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
    EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_PRESSED);
    EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
 
    // Test similarly on UIA node.
    IRawElementProviderSimple* uia_node;
    native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
    ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
                                         &native_state),
              S_OK);
    EXPECT_EQ(native_state.lVal, ToggleState_Off);
    ASSERT_EQ(
        uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
        S_OK);
    EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=false"), nullptr);
  }
}

◆ TEST() [498/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		TestEmptyFrameResizes
	)

Definition at line 917 of file flutter_windows_view_unittests.cc.

                                                    {
  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
  std::unique_ptr<FlutterWindowsEngine> engine =
      GetTestEngine(windows_proc_table);
 
  EngineModifier engine_modifier{engine.get()};
  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
      PostRenderThreadTask,
      ([](auto engine, VoidCallback callback, void* user_data) {
        callback(user_data);
        return kSuccess;
      }));
 
  auto egl_manager = std::make_unique<egl::MockManager>();
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
  auto resized_surface_ptr = resized_surface.get();
 
  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
 
  EXPECT_CALL(*egl_manager.get(),
              CreateWindowSurface(_, /*width=*/500, /*height=*/500))
      .WillOnce(Return(std::move((resized_surface))));
  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
 
  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
 
  fml::AutoResetWaitableEvent metrics_sent_latch;
  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&metrics_sent_latch](auto engine,
                             const FlutterWindowMetricsEvent* event) {
        metrics_sent_latch.Signal();
        return kSuccess;
      }));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  ViewModifier view_modifier{view.get()};
  engine_modifier.SetEGLManager(std::move(egl_manager));
  view_modifier.SetSurface(std::move(surface));
 
  fml::AutoResetWaitableEvent resized_latch;
  std::thread([&resized_latch, &view]() {
    // Start the window resize. This sends the new window metrics
    // and then blocks until another thread completes the window resize.
    EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
    resized_latch.Signal();
  }).detach();
 
  // Wait until the platform thread has started the window resize.
  metrics_sent_latch.Wait();
 
  // Complete the window resize by reporting an empty frame.
  view->OnEmptyFrameGenerated();
  view->OnFramePresented();
  resized_latch.Wait();
}

◆ TEST() [499/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		TooltipNodeData
	)

Definition at line 1377 of file flutter_windows_view_unittests.cc.

                                              {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().UpdateSemanticsEnabled =
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
        return kSuccess;
      };
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  // Enable semantics to instantiate accessibility bridge.
  view->OnUpdateSemanticsEnabled(true);
 
  auto bridge = view->accessibility_bridge().lock();
  ASSERT_TRUE(bridge);
 
  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
  root.id = 0;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "tooltip";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(
      FlutterSemanticsFlag::kFlutterSemanticsFlagIsTextField);
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  std::string tooltip = root_node->GetData().GetStringAttribute(
      ax::mojom::StringAttribute::kTooltip);
  EXPECT_EQ(tooltip, "tooltip");
 
  // Check that MSAA name contains the tooltip.
  IAccessible* native_view = bridge->GetFlutterPlatformNodeDelegateFromID(0)
                                 .lock()
                                 ->GetNativeViewAccessible();
  VARIANT varchild = {.vt = VT_I4, .lVal = CHILDID_SELF};
  BSTR bname;
  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
  EXPECT_NE(std::wcsstr(bname, L"tooltip"), nullptr);
 
  // Check that UIA help text is equal to the tooltip.
  IRawElementProviderSimple* uia_node;
  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
  VARIANT varname{};
  ASSERT_EQ(uia_node->GetPropertyValue(UIA_HelpTextPropertyId, &varname), S_OK);
  std::string uia_tooltip = _com_util::ConvertBSTRToString(varname.bstrVal);
  EXPECT_EQ(uia_tooltip, "tooltip");
}

◆ TEST() [500/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		UpdatesVSyncOnDwmUpdates
	)

Definition at line 1595 of file flutter_windows_view_unittests.cc.

                                                       {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
  auto egl_manager = std::make_unique<egl::MockManager>();
  egl::MockContext render_context;
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto surface_ptr = surface.get();
 
  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
 
  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
      .WillRepeatedly([](fml::closure callback) {
        callback();
        return true;
      });
 
  EXPECT_CALL(*egl_manager.get(), render_context)
      .WillRepeatedly(Return(&render_context));
 
  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
  EXPECT_CALL(render_context, ClearCurrent).WillRepeatedly(Return(true));
 
  InSequence s;
 
  // Mock render surface initialization.
  std::unique_ptr<FlutterWindowsView> view;
  {
    EXPECT_CALL(*egl_manager, CreateWindowSurface)
        .WillOnce(Return(std::move(surface)));
    EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
        .WillOnce(Return(true));
    EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
 
    EngineModifier engine_modifier{engine.get()};
    engine_modifier.SetEGLManager(std::move(egl_manager));
 
    view = engine->CreateView(
        std::make_unique<NiceMock<MockWindowBindingHandler>>());
  }
 
  // Disabling DWM composition should enable vsync blocking on the surface.
  {
    EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
        .WillOnce(Return(false));
    EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
 
    engine->OnDwmCompositionChanged();
  }
 
  // Enabling DWM composition should disable vsync blocking on the surface.
  {
    EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
        .WillOnce(Return(true));
    EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
 
    engine->OnDwmCompositionChanged();
  }
}

◆ TEST() [501/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		WindowRepaintTests
	)

Definition at line 1092 of file flutter_windows_view_unittests.cc.

                                                 {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
 
  FlutterWindowsView view{kImplicitViewId, engine.get(),
                          std::make_unique<flutter::FlutterWindow>(100, 100)};
 
  bool schedule_frame_called = false;
  modifier.embedder_api().ScheduleFrame =
      MOCK_ENGINE_PROC(ScheduleFrame, ([&schedule_frame_called](auto engine) {
                         schedule_frame_called = true;
                         return kSuccess;
                       }));
 
  view.OnWindowRepaint();
  EXPECT_TRUE(schedule_frame_called);
}

◆ TEST() [502/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		WindowResizeInvalidSurface
	)

Definition at line 1030 of file flutter_windows_view_unittests.cc.

                                                         {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
 
  EngineModifier engine_modifier(engine.get());
  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
      PostRenderThreadTask,
      ([](auto engine, VoidCallback callback, void* user_data) {
        callback(user_data);
        return kSuccess;
      }));
 
  auto egl_manager = std::make_unique<egl::MockManager>();
  auto surface = std::make_unique<egl::MockWindowSurface>();
 
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(false));
  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(false));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  ViewModifier view_modifier{view.get()};
  engine_modifier.SetEGLManager(std::move(egl_manager));
  view_modifier.SetSurface(std::move(surface));
 
  auto metrics_sent = false;
  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
        metrics_sent = true;
        return kSuccess;
      }));
 
  view->OnWindowSizeChanged(500, 500);
}

◆ TEST() [503/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		WindowResizeRace
	)

Definition at line 983 of file flutter_windows_view_unittests.cc.

                                               {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
 
  EngineModifier engine_modifier(engine.get());
  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
      PostRenderThreadTask,
      ([](auto engine, VoidCallback callback, void* user_data) {
        callback(user_data);
        return kSuccess;
      }));
 
  auto egl_manager = std::make_unique<egl::MockManager>();
  auto surface = std::make_unique<egl::MockWindowSurface>();
 
  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  ViewModifier view_modifier{view.get()};
  engine_modifier.SetEGLManager(std::move(egl_manager));
  view_modifier.SetSurface(std::move(surface));
 
  // Begin a frame.
  ASSERT_TRUE(view->OnFrameGenerated(100, 100));
 
  // Inject a window resize between the frame generation and
  // frame presentation. The new size invalidates the current frame.
  fml::AutoResetWaitableEvent resized_latch;
  std::thread([&resized_latch, &view]() {
    // The resize is never completed. The view times out and returns false.
    EXPECT_FALSE(view->OnWindowSizeChanged(500, 500));
    resized_latch.Signal();
  }).detach();
 
  // Wait until the platform thread has started the window resize.
  resized_latch.Wait();
 
  // Complete the invalidated frame while a resize is pending. Although this
  // might mean that we presented a frame with the wrong size, this should not
  // crash the app.
  view->OnFramePresented();
}

◆ TEST() [504/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		WindowResizeTests
	)

Definition at line 844 of file flutter_windows_view_unittests.cc.

                                                {
  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
  std::unique_ptr<FlutterWindowsEngine> engine =
      GetTestEngine(windows_proc_table);
 
  EngineModifier engine_modifier{engine.get()};
  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
      PostRenderThreadTask,
      ([](auto engine, VoidCallback callback, void* user_data) {
        callback(user_data);
        return kSuccess;
      }));
 
  auto egl_manager = std::make_unique<egl::MockManager>();
  auto surface = std::make_unique<egl::MockWindowSurface>();
  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
  egl::MockContext render_context;
 
  auto surface_ptr = surface.get();
  auto resized_surface_ptr = resized_surface.get();
 
  // Mock render surface creation
  EXPECT_CALL(*egl_manager, CreateWindowSurface)
      .WillOnce(Return(std::move(surface)));
  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
  EXPECT_CALL(*egl_manager, render_context).WillOnce(Return(&render_context));
  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
 
  // Mock render surface resize
  EXPECT_CALL(*surface_ptr, Destroy).WillOnce(Return(true));
  EXPECT_CALL(*egl_manager.get(),
              CreateWindowSurface(_, /*width=*/500, /*height=*/500))
      .WillOnce(Return(std::move((resized_surface))));
  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
 
  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
 
  engine_modifier.SetEGLManager(std::move(egl_manager));
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  fml::AutoResetWaitableEvent metrics_sent_latch;
  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&metrics_sent_latch](auto engine,
                             const FlutterWindowMetricsEvent* event) {
        metrics_sent_latch.Signal();
        return kSuccess;
      }));
 
  fml::AutoResetWaitableEvent resized_latch;
  std::thread([&resized_latch, &view]() {
    // Start the window resize. This sends the new window metrics
    // and then blocks until another thread completes the window resize.
    EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
    resized_latch.Signal();
  }).detach();
 
  // Wait until the platform thread has started the window resize.
  metrics_sent_latch.Wait();
 
  // Complete the window resize by reporting a frame with the new window size.
  ASSERT_TRUE(view->OnFrameGenerated(500, 500));
  view->OnFramePresented();
  resized_latch.Wait();
}

◆ TEST() [505/715]

flutter::testing::TEST	(	FlutterWindowsViewTest	,
		WindowResizeWithoutSurface
	)

Definition at line 1068 of file flutter_windows_view_unittests.cc.

                                                         {
  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
  EngineModifier modifier(engine.get());
 
  auto egl_manager = std::make_unique<egl::MockManager>();
 
  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
 
  std::unique_ptr<FlutterWindowsView> view = engine->CreateView(
      std::make_unique<NiceMock<MockWindowBindingHandler>>());
 
  modifier.SetEGLManager(std::move(egl_manager));
 
  auto metrics_sent = false;
  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
        metrics_sent = true;
        return kSuccess;
      }));
 
  view->OnWindowSizeChanged(500, 500);
}

◆ TEST() [506/715]

flutter::testing::TEST	(	GLContextSwitchTest	,
		SwitchKeepsContextCurrentWhileInScope
	)

Definition at line 19 of file gl_context_switch_unittests.cc.

                                                                 {
  {
    auto test_gl_context = std::make_unique<TestSwitchableGLContext>(0);
    auto context_switch = GLContextSwitch(std::move(test_gl_context));
    ASSERT_EQ(TestSwitchableGLContext::GetCurrentContext(), 0);
  }
  ASSERT_EQ(TestSwitchableGLContext::GetCurrentContext(), -1);
}

◆ TEST() [507/715]

flutter::testing::TEST	(	GPUSurfaceMetalImpeller	,
		AcquireFrameFromCAMetalLayerDoesNotRetainThis
	)

Definition at line 83 of file gpu_surface_metal_impeller_unittests.mm.

                                                                             {
  auto delegate = std::make_shared<TestGPUSurfaceMetalDelegate>();
  delegate->SetDevice();
  std::unique_ptr<Surface> surface =
      std::make_unique<GPUSurfaceMetalImpeller>(delegate.get(), CreateImpellerContext());
 
  ASSERT_TRUE(surface->IsValid());
 
  auto frame = surface->AcquireFrame(SkISize::Make(100, 100));
  ASSERT_TRUE(frame);
 
  // Simulate a rasterizer teardown, e.g. due to going to the background.
  surface.reset();
 
  ASSERT_TRUE(frame->Submit());
}

◆ TEST() [508/715]

flutter::testing::TEST	(	GPUSurfaceMetalImpeller	,
		AcquireFrameFromCAMetalLayerNullChecksDrawable
	)

Definition at line 72 of file gpu_surface_metal_impeller_unittests.mm.

                                                                              {
  auto delegate = std::make_shared<TestGPUSurfaceMetalDelegate>();
  std::shared_ptr<Surface> surface =
      std::make_shared<GPUSurfaceMetalImpeller>(delegate.get(), CreateImpellerContext());
 
  ASSERT_TRUE(surface->IsValid());
 
  auto frame = surface->AcquireFrame(SkISize::Make(100, 100));
  ASSERT_EQ(frame, nullptr);
}

◆ TEST() [509/715]

flutter::testing::TEST	(	GPUSurfaceMetalImpeller	,
		CanCreateValidSurface
	)

Definition at line 65 of file gpu_surface_metal_impeller_unittests.mm.

                                                     {
  auto delegate = std::make_shared<TestGPUSurfaceMetalDelegate>();
  auto surface = std::make_shared<GPUSurfaceMetalImpeller>(delegate.get(), CreateImpellerContext());
 
  ASSERT_TRUE(surface->IsValid());
}

◆ TEST() [510/715]

flutter::testing::TEST	(	GPUSurfaceMetalImpeller	,
		InvalidImpellerContextCreatesCausesSurfaceToBeInvalid
	)

Definition at line 58 of file gpu_surface_metal_impeller_unittests.mm.

                                                                                     {
  auto delegate = std::make_shared<TestGPUSurfaceMetalDelegate>();
  auto surface = std::make_shared<GPUSurfaceMetalImpeller>(delegate.get(), nullptr);
 
  ASSERT_FALSE(surface->IsValid());
}

◆ TEST() [511/715]

flutter::testing::TEST	(	ImageDecoderNoGLTest	,
		ImpellerWideGamutDisplayP3
	)

Definition at line 76 of file image_decoder_no_gl_unittests.cc.

                                                       {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Fuchsia can't load the test fixtures.";
#endif
  auto data = flutter::testing::OpenFixtureAsSkData("DisplayP3Logo.png");
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(100, 100), image->dimensions());
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
 
  ASSERT_FALSE(
      IsPngWithPLTE(descriptor->data()->bytes(), descriptor->data()->size()));
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> wide_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/true, allocator);
  ASSERT_TRUE(wide_result.has_value());
  ASSERT_EQ(wide_result->image_info.colorType(), kRGBA_F16_SkColorType);
  ASSERT_TRUE(wide_result->image_info.colorSpace()->isSRGB());
 
  const SkPixmap& wide_pixmap = wide_result->sk_bitmap->pixmap();
  const uint16_t* half_ptr = static_cast<const uint16_t*>(wide_pixmap.addr());
  bool found_deep_red = false;
  for (int i = 0; i < wide_pixmap.width() * wide_pixmap.height(); ++i) {
    float red = HalfToFloat(*half_ptr++);
    float green = HalfToFloat(*half_ptr++);
    float blue = HalfToFloat(*half_ptr++);
    half_ptr++;  // alpha
    if (fabsf(red - 1.0931f) < 0.01f && fabsf(green - -0.2268f) < 0.01f &&
        fabsf(blue - -0.1501f) < 0.01f) {
      found_deep_red = true;
      break;
    }
  }
 
  ASSERT_TRUE(found_deep_red);
  std::optional<DecompressResult> narrow_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/false, allocator);
 
  ASSERT_TRUE(narrow_result.has_value());
  ASSERT_EQ(narrow_result->image_info.colorType(), kRGBA_8888_SkColorType);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST() [512/715]

flutter::testing::TEST	(	ImageDecoderNoGLTest	,
		ImpellerWideGamutIndexedPng
	)

Definition at line 133 of file image_decoder_no_gl_unittests.cc.

                                                        {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Fuchsia can't load the test fixtures.";
#endif
  auto data = flutter::testing::OpenFixtureAsSkData("WideGamutIndexed.png");
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(100, 100), image->dimensions());
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
 
  ASSERT_TRUE(
      IsPngWithPLTE(descriptor->data()->bytes(), descriptor->data()->size()));
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> wide_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/true, allocator);
  ASSERT_EQ(wide_result->image_info.colorType(), kBGR_101010x_XR_SkColorType);
  ASSERT_TRUE(wide_result->image_info.colorSpace()->isSRGB());
 
  const SkPixmap& wide_pixmap = wide_result->sk_bitmap->pixmap();
  const uint32_t* pixel_ptr = static_cast<const uint32_t*>(wide_pixmap.addr());
  bool found_deep_red = false;
  for (int i = 0; i < wide_pixmap.width() * wide_pixmap.height(); ++i) {
    uint32_t pixel = *pixel_ptr++;
    float blue = DecodeBGR10((pixel >> 0) & 0x3ff);
    float green = DecodeBGR10((pixel >> 10) & 0x3ff);
    float red = DecodeBGR10((pixel >> 20) & 0x3ff);
    if (fabsf(red - 1.0931f) < 0.01f && fabsf(green - -0.2268f) < 0.01f &&
        fabsf(blue - -0.1501f) < 0.01f) {
      found_deep_red = true;
      break;
    }
  }
 
  ASSERT_TRUE(found_deep_red);
  std::optional<DecompressResult> narrow_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/false, allocator);
 
  ASSERT_TRUE(narrow_result.has_value());
  ASSERT_EQ(narrow_result->image_info.colorType(), kRGBA_8888_SkColorType);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST() [513/715]

flutter::testing::TEST	(	ImageDecoderTest	,
		ImagesWithTransparencyArePremulAlpha
	)

Definition at line 743 of file image_decoder_unittests.cc.

                                                             {
  auto data = flutter::testing::OpenFixtureAsSkData("heart_end.png");
  ASSERT_TRUE(data);
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
  auto compressed_image = ImageDecoderSkia::ImageFromCompressedData(
      descriptor.get(), 250, 250, fml::tracing::TraceFlow(""));
  ASSERT_TRUE(compressed_image);
  ASSERT_EQ(compressed_image->width(), 250);
  ASSERT_EQ(compressed_image->height(), 250);
  ASSERT_EQ(compressed_image->alphaType(), kPremul_SkAlphaType);
}

◆ TEST() [514/715]

flutter::testing::TEST	(	ImageDecoderTest	,
		VerifyCodecRepeatCountsForGifAndWebPAreConsistentWithLoopCounts
	)

Definition at line 684 of file image_decoder_unittests.cc.

                                                                      {
  auto gif_mapping = flutter::testing::OpenFixtureAsSkData("hello_loop_2.gif");
  auto webp_mapping =
      flutter::testing::OpenFixtureAsSkData("hello_loop_2.webp");
 
  ASSERT_TRUE(gif_mapping);
  ASSERT_TRUE(webp_mapping);
 
  ImageGeneratorRegistry registry;
 
  auto gif_generator = registry.CreateCompatibleGenerator(gif_mapping);
  auto webp_generator = registry.CreateCompatibleGenerator(webp_mapping);
 
  ASSERT_TRUE(gif_generator);
  ASSERT_TRUE(webp_generator);
 
  // Both fixtures have a loop count of 2.
  ASSERT_EQ(gif_generator->GetPlayCount(), static_cast<unsigned int>(2));
  ASSERT_EQ(webp_generator->GetPlayCount(), static_cast<unsigned int>(2));
}

◆ TEST() [515/715]

flutter::testing::TEST	(	ImageDecoderTest	,
		VerifySimpleDecoding
	)

Definition at line 706 of file image_decoder_unittests.cc.

                                             {
  auto data = flutter::testing::OpenFixtureAsSkData("Horizontal.jpg");
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(600, image->width());
  ASSERT_EQ(200, image->height());
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
  auto compressed_image = ImageDecoderSkia::ImageFromCompressedData(
      descriptor.get(), 6, 2, fml::tracing::TraceFlow(""));
  ASSERT_EQ(compressed_image->width(), 6);
  ASSERT_EQ(compressed_image->height(), 2);
  ASSERT_EQ(compressed_image->alphaType(), kOpaque_SkAlphaType);
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  auto result_1 = ImageDecoderImpeller::DecompressTexture(
      descriptor.get(), SkISize::Make(6, 2), {100, 100},
      /*supports_wide_gamut=*/false, allocator);
  ASSERT_EQ(result_1.sk_bitmap->width(), 6);
  ASSERT_EQ(result_1.sk_bitmap->height(), 2);
 
  auto result_2 = ImageDecoderImpeller::DecompressTexture(
      descriptor.get(), SkISize::Make(60, 20), {10, 10},
      /*supports_wide_gamut=*/false, allocator);
  ASSERT_EQ(result_2.sk_bitmap->width(), 10);
  ASSERT_EQ(result_2.sk_bitmap->height(), 10);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST() [516/715]

flutter::testing::TEST	(	ImageDecoderTest	,
		VerifySubpixelDecodingPreservesExifOrientation
	)

Definition at line 761 of file image_decoder_unittests.cc.

                                                                       {
  auto data = flutter::testing::OpenFixtureAsSkData("Horizontal.jpg");
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
  auto descriptor =
      fml::MakeRefCounted<ImageDescriptor>(data, std::move(generator));
 
  // If Exif metadata is ignored, the height and width will be swapped because
  // "Rotate 90 CW" is what is encoded there.
  ASSERT_EQ(600, descriptor->width());
  ASSERT_EQ(200, descriptor->height());
 
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(600, image->width());
  ASSERT_EQ(200, image->height());
 
  auto decode = [descriptor](uint32_t target_width, uint32_t target_height) {
    return ImageDecoderSkia::ImageFromCompressedData(
        descriptor.get(), target_width, target_height,
        fml::tracing::TraceFlow(""));
  };
 
  auto expected_data = flutter::testing::OpenFixtureAsSkData("Horizontal.png");
  ASSERT_TRUE(expected_data != nullptr);
  ASSERT_FALSE(expected_data->isEmpty());
 
  auto assert_image = [&](auto decoded_image, const std::string& decode_error) {
    ASSERT_EQ(decoded_image->dimensions(), SkISize::Make(300, 100));
    sk_sp<SkData> encoded =
        SkPngEncoder::Encode(nullptr, decoded_image.get(), {});
    ASSERT_TRUE(encoded->equals(expected_data.get()));
  };
 
  assert_image(decode(300, 100), {});
}

◆ TEST() [517/715]

flutter::testing::TEST	(	ImageLRU	,
		CanClear
	)

Definition at line 40 of file image_lru_unittests.cc.

                         {
  auto image = DlImage::Make(nullptr);
  ImageLRU image_lru;
 
  // Fill up the cache, nothing is removed
  for (auto i = 0u; i < kImageReaderSwapchainSize; i++) {
    EXPECT_EQ(image_lru.AddImage(image, i + 1), 0u);
  }
  image_lru.Clear();
 
  // Expect no cache entries.
  for (auto i = 0u; i < kImageReaderSwapchainSize; i++) {
    EXPECT_EQ(image_lru.FindImage(i + 1), nullptr);
  }
}

◆ TEST() [518/715]

flutter::testing::TEST	(	ImageLRU	,
		CanStoreSingleImage
	)

Definition at line 11 of file image_lru_unittests.cc.

                                    {
  auto image = DlImage::Make(nullptr);
  ImageLRU image_lru;
 
  EXPECT_EQ(image_lru.FindImage(1), nullptr);
 
  image_lru.AddImage(image, 1);
 
  EXPECT_EQ(image_lru.FindImage(1), image);
}

◆ TEST() [519/715]

flutter::testing::TEST	(	ImageLRU	,
		EvictsLRU
	)

Definition at line 22 of file image_lru_unittests.cc.

                          {
  auto image = DlImage::Make(nullptr);
  ImageLRU image_lru;
 
  // Fill up the cache, nothing is removed
  for (auto i = 0u; i < kImageReaderSwapchainSize; i++) {
    EXPECT_EQ(image_lru.AddImage(image, i + 1), 0u);
  }
  // Confirm each image is in the cache. This should keep the LRU
  // order the same.
  for (auto i = 0u; i < kImageReaderSwapchainSize; i++) {
    EXPECT_EQ(image_lru.FindImage(i + 1), image);
  }
 
  // Insert new image and verify least recently used was removed.
  EXPECT_EQ(image_lru.AddImage(image, 100), 1u);
}

◆ TEST() [520/715]

flutter::testing::TEST	(	Instrumentation	,
		GetCurrentSampleTest
	)

Definition at line 57 of file stopwatch_unittests.cc.

                                            {
  fml::Milliseconds frame_budget_90fps = fml::RefreshRateToFrameBudget(90);
  FixedRefreshRateStopwatch stopwatch(frame_budget_90fps);
  stopwatch.Start();
  stopwatch.Stop();
  EXPECT_EQ(stopwatch.GetCurrentSample(), size_t(1));
}

◆ TEST() [521/715]

flutter::testing::TEST	(	Instrumentation	,
		GetDefaultFrameBudgetTest
	)

Definition at line 25 of file stopwatch_unittests.cc.

                                                 {
  fml::Milliseconds frame_budget_60fps = fml::RefreshRateToFrameBudget(60);
  // The default constructor sets the frame_budget to 16.6667 (60 fps).
  FixedRefreshRateStopwatch stopwatch;
  fml::Milliseconds actual_frame_budget = stopwatch.GetFrameBudget();
  EXPECT_EQ(frame_budget_60fps, actual_frame_budget);
}

◆ TEST() [522/715]

flutter::testing::TEST	(	Instrumentation	,
		GetFrameBudgetFromUpdaterTest
	)

Definition at line 40 of file stopwatch_unittests.cc.

                                                     {
  FakeRefreshRateUpdater updater;
  fml::Milliseconds frame_budget_90fps = fml::RefreshRateToFrameBudget(90);
  updater.SetFrameBudget(frame_budget_90fps);
 
  Stopwatch stopwatch(updater);
  fml::Milliseconds actual_frame_budget = stopwatch.GetFrameBudget();
  EXPECT_EQ(frame_budget_90fps, actual_frame_budget);
}

◆ TEST() [523/715]

flutter::testing::TEST	(	Instrumentation	,
		GetLapByIndexTest
	)

Definition at line 50 of file stopwatch_unittests.cc.

                                         {
  fml::Milliseconds frame_budget_90fps = fml::RefreshRateToFrameBudget(90);
  FixedRefreshRateStopwatch stopwatch(frame_budget_90fps);
  stopwatch.SetLapTime(fml::TimeDelta::FromMilliseconds(10));
  EXPECT_EQ(stopwatch.GetLap(1), fml::TimeDelta::FromMilliseconds(10));
}

◆ TEST() [524/715]

flutter::testing::TEST	(	Instrumentation	,
		GetLapsCount
	)

Definition at line 65 of file stopwatch_unittests.cc.

                                    {
  fml::Milliseconds frame_budget_90fps = fml::RefreshRateToFrameBudget(90);
  FixedRefreshRateStopwatch stopwatch(frame_budget_90fps);
  stopwatch.SetLapTime(fml::TimeDelta::FromMilliseconds(10));
  EXPECT_EQ(stopwatch.GetLapsCount(), size_t(120));
}

◆ TEST() [525/715]

flutter::testing::TEST	(	Instrumentation	,
		GetOneShotFrameBudgetTest
	)

Definition at line 33 of file stopwatch_unittests.cc.

                                                 {
  fml::Milliseconds frame_budget_90fps = fml::RefreshRateToFrameBudget(90);
  FixedRefreshRateStopwatch stopwatch(frame_budget_90fps);
  fml::Milliseconds actual_frame_budget = stopwatch.GetFrameBudget();
  EXPECT_EQ(frame_budget_90fps, actual_frame_budget);
}

◆ TEST() [526/715]

flutter::testing::TEST	(	JNIMock	,
		FlutterViewHandlePlatformMessage
	)

Definition at line 13 of file jni_mock_unittest.cc.

                                                {
  JNIMock mock;
 
  auto message = std::make_unique<PlatformMessage>("<channel-name>", nullptr);
  auto response_id = 1;
 
  EXPECT_CALL(mock,
              FlutterViewHandlePlatformMessage(
                  ::testing::Property(&std::unique_ptr<PlatformMessage>::get,
                                      message.get()),
                  response_id));
 
  mock.FlutterViewHandlePlatformMessage(std::move(message), response_id);
}

◆ TEST() [527/715]

flutter::testing::TEST	(	KeyboardKeyChannelHandlerTest	,
		DeadKeysDoNotCrash
	)

Definition at line 128 of file keyboard_key_channel_handler_unittests.cc.

                                                        {
  bool received = false;
  TestBinaryMessenger messenger(
      [&received](const std::string& channel, const uint8_t* message,
                  size_t message_size, BinaryReply reply) {
        if (channel == "flutter/keyevent") {
          auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
              message, message_size);
          uint32_t character = (*message_doc)[kCharacterCodePointKey].GetUint();
          EXPECT_EQ(character, (uint32_t)'^');
          received = true;
        }
        return true;
      });
 
  KeyboardKeyChannelHandler handler(&messenger);
  // Extended key flag is passed to redispatched events if set.
  handler.KeyboardHook(0xDD, 0x1a, WM_KEYDOWN, 0x8000005E, false, false,
                       [](bool handled) {});
 
  // EXPECT is done during the callback above.
  EXPECT_TRUE(received);
}

◆ TEST() [528/715]

flutter::testing::TEST	(	KeyboardKeyChannelHandlerTest	,
		EmptyResponsesDoNotCrash
	)

Definition at line 152 of file keyboard_key_channel_handler_unittests.cc.

                                                              {
  bool received = false;
  TestBinaryMessenger messenger(
      [&received](const std::string& channel, const uint8_t* message,
                  size_t message_size, BinaryReply reply) {
        if (channel == "flutter/keyevent") {
          std::string empty_message = "";
          std::vector<uint8_t> empty_response(empty_message.begin(),
                                              empty_message.end());
          reply(empty_response.data(), empty_response.size());
          received = true;
        }
        return true;
      });
 
  KeyboardKeyChannelHandler handler(&messenger);
  handler.KeyboardHook(64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
                       [](bool handled) {});
 
  // Passes if it does not crash.
  EXPECT_TRUE(received);
}

◆ TEST() [529/715]

flutter::testing::TEST	(	KeyboardKeyChannelHandlerTest	,
		ExtendedKeysAreSentToRedispatch
	)

Definition at line 88 of file keyboard_key_channel_handler_unittests.cc.

                                                                     {
  auto handled_message = CreateResponse(true);
  auto unhandled_message = CreateResponse(false);
  int received_scancode = 0;
 
  TestBinaryMessenger messenger(
      [&received_scancode, &handled_message, &unhandled_message](
          const std::string& channel, const uint8_t* message,
          size_t message_size, BinaryReply reply) {
        if (channel == "flutter/keyevent") {
          auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
              message, message_size);
          received_scancode = (*message_doc)[kScanCodeKey].GetInt();
          if (received_scancode == kHandledScanCode) {
            reply(handled_message->data(), handled_message->size());
          } else {
            reply(unhandled_message->data(), unhandled_message->size());
          }
        }
      });
 
  KeyboardKeyChannelHandler handler(&messenger);
  bool last_handled = true;
 
  // Extended key flag is passed to redispatched events if set.
  handler.KeyboardHook(
      64, kUnhandledScanCode, WM_KEYDOWN, L'b', true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(received_scancode, kUnhandledScanCodeExtended);
 
  last_handled = true;
  // Extended key flag is not passed to redispatched events if not set.
  handler.KeyboardHook(
      64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(received_scancode, kUnhandledScanCode);
}

◆ TEST() [530/715]

flutter::testing::TEST	(	KeyboardKeyChannelHandlerTest	,
		KeyboardHookHandling
	)

Definition at line 33 of file keyboard_key_channel_handler_unittests.cc.

                                                          {
  auto handled_message = CreateResponse(true);
  auto unhandled_message = CreateResponse(false);
  int received_scancode = 0;
 
  TestBinaryMessenger messenger(
      [&received_scancode, &handled_message, &unhandled_message](
          const std::string& channel, const uint8_t* message,
          size_t message_size, BinaryReply reply) {
        if (channel == "flutter/keyevent") {
          auto message_doc = JsonMessageCodec::GetInstance().DecodeMessage(
              message, message_size);
          received_scancode = (*message_doc)[kScanCodeKey].GetInt();
          if (received_scancode == kHandledScanCode) {
            reply(handled_message->data(), handled_message->size());
          } else {
            reply(unhandled_message->data(), unhandled_message->size());
          }
        }
      });
 
  KeyboardKeyChannelHandler handler(&messenger);
  bool last_handled = false;
 
  handler.KeyboardHook(
      64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(received_scancode, kHandledScanCode);
  EXPECT_EQ(last_handled, true);
 
  received_scancode = 0;
 
  handler.KeyboardHook(
      64, kUnhandledScanCode, WM_KEYDOWN, L'b', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(received_scancode, kUnhandledScanCode);
  EXPECT_EQ(last_handled, false);
 
  received_scancode = 0;
 
  handler.KeyboardHook(
      64, kHandledScanCode, WM_SYSKEYDOWN, L'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(received_scancode, kHandledScanCode);
  EXPECT_EQ(last_handled, true);
 
  received_scancode = 0;
 
  handler.KeyboardHook(
      64, kUnhandledScanCode, WM_SYSKEYDOWN, L'c', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(received_scancode, kUnhandledScanCode);
  EXPECT_EQ(last_handled, false);
}

◆ TEST() [531/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		AbruptRepeatIsConvertedToDown
	)

Definition at line 764 of file keyboard_key_embedder_handler_unittests.cc.

                                                                    {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
  last_handled = false;
 
  key_state.Set(kVirtualKeyA, true);
 
  // Press A (with was_down true)
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release A
  last_handled = false;
  key_state.Set(kVirtualKeyA, false);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
}

◆ TEST() [532/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		AbruptUpIsIgnored
	)

Definition at line 818 of file keyboard_key_embedder_handler_unittests.cc.

                                                        {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
  last_handled = false;
 
  // KeyA's key down is missed.
 
  key_state.Set(kVirtualKeyA, true);
 
  // Press A again (should yield an empty event)
  last_handled = false;
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->physical, 0);
  EXPECT_EQ(event->logical, 0);
  EXPECT_EQ(event->callback, nullptr);
  results.clear();
}

◆ TEST() [533/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		BasicKeyPressingAndHolding
	)

Definition at line 119 of file keyboard_key_embedder_handler_unittests.cc.

                                                                 {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press KeyA.
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
  key_state.Set(kVirtualKeyA, true);
 
  // Hold KeyA.
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(false, event->user_data);
  EXPECT_EQ(last_handled, false);
  results.clear();
 
  // Release KeyA.
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  event->callback(false, event->user_data);
}

◆ TEST() [534/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		ConvertChar32ToUtf8
	)

Definition at line 90 of file keyboard_key_embedder_handler_unittests.cc.

                                                          {
  std::string result;
 
  result = ConvertChar32ToUtf8(0x0024);
  EXPECT_EQ(result.length(), 1);
  EXPECT_EQ(result[0], '\x24');
 
  result = ConvertChar32ToUtf8(0x00A2);
  EXPECT_EQ(result.length(), 2);
  EXPECT_EQ(result[0], '\xC2');
  EXPECT_EQ(result[1], '\xA2');
 
  result = ConvertChar32ToUtf8(0x0939);
  EXPECT_EQ(result.length(), 3);
  EXPECT_EQ(result[0], '\xE0');
  EXPECT_EQ(result[1], '\xA4');
  EXPECT_EQ(result[2], '\xB9');
 
  result = ConvertChar32ToUtf8(0x10348);
  EXPECT_EQ(result.length(), 4);
  EXPECT_EQ(result[0], '\xF0');
  EXPECT_EQ(result[1], '\x90');
  EXPECT_EQ(result[2], '\x8D');
  EXPECT_EQ(result[3], '\x88');
}

◆ TEST() [535/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		DoNotSynthesizeModifierDownWhenPressed
	)

Definition at line 562 of file keyboard_key_embedder_handler_unittests.cc.

                                                                             {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Should not synthesize shift left key down event when shift left key
  // is already pressed.
  handler->KeyboardHook(
      VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(kShift);
  EXPECT_EQ(results.size(), 0);
 
  // Should not synthesize shift left key down event when shift right key
  // is already pressed.
  handler->KeyboardHook(
      VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(kShift);
  EXPECT_EQ(results.size(), 0);
 
  // Should not synthesize control left key down event when control left key
  // is already pressed.
  handler->KeyboardHook(
      VK_LCONTROL, kScanCodeControlLeft, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(kControl);
  EXPECT_EQ(results.size(), 0);
 
  // Should not synthesize control left key down event when control right key
  // is already pressed .
  handler->KeyboardHook(
      VK_RCONTROL, kScanCodeControlRight, WM_KEYDOWN, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(kControl);
  EXPECT_EQ(results.size(), 0);
}

◆ TEST() [536/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		DoNotSynthesizeModifierUpWhenNotPressed
	)

Definition at line 696 of file keyboard_key_embedder_handler_unittests.cc.

                                                                              {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Should not synthesize up events when no modifier key is pressed
  // in pressing state and modifiers state is zero.
  handler->SyncModifiersIfNeeded(0);
  EXPECT_EQ(results.size(), 0);
}

◆ TEST() [537/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		ImeEventsAreIgnored
	)

Definition at line 259 of file keyboard_key_embedder_handler_unittests.cc.

                                                          {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press A in an IME
  last_handled = false;
  handler->KeyboardHook(
      VK_PROCESSKEY, kScanCodeKeyA, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
 
  // The A key down should yield an empty event.
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->physical, 0);
  EXPECT_EQ(event->logical, 0);
  EXPECT_EQ(event->callback, nullptr);
  results.clear();
 
  // Release A in an IME
  last_handled = false;
  handler->KeyboardHook(
      // The up event for an IME press has a normal virtual key.
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
 
  // The A key up should yield an empty event.
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->physical, 0);
  EXPECT_EQ(event->logical, 0);
  EXPECT_EQ(event->callback, nullptr);
  results.clear();
 
  // Press A out of an IME
  key_state.Set(kVirtualKeyA, true);
  last_handled = false;
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  // Not decided yet
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  last_handled = false;
  key_state.Set(kVirtualKeyA, false);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
}

◆ TEST() [538/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		ModifierKeysByExtendedBit
	)

Definition at line 333 of file keyboard_key_embedder_handler_unittests.cc.

                                                                {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press Ctrl left.
  last_handled = false;
  key_state.Set(VK_LCONTROL, true);
  handler->KeyboardHook(
      VK_LCONTROL, kScanCodeControl, WM_KEYDOWN, 0, false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Press Ctrl right.
  last_handled = false;
  key_state.Set(VK_RCONTROL, true);
  handler->KeyboardHook(
      VK_RCONTROL, kScanCodeControl, WM_KEYDOWN, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalControlRight);
  EXPECT_EQ(event->logical, kLogicalControlRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release Ctrl left.
  last_handled = false;
  key_state.Set(VK_LCONTROL, false);
  handler->KeyboardHook(
      VK_LCONTROL, kScanCodeControl, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release Ctrl right.
  last_handled = false;
  key_state.Set(VK_RCONTROL, false);
  handler->KeyboardHook(
      VK_RCONTROL, kScanCodeControl, WM_KEYUP, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalControlRight);
  EXPECT_EQ(event->logical, kLogicalControlRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
}

◆ TEST() [539/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		ModifierKeysByVirtualKey
	)

Definition at line 426 of file keyboard_key_embedder_handler_unittests.cc.

                                                               {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press Shift left.
  last_handled = false;
  key_state.Set(VK_LSHIFT, true);
  handler->KeyboardHook(
      VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Press Shift right.
  last_handled = false;
  key_state.Set(VK_RSHIFT, true);
  handler->KeyboardHook(
      VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release Shift left.
  last_handled = false;
  key_state.Set(VK_LSHIFT, false);
  handler->KeyboardHook(
      VK_LSHIFT, kScanCodeShiftLeft, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release Shift right.
  last_handled = false;
  key_state.Set(VK_RSHIFT, false);
  handler->KeyboardHook(
      VK_RSHIFT, kScanCodeShiftRight, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
}

◆ TEST() [540/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		RepeatedDownIsIgnored
	)

Definition at line 716 of file keyboard_key_embedder_handler_unittests.cc.

                                                            {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
  last_handled = false;
 
  // Press A (should yield a normal event)
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // KeyA's key up is missed.
 
  // Press A again (should yield an empty event)
  last_handled = false;
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->physical, 0);
  EXPECT_EQ(event->logical, 0);
  EXPECT_EQ(event->callback, nullptr);
  results.clear();
}

◆ TEST() [541/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeForDesyncPressingState
	)

Definition at line 851 of file keyboard_key_embedder_handler_unittests.cc.

                                                                       {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // A key down of control left is missed.
  key_state.Set(VK_LCONTROL, true);
 
  // Send a normal event
  key_state.Set(kVirtualKeyA, true);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 2);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  last_handled = true;
  event->callback(false, event->user_data);
  EXPECT_EQ(last_handled, false);
  results.clear();
 
  // A key down of control right is missed.
  key_state.Set(VK_LCONTROL, false);
 
  // Hold KeyA.
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 2);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  last_handled = true;
  event->callback(false, event->user_data);
  EXPECT_EQ(last_handled, false);
  results.clear();
 
  // Release KeyA.
  key_state.Set(kVirtualKeyA, false);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  event->callback(false, event->user_data);
}

◆ TEST() [542/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeForDesyncToggledState
	)

Definition at line 939 of file keyboard_key_embedder_handler_unittests.cc.

                                                                      {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // The NumLock is desynchronized by toggled on
  key_state.Set(VK_NUMLOCK, false, true);
 
  // Send a normal event
  key_state.Set(kVirtualKeyA, true);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 3);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
 
  event = &results[2];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Test if the NumLock is mis-toggled while it should also be pressed
  key_state.Set(VK_NUMLOCK, true, true);
 
  // Send a normal event
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, true);
  EXPECT_EQ(results.size(), 2);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeRepeat);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "a");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(false, event->user_data);
  EXPECT_EQ(last_handled, false);
  results.clear();
 
  // Numlock is pressed at this moment.
 
  // Test if the NumLock is mis-toggled while it should also be released
  key_state.Set(VK_NUMLOCK, false, false);
 
  // Send a normal event
  key_state.Set(kVirtualKeyA, false);
  handler->KeyboardHook(
      kVirtualKeyA, kScanCodeKeyA, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 4);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[2];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[3];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalKeyA);
  EXPECT_EQ(event->logical, kLogicalKeyA);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  event->callback(false, event->user_data);
}

◆ TEST() [543/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeForDesyncToggledStateByItselfsDown
	)

Definition at line 1119 of file keyboard_key_embedder_handler_unittests.cc.

                                                   {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  // NumLock is started up and disabled
  key_state.Set(VK_NUMLOCK, false, false);
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // NumLock is toggled somewhere else
  // key_state.Set(VK_NUMLOCK, false, true);
 
  // NumLock is pressed
  key_state.Set(VK_NUMLOCK, true, false);
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  // 4 total events should be fired:
  // Pre-synchronization toggle, pre-sync press,
  // main event, and post-sync press.
  EXPECT_EQ(results.size(), 4);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[2];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  last_handled = false;
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
}

◆ TEST() [544/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeForDesyncToggledStateByItselfsUp
	)

Definition at line 1059 of file keyboard_key_embedder_handler_unittests.cc.

                                                 {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // When NumLock is down
  key_state.Set(VK_NUMLOCK, true, true);
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  event = &results.back();
  event->callback(false, event->user_data);
  results.clear();
 
  // Numlock is desynchronized by being off and released
  key_state.Set(VK_NUMLOCK, false, false);
  // Send a NumLock key up
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYUP, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 3);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[1];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  EXPECT_EQ(event->callback, nullptr);
 
  event = &results[2];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  last_handled = false;
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
}

◆ TEST() [545/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeModifierLeftKeyDownWhenNotPressed
	)

Definition at line 519 of file keyboard_key_embedder_handler_unittests.cc.

                                                  {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Should synthesize shift left key down event.
  handler->SyncModifiersIfNeeded(kShift);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  results.clear();
 
  // Clear the pressing state.
  handler->SyncModifiersIfNeeded(0);
  results.clear();
 
  // Should synthesize control left key down event.
  handler->SyncModifiersIfNeeded(kControl);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
}

◆ TEST() [546/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeModifierUpWhenPressed
	)

Definition at line 615 of file keyboard_key_embedder_handler_unittests.cc.

                                                                      {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Should synthesize shift left key up event when shift left key is
  // already pressed and modifiers state is zero.
  handler->KeyboardHook(
      VK_LSHIFT, kScanCodeShiftLeft, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(0);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftLeft);
  EXPECT_EQ(event->logical, kLogicalShiftLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  results.clear();
 
  // Should synthesize shift right key up event when shift right key is
  // already pressed and modifiers state is zero.
  handler->KeyboardHook(
      VK_RSHIFT, kScanCodeShiftRight, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(0);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalShiftRight);
  EXPECT_EQ(event->logical, kLogicalShiftRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  results.clear();
 
  // Should synthesize control left key up event when control left key is
  // already pressed and modifiers state is zero.
  handler->KeyboardHook(
      VK_LCONTROL, kScanCodeControlLeft, WM_KEYDOWN, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(0);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalControlLeft);
  EXPECT_EQ(event->logical, kLogicalControlLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  results.clear();
 
  // Should synthesize control right key up event when control right key is
  // already pressed and modifiers state is zero.
  handler->KeyboardHook(
      VK_RCONTROL, kScanCodeControlRight, WM_KEYDOWN, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  results.clear();
  handler->SyncModifiersIfNeeded(0);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalControlRight);
  EXPECT_EQ(event->logical, kLogicalControlRight);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, true);
  results.clear();
}

◆ TEST() [547/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SynthesizeWithInitialTogglingState
	)

Definition at line 1177 of file keyboard_key_embedder_handler_unittests.cc.

                                                                         {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  // The app starts with NumLock toggled on
  key_state.Set(VK_NUMLOCK, false, true);
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // NumLock key down
  key_state.Set(VK_NUMLOCK, true, false);
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
}

◆ TEST() [548/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		SysKeyPress
	)

Definition at line 1213 of file keyboard_key_embedder_handler_unittests.cc.

                                                  {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press KeyAltLeft.
  key_state.Set(VK_LMENU, true);
  handler->KeyboardHook(
      VK_LMENU, kScanCodeAltLeft, WM_SYSKEYDOWN, 0, false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(last_handled, false);
  EXPECT_EQ(results.size(), 1);
  event = results.data();
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalAltLeft);
  EXPECT_EQ(event->logical, kLogicalAltLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
 
  event->callback(true, event->user_data);
  EXPECT_EQ(last_handled, true);
  results.clear();
 
  // Release KeyAltLeft.
  key_state.Set(VK_LMENU, false);
  handler->KeyboardHook(
      VK_LMENU, kScanCodeAltLeft, WM_SYSKEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = results.data();
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalAltLeft);
  EXPECT_EQ(event->logical, kLogicalAltLeft);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  event->callback(false, event->user_data);
}

◆ TEST() [549/715]

flutter::testing::TEST	(	KeyboardKeyEmbedderHandlerTest	,
		ToggleNumLockDuringNumpadPress
	)

Definition at line 187 of file keyboard_key_embedder_handler_unittests.cc.

                                                                     {
  TestKeystate key_state;
  std::vector<TestFlutterKeyEvent> results;
  TestFlutterKeyEvent* event;
  bool last_handled = false;
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [&results](const FlutterKeyEvent& event,
                     FlutterKeyEventCallback callback, void* user_data) {
            results.emplace_back(event, callback, user_data);
          },
          key_state.Getter(), DefaultMapVkToScan);
 
  // Press NumPad1.
  key_state.Set(VK_NUMPAD1, true);
  handler->KeyboardHook(
      VK_NUMPAD1, kScanCodeNumpad1, WM_KEYDOWN, 0, false, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumpad1);
  EXPECT_EQ(event->logical, kLogicalNumpad1);
  // EXPECT_STREQ(event->character, "1"); // TODO
  EXPECT_EQ(event->synthesized, false);
  results.clear();
 
  // Press NumLock.
  key_state.Set(VK_NUMLOCK, true, true);
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYDOWN, 0, true, false,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeDown);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  results.clear();
 
  // Release NumLock.
  key_state.Set(VK_NUMLOCK, false, true);
  handler->KeyboardHook(
      VK_NUMLOCK, kScanCodeNumLock, WM_KEYUP, 0, true, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumLock);
  EXPECT_EQ(event->logical, kLogicalNumLock);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  results.clear();
 
  // Release NumPad1. (The logical key is now NumpadEnd)
  handler->KeyboardHook(
      VK_END, kScanCodeNumpad1, WM_KEYUP, 0, false, true,
      [&last_handled](bool handled) { last_handled = handled; });
  EXPECT_EQ(results.size(), 1);
  event = &results[0];
  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
  EXPECT_EQ(event->physical, kPhysicalNumpad1);
  EXPECT_EQ(event->logical, kLogicalNumpad1);
  EXPECT_STREQ(event->character, "");
  EXPECT_EQ(event->synthesized, false);
  results.clear();
}

◆ TEST() [550/715]

flutter::testing::TEST	(	KeyboardKeyHandlerTest	,
		HandlerGetPressedState
	)

Definition at line 311 of file keyboard_key_handler_unittests.cc.

                                                     {
  TestKeystate key_state;
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  KeyboardKeyHandler handler(&messenger);
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> embedder_handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
             void* user_data) {},
          key_state.Getter(), DefaultMapVkToScan);
  handler.AddDelegate(std::move(embedder_handler));
 
  // Dispatch a key event.
  handler.KeyboardHook(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false,
                       false, OnKeyEventResult);
 
  std::map<uint64_t, uint64_t> pressed_state = handler.GetPressedState();
  EXPECT_EQ(pressed_state.size(), 1);
  EXPECT_EQ(pressed_state.at(kPhysicalKeyA), kLogicalKeyA);
}

◆ TEST() [551/715]

flutter::testing::TEST	(	KeyboardKeyHandlerTest	,
		KeyboardChannelGetPressedState
	)

Definition at line 335 of file keyboard_key_handler_unittests.cc.

                                                             {
  TestKeystate key_state;
  TestBinaryMessenger messenger;
  KeyboardKeyHandler handler(&messenger);
 
  std::unique_ptr<KeyboardKeyEmbedderHandler> embedder_handler =
      std::make_unique<KeyboardKeyEmbedderHandler>(
          [](const FlutterKeyEvent& event, FlutterKeyEventCallback callback,
             void* user_data) {},
          key_state.Getter(), DefaultMapVkToScan);
  handler.AddDelegate(std::move(embedder_handler));
  handler.InitKeyboardChannel();
 
  // Dispatch a key event.
  handler.KeyboardHook(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false,
                       false, OnKeyEventResult);
 
  bool success = false;
 
  MethodResultFunctions<> result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        auto& map = std::get<EncodableMap>(*result);
        EXPECT_EQ(map.size(), 1);
        EncodableValue physical_value(static_cast<long long>(kPhysicalKeyA));
        EncodableValue logical_value(static_cast<long long>(kLogicalKeyA));
        EXPECT_EQ(map.at(physical_value), logical_value);
      },
      nullptr, nullptr);
 
  SimulateKeyboardMessage(&messenger, kGetKeyboardStateMethod, nullptr,
                          &result_handler);
  EXPECT_TRUE(success);
}

◆ TEST() [552/715]

flutter::testing::TEST	(	KeyboardKeyHandlerTest	,
		SingleDelegateWithAsyncResponds
	)

Test 1: One event that is handled by the framework

Test 2: Two events that are unhandled by the framework

Definition at line 208 of file keyboard_key_handler_unittests.cc.

                                                              {
  std::list<MockKeyHandlerDelegate::KeyboardHookCall> hook_history;
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  KeyboardKeyHandler handler(&messenger);
 
  // Add one delegate
  auto delegate = std::make_unique<MockKeyHandlerDelegate>(1, &hook_history);
  handler.AddDelegate(std::move(delegate));
 
  /// Test 1: One event that is handled by the framework
 
  // Dispatch a key event
  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, true,
                       OnKeyEventResult);
  EXPECT_EQ(key_event_response, kNoResponse);
  EXPECT_EQ(hook_history.size(), 1);
  EXPECT_EQ(hook_history.back().delegate_id, 1);
  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
  EXPECT_EQ(hook_history.back().was_down, true);
 
  EXPECT_EQ(key_event_response, kNoResponse);
  hook_history.back().callback(true);
  EXPECT_EQ(key_event_response, kHandled);
 
  key_event_response = kNoResponse;
  hook_history.clear();
 
  /// Test 2: Two events that are unhandled by the framework
 
  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
                       OnKeyEventResult);
  EXPECT_EQ(key_event_response, kNoResponse);
  EXPECT_EQ(hook_history.size(), 1);
  EXPECT_EQ(hook_history.back().delegate_id, 1);
  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
  EXPECT_EQ(hook_history.back().was_down, false);
 
  // Dispatch another key event
  handler.KeyboardHook(65, kHandledScanCode2, WM_KEYUP, L'b', false, true,
                       OnKeyEventResult);
  EXPECT_EQ(key_event_response, kNoResponse);
  EXPECT_EQ(hook_history.size(), 2);
  EXPECT_EQ(hook_history.back().delegate_id, 1);
  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode2);
  EXPECT_EQ(hook_history.back().was_down, true);
 
  // Resolve the second event first to test out-of-order response
  hook_history.back().callback(false);
  EXPECT_EQ(key_event_response, kUnhandled);
  key_event_response = kNoResponse;
 
  // Resolve the first event then
  hook_history.front().callback(false);
  EXPECT_EQ(key_event_response, kUnhandled);
 
  hook_history.clear();
  key_event_response = kNoResponse;
}

◆ TEST() [553/715]

flutter::testing::TEST	(	KeyboardKeyHandlerTest	,
		SingleDelegateWithSyncResponds
	)

Test 1: One event that is handled by the framework

Test 2: An event unhandled by the framework

Definition at line 270 of file keyboard_key_handler_unittests.cc.

                                                             {
  std::list<MockKeyHandlerDelegate::KeyboardHookCall> hook_history;
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  KeyboardKeyHandler handler(&messenger);
  // Add one delegate
  auto delegate = std::make_unique<MockKeyHandlerDelegate>(1, &hook_history);
  CallbackHandler& delegate_handler = delegate->callback_handler;
  handler.AddDelegate(std::move(delegate));
 
  /// Test 1: One event that is handled by the framework
 
  // Dispatch a key event
  delegate_handler = respond_true;
  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
                       OnKeyEventResult);
  EXPECT_EQ(key_event_response, kHandled);
  EXPECT_EQ(hook_history.size(), 1);
  EXPECT_EQ(hook_history.back().delegate_id, 1);
  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
  EXPECT_EQ(hook_history.back().was_down, false);
 
  hook_history.clear();
 
  /// Test 2: An event unhandled by the framework
 
  delegate_handler = respond_false;
  handler.KeyboardHook(64, kHandledScanCode, WM_KEYDOWN, L'a', false, false,
                       OnKeyEventResult);
  EXPECT_EQ(key_event_response, kUnhandled);
  EXPECT_EQ(hook_history.size(), 1);
  EXPECT_EQ(hook_history.back().delegate_id, 1);
  EXPECT_EQ(hook_history.back().scancode, kHandledScanCode);
  EXPECT_EQ(hook_history.back().was_down, false);
 
  hook_history.clear();
  key_event_response = kNoResponse;
}

◆ TEST() [554/715]

flutter::testing::TEST	(	KeyboardWin32CommonTest	,
		EncodeUtf16
	)

Definition at line 11 of file keyboard_utils_unittests.cc.

                                           {
  std::u16string result;
 
  result = EncodeUtf16(0x24);
  EXPECT_EQ(result.size(), 1);
  EXPECT_EQ(result[0], 0x24);
 
  result = EncodeUtf16(0x20AC);
  EXPECT_EQ(result.size(), 1);
  EXPECT_EQ(result[0], 0x20AC);
 
  result = EncodeUtf16(0x10437);
  EXPECT_EQ(result.size(), 2);
  EXPECT_EQ(result[0], 0xD801);
  EXPECT_EQ(result[1], 0xDC37);
 
  result = EncodeUtf16(0x24B62);
  EXPECT_EQ(result.size(), 2);
  EXPECT_EQ(result[0], 0xD852);
  EXPECT_EQ(result[1], 0xDF62);
}

◆ TEST() [555/715]

flutter::testing::TEST	(	KeyMappingTest	,
		HasExpectedValues
	)

Definition at line 20 of file KeyCodeMapTest.mm.

                                        {
  // Has Space
  EXPECT_NE(std::find(kLayoutGoals.begin(), kLayoutGoals.end(), LayoutGoal{0x31, 0x20, false}),
            kLayoutGoals.end());
  // Has Digit0
  EXPECT_NE(std::find(kLayoutGoals.begin(), kLayoutGoals.end(), LayoutGoal{0x1d, 0x30, true}),
            kLayoutGoals.end());
  // Has KeyA
  EXPECT_NE(std::find(kLayoutGoals.begin(), kLayoutGoals.end(), LayoutGoal{0x00, 0x61, true}),
            kLayoutGoals.end());
  // Has Equal
  EXPECT_NE(std::find(kLayoutGoals.begin(), kLayoutGoals.end(), LayoutGoal{0x18, 0x3d, false}),
            kLayoutGoals.end());
  // Has IntlBackslash
  EXPECT_NE(
      std::find(kLayoutGoals.begin(), kLayoutGoals.end(), LayoutGoal{0x0a, 0x200000020, false}),
      kLayoutGoals.end());
}

◆ TEST() [556/715]

flutter::testing::TEST	(	LayerStateStack	,
		AccessorsDieWithoutDelegate
	)

Definition at line 17 of file layer_state_stack_unittests.cc.

                                                   {
  LayerStateStack state_stack;
 
  EXPECT_DEATH_IF_SUPPORTED(state_stack.device_cull_rect(),
                            "LayerStateStack state queried without a delegate");
  EXPECT_DEATH_IF_SUPPORTED(state_stack.local_cull_rect(),
                            "LayerStateStack state queried without a delegate");
  EXPECT_DEATH_IF_SUPPORTED(state_stack.transform_3x3(),
                            "LayerStateStack state queried without a delegate");
  EXPECT_DEATH_IF_SUPPORTED(state_stack.transform_4x4(),
                            "LayerStateStack state queried without a delegate");
  EXPECT_DEATH_IF_SUPPORTED(state_stack.content_culled({}),
                            "LayerStateStack state queried without a delegate");
  {
    // state_stack.set_preroll_delegate(kGiantRect, SkMatrix::I());
    auto mutator = state_stack.save();
    mutator.applyOpacity({}, 0.5);
    state_stack.clear_delegate();
    auto restore = state_stack.applyState({}, 0);
  }
}

◆ TEST() [557/715]

flutter::testing::TEST	(	LayerStateStack	,
		ColorFilter
	)

Definition at line 208 of file layer_state_stack_unittests.cc.

                                   {
  SkRect rect = {10, 10, 20, 20};
  std::shared_ptr<DlBlendColorFilter> outer_filter =
      std::make_shared<DlBlendColorFilter>(DlColor::kYellow(),
                                           DlBlendMode::kColorBurn);
  std::shared_ptr<DlBlendColorFilter> inner_filter =
      std::make_shared<DlBlendColorFilter>(DlColor::kRed(),
                                           DlBlendMode::kColorBurn);
 
  LayerStateStack state_stack;
  state_stack.set_preroll_delegate(SkRect::MakeLTRB(0, 0, 50, 50));
  {
    auto mutator = state_stack.save();
    mutator.applyColorFilter(rect, outer_filter);
 
    ASSERT_EQ(state_stack.outstanding_color_filter(), outer_filter);
 
    // Check nested color filters result in nested saveLayers
    {
      auto mutator2 = state_stack.save();
      mutator.applyColorFilter(rect, inner_filter);
 
      ASSERT_EQ(state_stack.outstanding_color_filter(), inner_filter);
 
      // Verify output with applyState that does not accept color filters
      {
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(rect, 0);
          ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        DlPaint outer_save_paint = DlPaint().setColorFilter(outer_filter);
        DlPaint inner_save_paint = DlPaint().setColorFilter(inner_filter);
        expected.SaveLayer(&rect, &outer_save_paint);
        expected.SaveLayer(&rect, &inner_save_paint);
        expected.DrawRect(rect, DlPaint());
        expected.Restore();
        expected.Restore();
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
 
      // Verify output with applyState that accepts color filters
      {
        SkRect rect = {10, 10, 20, 20};
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(
              rect, LayerStateStack::kCallerCanApplyColorFilter);
          ASSERT_EQ(state_stack.outstanding_color_filter(), inner_filter);
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        DlPaint save_paint = DlPaint().setColorFilter(outer_filter);
        DlPaint draw_paint = DlPaint().setColorFilter(inner_filter);
        expected.SaveLayer(&rect, &save_paint);
        expected.DrawRect(rect, draw_paint);
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
    }
 
    ASSERT_EQ(state_stack.outstanding_color_filter(), outer_filter);
  }
 
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
}

◆ TEST() [558/715]

flutter::testing::TEST	(	LayerStateStack	,
		ColorFilterAndImageFilterInteraction
	)

Definition at line 489 of file layer_state_stack_unittests.cc.

                                                            {
  SkRect rect = {10, 10, 20, 20};
  std::shared_ptr<DlBlendColorFilter> color_filter =
      std::make_shared<DlBlendColorFilter>(DlColor::kYellow(),
                                           DlBlendMode::kColorBurn);
  std::shared_ptr<DlBlurImageFilter> image_filter =
      std::make_shared<DlBlurImageFilter>(2.0f, 2.0f, DlTileMode::kClamp);
 
  DisplayListBuilder builder;
  LayerStateStack state_stack;
  state_stack.set_delegate(&builder);
  ASSERT_EQ(builder.GetSaveCount(), 1);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyColorFilter(rect, color_filter);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyImageFilter(rect, image_filter);
 
      // color filter applied to image filter can be applied together
      ASSERT_EQ(builder.GetSaveCount(), 1);
      ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
      ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
    ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyImageFilter(rect, image_filter);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyColorFilter(rect, color_filter);
 
      // The image filter will have been resolved by a saveLayer
      ASSERT_EQ(builder.GetSaveCount(), 2);
      ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
      ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
    ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
}

◆ TEST() [559/715]

flutter::testing::TEST	(	LayerStateStack	,
		Defaults
	)

Definition at line 40 of file layer_state_stack_unittests.cc.

                                {
  LayerStateStack state_stack;
 
  ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_bounds(), SkRect());
 
  state_stack.set_preroll_delegate(kGiantRect, SkMatrix::I());
  ASSERT_EQ(state_stack.device_cull_rect(), kGiantRect);
  ASSERT_EQ(state_stack.local_cull_rect(), kGiantRect);
  ASSERT_EQ(state_stack.transform_3x3(), SkMatrix::I());
  ASSERT_EQ(state_stack.transform_4x4(), SkM44());
 
  DlPaint dl_paint;
  state_stack.fill(dl_paint);
  ASSERT_EQ(dl_paint, DlPaint());
}

◆ TEST() [560/715]

flutter::testing::TEST	(	LayerStateStack	,
		ImageFilter
	)

Definition at line 288 of file layer_state_stack_unittests.cc.

                                   {
  SkRect rect = {10, 10, 20, 20};
  std::shared_ptr<DlBlurImageFilter> outer_filter =
      std::make_shared<DlBlurImageFilter>(2.0f, 2.0f, DlTileMode::kClamp);
  std::shared_ptr<DlBlurImageFilter> inner_filter =
      std::make_shared<DlBlurImageFilter>(3.0f, 3.0f, DlTileMode::kClamp);
  SkRect inner_src_rect = rect;
  SkRect outer_src_rect;
  ASSERT_EQ(inner_filter->map_local_bounds(rect, outer_src_rect),
            &outer_src_rect);
 
  LayerStateStack state_stack;
  state_stack.set_preroll_delegate(SkRect::MakeLTRB(0, 0, 50, 50));
  {
    auto mutator = state_stack.save();
    mutator.applyImageFilter(outer_src_rect, outer_filter);
 
    ASSERT_EQ(state_stack.outstanding_image_filter(), outer_filter);
 
    // Check nested color filters result in nested saveLayers
    {
      auto mutator2 = state_stack.save();
      mutator.applyImageFilter(rect, inner_filter);
 
      ASSERT_EQ(state_stack.outstanding_image_filter(), inner_filter);
 
      // Verify output with applyState that does not accept color filters
      {
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(rect, 0);
          ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        DlPaint outer_save_paint = DlPaint().setImageFilter(outer_filter);
        DlPaint inner_save_paint = DlPaint().setImageFilter(inner_filter);
        expected.SaveLayer(&outer_src_rect, &outer_save_paint);
        expected.SaveLayer(&inner_src_rect, &inner_save_paint);
        expected.DrawRect(rect, DlPaint());
        expected.Restore();
        expected.Restore();
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
 
      // Verify output with applyState that accepts color filters
      {
        SkRect rect = {10, 10, 20, 20};
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(
              rect, LayerStateStack::kCallerCanApplyImageFilter);
          ASSERT_EQ(state_stack.outstanding_image_filter(), inner_filter);
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        DlPaint save_paint = DlPaint().setImageFilter(outer_filter);
        DlPaint draw_paint = DlPaint().setImageFilter(inner_filter);
        expected.SaveLayer(&outer_src_rect, &save_paint);
        expected.DrawRect(rect, draw_paint);
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
    }
 
    ASSERT_EQ(state_stack.outstanding_image_filter(), outer_filter);
  }
 
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
}

◆ TEST() [561/715]

flutter::testing::TEST	(	LayerStateStack	,
		OldDelegateIsRolledBack
	)

Definition at line 91 of file layer_state_stack_unittests.cc.

                                               {
  LayerStateStack state_stack;
  DisplayListBuilder builder;
  DisplayListBuilder builder2;
  DlCanvas& canvas = builder2;
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
 
  state_stack.set_delegate(&builder);
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
 
  auto mutator = state_stack.save();
  mutator.translate({10, 10});
 
  ASSERT_EQ(builder.GetTransform(), SkMatrix::Translate(10, 10));
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
 
  state_stack.set_delegate(&canvas);
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_EQ(canvas.GetTransform(), SkMatrix::Translate(10, 10));
 
  state_stack.set_preroll_delegate(SkRect::MakeWH(100, 100));
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
 
  state_stack.set_delegate(&builder);
  state_stack.clear_delegate();
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
 
  state_stack.set_delegate(&canvas);
  state_stack.clear_delegate();
 
  ASSERT_TRUE(builder.GetTransform().isIdentity());
  ASSERT_TRUE(canvas.GetTransform().isIdentity());
}

◆ TEST() [562/715]

flutter::testing::TEST	(	LayerStateStack	,
		Opacity
	)

Definition at line 134 of file layer_state_stack_unittests.cc.

                               {
  SkRect rect = {10, 10, 20, 20};
 
  LayerStateStack state_stack;
  state_stack.set_preroll_delegate(SkRect::MakeLTRB(0, 0, 50, 50));
  {
    auto mutator = state_stack.save();
    mutator.applyOpacity(rect, 0.5f);
 
    ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
    ASSERT_EQ(state_stack.outstanding_bounds(), rect);
 
    // Check nested opacities multiply with each other
    {
      auto mutator2 = state_stack.save();
      mutator.applyOpacity(rect, 0.5f);
 
      ASSERT_EQ(state_stack.outstanding_opacity(), 0.25f);
      ASSERT_EQ(state_stack.outstanding_bounds(), rect);
 
      // Verify output with applyState that does not accept opacity
      {
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(rect, 0);
          ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
          ASSERT_EQ(state_stack.outstanding_bounds(), SkRect());
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        DlPaint save_paint =
            DlPaint().setOpacity(state_stack.outstanding_opacity());
        expected.SaveLayer(&rect, &save_paint);
        expected.DrawRect(rect, DlPaint());
        expected.Restore();
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
 
      // Verify output with applyState that accepts opacity
      {
        DisplayListBuilder builder;
        state_stack.set_delegate(&builder);
        {
          auto restore = state_stack.applyState(
              rect, LayerStateStack::kCallerCanApplyOpacity);
          ASSERT_EQ(state_stack.outstanding_opacity(), 0.25f);
          ASSERT_EQ(state_stack.outstanding_bounds(), rect);
 
          DlPaint paint;
          state_stack.fill(paint);
          builder.DrawRect(rect, paint);
        }
        state_stack.clear_delegate();
 
        DisplayListBuilder expected;
        expected.DrawRect(rect, DlPaint().setOpacity(0.25f));
        ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), expected.Build()));
      }
    }
 
    ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
    ASSERT_EQ(state_stack.outstanding_bounds(), rect);
  }
 
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
  ASSERT_EQ(state_stack.outstanding_bounds(), SkRect());
}

◆ TEST() [563/715]

flutter::testing::TEST	(	LayerStateStack	,
		OpacityAndColorFilterInteraction
	)

Definition at line 370 of file layer_state_stack_unittests.cc.

                                                        {
  SkRect rect = {10, 10, 20, 20};
  std::shared_ptr<DlBlendColorFilter> color_filter =
      std::make_shared<DlBlendColorFilter>(DlColor::kYellow(),
                                           DlBlendMode::kColorBurn);
 
  DisplayListBuilder builder;
  LayerStateStack state_stack;
  state_stack.set_delegate(&builder);
  ASSERT_EQ(builder.GetSaveCount(), 1);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyOpacity(rect, 0.5f);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyColorFilter(rect, color_filter);
 
      // The opacity will have been resolved by a saveLayer
      ASSERT_EQ(builder.GetSaveCount(), 2);
      ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
      ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
    ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyColorFilter(rect, color_filter);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyOpacity(rect, 0.5f);
 
      // color filter applied to opacity can be applied together
      ASSERT_EQ(builder.GetSaveCount(), 1);
      ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
      ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_color_filter(), color_filter);
    ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_color_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
}

◆ TEST() [564/715]

flutter::testing::TEST	(	LayerStateStack	,
		OpacityAndImageFilterInteraction
	)

Definition at line 430 of file layer_state_stack_unittests.cc.

                                                        {
  SkRect rect = {10, 10, 20, 20};
  std::shared_ptr<DlBlurImageFilter> image_filter =
      std::make_shared<DlBlurImageFilter>(2.0f, 2.0f, DlTileMode::kClamp);
 
  DisplayListBuilder builder;
  LayerStateStack state_stack;
  state_stack.set_delegate(&builder);
  ASSERT_EQ(builder.GetSaveCount(), 1);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyOpacity(rect, 0.5f);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyImageFilter(rect, image_filter);
 
      // opacity applied to image filter can be applied together
      ASSERT_EQ(builder.GetSaveCount(), 1);
      ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
      ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
    ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
 
  {
    auto mutator1 = state_stack.save();
    ASSERT_EQ(builder.GetSaveCount(), 1);
    mutator1.applyImageFilter(rect, image_filter);
    ASSERT_EQ(builder.GetSaveCount(), 1);
 
    {
      auto mutator2 = state_stack.save();
      ASSERT_EQ(builder.GetSaveCount(), 1);
      mutator2.applyOpacity(rect, 0.5f);
 
      // The image filter will have been resolved by a saveLayer
      ASSERT_EQ(builder.GetSaveCount(), 2);
      ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
      ASSERT_EQ(state_stack.outstanding_opacity(), 0.5f);
    }
    ASSERT_EQ(builder.GetSaveCount(), 1);
    ASSERT_EQ(state_stack.outstanding_image_filter(), image_filter);
    ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
  }
  ASSERT_EQ(builder.GetSaveCount(), 1);
  ASSERT_EQ(state_stack.outstanding_image_filter(), nullptr);
  ASSERT_EQ(state_stack.outstanding_opacity(), SK_Scalar1);
}

◆ TEST() [565/715]

flutter::testing::TEST	(	LayerStateStack	,
		SingularDelegate
	)

Definition at line 60 of file layer_state_stack_unittests.cc.

                                        {
  LayerStateStack state_stack;
  ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
 
  // Two different DlCanvas implementators
  DisplayListBuilder builder;
  DisplayListBuilder builder2;
  DlCanvas& canvas = builder2;
 
  // no delegate -> builder delegate
  state_stack.set_delegate(&builder);
  ASSERT_EQ(state_stack.canvas_delegate(), &builder);
 
  // builder delegate -> DlCanvas delegate
  state_stack.set_delegate(&canvas);
  ASSERT_EQ(state_stack.canvas_delegate(), &canvas);
 
  // DlCanvas delegate -> builder delegate
  state_stack.set_delegate(&builder);
  ASSERT_EQ(state_stack.canvas_delegate(), &builder);
 
  // builder delegate -> no delegate
  state_stack.clear_delegate();
  ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
 
  // DlCanvas delegate -> no delegate
  state_stack.set_delegate(&canvas);
  state_stack.clear_delegate();
  ASSERT_EQ(state_stack.canvas_delegate(), nullptr);
}

◆ TEST() [566/715]

flutter::testing::TEST	(	MathTest	,
		Constants
	)

Definition at line 13 of file math_unittests.cc.

                          {
  // Don't use the constants in cmath as those aren't portable.
  EXPECT_FLOAT_EQ(std::log2(math::kE), math::kLog2E);
  EXPECT_FLOAT_EQ(std::log10(math::kE), math::kLog10E);
  EXPECT_FLOAT_EQ(std::log(2.0f), math::kLogE2);
  EXPECT_FLOAT_EQ(math::kPi / 2.0f, math::kPiOver2);
  EXPECT_FLOAT_EQ(math::kPi / 4.0f, math::kPiOver4);
  EXPECT_FLOAT_EQ(1.0f / math::kPi, math::k1OverPi);
  EXPECT_FLOAT_EQ(2.0f / math::kPi, math::k2OverPi);
  EXPECT_FLOAT_EQ(std::sqrt(2.0f), math::kSqrt2);
  EXPECT_FLOAT_EQ(1.0f / std::sqrt(2.0f), math::k1OverSqrt2);
}

◆ TEST() [567/715]

flutter::testing::TEST	(	MockTextureTest	,
		Callbacks
	)

Definition at line 14 of file mock_texture_unittests.cc.

                                 {
  auto texture = std::make_shared<MockTexture>(0);
 
  ASSERT_FALSE(texture->gr_context_created());
  texture->OnGrContextCreated();
  ASSERT_TRUE(texture->gr_context_created());
 
  ASSERT_FALSE(texture->gr_context_destroyed());
  texture->OnGrContextDestroyed();
  ASSERT_TRUE(texture->gr_context_destroyed());
 
  ASSERT_FALSE(texture->unregistered());
  texture->OnTextureUnregistered();
  ASSERT_TRUE(texture->unregistered());
}

◆ TEST() [568/715]

flutter::testing::TEST	(	MockTextureTest	,
		PaintCalls
	)

Definition at line 30 of file mock_texture_unittests.cc.

                                  {
  DisplayListBuilder builder;
  const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
  const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
  const DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  const auto texture_image = MockTexture::MakeTestTexture(20, 20, 5);
  auto texture = std::make_shared<MockTexture>(0, texture_image);
 
  Texture::PaintContext context{
      .canvas = &builder,
  };
  texture->Paint(context, paint_bounds1, false, sampling);
  texture->Paint(context, paint_bounds2, true, sampling);
 
  SkRect src1 = SkRect::Make(texture_image->bounds());
  SkRect src2 = src1.makeInset(1.0, 1.0f);
 
  DisplayListBuilder expected_builder;
  expected_builder.DrawImageRect(texture_image, src1, paint_bounds1, sampling);
  expected_builder.DrawImageRect(texture_image, src2, paint_bounds2, sampling);
  EXPECT_TRUE(
      DisplayListsEQ_Verbose(builder.Build(), expected_builder.Build()));
}

◆ TEST() [569/715]

flutter::testing::TEST	(	MockTextureTest	,
		PaintCallsWithLinearSampling
	)

Definition at line 54 of file mock_texture_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
  const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
  const auto sampling = DlImageSampling::kLinear;
  const auto texture_image = MockTexture::MakeTestTexture(20, 20, 5);
  auto texture = std::make_shared<MockTexture>(0, texture_image);
 
  Texture::PaintContext context{
      .canvas = &builder,
  };
  texture->Paint(context, paint_bounds1, false, sampling);
  texture->Paint(context, paint_bounds2, true, sampling);
 
  SkRect src1 = SkRect::Make(texture_image->bounds());
  SkRect src2 = src1.makeInset(1.0, 1.0f);
 
  DisplayListBuilder expected_builder;
  expected_builder.DrawImageRect(texture_image, src1, paint_bounds1, sampling);
  expected_builder.DrawImageRect(texture_image, src2, paint_bounds2, sampling);
  EXPECT_TRUE(
      DisplayListsEQ_Verbose(builder.Build(), expected_builder.Build()));
}

◆ TEST() [570/715]

flutter::testing::TEST	(	MockWindow	,
		CreateDestroy
	)

Definition at line 23 of file window_unittests.cc.

                                {
  MockWindow window;
  ASSERT_TRUE(TRUE);
}

◆ TEST() [571/715]

flutter::testing::TEST	(	MockWindow	,
		DISABLED_GetObjectUia
	)

Definition at line 364 of file window_unittests.cc.

                                        {
  MockWindow window;
  bool uia_called = false;
  ON_CALL(window, OnGetObject)
      .WillByDefault(Invoke([&uia_called](UINT msg, WPARAM wpar, LPARAM lpar) {
#ifdef FLUTTER_ENGINE_USE_UIA
        uia_called = true;
#endif  // FLUTTER_ENGINE_USE_UIA
        return static_cast<LRESULT>(0);
      }));
  EXPECT_CALL(window, OnGetObject).Times(1);
 
  window.InjectWindowMessage(WM_GETOBJECT, 0, UiaRootObjectId);
 
  EXPECT_TRUE(uia_called);
}

◆ TEST() [572/715]

flutter::testing::TEST	(	MockWindow	,
		GetDpiAfterCreate
	)

Definition at line 28 of file window_unittests.cc.

                                    {
  MockWindow window;
  ASSERT_TRUE(window.GetDpi() > 0);
}

◆ TEST() [573/715]

flutter::testing::TEST	(	MockWindow	,
		HorizontalScroll
	)

Definition at line 152 of file window_unittests.cc.

                                   {
  MockWindow window;
  const int scroll_amount = 10;
  // Vertical scroll should be passed along, adjusted for scroll tick size.
  EXPECT_CALL(window, OnScroll(scroll_amount / 120.0, 0,
                               kFlutterPointerDeviceKindMouse, 0))
      .Times(1);
 
  window.InjectWindowMessage(WM_MOUSEHWHEEL, MAKEWPARAM(0, scroll_amount), 0);
}

◆ TEST() [574/715]

flutter::testing::TEST	(	MockWindow	,
		KeyDown
	)

Definition at line 179 of file window_unittests.cc.

                          {
  MockWindow window;
  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
  LPARAM lparam = CreateKeyEventLparam(42, false, false);
  // send a "Shift" key down event.
  window.InjectWindowMessage(WM_KEYDOWN, 16, lparam);
}

◆ TEST() [575/715]

flutter::testing::TEST	(	MockWindow	,
		KeyDownPrintable
	)

Definition at line 211 of file window_unittests.cc.

                                   {
  MockWindow window;
  LPARAM lparam = CreateKeyEventLparam(30, false, false);
 
  auto respond_false = [](int key, int scancode, int action, char32_t character,
                          bool extended, bool was_down,
                          std::function<void(bool)> callback) {
    callback(false);
  };
  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _))
      .Times(1)
      .WillOnce(respond_false);
  EXPECT_CALL(window, OnText(_)).Times(1);
  std::array<Win32Message, 2> messages = {
      Win32Message{WM_KEYDOWN, 65, lparam, kWmResultDontCheck},
      Win32Message{WM_CHAR, 65, lparam, kWmResultDontCheck}};
  window.InjectMessageList(2, messages.data());
}

◆ TEST() [576/715]

flutter::testing::TEST	(	MockWindow	,
		KeyDownWithCtrl
	)

Definition at line 230 of file window_unittests.cc.

                                  {
  MockWindow window;
 
  // Simulate CONTROL pressed
  std::array<BYTE, 256> keyboard_state;
  keyboard_state[VK_CONTROL] = -1;
  SetKeyboardState(keyboard_state.data());
 
  LPARAM lparam = CreateKeyEventLparam(30, false, false);
 
  // Expect OnKey, but not OnText, because Control + Key is not followed by
  // WM_CHAR
  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _)).Times(1);
  EXPECT_CALL(window, OnText(_)).Times(0);
 
  window.InjectWindowMessage(WM_KEYDOWN, 65, lparam);
 
  keyboard_state.fill(0);
  SetKeyboardState(keyboard_state.data());
}

◆ TEST() [577/715]

flutter::testing::TEST	(	MockWindow	,
		KeyDownWithCtrlToggled
	)

Definition at line 251 of file window_unittests.cc.

                                         {
  MockWindow window;
 
  auto respond_false = [](int key, int scancode, int action, char32_t character,
                          bool extended, bool was_down,
                          std::function<void(bool)> callback) {
    callback(false);
  };
 
  // Simulate CONTROL toggled
  std::array<BYTE, 256> keyboard_state;
  keyboard_state[VK_CONTROL] = 1;
  SetKeyboardState(keyboard_state.data());
 
  LPARAM lparam = CreateKeyEventLparam(30, false, false);
 
  EXPECT_CALL(window, OnKey(65, 30, WM_KEYDOWN, 0, false, false, _))
      .Times(1)
      .WillOnce(respond_false);
  EXPECT_CALL(window, OnText(_)).Times(1);
 
  // send a "A" key down event.
  Win32Message messages[] = {{WM_KEYDOWN, 65, lparam, kWmResultDontCheck},
                             {WM_CHAR, 65, lparam, kWmResultDontCheck}};
  window.InjectMessageList(2, messages);
 
  keyboard_state.fill(0);
  SetKeyboardState(keyboard_state.data());
}

◆ TEST() [578/715]

flutter::testing::TEST	(	MockWindow	,
		KeyUp
	)

Definition at line 187 of file window_unittests.cc.

                        {
  MockWindow window;
  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
  LPARAM lparam = CreateKeyEventLparam(42, false, true);
  // send a "Shift" key up event.
  window.InjectWindowMessage(WM_KEYUP, 16, lparam);
}

◆ TEST() [579/715]

flutter::testing::TEST	(	MockWindow	,
		MouseLeave
	)

Definition at line 163 of file window_unittests.cc.

                             {
  MockWindow window;
  const double mouse_x = 10.0;
  const double mouse_y = 20.0;
 
  EXPECT_CALL(window, OnPointerMove(mouse_x, mouse_y,
                                    kFlutterPointerDeviceKindMouse, 0, 0))
      .Times(1);
  EXPECT_CALL(window, OnPointerLeave(mouse_x, mouse_y,
                                     kFlutterPointerDeviceKindMouse, 0))
      .Times(1);
 
  window.InjectWindowMessage(WM_MOUSEMOVE, 0, MAKELPARAM(mouse_x, mouse_y));
  window.InjectWindowMessage(WM_MOUSELEAVE, 0, 0);
}

◆ TEST() [580/715]

flutter::testing::TEST	(	MockWindow	,
		OnImeCompositionClearChange
	)

Definition at line 135 of file window_unittests.cc.

                                              {
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto* text_input_manager = new MockTextInputManager();
  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager_ptr));
  EXPECT_CALL(window, OnComposeChange(std::u16string(u""), 0)).Times(1);
  EXPECT_CALL(window, OnComposeCommit()).Times(1);
  ON_CALL(window, OnImeComposition)
      .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
 
  // send an IME_COMPOSITION event that contains both the result string and the
  // composition string.
  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, 0);
}

◆ TEST() [581/715]

flutter::testing::TEST	(	MockWindow	,
		OnImeCompositionCompose
	)

Definition at line 45 of file window_unittests.cc.

                                          {
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto* text_input_manager = new MockTextInputManager();
  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager_ptr));
  EXPECT_CALL(*text_input_manager, GetComposingString())
      .WillRepeatedly(
          Return(std::optional<std::u16string>(std::u16string(u"nihao"))));
  EXPECT_CALL(*text_input_manager, GetResultString())
      .WillRepeatedly(
          Return(std::optional<std::u16string>(std::u16string(u"`}"))));
  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
      .WillRepeatedly(Return((int)0));
 
  EXPECT_CALL(window, OnComposeChange(std::u16string(u"nihao"), 0)).Times(1);
  EXPECT_CALL(window, OnComposeChange(std::u16string(u"`}"), 0)).Times(0);
  EXPECT_CALL(window, OnComposeCommit()).Times(0);
  ON_CALL(window, OnImeComposition)
      .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
 
  // Send an IME_COMPOSITION event that contains just the composition string.
  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, GCS_COMPSTR);
}

◆ TEST() [582/715]

flutter::testing::TEST	(	MockWindow	,
		OnImeCompositionResult
	)

Definition at line 71 of file window_unittests.cc.

                                         {
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto* text_input_manager = new MockTextInputManager();
  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager_ptr));
  EXPECT_CALL(*text_input_manager, GetComposingString())
      .WillRepeatedly(
          Return(std::optional<std::u16string>(std::u16string(u"nihao"))));
  EXPECT_CALL(*text_input_manager, GetResultString())
      .WillRepeatedly(
          Return(std::optional<std::u16string>(std::u16string(u"`}"))));
  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
      .WillRepeatedly(Return((int)0));
 
  EXPECT_CALL(window, OnComposeChange(std::u16string(u"nihao"), 0)).Times(0);
  EXPECT_CALL(window, OnComposeChange(std::u16string(u"`}"), 0)).Times(1);
  EXPECT_CALL(window, OnComposeCommit()).Times(1);
  ON_CALL(window, OnImeComposition)
      .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
 
  // Send an IME_COMPOSITION event that contains just the result string.
  window.InjectWindowMessage(WM_IME_COMPOSITION, 0, GCS_RESULTSTR);
}

◆ TEST() [583/715]

flutter::testing::TEST	(	MockWindow	,
		OnImeCompositionResultAndCompose
	)

Definition at line 97 of file window_unittests.cc.

                                                   {
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto* text_input_manager = new MockTextInputManager();
  std::unique_ptr<TextInputManager> text_input_manager_ptr(text_input_manager);
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager_ptr));
 
  // This situation is that Google Japanese Input finished composing "今日" in
  // "今日は" but is still composing "は".
  {
    InSequence dummy;
    EXPECT_CALL(*text_input_manager, GetResultString())
        .WillRepeatedly(
            Return(std::optional<std::u16string>(std::u16string(u"今日"))));
    EXPECT_CALL(*text_input_manager, GetComposingString())
        .WillRepeatedly(
            Return(std::optional<std::u16string>(std::u16string(u"は"))));
  }
  {
    InSequence dummy;
    EXPECT_CALL(window, OnComposeChange(std::u16string(u"今日"), 0)).Times(1);
    EXPECT_CALL(window, OnComposeCommit()).Times(1);
    EXPECT_CALL(window, OnComposeChange(std::u16string(u"は"), 0)).Times(1);
  }
 
  EXPECT_CALL(*text_input_manager, GetComposingCursorPosition())
      .WillRepeatedly(Return((int)0));
 
  ON_CALL(window, OnImeComposition)
      .WillByDefault(Invoke(&window, &MockWindow::CallOnImeComposition));
  EXPECT_CALL(window, OnImeComposition(_, _, _)).Times(1);
 
  // send an IME_COMPOSITION event that contains both the result string and the
  // composition string.
  window.InjectWindowMessage(WM_IME_COMPOSITION, 0,
                             GCS_COMPSTR | GCS_RESULTSTR);
}

◆ TEST() [584/715]

flutter::testing::TEST	(	MockWindow	,
		Paint
	)

Definition at line 281 of file window_unittests.cc.

                        {
  MockWindow window;
  EXPECT_CALL(window, OnPaint()).Times(1);
  window.InjectWindowMessage(WM_PAINT, 0, 0);
}

◆ TEST() [585/715]

flutter::testing::TEST	(	MockWindow	,
		PointerHitTest
	)

Definition at line 288 of file window_unittests.cc.

                                 {
  UINT32 pointer_id = 123;
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto text_input_manager = std::make_unique<MockTextInputManager>();
 
  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
      .Times(1)
      .WillOnce([](UINT32 pointer_id, POINTER_INPUT_TYPE* type) {
        *type = PT_POINTER;
        return TRUE;
      });
 
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager));
 
  auto direct_manipulation =
      std::make_unique<MockDirectManipulationOwner>(&window);
 
  EXPECT_CALL(*direct_manipulation, SetContact).Times(0);
 
  window.SetDirectManipulationOwner(std::move(direct_manipulation));
  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
}

◆ TEST() [586/715]

flutter::testing::TEST	(	MockWindow	,
		SysKeyDown
	)

Definition at line 195 of file window_unittests.cc.

                             {
  MockWindow window;
  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
  LPARAM lparam = CreateKeyEventLparam(42, false, false);
  // send a "Shift" key down event.
  window.InjectWindowMessage(WM_SYSKEYDOWN, 16, lparam);
}

◆ TEST() [587/715]

flutter::testing::TEST	(	MockWindow	,
		SysKeyUp
	)

Definition at line 203 of file window_unittests.cc.

                           {
  MockWindow window;
  EXPECT_CALL(window, OnKey(_, _, _, _, _, _, _)).Times(1);
  LPARAM lparam = CreateKeyEventLparam(42, false, true);
  // send a "Shift" key up event.
  window.InjectWindowMessage(WM_SYSKEYUP, 16, lparam);
}

◆ TEST() [588/715]

flutter::testing::TEST	(	MockWindow	,
		TouchPadHitTest
	)

Definition at line 313 of file window_unittests.cc.

                                  {
  UINT32 pointer_id = 123;
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto text_input_manager = std::make_unique<MockTextInputManager>();
 
  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
      .Times(1)
      .WillOnce([](UINT32 pointer_id, POINTER_INPUT_TYPE* type) {
        *type = PT_TOUCHPAD;
        return TRUE;
      });
 
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager));
 
  auto direct_manipulation =
      std::make_unique<MockDirectManipulationOwner>(&window);
 
  EXPECT_CALL(*direct_manipulation, SetContact(Eq(pointer_id))).Times(1);
 
  window.SetDirectManipulationOwner(std::move(direct_manipulation));
  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
}

◆ TEST() [589/715]

flutter::testing::TEST	(	MockWindow	,
		UnknownPointerTypeSkipsDirectManipulation
	)

Definition at line 341 of file window_unittests.cc.

                                                            {
  UINT32 pointer_id = 123;
  auto windows_proc_table = std::make_unique<MockWindowsProcTable>();
  auto text_input_manager = std::make_unique<MockTextInputManager>();
 
  EXPECT_CALL(*windows_proc_table, GetPointerType(Eq(pointer_id), _))
      .Times(1)
      .WillOnce(
          [](UINT32 pointer_id, POINTER_INPUT_TYPE* type) { return FALSE; });
 
  MockWindow window(std::move(windows_proc_table),
                    std::move(text_input_manager));
 
  auto direct_manipulation =
      std::make_unique<MockDirectManipulationOwner>(&window);
 
  EXPECT_CALL(*direct_manipulation, SetContact).Times(0);
 
  window.SetDirectManipulationOwner(std::move(direct_manipulation));
  window.InjectWindowMessage(DM_POINTERHITTEST, MAKEWPARAM(pointer_id, 0), 0);
}

◆ TEST() [590/715]

flutter::testing::TEST	(	MockWindow	,
		VerticalScroll
	)

Definition at line 33 of file window_unittests.cc.

                                 {
  MockWindow window;
  const int scroll_amount = 10;
  // Vertical scroll should be passed along, adjusted for scroll tick size
  // and direction.
  EXPECT_CALL(window, OnScroll(0, -scroll_amount / 120.0,
                               kFlutterPointerDeviceKindMouse, 0))
      .Times(1);
 
  window.InjectWindowMessage(WM_MOUSEWHEEL, MAKEWPARAM(0, scroll_amount), 0);
}

◆ TEST() [591/715]

flutter::testing::TEST	(	Mutator	,
		CopyConstructor
	)

Definition at line 224 of file mutators_stack_unittests.cc.

                               {
  SkRect rect = SkRect::MakeEmpty();
  Mutator mutator = Mutator(rect);
  Mutator copy = Mutator(mutator);
  ASSERT_TRUE(mutator == copy);
 
  SkRRect rrect = SkRRect::MakeEmpty();
  Mutator mutator2 = Mutator(rrect);
  Mutator copy2 = Mutator(mutator2);
  ASSERT_TRUE(mutator2 == copy2);
 
  SkPath path;
  Mutator mutator3 = Mutator(path);
  Mutator copy3 = Mutator(mutator3);
  ASSERT_TRUE(mutator3 == copy3);
 
  SkMatrix matrix;
  matrix.setIdentity();
  Mutator mutator4 = Mutator(matrix);
  Mutator copy4 = Mutator(mutator4);
  ASSERT_TRUE(mutator4 == copy4);
 
  int alpha = 240;
  Mutator mutator5 = Mutator(alpha);
  Mutator copy5 = Mutator(mutator5);
  ASSERT_TRUE(mutator5 == copy5);
 
  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  Mutator mutator6 = Mutator(filter, SkRect::MakeEmpty());
  Mutator copy6 = Mutator(mutator6);
  ASSERT_TRUE(mutator6 == copy6);
}

◆ TEST() [592/715]

flutter::testing::TEST	(	Mutator	,
		Equality
	)

Definition at line 257 of file mutators_stack_unittests.cc.

                        {
  SkMatrix matrix;
  matrix.setIdentity();
  Mutator mutator = Mutator(matrix);
  Mutator other_mutator = Mutator(matrix);
  ASSERT_TRUE(mutator == other_mutator);
 
  SkRect rect = SkRect::MakeEmpty();
  Mutator mutator2 = Mutator(rect);
  Mutator other_mutator2 = Mutator(rect);
  ASSERT_TRUE(mutator2 == other_mutator2);
 
  SkRRect rrect = SkRRect::MakeEmpty();
  Mutator mutator3 = Mutator(rrect);
  Mutator other_mutator3 = Mutator(rrect);
  ASSERT_TRUE(mutator3 == other_mutator3);
 
  SkPath path;
  flutter::Mutator mutator4 = flutter::Mutator(path);
  flutter::Mutator other_mutator4 = flutter::Mutator(path);
  ASSERT_TRUE(mutator4 == other_mutator4);
  ASSERT_FALSE(mutator2 == mutator);
  int alpha = 240;
  Mutator mutator5 = Mutator(alpha);
  Mutator other_mutator5 = Mutator(alpha);
  ASSERT_TRUE(mutator5 == other_mutator5);
 
  auto filter1 = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  auto filter2 = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  Mutator mutator6 = Mutator(filter1, SkRect::MakeEmpty());
  Mutator other_mutator6 = Mutator(filter2, SkRect::MakeEmpty());
  ASSERT_TRUE(mutator6 == other_mutator6);
}

◆ TEST() [593/715]

flutter::testing::TEST	(	Mutator	,
		Initialization
	)

Definition at line 192 of file mutators_stack_unittests.cc.

                              {
  SkRect rect = SkRect::MakeEmpty();
  Mutator mutator = Mutator(rect);
  ASSERT_TRUE(mutator.GetType() == MutatorType::kClipRect);
  ASSERT_TRUE(mutator.GetRect() == rect);
 
  SkRRect rrect = SkRRect::MakeEmpty();
  Mutator mutator2 = Mutator(rrect);
  ASSERT_TRUE(mutator2.GetType() == MutatorType::kClipRRect);
  ASSERT_TRUE(mutator2.GetRRect() == rrect);
 
  SkPath path;
  Mutator mutator3 = Mutator(path);
  ASSERT_TRUE(mutator3.GetType() == MutatorType::kClipPath);
  ASSERT_TRUE(mutator3.GetPath() == path);
 
  SkMatrix matrix;
  matrix.setIdentity();
  Mutator mutator4 = Mutator(matrix);
  ASSERT_TRUE(mutator4.GetType() == MutatorType::kTransform);
  ASSERT_TRUE(mutator4.GetMatrix() == matrix);
 
  int alpha = 240;
  Mutator mutator5 = Mutator(alpha);
  ASSERT_TRUE(mutator5.GetType() == MutatorType::kOpacity);
 
  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  Mutator mutator6 = Mutator(filter, SkRect::MakeEmpty());
  ASSERT_TRUE(mutator6.GetType() == MutatorType::kBackdropFilter);
  ASSERT_TRUE(mutator6.GetFilterMutation().GetFilter() == *filter);
}

◆ TEST() [594/715]

flutter::testing::TEST	(	Mutator	,
		UnEquality
	)

Definition at line 291 of file mutators_stack_unittests.cc.

                          {
  SkRect rect = SkRect::MakeEmpty();
  Mutator mutator = Mutator(rect);
  SkMatrix matrix;
  matrix.setIdentity();
  Mutator not_equal_mutator = Mutator(matrix);
  ASSERT_TRUE(not_equal_mutator != mutator);
 
  int alpha = 240;
  int alpha2 = 241;
  Mutator mutator2 = Mutator(alpha);
  Mutator other_mutator2 = Mutator(alpha2);
  ASSERT_TRUE(mutator2 != other_mutator2);
 
  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  auto filter2 =
      std::make_shared<DlBlurImageFilter>(10, 10, DlTileMode::kClamp);
  Mutator mutator3 = Mutator(filter, SkRect::MakeEmpty());
  Mutator other_mutator3 = Mutator(filter2, SkRect::MakeEmpty());
  ASSERT_TRUE(mutator3 != other_mutator3);
}

◆ TEST() [595/715]

flutter::testing::TEST	(	MutatorsStack	,
		CopyAndUpdateTheCopy
	)

Definition at line 26 of file mutators_stack_unittests.cc.

                                          {
  MutatorsStack stack;
  auto rrect = SkRRect::MakeEmpty();
  auto rect = SkRect::MakeEmpty();
  stack.PushClipRect(rect);
  stack.PushClipRRect(rrect);
  MutatorsStack copy = MutatorsStack(stack);
  copy.Pop();
  copy.Pop();
  ASSERT_TRUE(copy != stack);
  ASSERT_TRUE(copy.is_empty());
  ASSERT_TRUE(!stack.is_empty());
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRRect);
  ASSERT_TRUE(iter->get()->GetRRect() == rrect);
  ++iter;
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRect);
  ASSERT_TRUE(iter->get()->GetRect() == rect);
}

◆ TEST() [596/715]

flutter::testing::TEST	(	MutatorsStack	,
		CopyConstructor
	)

Definition at line 16 of file mutators_stack_unittests.cc.

                                     {
  MutatorsStack stack;
  auto rrect = SkRRect::MakeEmpty();
  auto rect = SkRect::MakeEmpty();
  stack.PushClipRect(rect);
  stack.PushClipRRect(rrect);
  MutatorsStack copy = MutatorsStack(stack);
  ASSERT_TRUE(copy == stack);
}

◆ TEST() [597/715]

flutter::testing::TEST	(	MutatorsStack	,
		Equality
	)

Definition at line 159 of file mutators_stack_unittests.cc.

                              {
  MutatorsStack stack;
  SkMatrix matrix = SkMatrix::Scale(1, 1);
  stack.PushTransform(matrix);
  SkRect rect = SkRect::MakeEmpty();
  stack.PushClipRect(rect);
  SkRRect rrect = SkRRect::MakeEmpty();
  stack.PushClipRRect(rrect);
  SkPath path;
  stack.PushClipPath(path);
  int alpha = 240;
  stack.PushOpacity(alpha);
  auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  stack.PushBackdropFilter(filter, SkRect::MakeEmpty());
 
  MutatorsStack stack_other;
  SkMatrix matrix_other = SkMatrix::Scale(1, 1);
  stack_other.PushTransform(matrix_other);
  SkRect rect_other = SkRect::MakeEmpty();
  stack_other.PushClipRect(rect_other);
  SkRRect rrect_other = SkRRect::MakeEmpty();
  stack_other.PushClipRRect(rrect_other);
  SkPath other_path;
  stack_other.PushClipPath(other_path);
  int other_alpha = 240;
  stack_other.PushOpacity(other_alpha);
  auto other_filter =
      std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  stack_other.PushBackdropFilter(other_filter, SkRect::MakeEmpty());
 
  ASSERT_TRUE(stack == stack_other);
}

◆ TEST() [598/715]

flutter::testing::TEST	(	MutatorsStack	,
		Initialization
	)

Definition at line 11 of file mutators_stack_unittests.cc.

                                    {
  MutatorsStack stack;
  ASSERT_TRUE(true);
}

◆ TEST() [599/715]

flutter::testing::TEST	(	MutatorsStack	,
		Pop
	)

Definition at line 116 of file mutators_stack_unittests.cc.

                         {
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setIdentity();
  stack.PushTransform(matrix);
  stack.Pop();
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter == stack.Top());
}

◆ TEST() [600/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushBackdropFilter
	)

Definition at line 92 of file mutators_stack_unittests.cc.

                                        {
  MutatorsStack stack;
  const int num_of_mutators = 10;
  for (int i = 0; i < num_of_mutators; i++) {
    auto filter = std::make_shared<DlBlurImageFilter>(i, 5, DlTileMode::kClamp);
    stack.PushBackdropFilter(filter, SkRect::MakeXYWH(i, i, i, i));
  }
 
  auto iter = stack.Begin();
  int i = 0;
  while (iter != stack.End()) {
    ASSERT_EQ(iter->get()->GetType(), MutatorType::kBackdropFilter);
    ASSERT_EQ(iter->get()->GetFilterMutation().GetFilter().asBlur()->sigma_x(),
              i);
    ASSERT_EQ(iter->get()->GetFilterMutation().GetFilterRect().x(), i);
    ASSERT_EQ(iter->get()->GetFilterMutation().GetFilterRect().x(), i);
    ASSERT_EQ(iter->get()->GetFilterMutation().GetFilterRect().width(), i);
    ASSERT_EQ(iter->get()->GetFilterMutation().GetFilterRect().height(), i);
    ++iter;
    ++i;
  }
  ASSERT_EQ(i, num_of_mutators);
}

◆ TEST() [601/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipPath
	)

Definition at line 64 of file mutators_stack_unittests.cc.

                                  {
  MutatorsStack stack;
  SkPath path;
  stack.PushClipPath(path);
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == flutter::MutatorType::kClipPath);
  ASSERT_TRUE(iter->get()->GetPath() == path);
}

◆ TEST() [602/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipRect
	)

Definition at line 46 of file mutators_stack_unittests.cc.

                                  {
  MutatorsStack stack;
  auto rect = SkRect::MakeEmpty();
  stack.PushClipRect(rect);
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRect);
  ASSERT_TRUE(iter->get()->GetRect() == rect);
}

◆ TEST() [603/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipRRect
	)

Definition at line 55 of file mutators_stack_unittests.cc.

                                   {
  MutatorsStack stack;
  auto rrect = SkRRect::MakeEmpty();
  stack.PushClipRRect(rrect);
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRRect);
  ASSERT_TRUE(iter->get()->GetRRect() == rrect);
}

◆ TEST() [604/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushOpacity
	)

Definition at line 83 of file mutators_stack_unittests.cc.

                                 {
  MutatorsStack stack;
  int alpha = 240;
  stack.PushOpacity(alpha);
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kOpacity);
  ASSERT_TRUE(iter->get()->GetAlpha() == 240);
}

◆ TEST() [605/715]

flutter::testing::TEST	(	MutatorsStack	,
		PushTransform
	)

Definition at line 73 of file mutators_stack_unittests.cc.

                                   {
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setIdentity();
  stack.PushTransform(matrix);
  auto iter = stack.Bottom();
  ASSERT_TRUE(iter->get()->GetType() == MutatorType::kTransform);
  ASSERT_TRUE(iter->get()->GetMatrix() == matrix);
}

◆ TEST() [606/715]

flutter::testing::TEST	(	MutatorsStack	,
		Traversal
	)

Definition at line 126 of file mutators_stack_unittests.cc.

                               {
  MutatorsStack stack;
  SkMatrix matrix;
  matrix.setIdentity();
  stack.PushTransform(matrix);
  auto rect = SkRect::MakeEmpty();
  stack.PushClipRect(rect);
  auto rrect = SkRRect::MakeEmpty();
  stack.PushClipRRect(rrect);
  auto iter = stack.Bottom();
  int index = 0;
  while (iter != stack.Top()) {
    switch (index) {
      case 0:
        ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRRect);
        ASSERT_TRUE(iter->get()->GetRRect() == rrect);
        break;
      case 1:
        ASSERT_TRUE(iter->get()->GetType() == MutatorType::kClipRect);
        ASSERT_TRUE(iter->get()->GetRect() == rect);
        break;
      case 2:
        ASSERT_TRUE(iter->get()->GetType() == MutatorType::kTransform);
        ASSERT_TRUE(iter->get()->GetMatrix() == matrix);
        break;
      default:
        break;
    }
    ++iter;
    ++index;
  }
}

◆ TEST() [607/715]

flutter::testing::TEST	(	OffscreenSurfaceTest	,
		EmptySurfaceIsInvalid
	)

Definition at line 16 of file offscreen_surface_unittests.cc.

                                                  {
  auto surface =
      std::make_unique<OffscreenSurface>(nullptr, SkISize::MakeEmpty());
  ASSERT_FALSE(surface->IsValid());
}

◆ TEST() [608/715]

flutter::testing::TEST	(	OffscreenSurfaceTest	,
		OnexOneSurfaceIsValid
	)

Definition at line 22 of file offscreen_surface_unittests.cc.

                                                  {
  auto surface =
      std::make_unique<OffscreenSurface>(nullptr, SkISize::Make(1, 1));
  ASSERT_TRUE(surface->IsValid());
}

◆ TEST() [609/715]

flutter::testing::TEST	(	OffscreenSurfaceTest	,
		PaintSurfaceBlack
	)

Definition at line 28 of file offscreen_surface_unittests.cc.

                                              {
  auto surface =
      std::make_unique<OffscreenSurface>(nullptr, SkISize::Make(1, 1));
 
  DlCanvas* canvas = surface->GetCanvas();
  canvas->Clear(DlColor::kBlack());
  canvas->Flush();
 
  auto raster_data = surface->GetRasterData(false);
  const uint32_t* actual =
      reinterpret_cast<const uint32_t*>(raster_data->data());
 
  // picking black as the color since byte ordering seems to matter.
  ASSERT_EQ(actual[0], 0xFF000000u);
}

◆ TEST() [610/715]

flutter::testing::TEST	(	PerformanceOverlayLayer120fps	,
		Gold
	)

Definition at line 230 of file performance_overlay_layer_unittests.cc.

                                          {
  TestPerformanceOverlayLayerGold(120);
}

◆ TEST() [611/715]

flutter::testing::TEST	(	PerformanceOverlayLayer90fps	,
		Gold
	)

Definition at line 226 of file performance_overlay_layer_unittests.cc.

                                         {
  TestPerformanceOverlayLayerGold(90);
}

◆ TEST() [612/715]

flutter::testing::TEST	(	PerformanceOverlayLayerDefault	,
		Gold
	)

Definition at line 222 of file performance_overlay_layer_unittests.cc.

                                           {
  TestPerformanceOverlayLayerGold(60);
}

◆ TEST() [613/715]

flutter::testing::TEST	(	PipelineTest	,
		ConsumeOneVal
	)

Definition at line 21 of file pipeline_unittests.cc.

                                  {
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(2);
 
  Continuation continuation = pipeline->Produce();
 
  const int test_val = 1;
  PipelineProduceResult result =
      continuation.Complete(std::make_unique<int>(test_val));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
 
  PipelineConsumeResult consume_result = pipeline->Consume(
      [&test_val](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val); });
 
  ASSERT_EQ(consume_result, PipelineConsumeResult::Done);
}

◆ TEST() [614/715]

flutter::testing::TEST	(	PipelineTest	,
		ContinuationCanOnlyBeUsedOnce
	)

Definition at line 38 of file pipeline_unittests.cc.

                                                  {
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(2);
 
  Continuation continuation = pipeline->Produce();
 
  const int test_val = 1;
  PipelineProduceResult result =
      continuation.Complete(std::make_unique<int>(test_val));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
 
  PipelineConsumeResult consume_result_1 = pipeline->Consume(
      [&test_val](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val); });
 
  result = continuation.Complete(std::make_unique<int>(test_val));
  ASSERT_EQ(result.success, false);
  ASSERT_EQ(consume_result_1, PipelineConsumeResult::Done);
 
  PipelineConsumeResult consume_result_2 =
      pipeline->Consume([](std::unique_ptr<int> v) { FAIL(); });
 
  result = continuation.Complete(std::make_unique<int>(test_val));
  ASSERT_EQ(result.success, false);
  ASSERT_EQ(consume_result_2, PipelineConsumeResult::NoneAvailable);
}

◆ TEST() [615/715]

flutter::testing::TEST	(	PipelineTest	,
		ProduceIfEmptyDoesNotConsumeWhenQueueIsNotEmpty
	)

Definition at line 110 of file pipeline_unittests.cc.

                                                                    {
  const int depth = 2;
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(depth);
 
  Continuation continuation_1 = pipeline->Produce();
  Continuation continuation_2 = pipeline->ProduceIfEmpty();
 
  const int test_val_1 = 1, test_val_2 = 2;
  PipelineProduceResult result =
      continuation_1.Complete(std::make_unique<int>(test_val_1));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
  result = continuation_2.Complete(std::make_unique<int>(test_val_2));
  ASSERT_EQ(result.success, false);
 
  PipelineConsumeResult consume_result_1 = pipeline->Consume(
      [&test_val_1](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val_1); });
  ASSERT_EQ(consume_result_1, PipelineConsumeResult::Done);
}

◆ TEST() [616/715]

flutter::testing::TEST	(	PipelineTest	,
		ProduceIfEmptySuccessfulIfQueueIsEmpty
	)

Definition at line 130 of file pipeline_unittests.cc.

                                                           {
  const int depth = 1;
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(depth);
 
  Continuation continuation_1 = pipeline->ProduceIfEmpty();
 
  const int test_val_1 = 1;
  PipelineProduceResult result =
      continuation_1.Complete(std::make_unique<int>(test_val_1));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
 
  PipelineConsumeResult consume_result_1 = pipeline->Consume(
      [&test_val_1](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val_1); });
  ASSERT_EQ(consume_result_1, PipelineConsumeResult::Done);
}

◆ TEST() [617/715]

flutter::testing::TEST	(	PipelineTest	,
		PushingMoreThanDepthCompletesFirstSubmission
	)

Definition at line 64 of file pipeline_unittests.cc.

                                                                 {
  const int depth = 1;
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(depth);
 
  Continuation continuation_1 = pipeline->Produce();
  Continuation continuation_2 = pipeline->Produce();
 
  const int test_val_1 = 1, test_val_2 = 2;
  PipelineProduceResult result =
      continuation_1.Complete(std::make_unique<int>(test_val_1));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
  result = continuation_2.Complete(std::make_unique<int>(test_val_2));
  ASSERT_EQ(result.success, false);
 
  PipelineConsumeResult consume_result_1 = pipeline->Consume(
      [&test_val_1](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val_1); });
 
  ASSERT_EQ(consume_result_1, PipelineConsumeResult::Done);
}

◆ TEST() [618/715]

flutter::testing::TEST	(	PipelineTest	,
		PushingMultiProcessesInOrder
	)

Definition at line 85 of file pipeline_unittests.cc.

                                                 {
  const int depth = 2;
  std::shared_ptr<IntPipeline> pipeline = std::make_shared<IntPipeline>(depth);
 
  Continuation continuation_1 = pipeline->Produce();
  Continuation continuation_2 = pipeline->Produce();
 
  const int test_val_1 = 1, test_val_2 = 2;
  PipelineProduceResult result =
      continuation_1.Complete(std::make_unique<int>(test_val_1));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, true);
  result = continuation_2.Complete(std::make_unique<int>(test_val_2));
  ASSERT_EQ(result.success, true);
  ASSERT_EQ(result.is_first_item, false);
 
  PipelineConsumeResult consume_result_1 = pipeline->Consume(
      [&test_val_1](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val_1); });
  ASSERT_EQ(consume_result_1, PipelineConsumeResult::MoreAvailable);
 
  PipelineConsumeResult consume_result_2 = pipeline->Consume(
      [&test_val_2](std::unique_ptr<int> v) { ASSERT_EQ(*v, test_val_2); });
  ASSERT_EQ(consume_result_2, PipelineConsumeResult::Done);
}

◆ TEST() [619/715]

flutter::testing::TEST	(	PlatformViewEmbedderTest	,
		DeletionDisabledDispatch
	)

Definition at line 172 of file platform_view_embedder_unittests.cc.

                                                         {
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  flutter::TaskRunners task_runners = flutter::TaskRunners(
      "HasPlatformMessageHandler", thread_host.platform_thread->GetTaskRunner(),
      nullptr, nullptr, nullptr);
  bool did_call = false;
  {
    fml::AutoResetWaitableEvent latch;
    task_runners.GetPlatformTaskRunner()->PostTask([&latch, task_runners,
                                                    &did_call] {
      MockDelegate delegate;
      EmbedderSurfaceSoftware::SoftwareDispatchTable software_dispatch_table;
      PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table;
      platform_dispatch_table.platform_message_response_callback =
          [&did_call](std::unique_ptr<PlatformMessage> message) {
            did_call = true;
          };
      std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder;
      auto embedder = std::make_unique<PlatformViewEmbedder>(
          delegate, task_runners, software_dispatch_table,
          platform_dispatch_table, external_view_embedder);
      auto platform_message_handler = embedder->GetPlatformMessageHandler();
      fml::RefPtr<PlatformMessageResponse> response =
          fml::MakeRefCounted<MockResponse>();
      std::unique_ptr<PlatformMessage> message =
          std::make_unique<PlatformMessage>("foo", response);
      platform_message_handler->HandlePlatformMessage(std::move(message));
      embedder.reset();
      latch.Signal();
    });
    latch.Wait();
  }
  {
    fml::AutoResetWaitableEvent latch;
    thread_host.platform_thread->GetTaskRunner()->PostTask(
        [&latch] { latch.Signal(); });
    latch.Wait();
  }
 
  EXPECT_FALSE(did_call);
}

◆ TEST() [620/715]

flutter::testing::TEST	(	PlatformViewEmbedderTest	,
		Dispatches
	)

Definition at line 127 of file platform_view_embedder_unittests.cc.

                                           {
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  flutter::TaskRunners task_runners = flutter::TaskRunners(
      "HasPlatformMessageHandler", thread_host.platform_thread->GetTaskRunner(),
      nullptr, nullptr, nullptr);
  bool did_call = false;
  std::unique_ptr<PlatformViewEmbedder> embedder;
  {
    fml::AutoResetWaitableEvent latch;
    task_runners.GetPlatformTaskRunner()->PostTask([&latch, task_runners,
                                                    &did_call, &embedder] {
      MockDelegate delegate;
      EmbedderSurfaceSoftware::SoftwareDispatchTable software_dispatch_table;
      PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table;
      platform_dispatch_table.platform_message_response_callback =
          [&did_call](std::unique_ptr<PlatformMessage> message) {
            did_call = true;
          };
      std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder;
      embedder = std::make_unique<PlatformViewEmbedder>(
          delegate, task_runners, software_dispatch_table,
          platform_dispatch_table, external_view_embedder);
      auto platform_message_handler = embedder->GetPlatformMessageHandler();
      fml::RefPtr<PlatformMessageResponse> response =
          fml::MakeRefCounted<MockResponse>();
      std::unique_ptr<PlatformMessage> message =
          std::make_unique<PlatformMessage>("foo", response);
      platform_message_handler->HandlePlatformMessage(std::move(message));
      latch.Signal();
    });
    latch.Wait();
  }
  {
    fml::AutoResetWaitableEvent latch;
    thread_host.platform_thread->GetTaskRunner()->PostTask([&latch, &embedder] {
      embedder.reset();
      latch.Signal();
    });
    latch.Wait();
  }
 
  EXPECT_TRUE(did_call);
}

◆ TEST() [621/715]

flutter::testing::TEST	(	PlatformViewEmbedderTest	,
		HasPlatformMessageHandler
	)

Definition at line 105 of file platform_view_embedder_unittests.cc.

                                                          {
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  flutter::TaskRunners task_runners = flutter::TaskRunners(
      "HasPlatformMessageHandler", thread_host.platform_thread->GetTaskRunner(),
      nullptr, nullptr, nullptr);
  fml::AutoResetWaitableEvent latch;
  task_runners.GetPlatformTaskRunner()->PostTask([&latch, task_runners] {
    MockDelegate delegate;
    EmbedderSurfaceSoftware::SoftwareDispatchTable software_dispatch_table;
    PlatformViewEmbedder::PlatformDispatchTable platform_dispatch_table;
    std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder;
    auto embedder = std::make_unique<PlatformViewEmbedder>(
        delegate, task_runners, software_dispatch_table,
        platform_dispatch_table, external_view_embedder);
 
    ASSERT_TRUE(embedder->GetPlatformMessageHandler());
    latch.Signal();
  });
  latch.Wait();
}

◆ TEST() [622/715]

flutter::testing::TEST	(	PlatformViewShell	,
		UpdateSemanticsDoesFlutterViewUpdateCustomAccessibilityActions
	)

Definition at line 165 of file platform_view_android_delegate_unittests.cc.

                                                                     {
  auto jni_mock = std::make_shared<JNIMock>();
  auto delegate = std::make_unique<PlatformViewAndroidDelegate>(jni_mock);
 
  flutter::CustomAccessibilityActionUpdates actions;
  flutter::CustomAccessibilityAction action0;
  action0.id = 0;
  action0.overrideId = 1;
  action0.label = "label";
  action0.hint = "hint";
  actions.insert(std::make_pair(0, action0));
 
  std::vector<uint8_t> expected_actions_buffer(16);
  int32_t* actions_buffer_int32 =
      reinterpret_cast<int32_t*>(&expected_actions_buffer[0]);
  std::vector<std::string> expected_action_strings;
  actions_buffer_int32[0] = action0.id;
  actions_buffer_int32[1] = action0.overrideId;
  actions_buffer_int32[2] = expected_action_strings.size();
  expected_action_strings.push_back(action0.label);
  actions_buffer_int32[3] = expected_action_strings.size();
  expected_action_strings.push_back(action0.hint);
 
  EXPECT_CALL(*jni_mock, FlutterViewUpdateCustomAccessibilityActions(
                             expected_actions_buffer, expected_action_strings));
  // Creates empty update.
  flutter::SemanticsNodeUpdates update;
  delegate->UpdateSemantics(update, actions);
}

◆ TEST() [623/715]

flutter::testing::TEST	(	PlatformViewShell	,
		UpdateSemanticsDoesFlutterViewUpdateSemantics
	)

Definition at line 14 of file platform_view_android_delegate_unittests.cc.

                                                                       {
  auto jni_mock = std::make_shared<JNIMock>();
  auto delegate = std::make_unique<PlatformViewAndroidDelegate>(jni_mock);
 
  flutter::SemanticsNodeUpdates update;
  flutter::SemanticsNode node0;
  node0.id = 0;
  node0.identifier = "identifier";
  node0.label = "label";
  node0.tooltip = "tooltip";
  update.insert(std::make_pair(0, node0));
 
  std::vector<uint8_t> expected_buffer(192);
  std::vector<std::vector<uint8_t>> expected_string_attribute_args(0);
  size_t position = 0;
  int32_t* buffer_int32 = reinterpret_cast<int32_t*>(&expected_buffer[0]);
  float* buffer_float32 = reinterpret_cast<float*>(&expected_buffer[0]);
  std::vector<std::string> expected_strings;
  buffer_int32[position++] = node0.id;
  buffer_int32[position++] = node0.flags;
  buffer_int32[position++] = node0.actions;
  buffer_int32[position++] = node0.maxValueLength;
  buffer_int32[position++] = node0.currentValueLength;
  buffer_int32[position++] = node0.textSelectionBase;
  buffer_int32[position++] = node0.textSelectionExtent;
  buffer_int32[position++] = node0.platformViewId;
  buffer_int32[position++] = node0.scrollChildren;
  buffer_int32[position++] = node0.scrollIndex;
  buffer_float32[position++] = static_cast<float>(node0.scrollPosition);
  buffer_float32[position++] = static_cast<float>(node0.scrollExtentMax);
  buffer_float32[position++] = static_cast<float>(node0.scrollExtentMin);
  buffer_int32[position++] = expected_strings.size();  // node0.identifier
  expected_strings.push_back(node0.identifier);
  buffer_int32[position++] = expected_strings.size();  // node0.label
  expected_strings.push_back(node0.label);
  buffer_int32[position++] = -1;  // node0.labelAttributes
  buffer_int32[position++] = -1;  // node0.value
  buffer_int32[position++] = -1;  // node0.valueAttributes
  buffer_int32[position++] = -1;  // node0.increasedValue
  buffer_int32[position++] = -1;  // node0.increasedValueAttributes
  buffer_int32[position++] = -1;  // node0.decreasedValue
  buffer_int32[position++] = -1;  // node0.decreasedValueAttributes
  buffer_int32[position++] = -1;  // node0.hint
  buffer_int32[position++] = -1;  // node0.hintAttributes
  buffer_int32[position++] = expected_strings.size();  // node0.tooltip
  expected_strings.push_back(node0.tooltip);
  buffer_int32[position++] = node0.textDirection;
  buffer_float32[position++] = node0.rect.left();
  buffer_float32[position++] = node0.rect.top();
  buffer_float32[position++] = node0.rect.right();
  buffer_float32[position++] = node0.rect.bottom();
  node0.transform.getColMajor(&buffer_float32[position]);
  position += 16;
  buffer_int32[position++] = 0;  // node0.childrenInTraversalOrder.size();
  buffer_int32[position++] = 0;  // node0.customAccessibilityActions.size();
  EXPECT_CALL(*jni_mock,
              FlutterViewUpdateSemantics(expected_buffer, expected_strings,
                                         expected_string_attribute_args));
  // Creates empty custom actions.
  flutter::CustomAccessibilityActionUpdates actions;
  delegate->UpdateSemantics(update, actions);
}

◆ TEST() [624/715]

flutter::testing::TEST	(	PlatformViewShell	,
		UpdateSemanticsDoesFlutterViewUpdateSemanticsWithStringAttribtes
	)

Definition at line 77 of file platform_view_android_delegate_unittests.cc.

                                                                       {
  auto jni_mock = std::make_shared<JNIMock>();
  auto delegate = std::make_unique<PlatformViewAndroidDelegate>(jni_mock);
 
  flutter::SemanticsNodeUpdates update;
  flutter::SemanticsNode node0;
  std::shared_ptr<SpellOutStringAttribute> spell_out_attribute =
      std::make_shared<SpellOutStringAttribute>();
  spell_out_attribute->start = 2;
  spell_out_attribute->end = 4;
  spell_out_attribute->type = flutter::StringAttributeType::kSpellOut;
  std::shared_ptr<LocaleStringAttribute> locale_attribute =
      std::make_shared<LocaleStringAttribute>();
  locale_attribute->start = 1;
  locale_attribute->end = 3;
  locale_attribute->type = flutter::StringAttributeType::kLocale;
  locale_attribute->locale = "en-US";
  node0.id = 0;
  node0.identifier = "identifier";
  node0.label = "label";
  node0.labelAttributes.push_back(spell_out_attribute);
  node0.hint = "hint";
  node0.hintAttributes.push_back(locale_attribute);
  update.insert(std::make_pair(0, node0));
 
  std::vector<uint8_t> expected_buffer(224);
  std::vector<std::vector<uint8_t>> expected_string_attribute_args;
  size_t position = 0;
  int32_t* buffer_int32 = reinterpret_cast<int32_t*>(&expected_buffer[0]);
  float* buffer_float32 = reinterpret_cast<float*>(&expected_buffer[0]);
  std::vector<std::string> expected_strings;
  buffer_int32[position++] = node0.id;
  buffer_int32[position++] = node0.flags;
  buffer_int32[position++] = node0.actions;
  buffer_int32[position++] = node0.maxValueLength;
  buffer_int32[position++] = node0.currentValueLength;
  buffer_int32[position++] = node0.textSelectionBase;
  buffer_int32[position++] = node0.textSelectionExtent;
  buffer_int32[position++] = node0.platformViewId;
  buffer_int32[position++] = node0.scrollChildren;
  buffer_int32[position++] = node0.scrollIndex;
  buffer_float32[position++] = static_cast<float>(node0.scrollPosition);
  buffer_float32[position++] = static_cast<float>(node0.scrollExtentMax);
  buffer_float32[position++] = static_cast<float>(node0.scrollExtentMin);
  buffer_int32[position++] = expected_strings.size();  // node0.identifier
  expected_strings.push_back(node0.identifier);
  buffer_int32[position++] = expected_strings.size();  // node0.label
  expected_strings.push_back(node0.label);
  buffer_int32[position++] = 1;   // node0.labelAttributes
  buffer_int32[position++] = 2;   // node0.labelAttributes[0].start
  buffer_int32[position++] = 4;   // node0.labelAttributes[0].end
  buffer_int32[position++] = 0;   // node0.labelAttributes[0].type
  buffer_int32[position++] = -1;  // node0.labelAttributes[0].args
  buffer_int32[position++] = -1;  // node0.value
  buffer_int32[position++] = -1;  // node0.valueAttributes
  buffer_int32[position++] = -1;  // node0.increasedValue
  buffer_int32[position++] = -1;  // node0.increasedValueAttributes
  buffer_int32[position++] = -1;  // node0.decreasedValue
  buffer_int32[position++] = -1;  // node0.decreasedValueAttributes
  buffer_int32[position++] = expected_strings.size();  // node0.hint
  expected_strings.push_back(node0.hint);
  buffer_int32[position++] = 1;  // node0.hintAttributes
  buffer_int32[position++] = 1;  // node0.hintAttributes[0].start
  buffer_int32[position++] = 3;  // node0.hintAttributes[0].end
  buffer_int32[position++] = 1;  // node0.hintAttributes[0].type
  buffer_int32[position++] =
      expected_string_attribute_args.size();  // node0.hintAttributes[0].args
  expected_string_attribute_args.push_back(
      {locale_attribute->locale.begin(), locale_attribute->locale.end()});
  buffer_int32[position++] = -1;  // node0.tooltip
  buffer_int32[position++] = node0.textDirection;
  buffer_float32[position++] = node0.rect.left();
  buffer_float32[position++] = node0.rect.top();
  buffer_float32[position++] = node0.rect.right();
  buffer_float32[position++] = node0.rect.bottom();
  node0.transform.getColMajor(&buffer_float32[position]);
  position += 16;
  buffer_int32[position++] = 0;  // node0.childrenInTraversalOrder.size();
  buffer_int32[position++] = 0;  // node0.customAccessibilityActions.size();
  EXPECT_CALL(*jni_mock,
              FlutterViewUpdateSemantics(expected_buffer, expected_strings,
                                         expected_string_attribute_args));
  // Creates empty custom actions.
  flutter::CustomAccessibilityActionUpdates actions;
  delegate->UpdateSemantics(update, actions);
}

◆ TEST() [625/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		AlwaysForwardMoveEvent
	)

Definition at line 329 of file pointer_data_packet_converter_unittests.cc.

                                                             {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(4);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(1, data);
  // Creates a move event without a location change.
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 0, 0.0, 0.0, 1);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 0.0, 0.0, 0);
  packet->SetPointerData(3, data);
 
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)4);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].synthesized, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kDown);
  ASSERT_EQ(result[1].pointer_identifier, 1);
  ASSERT_EQ(result[1].synthesized, 0);
 
  // Does not filter out the move event.
  ASSERT_EQ(result[2].change, PointerData::Change::kMove);
  ASSERT_EQ(result[2].pointer_identifier, 1);
  ASSERT_EQ(result[2].synthesized, 0);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kUp);
  ASSERT_EQ(result[3].pointer_identifier, 1);
  ASSERT_EQ(result[3].synthesized, 0);
}

◆ TEST() [626/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanConvertPointerDataPacket
	)

Definition at line 168 of file pointer_data_packet_converter_unittests.cc.

                                                                  {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(6);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kHover, 0, 3.0, 0.0, 0);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 3.0, 0.0, 1);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 0, 3.0, 4.0, 1);
  packet->SetPointerData(3, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 3.0, 4.0, 0);
  packet->SetPointerData(4, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 0, 3.0, 4.0,
                             0);
  packet->SetPointerData(5, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)6);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].synthesized, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kHover);
  ASSERT_EQ(result[1].synthesized, 0);
  ASSERT_EQ(result[1].physical_delta_x, 3.0);
  ASSERT_EQ(result[1].physical_delta_y, 0.0);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kDown);
  ASSERT_EQ(result[2].pointer_identifier, 1);
  ASSERT_EQ(result[2].synthesized, 0);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kMove);
  ASSERT_EQ(result[3].pointer_identifier, 1);
  ASSERT_EQ(result[3].synthesized, 0);
  ASSERT_EQ(result[3].physical_delta_x, 0.0);
  ASSERT_EQ(result[3].physical_delta_y, 4.0);
 
  ASSERT_EQ(result[4].change, PointerData::Change::kUp);
  ASSERT_EQ(result[4].pointer_identifier, 1);
  ASSERT_EQ(result[4].synthesized, 0);
 
  ASSERT_EQ(result[5].change, PointerData::Change::kRemove);
  ASSERT_EQ(result[5].synthesized, 0);
}

◆ TEST() [627/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanConvertPointerSignals
	)

Definition at line 590 of file pointer_data_packet_converter_unittests.cc.

                                                               {
  PointerData::SignalKind signal_kinds[] = {
      PointerData::SignalKind::kScroll,
      PointerData::SignalKind::kScrollInertiaCancel,
      PointerData::SignalKind::kScale,
  };
  for (const PointerData::SignalKind& kind : signal_kinds) {
    TestDelegate delegate;
    delegate.AddView(kImplicitViewId);
    PointerDataPacketConverter converter(delegate);
    auto packet = std::make_unique<PointerDataPacket>(6);
    PointerData data;
    CreateSimulatedMousePointerData(data, PointerData::Change::kAdd,
                                    PointerData::SignalKind::kNone, 0, 0.0, 0.0,
                                    0.0, 0.0, 0);
    packet->SetPointerData(0, data);
    CreateSimulatedMousePointerData(data, PointerData::Change::kAdd,
                                    PointerData::SignalKind::kNone, 1, 0.0, 0.0,
                                    0.0, 0.0, 0);
    packet->SetPointerData(1, data);
    CreateSimulatedMousePointerData(data, PointerData::Change::kDown,
                                    PointerData::SignalKind::kNone, 1, 0.0, 0.0,
                                    0.0, 0.0, 1);
    packet->SetPointerData(2, data);
    CreateSimulatedMousePointerData(data, PointerData::Change::kHover, kind, 0,
                                    34.0, 34.0, 30.0, 0.0, 0);
    packet->SetPointerData(3, data);
    CreateSimulatedMousePointerData(data, PointerData::Change::kHover, kind, 1,
                                    49.0, 49.0, 50.0, 0.0, 0);
    packet->SetPointerData(4, data);
    CreateSimulatedMousePointerData(data, PointerData::Change::kHover, kind, 2,
                                    10.0, 20.0, 30.0, 40.0, 0);
    packet->SetPointerData(5, data);
    auto converted_packet = converter.Convert(*packet);
 
    std::vector<PointerData> result;
    UnpackPointerPacket(result, std::move(converted_packet));
 
    ASSERT_EQ(result.size(), (size_t)9);
    ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
    ASSERT_EQ(result[0].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[0].device, 0);
    ASSERT_EQ(result[0].physical_x, 0.0);
    ASSERT_EQ(result[0].physical_y, 0.0);
    ASSERT_EQ(result[0].synthesized, 0);
 
    ASSERT_EQ(result[1].change, PointerData::Change::kAdd);
    ASSERT_EQ(result[1].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[1].device, 1);
    ASSERT_EQ(result[1].physical_x, 0.0);
    ASSERT_EQ(result[1].physical_y, 0.0);
    ASSERT_EQ(result[1].synthesized, 0);
 
    ASSERT_EQ(result[2].change, PointerData::Change::kDown);
    ASSERT_EQ(result[2].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[2].device, 1);
    ASSERT_EQ(result[2].physical_x, 0.0);
    ASSERT_EQ(result[2].physical_y, 0.0);
    ASSERT_EQ(result[2].synthesized, 0);
 
    // Converter will synthesize a hover to position for device 0.
    ASSERT_EQ(result[3].change, PointerData::Change::kHover);
    ASSERT_EQ(result[3].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[3].device, 0);
    ASSERT_EQ(result[3].physical_x, 34.0);
    ASSERT_EQ(result[3].physical_y, 34.0);
    ASSERT_EQ(result[3].physical_delta_x, 34.0);
    ASSERT_EQ(result[3].physical_delta_y, 34.0);
    ASSERT_EQ(result[3].buttons, 0);
    ASSERT_EQ(result[3].synthesized, 1);
 
    ASSERT_EQ(result[4].change, PointerData::Change::kHover);
    ASSERT_EQ(result[4].signal_kind, kind);
    ASSERT_EQ(result[4].device, 0);
    ASSERT_EQ(result[4].physical_x, 34.0);
    ASSERT_EQ(result[4].physical_y, 34.0);
    ASSERT_EQ(result[4].scroll_delta_x, 30.0);
    ASSERT_EQ(result[4].scroll_delta_y, 0.0);
 
    // Converter will synthesize a move to position for device 1.
    ASSERT_EQ(result[5].change, PointerData::Change::kMove);
    ASSERT_EQ(result[5].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[5].device, 1);
    ASSERT_EQ(result[5].physical_x, 49.0);
    ASSERT_EQ(result[5].physical_y, 49.0);
    ASSERT_EQ(result[5].physical_delta_x, 49.0);
    ASSERT_EQ(result[5].physical_delta_y, 49.0);
    ASSERT_EQ(result[5].buttons, 1);
    ASSERT_EQ(result[5].synthesized, 1);
 
    ASSERT_EQ(result[6].change, PointerData::Change::kHover);
    ASSERT_EQ(result[6].signal_kind, kind);
    ASSERT_EQ(result[6].device, 1);
    ASSERT_EQ(result[6].physical_x, 49.0);
    ASSERT_EQ(result[6].physical_y, 49.0);
    ASSERT_EQ(result[6].scroll_delta_x, 50.0);
    ASSERT_EQ(result[6].scroll_delta_y, 0.0);
 
    // Converter will synthesize an add for device 2.
    ASSERT_EQ(result[7].change, PointerData::Change::kAdd);
    ASSERT_EQ(result[7].signal_kind, PointerData::SignalKind::kNone);
    ASSERT_EQ(result[7].device, 2);
    ASSERT_EQ(result[7].physical_x, 10.0);
    ASSERT_EQ(result[7].physical_y, 20.0);
    ASSERT_EQ(result[7].synthesized, 1);
 
    ASSERT_EQ(result[8].change, PointerData::Change::kHover);
    ASSERT_EQ(result[8].signal_kind, kind);
    ASSERT_EQ(result[8].device, 2);
    ASSERT_EQ(result[8].physical_x, 10.0);
    ASSERT_EQ(result[8].physical_y, 20.0);
    ASSERT_EQ(result[8].scroll_delta_x, 30.0);
    ASSERT_EQ(result[8].scroll_delta_y, 40.0);
  }
}

◆ TEST() [628/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanConvertTrackpadGesture
	)

Definition at line 706 of file pointer_data_packet_converter_unittests.cc.

                                                                {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(3);
  PointerData data;
  CreateSimulatedTrackpadGestureData(data, PointerData::Change::kPanZoomStart,
                                     0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  packet->SetPointerData(0, data);
  CreateSimulatedTrackpadGestureData(data, PointerData::Change::kPanZoomUpdate,
                                     0, 0.0, 0.0, 3.0, 4.0, 1.0, 0.0);
  packet->SetPointerData(1, data);
  CreateSimulatedTrackpadGestureData(data, PointerData::Change::kPanZoomEnd, 0,
                                     0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
  packet->SetPointerData(2, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)4);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].device, 0);
  ASSERT_EQ(result[0].synthesized, 1);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kPanZoomStart);
  ASSERT_EQ(result[1].signal_kind, PointerData::SignalKind::kNone);
  ASSERT_EQ(result[1].device, 0);
  ASSERT_EQ(result[1].physical_x, 0.0);
  ASSERT_EQ(result[1].physical_y, 0.0);
  ASSERT_EQ(result[1].synthesized, 0);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kPanZoomUpdate);
  ASSERT_EQ(result[2].signal_kind, PointerData::SignalKind::kNone);
  ASSERT_EQ(result[2].device, 0);
  ASSERT_EQ(result[2].physical_x, 0.0);
  ASSERT_EQ(result[2].physical_y, 0.0);
  ASSERT_EQ(result[2].pan_x, 3.0);
  ASSERT_EQ(result[2].pan_y, 4.0);
  ASSERT_EQ(result[2].pan_delta_x, 3.0);
  ASSERT_EQ(result[2].pan_delta_y, 4.0);
  ASSERT_EQ(result[2].scale, 1.0);
  ASSERT_EQ(result[2].rotation, 0.0);
  ASSERT_EQ(result[2].synthesized, 0);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kPanZoomEnd);
  ASSERT_EQ(result[3].signal_kind, PointerData::SignalKind::kNone);
  ASSERT_EQ(result[3].device, 0);
  ASSERT_EQ(result[3].physical_x, 0.0);
  ASSERT_EQ(result[3].physical_y, 0.0);
  ASSERT_EQ(result[3].synthesized, 0);
}

◆ TEST() [629/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanConvertViewId
	)

Definition at line 759 of file pointer_data_packet_converter_unittests.cc.

                                                       {
  TestDelegate delegate;
  delegate.AddView(100);
  delegate.AddView(200);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(2);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  data.view_id = 100;
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kHover, 0, 1.0, 0.0, 0);
  data.view_id = 200;
  packet->SetPointerData(1, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)2);
  ASSERT_EQ(result[0].view_id, 100);
  ASSERT_EQ(result[1].view_id, 200);
}

◆ TEST() [630/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanHandleThreeFingerGesture
	)

Definition at line 513 of file pointer_data_packet_converter_unittests.cc.

                                                                  {
  // Regression test https://github.com/flutter/flutter/issues/20517.
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  PointerData data;
  std::vector<PointerData> result;
  // First finger down.
  auto packet = std::make_unique<PointerDataPacket>(1);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(0, data);
  auto converted_packet = converter.Convert(*packet);
  UnpackPointerPacket(result, std::move(converted_packet));
  // Second finger down.
  packet = std::make_unique<PointerDataPacket>(1);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 1, 33.0, 44.0,
                             1);
  packet->SetPointerData(0, data);
  converted_packet = converter.Convert(*packet);
  UnpackPointerPacket(result, std::move(converted_packet));
  // Triggers three cancels.
  packet = std::make_unique<PointerDataPacket>(3);
  CreateSimulatedPointerData(data, PointerData::Change::kCancel, 1, 33.0, 44.0,
                             0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kCancel, 0, 0.0, 0.0,
                             0);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kCancel, 2, 40.0, 50.0,
                             0);
  packet->SetPointerData(2, data);
  converted_packet = converter.Convert(*packet);
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)6);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].device, 0);
  ASSERT_EQ(result[0].physical_x, 0.0);
  ASSERT_EQ(result[0].physical_y, 0.0);
  ASSERT_EQ(result[0].synthesized, 1);
  ASSERT_EQ(result[0].buttons, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kDown);
  ASSERT_EQ(result[1].device, 0);
  ASSERT_EQ(result[1].physical_x, 0.0);
  ASSERT_EQ(result[1].physical_y, 0.0);
  ASSERT_EQ(result[1].synthesized, 0);
  ASSERT_EQ(result[1].buttons, 1);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[2].device, 1);
  ASSERT_EQ(result[2].physical_x, 33.0);
  ASSERT_EQ(result[2].physical_y, 44.0);
  ASSERT_EQ(result[2].synthesized, 1);
  ASSERT_EQ(result[2].buttons, 0);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kDown);
  ASSERT_EQ(result[3].device, 1);
  ASSERT_EQ(result[3].physical_x, 33.0);
  ASSERT_EQ(result[3].physical_y, 44.0);
  ASSERT_EQ(result[3].synthesized, 0);
  ASSERT_EQ(result[3].buttons, 1);
 
  ASSERT_EQ(result[4].change, PointerData::Change::kCancel);
  ASSERT_EQ(result[4].device, 1);
  ASSERT_EQ(result[4].physical_x, 33.0);
  ASSERT_EQ(result[4].physical_y, 44.0);
  ASSERT_EQ(result[4].synthesized, 0);
 
  ASSERT_EQ(result[5].change, PointerData::Change::kCancel);
  ASSERT_EQ(result[5].device, 0);
  ASSERT_EQ(result[5].physical_x, 0.0);
  ASSERT_EQ(result[5].physical_y, 0.0);
  ASSERT_EQ(result[5].synthesized, 0);
  // Third cancel should be dropped
}

◆ TEST() [631/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanSynthesizeAdd
	)

Definition at line 467 of file pointer_data_packet_converter_unittests.cc.

                                                       {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(2);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 330.0, 450.0,
                             1);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 0.0, 0.0, 0);
  packet->SetPointerData(1, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)4);
  // A add should be synthesized.
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].physical_x, 330.0);
  ASSERT_EQ(result[0].physical_y, 450.0);
  ASSERT_EQ(result[0].synthesized, 1);
  ASSERT_EQ(result[0].buttons, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kDown);
  ASSERT_EQ(result[1].physical_x, 330.0);
  ASSERT_EQ(result[1].physical_y, 450.0);
  ASSERT_EQ(result[1].synthesized, 0);
  ASSERT_EQ(result[1].buttons, 1);
 
  // A move should be synthesized.
  ASSERT_EQ(result[2].change, PointerData::Change::kMove);
  ASSERT_EQ(result[2].physical_delta_x, -330.0);
  ASSERT_EQ(result[2].physical_delta_y, -450.0);
  ASSERT_EQ(result[2].physical_x, 0.0);
  ASSERT_EQ(result[2].physical_y, 0.0);
  ASSERT_EQ(result[2].synthesized, 1);
  ASSERT_EQ(result[2].buttons, 1);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kUp);
  ASSERT_EQ(result[3].physical_x, 0.0);
  ASSERT_EQ(result[3].physical_y, 0.0);
  ASSERT_EQ(result[3].synthesized, 0);
  ASSERT_EQ(result[3].buttons, 0);
}

◆ TEST() [632/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanSynthesizeDownAndUp
	)

Definition at line 219 of file pointer_data_packet_converter_unittests.cc.

                                                             {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(4);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 3.0, 0.0, 1);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 3.0, 4.0, 0);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 0, 3.0, 4.0,
                             0);
  packet->SetPointerData(3, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)6);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].synthesized, 0);
 
  // A hover should be synthesized.
  ASSERT_EQ(result[1].change, PointerData::Change::kHover);
  ASSERT_EQ(result[1].synthesized, 1);
  ASSERT_EQ(result[1].physical_delta_x, 3.0);
  ASSERT_EQ(result[1].physical_delta_y, 0.0);
  ASSERT_EQ(result[1].buttons, 0);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kDown);
  ASSERT_EQ(result[2].pointer_identifier, 1);
  ASSERT_EQ(result[2].synthesized, 0);
  ASSERT_EQ(result[2].buttons, 1);
 
  // A move should be synthesized.
  ASSERT_EQ(result[3].change, PointerData::Change::kMove);
  ASSERT_EQ(result[3].pointer_identifier, 1);
  ASSERT_EQ(result[3].synthesized, 1);
  ASSERT_EQ(result[3].physical_delta_x, 0.0);
  ASSERT_EQ(result[3].physical_delta_y, 4.0);
  ASSERT_EQ(result[3].buttons, 1);
 
  ASSERT_EQ(result[4].change, PointerData::Change::kUp);
  ASSERT_EQ(result[4].pointer_identifier, 1);
  ASSERT_EQ(result[4].synthesized, 0);
  ASSERT_EQ(result[4].buttons, 0);
 
  ASSERT_EQ(result[5].change, PointerData::Change::kRemove);
  ASSERT_EQ(result[5].synthesized, 0);
}

◆ TEST() [633/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanUpdatePointerIdentifier
	)

Definition at line 272 of file pointer_data_packet_converter_unittests.cc.

                                                                 {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(7);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 0.0, 0.0, 0);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(3, data);
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 0, 3.0, 0.0, 1);
  packet->SetPointerData(4, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 3.0, 0.0, 0);
  packet->SetPointerData(5, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 0, 3.0, 0.0,
                             0);
  packet->SetPointerData(6, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)7);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].synthesized, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kDown);
  ASSERT_EQ(result[1].pointer_identifier, 1);
  ASSERT_EQ(result[1].synthesized, 0);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kUp);
  ASSERT_EQ(result[2].pointer_identifier, 1);
  ASSERT_EQ(result[2].synthesized, 0);
 
  // Pointer count increase to 2.
  ASSERT_EQ(result[3].change, PointerData::Change::kDown);
  ASSERT_EQ(result[3].pointer_identifier, 2);
  ASSERT_EQ(result[3].synthesized, 0);
 
  ASSERT_EQ(result[4].change, PointerData::Change::kMove);
  ASSERT_EQ(result[4].pointer_identifier, 2);
  ASSERT_EQ(result[4].synthesized, 0);
  ASSERT_EQ(result[4].physical_delta_x, 3.0);
  ASSERT_EQ(result[4].physical_delta_y, 0.0);
 
  ASSERT_EQ(result[5].change, PointerData::Change::kUp);
  ASSERT_EQ(result[5].pointer_identifier, 2);
  ASSERT_EQ(result[5].synthesized, 0);
 
  ASSERT_EQ(result[6].change, PointerData::Change::kRemove);
  ASSERT_EQ(result[6].synthesized, 0);
}

◆ TEST() [634/715]

flutter::testing::TEST	(	PointerDataPacketConverterTest	,
		CanWorkWithDifferentDevices
	)

Definition at line 368 of file pointer_data_packet_converter_unittests.cc.

                                                                  {
  TestDelegate delegate;
  delegate.AddView(kImplicitViewId);
  PointerDataPacketConverter converter(delegate);
  auto packet = std::make_unique<PointerDataPacket>(12);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0, 0.0, 0.0, 0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 1, 0.0, 0.0, 0);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 1, 0.0, 0.0, 1);
  packet->SetPointerData(3, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 0.0, 0.0, 0);
  packet->SetPointerData(4, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 0, 0.0, 0.0, 1);
  packet->SetPointerData(5, data);
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 1, 0.0, 4.0, 1);
  packet->SetPointerData(6, data);
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 0, 3.0, 0.0, 1);
  packet->SetPointerData(7, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 1, 0.0, 4.0, 0);
  packet->SetPointerData(8, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 0, 3.0, 0.0, 0);
  packet->SetPointerData(9, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 0, 3.0, 0.0,
                             0);
  packet->SetPointerData(10, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 1, 0.0, 4.0,
                             0);
  packet->SetPointerData(11, data);
  auto converted_packet = converter.Convert(*packet);
 
  std::vector<PointerData> result;
  UnpackPointerPacket(result, std::move(converted_packet));
 
  ASSERT_EQ(result.size(), (size_t)12);
  ASSERT_EQ(result[0].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[0].device, 0);
  ASSERT_EQ(result[0].synthesized, 0);
 
  ASSERT_EQ(result[1].change, PointerData::Change::kDown);
  ASSERT_EQ(result[1].device, 0);
  ASSERT_EQ(result[1].pointer_identifier, 1);
  ASSERT_EQ(result[1].synthesized, 0);
 
  ASSERT_EQ(result[2].change, PointerData::Change::kAdd);
  ASSERT_EQ(result[2].device, 1);
  ASSERT_EQ(result[2].synthesized, 0);
 
  ASSERT_EQ(result[3].change, PointerData::Change::kDown);
  ASSERT_EQ(result[3].device, 1);
  ASSERT_EQ(result[3].pointer_identifier, 2);
  ASSERT_EQ(result[3].synthesized, 0);
 
  ASSERT_EQ(result[4].change, PointerData::Change::kUp);
  ASSERT_EQ(result[4].device, 0);
  ASSERT_EQ(result[4].pointer_identifier, 1);
  ASSERT_EQ(result[4].synthesized, 0);
 
  ASSERT_EQ(result[5].change, PointerData::Change::kDown);
  ASSERT_EQ(result[5].device, 0);
  ASSERT_EQ(result[5].pointer_identifier, 3);
  ASSERT_EQ(result[5].synthesized, 0);
 
  ASSERT_EQ(result[6].change, PointerData::Change::kMove);
  ASSERT_EQ(result[6].device, 1);
  ASSERT_EQ(result[6].pointer_identifier, 2);
  ASSERT_EQ(result[6].synthesized, 0);
  ASSERT_EQ(result[6].physical_delta_x, 0.0);
  ASSERT_EQ(result[6].physical_delta_y, 4.0);
 
  ASSERT_EQ(result[7].change, PointerData::Change::kMove);
  ASSERT_EQ(result[7].device, 0);
  ASSERT_EQ(result[7].pointer_identifier, 3);
  ASSERT_EQ(result[7].synthesized, 0);
  ASSERT_EQ(result[7].physical_delta_x, 3.0);
  ASSERT_EQ(result[7].physical_delta_y, 0.0);
 
  ASSERT_EQ(result[8].change, PointerData::Change::kUp);
  ASSERT_EQ(result[8].device, 1);
  ASSERT_EQ(result[8].pointer_identifier, 2);
  ASSERT_EQ(result[8].synthesized, 0);
 
  ASSERT_EQ(result[9].change, PointerData::Change::kUp);
  ASSERT_EQ(result[9].device, 0);
  ASSERT_EQ(result[9].pointer_identifier, 3);
  ASSERT_EQ(result[9].synthesized, 0);
 
  ASSERT_EQ(result[10].change, PointerData::Change::kRemove);
  ASSERT_EQ(result[10].device, 0);
  ASSERT_EQ(result[10].synthesized, 0);
 
  ASSERT_EQ(result[11].change, PointerData::Change::kRemove);
  ASSERT_EQ(result[11].device, 1);
  ASSERT_EQ(result[11].synthesized, 0);
}

◆ TEST() [635/715]

flutter::testing::TEST	(	PointerDataPacketTest	,
		CanGetLength
	)

Definition at line 63 of file pointer_data_packet_unittests.cc.

                                          {
  auto packet = std::make_unique<PointerDataPacket>(6);
  ASSERT_EQ(packet->GetLength(), (size_t)6);
}

◆ TEST() [636/715]

flutter::testing::TEST	(	PointerDataPacketTest	,
		CanGetPointerData
	)

Definition at line 51 of file pointer_data_packet_unittests.cc.

                                               {
  auto packet = std::make_unique<PointerDataPacket>(1);
  PointerData data;
  CreateSimpleSimulatedPointerData(data, PointerData::Change::kAdd, 1, 2.0, 3.0,
                                   4);
  packet->SetPointerData(0, data);
 
  PointerData data_recovered = packet->GetPointerData(0);
  ASSERT_EQ(data_recovered.physical_x, 2.0);
  ASSERT_EQ(data_recovered.physical_y, 3.0);
}

◆ TEST() [637/715]

flutter::testing::TEST	(	RasterCache	,
		AccessThresholdOfZeroDisablesCachingForDisplayList
	)

Definition at line 146 of file raster_cache_unittests.cc.

                                                                      {
  size_t threshold = 0;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
}

◆ TEST() [638/715]

flutter::testing::TEST	(	RasterCache	,
		ComputeDeviceRectBasedOnFractionalTranslation
	)

Definition at line 323 of file raster_cache_unittests.cc.

                                                                 {
  SkRect logical_rect = SkRect::MakeLTRB(0, 0, 300.2, 300.3);
  SkMatrix ctm = SkMatrix::MakeAll(2.0, 0, 0, 0, 2.0, 0, 0, 0, 1);
  auto result = RasterCacheUtil::GetDeviceBounds(logical_rect, ctm);
  ASSERT_EQ(result, SkRect::MakeLTRB(0.0, 0.0, 600.4, 600.6));
}

◆ TEST() [639/715]

flutter::testing::TEST	(	RasterCache	,
		DeviceRectRoundOutForDisplayList
	)

Definition at line 333 of file raster_cache_unittests.cc.

                                                    {
  size_t threshold = 1;
  flutter::RasterCache cache(threshold);
 
  SkRect logical_rect = SkRect::MakeLTRB(28, 0, 354.56731, 310.288);
  DisplayListBuilder builder(logical_rect);
  builder.DrawRect(logical_rect, DlPaint(DlColor::kRed()));
  sk_sp<DisplayList> display_list = builder.Build();
 
  SkMatrix ctm = SkMatrix::MakeAll(1.3312, 0, 233, 0, 1.3312, 206, 0, 0, 1);
  DlPaint paint;
 
  MockCanvas canvas(1000, 1000);
  canvas.SetTransform(ctm);
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, ctm);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
 
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, ctm));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  ASSERT_TRUE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, ctm));
  ASSERT_TRUE(display_list_item.Draw(paint_context, &canvas, &paint));
 
  canvas.Translate(248, 0);
  ASSERT_TRUE(cache.Draw(display_list_item.GetId().value(), canvas, &paint));
  ASSERT_TRUE(display_list_item.Draw(paint_context, &canvas, &paint));
}

◆ TEST() [640/715]

flutter::testing::TEST	(	RasterCache	,
		DisplayListWithSingularMatrixIsNotCached
	)

Definition at line 500 of file raster_cache_unittests.cc.

                                                            {
  size_t threshold = 2;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrices[] = {
      SkMatrix::Scale(0, 1),
      SkMatrix::Scale(1, 0),
      SkMatrix::Skew(1, 1),
  };
  int matrix_count = sizeof(matrices) / sizeof(matrices[0]);
 
  auto display_list = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, SkMatrix::I());
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
 
  for (int i = 0; i < 10; i++) {
    cache.BeginFrame();
 
    for (int j = 0; j < matrix_count; j++) {
      display_list_item.set_matrix(matrices[j]);
      ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
          display_list_item, preroll_context, paint_context, matrices[j]));
    }
 
    for (int j = 0; j < matrix_count; j++) {
      dummy_canvas.SetTransform(matrices[j]);
      ASSERT_FALSE(
          display_list_item.Draw(paint_context, &dummy_canvas, &paint));
    }
 
    cache.EndFrame();
  }
}

◆ TEST() [641/715]

flutter::testing::TEST	(	RasterCache	,
		EvictUnusedCacheEntries
	)

Definition at line 223 of file raster_cache_unittests.cc.

                                           {
  size_t threshold = 1;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list_1 = GetSampleDisplayList();
  auto display_list_2 = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  DisplayListRasterCacheItem display_list_item_1(display_list_1, SkPoint(),
                                                 true, false);
  DisplayListRasterCacheItem display_list_item_2(display_list_2, SkPoint(),
                                                 true, false);
 
  cache.BeginFrame();
  RasterCacheItemPreroll(display_list_item_1, preroll_context, matrix);
  RasterCacheItemPreroll(display_list_item_2, preroll_context, matrix);
  cache.EvictUnusedCacheEntries();
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  ASSERT_FALSE(
      RasterCacheItemTryToRasterCache(display_list_item_1, paint_context));
  ASSERT_FALSE(
      RasterCacheItemTryToRasterCache(display_list_item_2, paint_context));
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  ASSERT_FALSE(display_list_item_1.Draw(paint_context, &dummy_canvas, &paint));
  ASSERT_FALSE(display_list_item_2.Draw(paint_context, &dummy_canvas, &paint));
  cache.EndFrame();
 
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_count(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 0u);
 
  cache.BeginFrame();
  RasterCacheItemPreroll(display_list_item_1, preroll_context, matrix);
  RasterCacheItemPreroll(display_list_item_2, preroll_context, matrix);
  cache.EvictUnusedCacheEntries();
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  ASSERT_TRUE(
      RasterCacheItemTryToRasterCache(display_list_item_1, paint_context));
  ASSERT_TRUE(
      RasterCacheItemTryToRasterCache(display_list_item_2, paint_context));
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 51248u);
  ASSERT_TRUE(display_list_item_1.Draw(paint_context, &dummy_canvas, &paint));
  ASSERT_TRUE(display_list_item_2.Draw(paint_context, &dummy_canvas, &paint));
  cache.EndFrame();
 
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 51248u);
  ASSERT_EQ(cache.picture_metrics().total_count(), 2u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 51248u);
 
  cache.BeginFrame();
  RasterCacheItemPreroll(display_list_item_1, preroll_context, matrix);
  cache.EvictUnusedCacheEntries();
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 25624u);
  ASSERT_TRUE(
      RasterCacheItemTryToRasterCache(display_list_item_1, paint_context));
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 25624u);
  ASSERT_TRUE(display_list_item_1.Draw(paint_context, &dummy_canvas, &paint));
  cache.EndFrame();
 
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 25624u);
  ASSERT_EQ(cache.picture_metrics().total_count(), 1u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 25624u);
 
  cache.BeginFrame();
  cache.EvictUnusedCacheEntries();
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  cache.EndFrame();
 
  ASSERT_EQ(cache.EstimatePictureCacheByteSize(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_count(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 0u);
 
  cache.BeginFrame();
  ASSERT_FALSE(
      cache.Draw(display_list_item_1.GetId().value(), dummy_canvas, &paint));
  ASSERT_FALSE(display_list_item_1.Draw(paint_context, &dummy_canvas, &paint));
  ASSERT_FALSE(
      cache.Draw(display_list_item_2.GetId().value(), dummy_canvas, &paint));
  ASSERT_FALSE(display_list_item_2.Draw(paint_context, &dummy_canvas, &paint));
  cache.EndFrame();
}

◆ TEST() [642/715]

flutter::testing::TEST	(	RasterCache	,
		MetricsOmitUnpopulatedEntries
	)

Definition at line 34 of file raster_cache_unittests.cc.

                                                 {
  size_t threshold = 2;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
 
  // 1st access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  ASSERT_EQ(cache.picture_metrics().total_count(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 0u);
  cache.BeginFrame();
 
  // 2nd access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  ASSERT_EQ(cache.picture_metrics().total_count(), 0u);
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 0u);
  cache.BeginFrame();
 
  // Now Prepare should cache it.
  ASSERT_TRUE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_TRUE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  ASSERT_EQ(cache.picture_metrics().total_count(), 1u);
  // 80w * 80h * 4bpp + image object overhead
  ASSERT_EQ(cache.picture_metrics().total_bytes(), 25624u);
}

◆ TEST() [643/715]

flutter::testing::TEST	(	RasterCache	,
		NaiveComplexityScoringDisplayList
	)

Definition at line 426 of file raster_cache_unittests.cc.

                                                     {
  DisplayListComplexityCalculator* calculator =
      DisplayListNaiveComplexityCalculator::GetInstance();
 
  size_t threshold = 1;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  // Five raster ops will not be cached
  auto display_list = GetSampleDisplayList(5);
  unsigned int complexity_score = calculator->Compute(display_list.get());
 
  ASSERT_EQ(complexity_score, 5u);
  ASSERT_EQ(display_list->op_count(), 5u);
  ASSERT_FALSE(calculator->ShouldBeCached(complexity_score));
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), false,
                                               false);
 
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  // Six raster ops should be cached
  display_list = GetSampleDisplayList(6);
  complexity_score = calculator->Compute(display_list.get());
 
  ASSERT_EQ(complexity_score, 6u);
  ASSERT_EQ(display_list->op_count(), 6u);
  ASSERT_TRUE(calculator->ShouldBeCached(complexity_score));
 
  DisplayListRasterCacheItem display_list_item_2 =
      DisplayListRasterCacheItem(display_list, SkPoint(), false, false);
  cache.BeginFrame();
 
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item_2, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item_2.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  ASSERT_TRUE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item_2, preroll_context, paint_context, matrix));
  ASSERT_TRUE(display_list_item_2.Draw(paint_context, &dummy_canvas, &paint));
}

◆ TEST() [644/715]

flutter::testing::TEST	(	RasterCache	,
		NestedOpCountMetricUsedForDisplayList
	)

Definition at line 382 of file raster_cache_unittests.cc.

                                                         {
  size_t threshold = 1;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list = GetSampleNestedDisplayList();
  ASSERT_EQ(display_list->op_count(), 1u);
  ASSERT_EQ(display_list->op_count(true), 36u);
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), false,
                                               false);
 
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  ASSERT_TRUE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_TRUE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
}

◆ TEST() [645/715]

flutter::testing::TEST	(	RasterCache	,
		PictureCacheLimitPerFrameIsRespectedWhenZeroForDisplayList
	)

Definition at line 180 of file raster_cache_unittests.cc.

                                                                              {
  size_t picture_cache_limit_per_frame = 0;
  flutter::RasterCache cache(3, picture_cache_limit_per_frame);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
  // 1st access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
  // 2nd access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
  // the picture_cache_limit_per_frame = 0, so don't cache it
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
}

◆ TEST() [646/715]

flutter::testing::TEST	(	RasterCache	,
		PrepareLayerTransform
	)

Definition at line 552 of file raster_cache_unittests.cc.

                                         {
  SkRect child_bounds = SkRect::MakeLTRB(10, 10, 50, 50);
  SkPath child_path = SkPath().addOval(child_bounds);
  auto child_layer = MockLayer::Make(child_path);
  auto blur_filter =
      std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
  auto blur_layer = std::make_shared<ImageFilterLayer>(blur_filter);
  SkMatrix matrix = SkMatrix::Scale(2, 2);
  auto transform_layer = std::make_shared<TransformLayer>(matrix);
  SkMatrix cache_matrix = SkMatrix::Translate(-20, -20);
  cache_matrix.preConcat(matrix);
  child_layer->set_expected_paint_matrix(cache_matrix);
 
  blur_layer->Add(child_layer);
  transform_layer->Add(blur_layer);
 
  size_t threshold = 2;
  MockRasterCache cache(threshold);
  MockCanvas dummy_canvas(1000, 1000);
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  std::vector<RasterCacheItem*> cache_items;
 
  cache.BeginFrame();
 
  auto preroll_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  preroll_holder.preroll_context.raster_cached_entries = &cache_items;
  transform_layer->Preroll(&preroll_holder.preroll_context);
 
  auto paint_holder = GetSamplePaintContextHolder(paint_state_stack, &cache,
                                                  &raster_time, &ui_time);
 
  cache.EvictUnusedCacheEntries();
  LayerTree::TryToRasterCache(
      *preroll_holder.preroll_context.raster_cached_entries,
      &paint_holder.paint_context);
 
  // Condition tested inside MockLayer::Paint against expected paint matrix.
}

◆ TEST() [647/715]

flutter::testing::TEST	(	RasterCache	,
		RasterCacheKeyHashFunction
	)

Definition at line 599 of file raster_cache_unittests.cc.

                                              {
  RasterCacheKey::Map<int> map;
  auto hash_function = map.hash_function();
  SkMatrix matrix = SkMatrix::I();
  uint64_t id = 5;
  RasterCacheKey layer_key(id, RasterCacheKeyType::kLayer, matrix);
  RasterCacheKey display_list_key(id, RasterCacheKeyType::kDisplayList, matrix);
  RasterCacheKey layer_children_key(id, RasterCacheKeyType::kLayerChildren,
                                    matrix);
 
  auto layer_cache_key_id = RasterCacheKeyID(id, RasterCacheKeyType::kLayer);
  auto layer_hash_code = hash_function(layer_key);
  ASSERT_EQ(layer_hash_code, layer_cache_key_id.GetHash());
 
  auto display_list_cache_key_id =
      RasterCacheKeyID(id, RasterCacheKeyType::kDisplayList);
  auto display_list_hash_code = hash_function(display_list_key);
  ASSERT_EQ(display_list_hash_code, display_list_cache_key_id.GetHash());
 
  auto layer_children_cache_key_id =
      RasterCacheKeyID(id, RasterCacheKeyType::kLayerChildren);
  auto layer_children_hash_code = hash_function(layer_children_key);
  ASSERT_EQ(layer_children_hash_code, layer_children_cache_key_id.GetHash());
}

◆ TEST() [648/715]

flutter::testing::TEST	(	RasterCache	,
		RasterCacheKeyIDEqual
	)

Definition at line 696 of file raster_cache_unittests.cc.

                                         {
  RasterCacheKeyID first = RasterCacheKeyID(1, RasterCacheKeyType::kLayer);
  RasterCacheKeyID second = RasterCacheKeyID(2, RasterCacheKeyType::kLayer);
  RasterCacheKeyID third =
      RasterCacheKeyID(1, RasterCacheKeyType::kLayerChildren);
 
  ASSERT_NE(first, second);
  ASSERT_NE(first, third);
  ASSERT_NE(second, third);
 
  RasterCacheKeyID fourth =
      RasterCacheKeyID({first, second}, RasterCacheKeyType::kLayer);
  RasterCacheKeyID fifth =
      RasterCacheKeyID({first, second}, RasterCacheKeyType::kLayerChildren);
  RasterCacheKeyID sixth =
      RasterCacheKeyID({second, first}, RasterCacheKeyType::kLayerChildren);
  ASSERT_NE(fourth, fifth);
  ASSERT_NE(fifth, sixth);
}

◆ TEST() [649/715]

flutter::testing::TEST	(	RasterCache	,
		RasterCacheKeyIDHashCode
	)

Definition at line 716 of file raster_cache_unittests.cc.

                                            {
  uint64_t foo = 1;
  uint64_t bar = 2;
  RasterCacheKeyID first = RasterCacheKeyID(foo, RasterCacheKeyType::kLayer);
  RasterCacheKeyID second = RasterCacheKeyID(bar, RasterCacheKeyType::kLayer);
  std::size_t first_hash = first.GetHash();
  std::size_t second_hash = second.GetHash();
 
  ASSERT_EQ(first_hash, fml::HashCombine(foo, RasterCacheKeyType::kLayer));
  ASSERT_EQ(second_hash, fml::HashCombine(bar, RasterCacheKeyType::kLayer));
 
  RasterCacheKeyID third =
      RasterCacheKeyID({first, second}, RasterCacheKeyType::kLayerChildren);
  RasterCacheKeyID fourth =
      RasterCacheKeyID({second, first}, RasterCacheKeyType::kLayerChildren);
  std::size_t third_hash = third.GetHash();
  std::size_t fourth_hash = fourth.GetHash();
 
  ASSERT_EQ(third_hash, fml::HashCombine(RasterCacheKeyID::kDefaultUniqueID,
                                         RasterCacheKeyType::kLayerChildren,
                                         first.GetHash(), second.GetHash()));
  ASSERT_EQ(fourth_hash, fml::HashCombine(RasterCacheKeyID::kDefaultUniqueID,
                                          RasterCacheKeyType::kLayerChildren,
                                          second.GetHash(), first.GetHash()));
 
  // Verify that the cached hash code is correct.
  ASSERT_EQ(first_hash, first.GetHash());
  ASSERT_EQ(second_hash, second.GetHash());
  ASSERT_EQ(third_hash, third.GetHash());
  ASSERT_EQ(fourth_hash, fourth.GetHash());
}

◆ TEST() [650/715]

flutter::testing::TEST	(	RasterCache	,
		RasterCacheKeySameID
	)

Definition at line 624 of file raster_cache_unittests.cc.

                                        {
  RasterCacheKey::Map<int> map;
  SkMatrix matrix = SkMatrix::I();
  uint64_t id = 5;
  RasterCacheKey layer_key(id, RasterCacheKeyType::kLayer, matrix);
  RasterCacheKey display_list_key(id, RasterCacheKeyType::kDisplayList, matrix);
  RasterCacheKey layer_children_key(id, RasterCacheKeyType::kLayerChildren,
                                    matrix);
  map[layer_key] = 100;
  map[display_list_key] = 300;
  map[layer_children_key] = 400;
 
  ASSERT_EQ(map[layer_key], 100);
  ASSERT_EQ(map[display_list_key], 300);
  ASSERT_EQ(map[layer_children_key], 400);
}

◆ TEST() [651/715]

flutter::testing::TEST	(	RasterCache	,
		RasterCacheKeySameType
	)

Definition at line 641 of file raster_cache_unittests.cc.

                                          {
  RasterCacheKey::Map<int> map;
  SkMatrix matrix = SkMatrix::I();
 
  RasterCacheKeyType type = RasterCacheKeyType::kLayer;
  RasterCacheKey layer_first_key(5, type, matrix);
  RasterCacheKey layer_second_key(10, type, matrix);
  RasterCacheKey layer_third_key(15, type, matrix);
  map[layer_first_key] = 50;
  map[layer_second_key] = 100;
  map[layer_third_key] = 150;
  ASSERT_EQ(map[layer_first_key], 50);
  ASSERT_EQ(map[layer_second_key], 100);
  ASSERT_EQ(map[layer_third_key], 150);
 
  type = RasterCacheKeyType::kDisplayList;
  RasterCacheKey picture_first_key(20, type, matrix);
  RasterCacheKey picture_second_key(25, type, matrix);
  RasterCacheKey picture_third_key(30, type, matrix);
  map[picture_first_key] = 200;
  map[picture_second_key] = 250;
  map[picture_third_key] = 300;
  ASSERT_EQ(map[picture_first_key], 200);
  ASSERT_EQ(map[picture_second_key], 250);
  ASSERT_EQ(map[picture_third_key], 300);
 
  type = RasterCacheKeyType::kDisplayList;
  RasterCacheKey display_list_first_key(35, type, matrix);
  RasterCacheKey display_list_second_key(40, type, matrix);
  RasterCacheKey display_list_third_key(45, type, matrix);
  map[display_list_first_key] = 350;
  map[display_list_second_key] = 400;
  map[display_list_third_key] = 450;
  ASSERT_EQ(map[display_list_first_key], 350);
  ASSERT_EQ(map[display_list_second_key], 400);
  ASSERT_EQ(map[display_list_third_key], 450);
 
  type = RasterCacheKeyType::kLayerChildren;
  RasterCacheKeyID foo = RasterCacheKeyID(10, RasterCacheKeyType::kLayer);
  RasterCacheKeyID bar = RasterCacheKeyID(20, RasterCacheKeyType::kLayer);
  RasterCacheKeyID baz = RasterCacheKeyID(30, RasterCacheKeyType::kLayer);
  RasterCacheKey layer_children_first_key(
      RasterCacheKeyID({foo, bar, baz}, type), matrix);
  RasterCacheKey layer_children_second_key(
      RasterCacheKeyID({foo, baz, bar}, type), matrix);
  RasterCacheKey layer_children_third_key(
      RasterCacheKeyID({baz, bar, foo}, type), matrix);
  map[layer_children_first_key] = 100;
  map[layer_children_second_key] = 200;
  map[layer_children_third_key] = 300;
  ASSERT_EQ(map[layer_children_first_key], 100);
  ASSERT_EQ(map[layer_children_second_key], 200);
  ASSERT_EQ(map[layer_children_third_key], 300);
}

◆ TEST() [652/715]

flutter::testing::TEST	(	RasterCache	,
		SimpleInitialization
	)

Definition at line 29 of file raster_cache_unittests.cc.

                                        {
  flutter::RasterCache cache;
  ASSERT_TRUE(true);
}

◆ TEST() [653/715]

flutter::testing::TEST	(	RasterCache	,
		ThresholdIsRespectedForDisplayList
	)

Definition at line 94 of file raster_cache_unittests.cc.

                                                      {
  size_t threshold = 2;
  flutter::RasterCache cache(threshold);
 
  SkMatrix matrix = SkMatrix::I();
 
  auto display_list = GetSampleDisplayList();
 
  MockCanvas dummy_canvas(1000, 1000);
  DlPaint paint;
 
  LayerStateStack preroll_state_stack;
  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
  LayerStateStack paint_state_stack;
  preroll_state_stack.set_delegate(&dummy_canvas);
 
  FixedRefreshRateStopwatch raster_time;
  FixedRefreshRateStopwatch ui_time;
  PrerollContextHolder preroll_context_holder = GetSamplePrerollContextHolder(
      preroll_state_stack, &cache, &raster_time, &ui_time);
  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
      paint_state_stack, &cache, &raster_time, &ui_time);
  auto& preroll_context = preroll_context_holder.preroll_context;
  auto& paint_context = paint_context_holder.paint_context;
 
  cache.BeginFrame();
 
  DisplayListRasterCacheItem display_list_item(display_list, SkPoint(), true,
                                               false);
 
  // 1st access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  // 2nd access.
  ASSERT_FALSE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_FALSE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
 
  cache.EndFrame();
  cache.BeginFrame();
 
  // Now Prepare should cache it.
  ASSERT_TRUE(RasterCacheItemPrerollAndTryToRasterCache(
      display_list_item, preroll_context, paint_context, matrix));
  ASSERT_TRUE(display_list_item.Draw(paint_context, &dummy_canvas, &paint));
}

◆ TEST() [654/715]

flutter::testing::TEST	(	RasterCacheUtilsTest	,
		SkM44IntegralTransCTM
	)

Definition at line 974 of file raster_cache_unittests.cc.

                                                  {
#define EXPECT_EQ_WITH_TRANSLATE(test, expected, tx, ty, label) \
  do {                                                          \
    EXPECT_EQ(test.rc(0, 0), expected.rc(0, 0)) << label;       \
    EXPECT_EQ(test.rc(0, 1), expected.rc(0, 1)) << label;       \
    EXPECT_EQ(test.rc(0, 2), expected.rc(0, 2)) << label;       \
    EXPECT_EQ(test.rc(0, 3), tx) << label;                      \
    EXPECT_EQ(test.rc(1, 0), expected.rc(1, 0)) << label;       \
    EXPECT_EQ(test.rc(1, 1), expected.rc(1, 1)) << label;       \
    EXPECT_EQ(test.rc(1, 2), expected.rc(1, 2)) << label;       \
    EXPECT_EQ(test.rc(1, 3), ty) << label;                      \
    EXPECT_EQ(test.rc(2, 0), expected.rc(2, 0)) << label;       \
    EXPECT_EQ(test.rc(2, 1), expected.rc(2, 1)) << label;       \
    EXPECT_EQ(test.rc(2, 2), expected.rc(2, 2)) << label;       \
    EXPECT_EQ(test.rc(2, 3), expected.rc(2, 3)) << label;       \
    EXPECT_EQ(test.rc(3, 0), expected.rc(3, 0)) << label;       \
    EXPECT_EQ(test.rc(3, 1), expected.rc(3, 1)) << label;       \
    EXPECT_EQ(test.rc(3, 2), expected.rc(3, 2)) << label;       \
    EXPECT_EQ(test.rc(3, 3), expected.rc(3, 3)) << label;       \
  } while (0)
 
#define EXPECT_NON_INTEGER_TRANSLATION(matrix)             \
  EXPECT_TRUE(SkScalarFraction(matrix.rc(0, 3)) != 0.0f || \
              SkScalarFraction(matrix.rc(1, 3)) != 0.0f)
 
  for (int r = 0; r < 4; r++) {
    for (int c = 0; c < 4; c++) {
      bool snaps;
      switch (r) {
        case 0:  // X equation
          if (c == 3) {
            continue;  // TranslateX, the value we are testing, skip
          }
          snaps = (c == 0);  // X Scale value yes, Skew by Y or Z no
          break;
        case 1:  // Y equation
          if (c == 3) {
            continue;  // TranslateY, the value we are testing, skip
          }
          snaps = (c == 1);  // Y Scale value yes, Skew by X or Z no
          break;
        case 2:  // Z equation, ignored, will snap
          snaps = true;
          break;
        case 3:  // W equation, modifications prevent snapping
          snaps = false;
          break;
        default:
          FML_UNREACHABLE();
      }
      auto label = std::to_string(r) + ", " + std::to_string(c);
      SkM44 matrix = SkM44::Translate(10.7f, 12.1f);
      EXPECT_NON_INTEGER_TRANSLATION(matrix) << label;
      matrix.setRC(r, c, 0.5f);
      if (snaps) {
        SkM44 compute;
        SkM44 get = RasterCacheUtil::GetIntegralTransCTM(matrix);
        EXPECT_TRUE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute))
            << label;
        EXPECT_EQ_WITH_TRANSLATE(get, matrix, 11.0f, 12.0f, label);
        EXPECT_EQ(get, compute) << label;
      } else {
        SkM44 compute;
        SkM44 get = RasterCacheUtil::GetIntegralTransCTM(matrix);
        EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute))
            << label;
        EXPECT_EQ(get, matrix) << label;
      }
    }
  }
#undef EXPECT_NON_INTEGER_TRANSLATION
#undef EXPECT_EQ_WITH_TRANSLATE
}

◆ TEST() [655/715]

flutter::testing::TEST	(	RasterCacheUtilsTest	,
		SkMatrixIntegralTransCTM
	)

Definition at line 773 of file raster_cache_unittests.cc.

                                                     {
#define EXPECT_EQ_WITH_TRANSLATE(test, expected, expected_tx, expected_ty) \
  do {                                                                     \
    EXPECT_EQ(test[SkMatrix::kMScaleX], expected[SkMatrix::kMScaleX]);     \
    EXPECT_EQ(test[SkMatrix::kMSkewX], expected[SkMatrix::kMSkewX]);       \
    EXPECT_EQ(test[SkMatrix::kMScaleY], expected[SkMatrix::kMScaleY]);     \
    EXPECT_EQ(test[SkMatrix::kMSkewY], expected[SkMatrix::kMSkewY]);       \
    EXPECT_EQ(test[SkMatrix::kMSkewX], expected[SkMatrix::kMSkewX]);       \
    EXPECT_EQ(test[SkMatrix::kMPersp0], expected[SkMatrix::kMPersp0]);     \
    EXPECT_EQ(test[SkMatrix::kMPersp1], expected[SkMatrix::kMPersp1]);     \
    EXPECT_EQ(test[SkMatrix::kMPersp2], expected[SkMatrix::kMPersp2]);     \
    EXPECT_EQ(test[SkMatrix::kMTransX], expected_tx);                      \
    EXPECT_EQ(test[SkMatrix::kMTransY], expected_ty);                      \
  } while (0)
 
#define EXPECT_NON_INTEGER_TRANSLATION(matrix)                        \
  EXPECT_TRUE(SkScalarFraction(matrix[SkMatrix::kMTransX]) != 0.0f || \
              SkScalarFraction(matrix[SkMatrix::kMTransY]) != 0.0f)
 
  {
    // Identity
    SkMatrix matrix = SkMatrix::I();
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Integer translate
    SkMatrix matrix = SkMatrix::Translate(10.0f, 12.0f);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Fractional x translate
    SkMatrix matrix = SkMatrix::Translate(10.2f, 12.0f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_TRUE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ_WITH_TRANSLATE(get, matrix, 10.0f, 12.0f);
    EXPECT_EQ(get, compute);
  }
  {
    // Fractional y translate
    SkMatrix matrix = SkMatrix::Translate(10.0f, 12.3f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_TRUE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ_WITH_TRANSLATE(get, matrix, 10.0f, 12.0f);
    EXPECT_EQ(get, compute);
  }
  {
    // Fractional x & y translate
    SkMatrix matrix = SkMatrix::Translate(10.7f, 12.3f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_TRUE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ_WITH_TRANSLATE(get, matrix, 11.0f, 12.0f);
    EXPECT_EQ(get, compute);
  }
  {
    // Scale
    SkMatrix matrix = SkMatrix::Scale(2.0f, 3.0f);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Scale, Integer translate
    SkMatrix matrix = SkMatrix::Scale(2.0f, 3.0f);
    matrix.preTranslate(10.0f, 12.0f);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Scale, Fractional translate
    SkMatrix matrix = SkMatrix::Scale(2.0f, 3.0f);
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_TRUE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ_WITH_TRANSLATE(get, matrix, 21.0f, 36.0f);
    EXPECT_EQ(get, compute);
  }
  {
    // Skew
    SkMatrix matrix = SkMatrix::Skew(0.5f, 0.1f);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Skew, Fractional translate - should be NOP
    SkMatrix matrix = SkMatrix::Skew(0.5f, 0.1f);
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Rotate
    SkMatrix matrix = SkMatrix::RotateDeg(45);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Rotate, Fractional Translate - should be NOP
    SkMatrix matrix = SkMatrix::RotateDeg(45);
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective x
    SkMatrix matrix = SkMatrix::I();
    matrix.setPerspX(0.1);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective x, Fractional Translate - should be NOP
    SkMatrix matrix = SkMatrix::I();
    matrix.setPerspX(0.1);
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective y
    SkMatrix matrix = SkMatrix::I();
    matrix.setPerspY(0.1);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective y, Fractional Translate - should be NOP
    SkMatrix matrix = SkMatrix::I();
    matrix.setPerspY(0.1);
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective weight
    // clang-format off
    SkMatrix matrix = SkMatrix::MakeAll(
        1.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.9f);
    // clang-format on
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
  {
    // Perspective weight, Fractional Translate - should be NOP
    // clang-format off
    SkMatrix matrix = SkMatrix::MakeAll(
        1.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.9f);
    // clang-format on
    matrix.preTranslate(10.7f, 12.1f);
    EXPECT_NON_INTEGER_TRANSLATION(matrix);
    SkMatrix get = RasterCacheUtil::GetIntegralTransCTM(matrix);
    SkMatrix compute;
    EXPECT_FALSE(RasterCacheUtil::ComputeIntegralTransCTM(matrix, &compute));
    EXPECT_EQ(get, matrix);
  }
#undef EXPECT_NON_INTEGER_TRANSLATION
#undef EXPECT_EQ_WITH_TRANSLATE
}

◆ TEST() [656/715]

flutter::testing::TEST	(	ResourceCacheLimitCalculatorTest	,
		GetResourceCacheMaxBytes
	)

Definition at line 28 of file resource_cache_limit_calculator_unittests.cc.

                                                                 {
  ResourceCacheLimitCalculator calculator(800U);
  auto item1 = std::make_unique<TestResourceCacheLimitItem>(100.0);
  calculator.AddResourceCacheLimitItem(item1->GetWeakPtr());
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(100U));
 
  auto item2 = std::make_unique<TestResourceCacheLimitItem>(200.0);
  calculator.AddResourceCacheLimitItem(item2->GetWeakPtr());
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(300U));
 
  auto item3 = std::make_unique<TestResourceCacheLimitItem>(300.0);
  calculator.AddResourceCacheLimitItem(item3->GetWeakPtr());
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(600U));
 
  auto item4 = std::make_unique<TestResourceCacheLimitItem>(400.0);
  calculator.AddResourceCacheLimitItem(item4->GetWeakPtr());
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(800U));
 
  item3.reset();
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(700U));
 
  item2.reset();
  EXPECT_EQ(calculator.GetResourceCacheMaxBytes(), static_cast<size_t>(500U));
}

◆ TEST() [657/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsIgnoresNonDrawingRecords
	)

Definition at line 57 of file rtree_unittests.cc.

                                                                    {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Creates two non drawing records.
  recording_canvas->translate(100, 100);
  // The result list should only contain the clipping rect.
  recording_canvas->clipRect(SkRect::MakeLTRB(40, 40, 50, 50),
                             SkClipOp::kIntersect);
  recording_canvas->drawRect(SkRect::MakeLTRB(20, 20, 80, 80), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  // The rtree has a translate, a clip and a rect record.
  ASSERT_EQ(3, rtree_factory.getInstance()->getCount());
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(0, 0, 1000, 1000));
  ASSERT_EQ(1UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(120, 120, 180, 180));
}

◆ TEST() [658/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase1
	)

Definition at line 116 of file rtree_unittests.cc.

                                                                         {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Given the A, and B rects, which intersect with the query rect,
  // the result list contains the three rectangles covering same area.
  //
  // +-----+        +-----+
  // |  A  |        |  A  |
  // |   +-----+    +---------+
  // |   |     |    |   B     |
  // +---|  B  |    +---+-----+
  //     |     |        |  C  |
  //     +-----+        +-----+
 
  // A
  recording_canvas->drawRect(SkRect::MakeLTRB(100, 100, 150, 150), rect_paint);
  // B
  recording_canvas->drawRect(SkRect::MakeLTRB(125, 125, 175, 175), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeXYWH(120, 120, 126, 126));
  ASSERT_EQ(3UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(100, 100, 150, 125));
  ASSERT_EQ(*std::next(hits.begin(), 1), SkRect::MakeLTRB(100, 125, 175, 150));
  ASSERT_EQ(*std::next(hits.begin(), 2), SkRect::MakeLTRB(125, 150, 175, 175));
}

◆ TEST() [659/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase2
	)

Definition at line 152 of file rtree_unittests.cc.

                                                                         {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Given the A, B, and C rects that intersect with the query rect,
  // there should be only C in the result list,
  // since A and B are contained in C.
  //
  // +---------------------+
  // | C                   |
  // |  +-----+   +-----+  |
  // |  |  A  |   |  B  |  |
  // |  +-----+   +-----+  |
  // +---------------------+
  //              +-----+
  //              |  D  |
  //              +-----+
 
  // A
  recording_canvas->drawRect(SkRect::MakeLTRB(100, 100, 200, 200), rect_paint);
  // B
  recording_canvas->drawRect(SkRect::MakeLTRB(300, 100, 400, 200), rect_paint);
  // C
  recording_canvas->drawRect(SkRect::MakeLTRB(50, 50, 500, 250), rect_paint);
  // D
  recording_canvas->drawRect(SkRect::MakeLTRB(280, 100, 280, 320), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(30, 30, 550, 270));
  ASSERT_EQ(1UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(50, 50, 500, 250));
}

◆ TEST() [660/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase3
	)

Definition at line 193 of file rtree_unittests.cc.

                                                                         {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Given the A, B, C and D rects that intersect with the query rect,
  // the result list contains two rects - D and remainder of C
  // these four rects.
  //
  // +------------------------------+
  // | D                            |
  // |  +-----+   +-----+   +-----+ |
  // |  |  A  |   |  B  |   |  C  | |
  // |  +-----+   +-----+   |     | |
  // +----------------------|     |-+
  //                        +-----+
  //              +-----+
  //              |  E  |
  //              +-----+
 
  // A
  recording_canvas->drawRect(SkRect::MakeLTRB(100, 100, 200, 200), rect_paint);
  // B
  recording_canvas->drawRect(SkRect::MakeLTRB(300, 100, 400, 200), rect_paint);
  // C
  recording_canvas->drawRect(SkRect::MakeLTRB(500, 100, 600, 300), rect_paint);
  // D
  recording_canvas->drawRect(SkRect::MakeLTRB(50, 50, 620, 250), rect_paint);
  // E
  recording_canvas->drawRect(SkRect::MakeLTRB(280, 100, 280, 320), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(30, 30, 550, 270));
  ASSERT_EQ(2UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(50, 50, 620, 250));
  ASSERT_EQ(*std::next(hits.begin(), 1), SkRect::MakeLTRB(500, 250, 600, 300));
}

◆ TEST() [661/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsMultipleRectIntersection
	)

Definition at line 85 of file rtree_unittests.cc.

                                                                    {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Given the A, B that intersect with the query rect,
  // there should be A and B in the result list since
  // they don't intersect with each other.
  //
  //  +-----+   +-----+
  //  |  A  |   |  B  |
  //  +-----+   +-----+
  // A
  recording_canvas->drawRect(SkRect::MakeLTRB(100, 100, 200, 200), rect_paint);
  // B
  recording_canvas->drawRect(SkRect::MakeLTRB(300, 100, 400, 200), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(0, 0, 1000, 1050));
  ASSERT_EQ(2UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(100, 100, 200, 200));
  ASSERT_EQ(*std::next(hits.begin(), 1), SkRect::MakeLTRB(300, 100, 400, 200));
}

◆ TEST() [662/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsNoIntersection
	)

Definition at line 15 of file rtree_unittests.cc.

                                                          {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // If no rect is intersected with the query rect, then the result list is
  // empty.
  recording_canvas->drawRect(SkRect::MakeLTRB(20, 20, 40, 40), rect_paint);
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(40, 40, 80, 80));
  ASSERT_TRUE(hits.empty());
}

◆ TEST() [663/715]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsSingleRectIntersection
	)

Definition at line 35 of file rtree_unittests.cc.

                                                                  {
  auto rtree_factory = RTreeFactory();
  auto recorder = std::make_unique<SkPictureRecorder>();
  auto recording_canvas =
      recorder->beginRecording(SkRect::MakeIWH(1000, 1000), &rtree_factory);
 
  auto rect_paint = SkPaint();
  rect_paint.setColor(SkColors::kCyan);
  rect_paint.setStyle(SkPaint::Style::kFill_Style);
 
  // Given a single rect A that intersects with the query rect,
  // the result list contains this rect.
  recording_canvas->drawRect(SkRect::MakeLTRB(120, 120, 160, 160), rect_paint);
 
  recorder->finishRecordingAsPicture();
 
  auto hits = rtree_factory.getInstance()->searchNonOverlappingDrawnRects(
      SkRect::MakeLTRB(140, 140, 150, 150));
  ASSERT_EQ(1UL, hits.size());
  ASSERT_EQ(*hits.begin(), SkRect::MakeLTRB(120, 120, 160, 160));
}

◆ TEST() [664/715]

flutter::testing::TEST	(	SequentialIdGeneratorTest	,
		MaybeRemoveNumbers
	)

Definition at line 35 of file sequential_id_generator_unittests.cc.

                                                    {
  const uint32_t kMinId = 0;
  const uint32_t kMaxId = 128;
 
  SequentialIdGenerator generator(kMinId, kMaxId);
 
  EXPECT_EQ(0U, generator.GetGeneratedId(42));
 
  generator.ReleaseNumber(42);
  EXPECT_FALSE(generator.HasGeneratedIdFor(42));
  generator.ReleaseNumber(42);
}

◆ TEST() [665/715]

flutter::testing::TEST	(	SequentialIdGeneratorTest	,
		RemoveMultipleNumbers
	)

Definition at line 12 of file sequential_id_generator_unittests.cc.

                                                       {
  const uint32_t kMinId = 4;
  const uint32_t kMaxId = 128;
 
  SequentialIdGenerator generator(kMinId, kMaxId);
 
  EXPECT_EQ(4U, generator.GetGeneratedId(45));
  EXPECT_EQ(5U, generator.GetGeneratedId(55));
  EXPECT_EQ(6U, generator.GetGeneratedId(15));
 
  generator.ReleaseNumber(45);
  EXPECT_FALSE(generator.HasGeneratedIdFor(45));
  generator.ReleaseNumber(15);
  EXPECT_FALSE(generator.HasGeneratedIdFor(15));
 
  EXPECT_EQ(5U, generator.GetGeneratedId(55));
  EXPECT_EQ(4U, generator.GetGeneratedId(12));
 
  generator.ReleaseNumber(12);
  generator.ReleaseNumber(55);
  EXPECT_EQ(4U, generator.GetGeneratedId(0));
}

◆ TEST() [666/715]

flutter::testing::TEST	(	SettingsPluginTest	,
		HighContrastModeHonored
	)

Definition at line 80 of file settings_plugin_unittests.cc.

                                                  {
  int times = 0;
  TestBinaryMessenger messenger(
      [&times](const std::string& channel, const uint8_t* message,
               size_t message_size, BinaryReply reply) {
        ASSERT_EQ(channel, "flutter/settings");
        times++;
      });
  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
 
  settings_plugin.UpdateHighContrastMode(true);
  EXPECT_TRUE(settings_plugin.is_high_contrast());
 
  settings_plugin.UpdateHighContrastMode(false);
  EXPECT_FALSE(settings_plugin.is_high_contrast());
 
  EXPECT_EQ(times, 2);
}

◆ TEST() [667/715]

flutter::testing::TEST	(	SettingsPluginTest	,
		SendSettingsGetsSettings
	)

Definition at line 55 of file settings_plugin_unittests.cc.

                                                   {
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
 
  EXPECT_CALL(settings_plugin, GetAlwaysUse24HourFormat).Times(1);
  EXPECT_CALL(settings_plugin, GetTextScaleFactor).Times(1);
  EXPECT_CALL(settings_plugin, GetPreferredBrightness).Times(1);
 
  settings_plugin.SendSettings();
}

◆ TEST() [668/715]

flutter::testing::TEST	(	SettingsPluginTest	,
		SendSettingsSendsMessage
	)

Definition at line 42 of file settings_plugin_unittests.cc.

                                                   {
  bool message_is_sent = false;
  TestBinaryMessenger messenger(
      [&message_is_sent](const std::string& channel, const uint8_t* message,
                         size_t message_size,
                         BinaryReply reply) { message_is_sent = true; });
  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
 
  settings_plugin.SendSettings();
 
  EXPECT_TRUE(message_is_sent);
}

◆ TEST() [669/715]

flutter::testing::TEST	(	SettingsPluginTest	,
		StartWatchingStartsWatchingChanges
	)

Definition at line 68 of file settings_plugin_unittests.cc.

                                                             {
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  ::testing::NiceMock<MockSettingsPlugin> settings_plugin(&messenger, nullptr);
 
  EXPECT_CALL(settings_plugin, WatchPreferredBrightnessChanged).Times(1);
  EXPECT_CALL(settings_plugin, WatchTextScaleFactorChanged).Times(1);
 
  settings_plugin.StartWatching();
}

◆ TEST() [670/715]

flutter::testing::TEST	(	SettingsTest	,
		FrameTimingSetsAndGetsProperly
	)

Definition at line 1505 of file shell_unittests.cc.

                                                   {
  // Ensure that all phases are in kPhases.
  ASSERT_EQ(sizeof(FrameTiming::kPhases),
            FrameTiming::kCount * sizeof(FrameTiming::Phase));
 
  int lastPhaseIndex = -1;
  FrameTiming timing;
  for (auto phase : FrameTiming::kPhases) {
    ASSERT_TRUE(phase > lastPhaseIndex);  // Ensure that kPhases are in order.
    lastPhaseIndex = phase;
    auto fake_time =
        fml::TimePoint::FromEpochDelta(fml::TimeDelta::FromMicroseconds(phase));
    timing.Set(phase, fake_time);
    ASSERT_TRUE(timing.Get(phase) == fake_time);
  }
}

◆ TEST() [671/715]

flutter::testing::TEST	(	SurfacePool	,
		DestroyLayers
	)

Definition at line 187 of file surface_pool_unittests.cc.

                                 {
  auto pool = std::make_unique<SurfacePool>();
  auto jni_mock = std::make_shared<JNIMock>();
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces()).Times(0);
  pool->DestroyLayers(jni_mock);
 
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .Times(1)
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  auto surface_factory =
      std::make_shared<TestAndroidSurfaceFactory>([gr_context, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()));
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  pool->GetLayer(gr_context.get(), *android_context, jni_mock, surface_factory);
 
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces());
 
  ASSERT_TRUE(pool->HasLayers());
  pool->DestroyLayers(jni_mock);
 
  ASSERT_FALSE(pool->HasLayers());
  ASSERT_TRUE(pool->GetUnusedLayers().empty());
}

◆ TEST() [672/715]

flutter::testing::TEST	(	SurfacePool	,
		DestroyLayersFrameSizeChanged
	)

Definition at line 224 of file surface_pool_unittests.cc.

                                                 {
  auto pool = std::make_unique<SurfacePool>();
  auto jni_mock = std::make_shared<JNIMock>();
 
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
 
  auto surface_factory =
      std::make_shared<TestAndroidSurfaceFactory>([gr_context, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()));
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  pool->SetFrameSize(SkISize::Make(10, 10));
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces()).Times(0);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .Times(1)
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  ASSERT_FALSE(pool->HasLayers());
 
  pool->GetLayer(gr_context.get(), *android_context, jni_mock, surface_factory);
 
  ASSERT_TRUE(pool->HasLayers());
 
  pool->SetFrameSize(SkISize::Make(20, 20));
  EXPECT_CALL(*jni_mock, FlutterViewDestroyOverlaySurfaces()).Times(1);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .Times(1)
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              1, window))));
  pool->GetLayer(gr_context.get(), *android_context, jni_mock, surface_factory);
 
  ASSERT_TRUE(pool->GetUnusedLayers().empty());
  ASSERT_TRUE(pool->HasLayers());
}

◆ TEST() [673/715]

flutter::testing::TEST	(	SurfacePool	,
		GetLayerAllocateOneLayer
	)

Definition at line 39 of file surface_pool_unittests.cc.

                                            {
  auto pool = std::make_unique<SurfacePool>();
 
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto jni_mock = std::make_shared<JNIMock>();
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  auto surface_factory =
      std::make_shared<TestAndroidSurfaceFactory>([gr_context, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()));
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  auto layer = pool->GetLayer(gr_context.get(), *android_context, jni_mock,
                              surface_factory);
 
  ASSERT_TRUE(pool->HasLayers());
  ASSERT_NE(nullptr, layer);
  ASSERT_EQ(reinterpret_cast<intptr_t>(gr_context.get()),
            layer->gr_context_key);
}

◆ TEST() [674/715]

flutter::testing::TEST	(	SurfacePool	,
		GetLayerAllocateTwoLayers
	)

Definition at line 148 of file surface_pool_unittests.cc.

                                             {
  auto pool = std::make_unique<SurfacePool>();
 
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto jni_mock = std::make_shared<JNIMock>();
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .Times(2)
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))))
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              1, window))));
 
  auto surface_factory =
      std::make_shared<TestAndroidSurfaceFactory>([gr_context, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()));
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  auto layer_1 = pool->GetLayer(gr_context.get(), *android_context, jni_mock,
                                surface_factory);
  auto layer_2 = pool->GetLayer(gr_context.get(), *android_context, jni_mock,
                                surface_factory);
 
  ASSERT_TRUE(pool->HasLayers());
  ASSERT_NE(nullptr, layer_1);
  ASSERT_NE(nullptr, layer_2);
  ASSERT_NE(layer_1, layer_2);
  ASSERT_EQ(0, layer_1->id);
  ASSERT_EQ(1, layer_2->id);
}

◆ TEST() [675/715]

flutter::testing::TEST	(	SurfacePool	,
		GetLayerRecycle
	)

Definition at line 103 of file surface_pool_unittests.cc.

                                   {
  auto pool = std::make_unique<SurfacePool>();
 
  auto gr_context_1 = GrDirectContext::MakeMock(nullptr);
  auto jni_mock = std::make_shared<JNIMock>();
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto gr_context_2 = GrDirectContext::MakeMock(nullptr);
  auto surface_factory = std::make_shared<TestAndroidSurfaceFactory>(
      [gr_context_1, gr_context_2, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        // Allocate two GPU surfaces for each gr context.
        EXPECT_CALL(*android_surface_mock,
                    CreateGPUSurface(gr_context_1.get()));
        EXPECT_CALL(*android_surface_mock,
                    CreateGPUSurface(gr_context_2.get()));
        // Set the native window once.
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  auto layer_1 = pool->GetLayer(gr_context_1.get(), *android_context, jni_mock,
                                surface_factory);
 
  pool->RecycleLayers();
 
  auto layer_2 = pool->GetLayer(gr_context_2.get(), *android_context, jni_mock,
                                surface_factory);
 
  ASSERT_TRUE(pool->HasLayers());
  ASSERT_NE(nullptr, layer_1);
  ASSERT_EQ(layer_1, layer_2);
  ASSERT_EQ(reinterpret_cast<intptr_t>(gr_context_2.get()),
            layer_1->gr_context_key);
  ASSERT_EQ(reinterpret_cast<intptr_t>(gr_context_2.get()),
            layer_2->gr_context_key);
}

◆ TEST() [676/715]

flutter::testing::TEST	(	SurfacePool	,
		GetUnusedLayers
	)

Definition at line 70 of file surface_pool_unittests.cc.

                                   {
  auto pool = std::make_unique<SurfacePool>();
 
  auto gr_context = GrDirectContext::MakeMock(nullptr);
  auto android_context =
      std::make_shared<AndroidContext>(AndroidRenderingAPI::kSoftware);
 
  auto jni_mock = std::make_shared<JNIMock>();
  auto window = fml::MakeRefCounted<AndroidNativeWindow>(nullptr);
  EXPECT_CALL(*jni_mock, FlutterViewCreateOverlaySurface())
      .WillOnce(Return(
          ByMove(std::make_unique<PlatformViewAndroidJNI::OverlayMetadata>(
              0, window))));
 
  auto surface_factory =
      std::make_shared<TestAndroidSurfaceFactory>([gr_context, window]() {
        auto android_surface_mock = std::make_unique<AndroidSurfaceMock>();
        EXPECT_CALL(*android_surface_mock, CreateGPUSurface(gr_context.get()));
        EXPECT_CALL(*android_surface_mock, SetNativeWindow(window));
        EXPECT_CALL(*android_surface_mock, IsValid()).WillOnce(Return(true));
        return android_surface_mock;
      });
  auto layer = pool->GetLayer(gr_context.get(), *android_context, jni_mock,
                              surface_factory);
  ASSERT_EQ(0UL, pool->GetUnusedLayers().size());
 
  pool->RecycleLayers();
 
  ASSERT_TRUE(pool->HasLayers());
  ASSERT_EQ(1UL, pool->GetUnusedLayers().size());
  ASSERT_EQ(layer, pool->GetUnusedLayers()[0]);
}

◆ TEST() [677/715]

flutter::testing::TEST	(	SwitchesTest	,
		EnableAsserts
	)

Definition at line 109 of file switches_unittests.cc.

                                  {
  fml::CommandLine command_line = fml::CommandLineFromInitializerList(
      {"command", "--dart-flags=--enable-asserts"});
  Settings settings = SettingsFromCommandLine(command_line);
  ASSERT_EQ(settings.dart_flags.size(), 1ul);
  EXPECT_EQ(settings.dart_flags[0], "--enable-asserts");
}

◆ TEST() [678/715]

flutter::testing::TEST	(	SwitchesTest	,
		EnableEmbedderAPI
	)

Definition at line 72 of file switches_unittests.cc.

                                      {
  {
    // enable
    fml::CommandLine command_line = fml::CommandLineFromInitializerList(
        {"command", "--enable-embedder-api"});
    Settings settings = SettingsFromCommandLine(command_line);
    EXPECT_EQ(settings.enable_embedder_api, true);
  }
  {
    // default
    fml::CommandLine command_line =
        fml::CommandLineFromInitializerList({"command"});
    Settings settings = SettingsFromCommandLine(command_line);
    EXPECT_EQ(settings.enable_embedder_api, false);
  }
}

◆ TEST() [679/715]

flutter::testing::TEST	(	SwitchesTest	,
		NoEnableImpeller
	)

Definition at line 89 of file switches_unittests.cc.

                                     {
  {
    // enable
    fml::CommandLine command_line =
        fml::CommandLineFromInitializerList({"command", "--enable-impeller"});
    EXPECT_TRUE(command_line.HasOption("enable-impeller"));
    Settings settings = SettingsFromCommandLine(command_line);
    EXPECT_EQ(settings.enable_impeller, true);
  }
  {
    // disable
    fml::CommandLine command_line = fml::CommandLineFromInitializerList(
        {"command", "--enable-impeller=false"});
    EXPECT_TRUE(command_line.HasOption("enable-impeller"));
    Settings settings = SettingsFromCommandLine(command_line);
    EXPECT_EQ(settings.enable_impeller, false);
  }
}

◆ TEST() [680/715]

flutter::testing::TEST	(	SwitchesTest	,
		RouteParsedFlag
	)

Definition at line 62 of file switches_unittests.cc.

                                    {
  fml::CommandLine command_line =
      fml::CommandLineFromInitializerList({"command", "--route=/animation"});
  Settings settings = SettingsFromCommandLine(command_line);
  EXPECT_EQ(settings.route, "/animation");
  command_line = fml::CommandLineFromInitializerList({"command", "--route"});
  settings = SettingsFromCommandLine(command_line);
  EXPECT_TRUE(settings.route.empty());
}

◆ TEST() [681/715]

flutter::testing::TEST	(	SwitchesTest	,
		SkiaTraceAllowlistFlag
	)

Definition at line 19 of file switches_unittests.cc.

                                           {
  fml::CommandLine command_line =
      fml::CommandLineFromInitializerList({"command"});
  Settings settings = SettingsFromCommandLine(command_line);
#if !FLUTTER_RELEASE
  EXPECT_TRUE(settings.trace_skia);
  EXPECT_TRUE(settings.trace_skia_allowlist.has_value());
  EXPECT_EQ(settings.trace_skia_allowlist->size(), 1ul);
#else
  EXPECT_FALSE(settings.trace_skia);
#endif
 
  command_line =
      fml::CommandLineFromInitializerList({"command", "--trace-skia"});
  settings = SettingsFromCommandLine(command_line);
#if !FLUTTER_RELEASE
  EXPECT_TRUE(settings.trace_skia);
  EXPECT_FALSE(settings.trace_skia_allowlist.has_value());
#else
  EXPECT_FALSE(settings.trace_skia);
#endif
 
  command_line = fml::CommandLineFromInitializerList(
      {"command", "--trace-skia-allowlist=aaa,bbb,ccc"});
  settings = SettingsFromCommandLine(command_line);
#if !FLUTTER_RELEASE
  EXPECT_TRUE(settings.trace_skia);
  EXPECT_TRUE(settings.trace_skia_allowlist.has_value());
  EXPECT_EQ(settings.trace_skia_allowlist->size(), 3ul);
  EXPECT_EQ(settings.trace_skia_allowlist->back(), "ccc");
#else
  EXPECT_FALSE(settings.trace_skia);
#endif
}

◆ TEST() [682/715]

flutter::testing::TEST	(	SwitchesTest	,
		TraceToFile
	)

Definition at line 54 of file switches_unittests.cc.

                                {
  fml::CommandLine command_line = fml::CommandLineFromInitializerList(
      {"command", "--trace-to-file=trace.binpb"});
  EXPECT_TRUE(command_line.HasOption("trace-to-file"));
  Settings settings = SettingsFromCommandLine(command_line);
  EXPECT_EQ(settings.trace_to_file, "trace.binpb");
}

◆ TEST() [683/715]

flutter::testing::TEST	(	SystemUtils	,
		GetPreferredLanguageInfo
	)

Definition at line 16 of file system_utils_unittests.cc.

                                            {
  WindowsProcTable proc_table;
  std::vector<LanguageInfo> languages =
      GetPreferredLanguageInfo(WindowsProcTable());
  // There should be at least one language.
  ASSERT_GE(languages.size(), 1);
  // The info should have a valid languge.
  EXPECT_GE(languages[0].language.size(), 2);
}

◆ TEST() [684/715]

flutter::testing::TEST	(	SystemUtils	,
		GetPreferredLanguages
	)

Definition at line 26 of file system_utils_unittests.cc.

                                         {
  MockWindowsProcTable proc_table;
  EXPECT_CALL(proc_table, GetThreadPreferredUILanguages)
      .WillRepeatedly(
          [](DWORD flags, PULONG count, PZZWSTR languages, PULONG size) {
            // Languages string ends in a double-null.
            static const wchar_t lang[] = L"en-US\0";
            static const size_t lang_len = sizeof(lang) / sizeof(wchar_t);
            static const int cnt = 1;
            if (languages == nullptr) {
              *size = lang_len;
              *count = cnt;
            } else if (*size >= lang_len) {
              memcpy(languages, lang, lang_len * sizeof(wchar_t));
            }
            return TRUE;
          });
  std::vector<std::wstring> languages = GetPreferredLanguages(proc_table);
  // There should be at least one language.
  ASSERT_GE(languages.size(), 1);
  // The language should be non-empty.
  EXPECT_FALSE(languages[0].empty());
  // There should not be a trailing null from the parsing step.
  EXPECT_EQ(languages[0].size(), wcslen(languages[0].c_str()));
  EXPECT_EQ(languages[0], L"en-US");
}

◆ TEST() [685/715]

flutter::testing::TEST	(	SystemUtils	,
		GetUserTimeFormat
	)

Definition at line 96 of file system_utils_unittests.cc.

                                     {
  // The value varies based on machine; just ensure that something is returned.
  EXPECT_FALSE(GetUserTimeFormat().empty());
}

◆ TEST() [686/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameGeneric
	)

Definition at line 53 of file system_utils_unittests.cc.

                                            {
  LanguageInfo info = ParseLanguageName(L"en");
  EXPECT_EQ(info.language, "en");
  EXPECT_TRUE(info.region.empty());
  EXPECT_TRUE(info.script.empty());
}

◆ TEST() [687/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithRegion
	)

Definition at line 60 of file system_utils_unittests.cc.

                                               {
  LanguageInfo info = ParseLanguageName(L"hu-HU");
  EXPECT_EQ(info.language, "hu");
  EXPECT_EQ(info.region, "HU");
  EXPECT_TRUE(info.script.empty());
}

◆ TEST() [688/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithRegionAndScript
	)

Definition at line 74 of file system_utils_unittests.cc.

                                                        {
  LanguageInfo info = ParseLanguageName(L"uz-Latn-UZ");
  EXPECT_EQ(info.language, "uz");
  EXPECT_EQ(info.region, "UZ");
  EXPECT_EQ(info.script, "Latn");
}

◆ TEST() [689/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithScript
	)

Definition at line 67 of file system_utils_unittests.cc.

                                               {
  LanguageInfo info = ParseLanguageName(L"us-Latn");
  EXPECT_EQ(info.language, "us");
  EXPECT_TRUE(info.region.empty());
  EXPECT_EQ(info.script, "Latn");
}

◆ TEST() [690/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithSuplementalLanguage
	)

Definition at line 81 of file system_utils_unittests.cc.

                                                            {
  LanguageInfo info = ParseLanguageName(L"en-US-x-fabricam");
  EXPECT_EQ(info.language, "en");
  EXPECT_EQ(info.region, "US");
  EXPECT_TRUE(info.script.empty());
}

◆ TEST() [691/715]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithThreeCharacterLanguage
	)

Definition at line 89 of file system_utils_unittests.cc.

                                                               {
  LanguageInfo info = ParseLanguageName(L"ale-ZZ");
  EXPECT_EQ(info.language, "ale");
  EXPECT_EQ(info.region, "ZZ");
  EXPECT_TRUE(info.script.empty());
}

◆ TEST() [692/715]

flutter::testing::TEST	(	SystemUtils	,
		Prefer24HourTimeHandles12Hour
	)

Definition at line 105 of file system_utils_unittests.cc.

                                                 {
  EXPECT_FALSE(Prefer24HourTime(L"h:mm:ss tt"));
}

◆ TEST() [693/715]

flutter::testing::TEST	(	SystemUtils	,
		Prefer24HourTimeHandles24Hour
	)

Definition at line 109 of file system_utils_unittests.cc.

                                                 {
  EXPECT_TRUE(Prefer24HourTime(L"HH:mm:ss"));
}

◆ TEST() [694/715]

flutter::testing::TEST	(	SystemUtils	,
		Prefer24HourTimeHandlesEmptyFormat
	)

Definition at line 101 of file system_utils_unittests.cc.

                                                      {
  EXPECT_FALSE(Prefer24HourTime(L""));
}

◆ TEST() [695/715]

flutter::testing::TEST	(	TaskRunnerTest	,
		MaybeExecuteTaskOnlyExpired
	)

Definition at line 68 of file task_runner_unittests.cc.

                                                  {
  std::set<uint64_t> executed_task;
  auto runner = MockTaskRunner(
      MockGetCurrentTime, [&executed_task](const FlutterTask* expired_task) {
        executed_task.insert(expired_task->task);
      });
 
  uint64_t task_expired_before_now = 1;
  uint64_t time_before_now = 0;
  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_before_now},
                         time_before_now);
 
  uint64_t task_expired_after_now = 2;
  uint64_t time_after_now = MockGetCurrentTime() * 2;
  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_after_now},
                         time_after_now);
 
  runner.SimulateTimerAwake();
 
  std::set<uint64_t> only_task_expired_before_now{task_expired_before_now};
  EXPECT_EQ(executed_task, only_task_expired_before_now);
}

◆ TEST() [696/715]

flutter::testing::TEST	(	TaskRunnerTest	,
		MaybeExecuteTaskWithExactOrder
	)

Definition at line 45 of file task_runner_unittests.cc.

                                                     {
  std::vector<uint64_t> executed_task_order;
  auto runner =
      MockTaskRunner(MockGetCurrentTime,
                     [&executed_task_order](const FlutterTask* expired_task) {
                       executed_task_order.push_back(expired_task->task);
                     });
 
  uint64_t time_now = MockGetCurrentTime();
 
  runner.PostFlutterTask(FlutterTask{nullptr, 1}, time_now);
  runner.PostFlutterTask(FlutterTask{nullptr, 2}, time_now);
  runner.PostTask(
      [&executed_task_order]() { executed_task_order.push_back(3); });
  runner.PostTask(
      [&executed_task_order]() { executed_task_order.push_back(4); });
 
  runner.SimulateTimerAwake();
 
  std::vector<uint64_t> posted_task_order{1, 2, 3, 4};
  EXPECT_EQ(executed_task_order, posted_task_order);
}

◆ TEST() [697/715]

flutter::testing::TEST	(	TestKeyboard	,
		CloneString
	)

Definition at line 13 of file test_keyboard_unittests.cc.

                                {
  const char* str1 = "123";
  char* cloned_str1 = clone_string(str1);
  EXPECT_STREQ(str1, cloned_str1);
  EXPECT_NE(str1, cloned_str1);
  delete[] cloned_str1;
 
  EXPECT_EQ(clone_string(nullptr), nullptr);
};

◆ TEST() [698/715]

flutter::testing::TEST	(	TestKeyboard	,
		CreateKeyEventLparam
	)

Definition at line 23 of file test_keyboard_unittests.cc.

                                         {
  EXPECT_EQ(CreateKeyEventLparam(0x1, true, true), 0xC1010001);
 
  EXPECT_EQ(CreateKeyEventLparam(0x05, false, false, 0, 1, 0), 0x20050000);
};

◆ TEST() [699/715]

flutter::testing::TEST	(	TextureRegistryTest	,
		CallsOnGrContextCreatedInInsertionOrder
	)

Definition at line 122 of file texture_unittests.cc.

                                                                   {
  TextureRegistry registry;
  std::vector<int> create_order;
  std::vector<int> destroy_order;
  auto create = [&](int id) { create_order.push_back(id); };
  auto destroy = [&](int id) { destroy_order.push_back(id); };
  auto a = std::make_shared<TestContextListener>(5, create, destroy);
  auto b = std::make_shared<TestContextListener>(4, create, destroy);
  auto c = std::make_shared<TestContextListener>(3, create, destroy);
  registry.RegisterContextListener(a->id, a);
  registry.RegisterContextListener(b->id, b);
  registry.RegisterContextListener(c->id, c);
  registry.OnGrContextDestroyed();
  registry.OnGrContextCreated();
 
  EXPECT_THAT(create_order, ::testing::ElementsAre(5, 4, 3));
  EXPECT_THAT(destroy_order, ::testing::ElementsAre(5, 4, 3));
}

◆ TEST() [700/715]

flutter::testing::TEST	(	TextureRegistryTest	,
		GrContextCallbackTriggered
	)

Definition at line 60 of file texture_unittests.cc.

                                                      {
  TextureRegistry registry;
  auto mock_texture1 = std::make_shared<MockTexture>(0);
  auto mock_texture2 = std::make_shared<MockTexture>(1);
 
  registry.RegisterTexture(mock_texture1);
  registry.RegisterTexture(mock_texture2);
  ASSERT_FALSE(mock_texture1->gr_context_created());
  ASSERT_FALSE(mock_texture2->gr_context_created());
  ASSERT_FALSE(mock_texture1->gr_context_destroyed());
  ASSERT_FALSE(mock_texture2->gr_context_destroyed());
 
  registry.OnGrContextCreated();
  ASSERT_TRUE(mock_texture1->gr_context_created());
  ASSERT_TRUE(mock_texture2->gr_context_created());
 
  registry.UnregisterTexture(0);
  registry.OnGrContextDestroyed();
  ASSERT_FALSE(mock_texture1->gr_context_destroyed());
  ASSERT_TRUE(mock_texture2->gr_context_created());
}

◆ TEST() [701/715]

flutter::testing::TEST	(	TextureRegistryTest	,
		RegisterTextureTwice
	)

Definition at line 82 of file texture_unittests.cc.

                                                {
  TextureRegistry registry;
  auto mock_texture1 = std::make_shared<MockTexture>(0);
  auto mock_texture2 = std::make_shared<MockTexture>(0);
 
  registry.RegisterTexture(mock_texture1);
  ASSERT_EQ(registry.GetTexture(0), mock_texture1);
  registry.RegisterTexture(mock_texture2);
  ASSERT_EQ(registry.GetTexture(0), mock_texture2);
  ASSERT_FALSE(mock_texture1->unregistered());
  ASSERT_FALSE(mock_texture2->unregistered());
 
  registry.UnregisterTexture(0);
  ASSERT_EQ(registry.GetTexture(0), nullptr);
  ASSERT_FALSE(mock_texture1->unregistered());
  ASSERT_TRUE(mock_texture2->unregistered());
}

◆ TEST() [702/715]

flutter::testing::TEST	(	TextureRegistryTest	,
		ReuseSameTextureSlot
	)

Definition at line 100 of file texture_unittests.cc.

                                                {
  TextureRegistry registry;
  auto mock_texture1 = std::make_shared<MockTexture>(0);
  auto mock_texture2 = std::make_shared<MockTexture>(0);
 
  registry.RegisterTexture(mock_texture1);
  ASSERT_EQ(registry.GetTexture(0), mock_texture1);
 
  registry.UnregisterTexture(0);
  ASSERT_EQ(registry.GetTexture(0), nullptr);
  ASSERT_TRUE(mock_texture1->unregistered());
  ASSERT_FALSE(mock_texture2->unregistered());
 
  registry.RegisterTexture(mock_texture2);
  ASSERT_EQ(registry.GetTexture(0), mock_texture2);
 
  registry.UnregisterTexture(0);
  ASSERT_EQ(registry.GetTexture(0), nullptr);
  ASSERT_TRUE(mock_texture1->unregistered());
  ASSERT_TRUE(mock_texture2->unregistered());
}

◆ TEST() [703/715]

flutter::testing::TEST	(	TextureRegistryTest	,
		UnregisterTextureCallbackTriggered
	)

Definition at line 37 of file texture_unittests.cc.

                                                              {
  TextureRegistry registry;
  auto mock_texture1 = std::make_shared<MockTexture>(0);
  auto mock_texture2 = std::make_shared<MockTexture>(1);
 
  registry.RegisterTexture(mock_texture1);
  registry.RegisterTexture(mock_texture2);
  ASSERT_EQ(registry.GetTexture(0), mock_texture1);
  ASSERT_EQ(registry.GetTexture(1), mock_texture2);
  ASSERT_FALSE(mock_texture1->unregistered());
  ASSERT_FALSE(mock_texture2->unregistered());
 
  registry.UnregisterTexture(0);
  ASSERT_EQ(registry.GetTexture(0), nullptr);
  ASSERT_TRUE(mock_texture1->unregistered());
  ASSERT_FALSE(mock_texture2->unregistered());
 
  registry.UnregisterTexture(1);
  ASSERT_EQ(registry.GetTexture(1), nullptr);
  ASSERT_TRUE(mock_texture1->unregistered());
  ASSERT_TRUE(mock_texture2->unregistered());
}

◆ TEST() [704/715]

flutter::testing::TEST	(	VariableRefreshRateDisplayTest	,
		Report0IfReporterSharedPointerIsDestroyedAfterDisplayCreation
	)

Definition at line 30 of file variable_refresh_rate_display_unittests.cc.

                                                                    {
  auto refresh_rate_reporter = std::make_shared<TestRefreshRateReporter>(60);
  auto display = flutter::VariableRefreshRateDisplay(
      0, std::weak_ptr<TestRefreshRateReporter>(refresh_rate_reporter), 600,
      800, 60);
  refresh_rate_reporter.reset();
  ASSERT_EQ(display.GetRefreshRate(), 0);
}

◆ TEST() [705/715]

flutter::testing::TEST	(	VariableRefreshRateDisplayTest	,
		Report0IfReporterSharedPointerIsDestroyedBeforeDisplayCreation
	)

Definition at line 40 of file variable_refresh_rate_display_unittests.cc.

                                                                     {
  auto refresh_rate_reporter = std::make_shared<TestRefreshRateReporter>(60);
  refresh_rate_reporter.reset();
  auto display = flutter::VariableRefreshRateDisplay(
      0, std::weak_ptr<TestRefreshRateReporter>(refresh_rate_reporter), 600,
      800, 60);
  ASSERT_EQ(display.GetRefreshRate(), 0);
}

◆ TEST() [706/715]

flutter::testing::TEST	(	VariableRefreshRateDisplayTest	,
		ReportCorrectInitialRefreshRate
	)

Definition at line 13 of file variable_refresh_rate_display_unittests.cc.

                                                                      {
  auto refresh_rate_reporter = std::make_shared<TestRefreshRateReporter>(60);
  auto display = flutter::VariableRefreshRateDisplay(
      0, std::weak_ptr<TestRefreshRateReporter>(refresh_rate_reporter), 600,
      800, 60);
  ASSERT_EQ(display.GetRefreshRate(), 60);
}

◆ TEST() [707/715]

flutter::testing::TEST	(	VariableRefreshRateDisplayTest	,
		ReportCorrectRefreshRateWhenUpdated
	)

Definition at line 21 of file variable_refresh_rate_display_unittests.cc.

                                                                          {
  auto refresh_rate_reporter = std::make_shared<TestRefreshRateReporter>(60);
  auto display = flutter::VariableRefreshRateDisplay(
      0, std::weak_ptr<TestRefreshRateReporter>(refresh_rate_reporter), 600,
      800, 60);
  refresh_rate_reporter->UpdateRefreshRate(30);
  ASSERT_EQ(display.GetRefreshRate(), 30);
}

◆ TEST() [708/715]

flutter::testing::TEST	(	VsyncWaiterTest	,
		NoUnneededAwaitVsync
	)

Definition at line 27 of file vsync_waiter_unittests.cc.

                                            {
  using flutter::ThreadHost;
  std::string prefix = "vsync_waiter_test";
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
 
  const flutter::TaskRunners task_runners(prefix, task_runner, task_runner,
                                          task_runner, task_runner);
 
  TestVsyncWaiter vsync_waiter(task_runners);
 
  vsync_waiter.ScheduleSecondaryCallback(1, [] {});
  EXPECT_EQ(vsync_waiter.await_vsync_call_count_, 1);
 
  vsync_waiter.ScheduleSecondaryCallback(2, [] {});
  EXPECT_EQ(vsync_waiter.await_vsync_call_count_, 1);
}

◆ TEST() [709/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		CallsCorrectly
	)

Definition at line 54 of file window_proc_delegate_manager_unittests.cc.

                                                    {
  WindowProcDelegateManager manager;
  HWND dummy_hwnd;
 
  bool called = false;
  TestWindowProcDelegate delegate = [&called, &dummy_hwnd](
                                        HWND hwnd, UINT message, WPARAM wparam,
                                        LPARAM lparam) {
    called = true;
    EXPECT_EQ(hwnd, dummy_hwnd);
    EXPECT_EQ(message, 2);
    EXPECT_EQ(wparam, 3);
    EXPECT_EQ(lparam, 4);
    return std::optional<LRESULT>();
  };
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback, &delegate);
  auto result = manager.OnTopLevelWindowProc(dummy_hwnd, 2, 3, 4);
 
  EXPECT_TRUE(called);
  EXPECT_FALSE(result);
}

◆ TEST() [710/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		ConflictingDelegates
	)

Definition at line 163 of file window_proc_delegate_manager_unittests.cc.

                                                          {
  WindowProcDelegateManager manager;
 
  bool called_a = false;
  TestWindowProcDelegate delegate_a =
      [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_a = true;
        return std::optional<LRESULT>(1);
      };
  bool called_b = false;
  TestWindowProcDelegate delegate_b =
      [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_b = true;
        return std::optional<LRESULT>(1);
      };
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                             &delegate_a);
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
                                             &delegate_b);
  auto result = manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
  EXPECT_TRUE(result);
  // Exactly one of the handlers should be called since each will claim to have
  // handled the message. Which one is unspecified, since the calling order is
  // unspecified.
  EXPECT_TRUE(called_a || called_b);
  EXPECT_NE(called_a, called_b);
}

◆ TEST() [711/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		Ordered
	)

Definition at line 128 of file window_proc_delegate_manager_unittests.cc.

                                             {
  TestWindowProcDelegate delegate_1 = [](HWND hwnd, UINT message, WPARAM wparam,
                                         LPARAM lparam) { return 1; };
  TestWindowProcDelegate delegate_2 = [](HWND hwnd, UINT message, WPARAM wparam,
                                         LPARAM lparam) { return 2; };
 
  // Result should be 1 if delegate '1' is registered before delegate '2'.
  {
    WindowProcDelegateManager manager;
    manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                               &delegate_1);
    manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
                                               &delegate_2);
 
    std::optional<LRESULT> result =
        manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
    EXPECT_EQ(result, 1);
  }
 
  // Result should be 2 if delegate '2' is registered before delegate '1'.
  {
    WindowProcDelegateManager manager;
    manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
                                               &delegate_2);
    manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                               &delegate_1);
 
    std::optional<LRESULT> result =
        manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
    EXPECT_EQ(result, 2);
  }
}

◆ TEST() [712/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		RegisterMultiple
	)

Definition at line 102 of file window_proc_delegate_manager_unittests.cc.

                                                      {
  WindowProcDelegateManager manager;
 
  bool called_a = false;
  TestWindowProcDelegate delegate_a =
      [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_a = true;
        return std::optional<LRESULT>();
      };
  bool called_b = false;
  TestWindowProcDelegate delegate_b =
      [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_b = true;
        return std::optional<LRESULT>();
      };
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                             &delegate_a);
  // Function pointer is different, so both should be called.
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback2,
                                             &delegate_b);
  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
  EXPECT_TRUE(called_a);
  EXPECT_TRUE(called_b);
}

◆ TEST() [713/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		ReplacementRegister
	)

Definition at line 76 of file window_proc_delegate_manager_unittests.cc.

                                                         {
  WindowProcDelegateManager manager;
 
  bool called_a = false;
  TestWindowProcDelegate delegate_a =
      [&called_a](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_a = true;
        return std::optional<LRESULT>();
      };
  bool called_b = false;
  TestWindowProcDelegate delegate_b =
      [&called_b](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
        called_b = true;
        return std::optional<LRESULT>();
      };
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                             &delegate_a);
  // The function pointer is the same, so this should replace, not add.
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback,
                                             &delegate_b);
  manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
  EXPECT_FALSE(called_a);
  EXPECT_TRUE(called_b);
}

◆ TEST() [714/715]

flutter::testing::TEST	(	WindowProcDelegateManagerTest	,
		Unregister
	)

Definition at line 192 of file window_proc_delegate_manager_unittests.cc.

                                                {
  WindowProcDelegateManager manager;
 
  bool called = false;
  TestWindowProcDelegate delegate = [&called](HWND hwnd, UINT message,
                                              WPARAM wparam, LPARAM lparam) {
    called = true;
    return std::optional<LRESULT>();
  };
  manager.RegisterTopLevelWindowProcDelegate(TestWindowProcCallback, &delegate);
  manager.UnregisterTopLevelWindowProcDelegate(TestWindowProcCallback);
  auto result = manager.OnTopLevelWindowProc(nullptr, 0, 0, 0);
 
  EXPECT_FALSE(result);
  EXPECT_FALSE(called);
}

◆ TEST() [715/715]

flutter::testing::TEST	(	WindowsNoFixtureTest	,
		GetTextureRegistrar
	)

Definition at line 64 of file flutter_windows_unittests.cc.

                                                {
  FlutterDesktopEngineProperties properties = {};
  properties.assets_path = L"";
  properties.icu_data_path = L"icudtl.dat";
  auto engine = FlutterDesktopEngineCreate(&properties);
  ASSERT_NE(engine, nullptr);
  auto texture_registrar = FlutterDesktopEngineGetTextureRegistrar(engine);
  EXPECT_NE(texture_registrar, nullptr);
  FlutterDesktopEngineDestroy(engine);
}

◆ TEST_F() [1/925]

flutter::testing::TEST_F	(	AccessibilityBridgeMacTest	,
		DoesNotSendAccessibilityCreateNotificationWhenHeadless
	)

Definition at line 213 of file AccessibilityBridgeMacTest.mm.

                                                                                           {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
 
  // Setting up bridge so that the AccessibilityBridgeMacDelegateSpy
  // can query semantics information from.
  engine.semanticsEnabled = YES;
  auto bridge = std::static_pointer_cast<AccessibilityBridgeMacSpy>(
      viewController.accessibilityBridge.lock());
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
  auto platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  // Creates a targeted event.
  ui::AXTree tree;
  ui::AXNode ax_node(&tree, nullptr, 0, 0);
  ui::AXNodeData node_data;
  node_data.id = 0;
  ax_node.SetData(node_data);
  std::vector<ui::AXEventIntent> intent;
  ui::AXEventGenerator::EventParams event_params(ui::AXEventGenerator::Event::CHILDREN_CHANGED,
                                                 ax::mojom::EventFrom::kNone, intent);
  ui::AXEventGenerator::TargetedEvent targeted_event(&ax_node, event_params);
 
  bridge->OnAccessibilityEvent(targeted_event);
 
  // Does not send any notification if the engine is headless.
  EXPECT_EQ(bridge->actual_notifications.size(), 0u);
  [engine shutDownEngine];
}

◆ TEST_F() [2/925]

flutter::testing::TEST_F	(	AccessibilityBridgeMacTest	,
		DoesNotSendAccessibilityCreateNotificationWhenNoWindow
	)

Definition at line 259 of file AccessibilityBridgeMacTest.mm.

                                                                                           {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
 
  // Setting up bridge so that the AccessibilityBridgeMacDelegateSpy
  // can query semantics information from.
  engine.semanticsEnabled = YES;
  auto bridge = std::static_pointer_cast<AccessibilityBridgeMacSpy>(
      viewController.accessibilityBridge.lock());
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
  auto platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  // Creates a targeted event.
  ui::AXTree tree;
  ui::AXNode ax_node(&tree, nullptr, 0, 0);
  ui::AXNodeData node_data;
  node_data.id = 0;
  ax_node.SetData(node_data);
  std::vector<ui::AXEventIntent> intent;
  ui::AXEventGenerator::EventParams event_params(ui::AXEventGenerator::Event::CHILDREN_CHANGED,
                                                 ax::mojom::EventFrom::kNone, intent);
  ui::AXEventGenerator::TargetedEvent targeted_event(&ax_node, event_params);
 
  bridge->OnAccessibilityEvent(targeted_event);
 
  // Does not send any notification if the flutter view is not attached to a NSWindow.
  EXPECT_EQ(bridge->actual_notifications.size(), 0u);
  [engine shutDownEngine];
}

◆ TEST_F() [3/925]

flutter::testing::TEST_F	(	AccessibilityBridgeMacWindowTest	,
		NonZeroRootNodeId
	)

Definition at line 147 of file AccessibilityBridgeMacTest.mm.

                                                            {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  NSWindow* expectedTarget = GetWindow();
  expectedTarget.contentView = viewController.view;
 
  // Setting up bridge so that the AccessibilityBridgeMacDelegateSpy
  // can query semantics information from.
  engine.semanticsEnabled = YES;
  auto bridge = std::static_pointer_cast<AccessibilityBridgeMacSpy>(
      viewController.accessibilityBridge.lock());
 
  FlutterSemanticsNode2 node1;
  std::vector<int32_t> node1_children{2};
  node1.id = 1;
  node1.flags = static_cast<FlutterSemanticsFlag>(0);
  node1.actions = static_cast<FlutterSemanticsAction>(0);
  node1.text_selection_base = -1;
  node1.text_selection_extent = -1;
  node1.label = "node1";
  node1.hint = "";
  node1.value = "";
  node1.increased_value = "";
  node1.decreased_value = "";
  node1.tooltip = "";
  node1.child_count = node1_children.size();
  node1.children_in_traversal_order = node1_children.data();
  node1.children_in_hit_test_order = node1_children.data();
  node1.custom_accessibility_actions_count = 0;
 
  FlutterSemanticsNode2 node2;
  node2.id = 2;
  node2.flags = static_cast<FlutterSemanticsFlag>(0);
  node2.actions = static_cast<FlutterSemanticsAction>(0);
  node2.text_selection_base = -1;
  node2.text_selection_extent = -1;
  node2.label = "node2";
  node2.hint = "";
  node2.value = "";
  node2.increased_value = "";
  node2.decreased_value = "";
  node2.tooltip = "";
  node2.child_count = 0;
  node2.custom_accessibility_actions_count = 0;
 
  bridge->AddFlutterSemanticsNodeUpdate(node1);
  bridge->AddFlutterSemanticsNodeUpdate(node2);
  bridge->CommitUpdates();
 
  // Look up the root node delegate.
  auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
  ASSERT_TRUE(root_delegate);
  ASSERT_EQ(root_delegate->GetChildCount(), 1);
 
  // Look up the child node delegate.
  auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
  ASSERT_TRUE(child_delegate);
  ASSERT_EQ(child_delegate->GetChildCount(), 0);
 
  // Ensure a node with ID 0 does not exist.
  auto invalid_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
  ASSERT_FALSE(invalid_delegate);
 
  [engine shutDownEngine];
}

◆ TEST_F() [4/925]

flutter::testing::TEST_F	(	AccessibilityBridgeMacWindowTest	,
		SendsAccessibilityCreateNotificationFlutterViewWindow
	)

Definition at line 90 of file AccessibilityBridgeMacTest.mm.

                                                                                                {
  FlutterViewController* viewController = CreateTestViewController();
  FlutterEngine* engine = viewController.engine;
  NSWindow* expectedTarget = GetWindow();
  expectedTarget.contentView = viewController.view;
 
  // Setting up bridge so that the AccessibilityBridgeMacDelegateSpy
  // can query semantics information from.
  engine.semanticsEnabled = YES;
  auto bridge = std::static_pointer_cast<AccessibilityBridgeMacSpy>(
      viewController.accessibilityBridge.lock());
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 0;
  root.custom_accessibility_actions_count = 0;
  bridge->AddFlutterSemanticsNodeUpdate(root);
 
  bridge->CommitUpdates();
  auto platform_node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
 
  // Creates a targeted event.
  ui::AXTree tree;
  ui::AXNode ax_node(&tree, nullptr, 0, 0);
  ui::AXNodeData node_data;
  node_data.id = 0;
  ax_node.SetData(node_data);
  std::vector<ui::AXEventIntent> intent;
  ui::AXEventGenerator::EventParams event_params(ui::AXEventGenerator::Event::CHILDREN_CHANGED,
                                                 ax::mojom::EventFrom::kNone, intent);
  ui::AXEventGenerator::TargetedEvent targeted_event(&ax_node, event_params);
 
  bridge->OnAccessibilityEvent(targeted_event);
 
  ASSERT_EQ(bridge->actual_notifications.size(), 1u);
  auto target = bridge->actual_notifications.find([NSAccessibilityCreatedNotification UTF8String]);
  ASSERT_NE(target, bridge->actual_notifications.end());
  EXPECT_EQ(target->second, expectedTarget);
  [engine shutDownEngine];
}

◆ TEST_F() [5/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		EmptyFilter
	)

Definition at line 53 of file backdrop_filter_layer_unittests.cc.

                                             {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer =
      std::make_shared<BackdropFilterLayer>(nullptr, DlBlendMode::kSrcOver);
  layer->Add(mock_layer);
  auto parent = std::make_shared<ClipRectLayer>(child_bounds, Clip::kHardEdge);
  parent->Add(layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  parent->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
  parent->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipRect)parent::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
                                false);
      /* (BackdropFilter)layer::Paint */ {
        expected_builder.Save();
        {
          expected_builder.SaveLayer(&child_bounds, nullptr, nullptr);
          {
            /* mock_layer::Paint */ {
              expected_builder.DrawPath(child_path, child_paint);
            }
          }
          expected_builder.Restore();
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [6/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		MultipleChildren
	)

Definition at line 198 of file backdrop_filter_layer_unittests.cc.

                                                  {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 2.5f, 3.5f);
  const SkPath child_path1 = SkPath().addRect(child_bounds);
  const SkPath child_path2 =
      SkPath().addRect(child_bounds.makeOffset(3.0f, 0.0f));
  const DlPaint child_paint1 = DlPaint(DlColor::kYellow());
  const DlPaint child_paint2 = DlPaint(DlColor::kCyan());
  SkRect children_bounds = child_path1.getBounds();
  children_bounds.join(child_path2.getBounds());
  auto layer_filter =
      std::make_shared<DlBlurImageFilter>(2.5, 3.2, DlTileMode::kClamp);
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer = std::make_shared<BackdropFilterLayer>(layer_filter,
                                                     DlBlendMode::kSrcOver);
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
  auto parent =
      std::make_shared<ClipRectLayer>(children_bounds, Clip::kHardEdge);
  parent->Add(layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  parent->Preroll(preroll_context());
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer->paint_bounds(), children_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), children_bounds);
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
 
  parent->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipRect)parent::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(children_bounds, DlCanvas::ClipOp::kIntersect,
                                false);
      /* (BackdropFilter)layer::Paint */ {
        expected_builder.Save();
        {
          expected_builder.SaveLayer(&children_bounds, nullptr,
                                     layer_filter.get());
          {
            /* mock_layer1::Paint */ {
              expected_builder.DrawPath(child_path1, child_paint1);
            }
            /* mock_layer2::Paint */ {
              expected_builder.DrawPath(child_path2, child_paint2);
            }
          }
          expected_builder.Restore();
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [7/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		Nested
	)

Definition at line 262 of file backdrop_filter_layer_unittests.cc.

                                        {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 2.5f, 3.5f);
  const SkPath child_path1 = SkPath().addRect(child_bounds);
  const SkPath child_path2 =
      SkPath().addRect(child_bounds.makeOffset(3.0f, 0.0f));
  const DlPaint child_paint1 = DlPaint(DlColor::kYellow());
  const DlPaint child_paint2 = DlPaint(DlColor::kCyan());
  SkRect children_bounds = child_path1.getBounds();
  children_bounds.join(child_path2.getBounds());
  auto layer_filter1 =
      std::make_shared<DlBlurImageFilter>(2.5, 3.2, DlTileMode::kClamp);
  auto layer_filter2 =
      std::make_shared<DlBlurImageFilter>(2.7, 3.1, DlTileMode::kDecal);
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer1 = std::make_shared<BackdropFilterLayer>(layer_filter1,
                                                      DlBlendMode::kSrcOver);
  auto layer2 = std::make_shared<BackdropFilterLayer>(layer_filter2,
                                                      DlBlendMode::kSrcOver);
  layer2->Add(mock_layer2);
  layer1->Add(mock_layer1);
  layer1->Add(layer2);
  auto parent =
      std::make_shared<ClipRectLayer>(children_bounds, Clip::kHardEdge);
  parent->Add(layer1);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  parent->Preroll(preroll_context());
 
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer1->paint_bounds(), children_bounds);
  EXPECT_EQ(layer2->paint_bounds(), children_bounds);
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer1->needs_painting(paint_context()));
  EXPECT_TRUE(layer2->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
 
  parent->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipRect)parent::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(children_bounds, DlCanvas::ClipOp::kIntersect,
                                false);
      /* (BackdropFilter)layer1::Paint */ {
        expected_builder.Save();
        {
          expected_builder.SaveLayer(&children_bounds, nullptr,
                                     layer_filter1.get());
          {
            /* mock_layer1::Paint */ {
              expected_builder.DrawPath(child_path1, child_paint1);
            }
            /* (BackdropFilter)layer2::Paint */ {
              expected_builder.Save();
              {
                expected_builder.SaveLayer(&children_bounds, nullptr,
                                           layer_filter2.get());
                {
                  /* mock_layer2::Paint */ {
                    expected_builder.DrawPath(child_path2, child_paint2);
                  }
                }
                expected_builder.Restore();
              }
              expected_builder.Restore();
            }
          }
          expected_builder.Restore();
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [8/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		NonSrcOverBlend
	)

Definition at line 146 of file backdrop_filter_layer_unittests.cc.

                                                 {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto layer_filter =
      std::make_shared<DlBlurImageFilter>(2.5, 3.2, DlTileMode::kClamp);
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer =
      std::make_shared<BackdropFilterLayer>(layer_filter, DlBlendMode::kSrc);
  layer->Add(mock_layer);
  auto parent = std::make_shared<ClipRectLayer>(child_bounds, Clip::kHardEdge);
  parent->Add(layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  parent->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
  DlPaint filter_paint = DlPaint();
  filter_paint.setBlendMode(DlBlendMode::kSrc);
 
  parent->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipRect)parent::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
                                false);
      /* (BackdropFilter)layer::Paint */ {
        expected_builder.Save();
        {
          DlPaint save_paint = DlPaint().setBlendMode(DlBlendMode::kSrc);
          expected_builder.SaveLayer(&child_bounds, &save_paint,
                                     layer_filter.get());
          {
            /* mock_layer::Paint */ {
              expected_builder.DrawPath(child_path, child_paint);
            }
          }
          expected_builder.Restore();
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [9/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		OpacityInheritance
	)

Definition at line 378 of file backdrop_filter_layer_unittests.cc.

                                                    {
  auto backdrop_filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
  const SkPath mock_path = SkPath().addRect(SkRect::MakeLTRB(0, 0, 10, 10));
  const DlPaint mock_paint = DlPaint(DlColor::kRed());
  const SkRect clip_rect = SkRect::MakeLTRB(0, 0, 100, 100);
 
  auto clip = std::make_shared<ClipRectLayer>(clip_rect, Clip::kHardEdge);
  auto parent = std::make_shared<OpacityLayer>(128, SkPoint::Make(0, 0));
  auto layer = std::make_shared<BackdropFilterLayer>(backdrop_filter.shared(),
                                                     DlBlendMode::kSrcOver);
  auto child = std::make_shared<MockLayer>(mock_path, mock_paint);
  layer->Add(child);
  parent->Add(layer);
  clip->Add(parent);
 
  clip->Preroll(preroll_context());
 
  clip->Paint(display_list_paint_context());
 
  DisplayListBuilder expected_builder;
  /* ClipRectLayer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(clip_rect, DlCanvas::ClipOp::kIntersect, false);
      /* OpacityLayer::Paint */ {
        // NOP - it hands opacity down to BackdropFilterLayer
        /* BackdropFilterLayer::Paint */ {
          DlPaint save_paint;
          save_paint.setAlpha(128);
          expected_builder.SaveLayer(&clip_rect, &save_paint, &backdrop_filter);
          {
            /* MockLayer::Paint */ {
              DlPaint child_paint;
              child_paint.setColor(DlColor::kRed());
              expected_builder.DrawPath(mock_path, child_paint);
            }
          }
          expected_builder.Restore();
        }
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [10/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		PaintBeforePrerollDies
	)

Definition at line 37 of file backdrop_filter_layer_unittests.cc.

                                                        {
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  auto filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
  auto layer = std::make_shared<BackdropFilterLayer>(filter.shared(),
                                                     DlBlendMode::kSrcOver);
  layer->Add(mock_layer);
 
  EXPECT_EQ(layer->paint_bounds(), kEmptyRect);
  EXPECT_EQ(layer->child_paint_bounds(), kEmptyRect);
  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
                            "needs_painting\\(context\\)");
}

◆ TEST_F() [11/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		PaintingEmptyLayerDies
	)

Definition at line 21 of file backdrop_filter_layer_unittests.cc.

                                                        {
  auto filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
  auto layer = std::make_shared<BackdropFilterLayer>(filter.shared(),
                                                     DlBlendMode::kSrcOver);
  auto parent = std::make_shared<ClipRectLayer>(kEmptyRect, Clip::kHardEdge);
  parent->Add(layer);
 
  parent->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), kEmptyRect);
  EXPECT_EQ(layer->child_paint_bounds(), kEmptyRect);
  EXPECT_FALSE(layer->needs_painting(paint_context()));
 
  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
                            "needs_painting\\(context\\)");
}

◆ TEST_F() [12/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		Readback
	)

Definition at line 344 of file backdrop_filter_layer_unittests.cc.

                                          {
  std::shared_ptr<DlImageFilter> no_filter;
  auto layer_filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
  auto initial_transform = SkMatrix();
 
  // BDF with filter always reads from surface
  auto layer1 = std::make_shared<BackdropFilterLayer>(layer_filter.shared(),
                                                      DlBlendMode::kSrcOver);
  preroll_context()->surface_needs_readback = false;
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer1->Preroll(preroll_context());
  EXPECT_TRUE(preroll_context()->surface_needs_readback);
 
  // BDF with no filter does not read from surface itself
  auto layer2 =
      std::make_shared<BackdropFilterLayer>(no_filter, DlBlendMode::kSrcOver);
  preroll_context()->surface_needs_readback = false;
  layer2->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->surface_needs_readback);
 
  // BDF with no filter does not block prior readback value
  preroll_context()->surface_needs_readback = true;
  layer2->Preroll(preroll_context());
  EXPECT_TRUE(preroll_context()->surface_needs_readback);
 
  // BDF with no filter blocks child with readback
  auto mock_layer = std::make_shared<MockLayer>(SkPath(), DlPaint());
  mock_layer->set_fake_reads_surface(true);
  layer2->Add(mock_layer);
  preroll_context()->surface_needs_readback = false;
  layer2->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->surface_needs_readback);
}

◆ TEST_F() [13/925]

flutter::testing::TEST_F	(	BackdropFilterLayerTest	,
		SimpleFilter
	)

Definition at line 98 of file backdrop_filter_layer_unittests.cc.

                                              {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto layer_filter =
      std::make_shared<DlBlurImageFilter>(2.5, 3.2, DlTileMode::kClamp);
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<BackdropFilterLayer>(layer_filter,
                                                     DlBlendMode::kSrcOver);
  layer->Add(mock_layer);
  auto parent = std::make_shared<ClipRectLayer>(child_bounds, Clip::kHardEdge);
  parent->Add(layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  parent->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
  parent->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipRect)parent::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipRect(child_bounds, DlCanvas::ClipOp::kIntersect,
                                false);
      /* (BackdropFilter)layer::Paint */ {
        expected_builder.Save();
        {
          expected_builder.SaveLayer(&child_bounds, nullptr,
                                     layer_filter.get());
          {
            /* mock_layer::Paint */ {
              expected_builder.DrawPath(child_path, child_paint);
            }
          }
          expected_builder.Restore();
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [14/925]

flutter::testing::TEST_F	(	BackdropLayerDiffTest	,
		BackdropLayer
	)

Definition at line 426 of file backdrop_filter_layer_unittests.cc.

                                             {
  auto filter = DlBlurImageFilter(10, 10, DlTileMode::kClamp);
 
  {
    // tests later assume 30px readback area, fail early if that's not the case
    SkIRect readback;
    EXPECT_EQ(filter.get_input_device_bounds(SkIRect::MakeWH(10, 10),
                                             SkMatrix::I(), readback),
              &readback);
    EXPECT_EQ(readback, SkIRect::MakeLTRB(-30, -30, 40, 40));
  }
 
  MockLayerTree l1(SkISize::Make(100, 100));
  l1.root()->Add(std::make_shared<BackdropFilterLayer>(filter.shared(),
                                                       DlBlendMode::kSrcOver));
 
  // no clip, effect over entire surface
  auto damage = DiffLayerTree(l1, MockLayerTree(SkISize::Make(100, 100)));
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeWH(100, 100));
 
  MockLayerTree l2(SkISize::Make(100, 100));
 
  auto clip = std::make_shared<ClipRectLayer>(SkRect::MakeLTRB(20, 20, 60, 60),
                                              Clip::kHardEdge);
  clip->Add(std::make_shared<BackdropFilterLayer>(filter.shared(),
                                                  DlBlendMode::kSrcOver));
  l2.root()->Add(clip);
  damage = DiffLayerTree(l2, MockLayerTree(SkISize::Make(100, 100)));
 
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 90, 90));
 
  MockLayerTree l3;
  auto scale = std::make_shared<TransformLayer>(SkMatrix::Scale(2.0, 2.0));
  scale->Add(clip);
  l3.root()->Add(scale);
 
  damage = DiffLayerTree(l3, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 180, 180));
 
  MockLayerTree l4;
  l4.root()->Add(scale);
 
  // path just outside of readback region, doesn't affect blur
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(180, 180, 190, 190));
  l4.root()->Add(std::make_shared<MockLayer>(path1));
  damage = DiffLayerTree(l4, l3);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(180, 180, 190, 190));
 
  MockLayerTree l5;
  l5.root()->Add(scale);
 
  // path just inside of readback region, must trigger backdrop repaint
  auto path2 = SkPath().addRect(SkRect::MakeLTRB(179, 179, 189, 189));
  l5.root()->Add(std::make_shared<MockLayer>(path2));
  damage = DiffLayerTree(l5, l4);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 190, 190));
}

◆ TEST_F() [15/925]

flutter::testing::TEST_F	(	BackdropLayerDiffTest	,
		BackdropLayerInvalidTransform
	)

Definition at line 509 of file backdrop_filter_layer_unittests.cc.

                                                             {
  auto filter = DlBlurImageFilter(10, 10, DlTileMode::kClamp);
 
  {
    // tests later assume 30px readback area, fail early if that's not the case
    SkIRect readback;
    EXPECT_EQ(filter.get_input_device_bounds(SkIRect::MakeWH(10, 10),
                                             SkMatrix::I(), readback),
              &readback);
    EXPECT_EQ(readback, SkIRect::MakeLTRB(-30, -30, 40, 40));
  }
 
  MockLayerTree l1(SkISize::Make(100, 100));
  SkMatrix transform;
  transform.setPerspX(0.1);
  transform.setPerspY(0.1);
 
  auto transform_layer = std::make_shared<TransformLayer>(transform);
  l1.root()->Add(transform_layer);
  transform_layer->Add(std::make_shared<BackdropFilterLayer>(
      filter.shared(), DlBlendMode::kSrcOver));
 
  auto damage = DiffLayerTree(l1, MockLayerTree(SkISize::Make(100, 100)));
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeWH(100, 100));
}

◆ TEST_F() [16/925]

flutter::testing::TEST_F	(	BackdropLayerDiffTest	,
		ReadbackOutsideOfPaintArea
	)

Definition at line 484 of file backdrop_filter_layer_unittests.cc.

                                                          {
  auto filter = DlMatrixImageFilter(SkMatrix::Translate(50, 50),
                                    DlImageSampling::kLinear);
 
  MockLayerTree l1(SkISize::Make(100, 100));
 
  auto clip = std::make_shared<ClipRectLayer>(SkRect::MakeLTRB(60, 60, 80, 80),
                                              Clip::kHardEdge);
  clip->Add(std::make_shared<BackdropFilterLayer>(filter.shared(),
                                                  DlBlendMode::kSrcOver));
  l1.root()->Add(clip);
  auto damage = DiffLayerTree(l1, MockLayerTree(SkISize::Make(100, 100)));
 
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(60 - 50, 60 - 50, 80, 80));
 
  MockLayerTree l2(SkISize::Make(100, 100));
  // path inside readback area must trigger whole readback repaint + filter
  // repaint.
  auto path2 = SkPath().addRect(SkRect::MakeXYWH(60 - 50, 60 - 50, 10, 10));
  l2.root()->Add(clip);
  l2.root()->Add(std::make_shared<MockLayer>(path2));
  damage = DiffLayerTree(l2, l1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(60 - 50, 60 - 50, 80, 80));
}

◆ TEST_F() [17/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		ChildOutsideBounds
	)

Definition at line 100 of file clip_path_layer_unittests.cc.

                                              {
  const SkMatrix initial_matrix = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect local_cull_bounds = SkRect::MakeXYWH(0.0, 0.0, 2.0, 4.0);
  const SkRect device_cull_bounds = initial_matrix.mapRect(local_cull_bounds);
  const SkRect child_bounds = SkRect::MakeXYWH(2.5, 5.0, 4.5, 4.0);
  const SkRect clip_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const SkPath clip_path = SkPath().addRect(clip_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ClipPathLayer>(clip_path, Clip::kHardEdge);
  layer->Add(mock_layer);
 
  SkRect clip_cull_rect = local_cull_bounds;
  ASSERT_TRUE(clip_cull_rect.intersect(clip_bounds));
  SkRect clip_layer_bounds = child_bounds;
  ASSERT_TRUE(clip_layer_bounds.intersect(clip_bounds));
 
  // Set up both contexts to cull clipped child
  preroll_context()->state_stack.set_preroll_delegate(device_cull_bounds,
                                                      initial_matrix);
  paint_context().canvas->ClipRect(device_cull_bounds);
  paint_context().canvas->Transform(initial_matrix);
 
  layer->Preroll(preroll_context());
  // Untouched
  EXPECT_EQ(preroll_context()->state_stack.device_cull_rect(),
            device_cull_bounds);
  EXPECT_EQ(preroll_context()->state_stack.local_cull_rect(),
            local_cull_bounds);
  EXPECT_TRUE(preroll_context()->state_stack.is_empty());
 
  EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->paint_bounds(), clip_layer_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_EQ(mock_layer->parent_cull_rect(), clip_cull_rect);
  EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
  EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(clip_path)}));
 
  EXPECT_FALSE(layer->needs_painting(paint_context()));
  EXPECT_FALSE(mock_layer->needs_painting(paint_context()));
  // Top level layer not visible so calling layer->Paint()
  // would trip an FML_DCHECK
}

◆ TEST_F() [18/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		ClipNoneBehaviorDies
	)

Definition at line 27 of file clip_path_layer_unittests.cc.

                                                {
  EXPECT_DEATH_IF_SUPPORTED(
      auto clip = std::make_shared<ClipPathLayer>(SkPath(), Clip::kNone),
      "clip_behavior != Clip::kNone");
}

◆ TEST_F() [19/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		EmptyClipDoesNotCullPlatformView
	)

Definition at line 547 of file clip_path_layer_unittests.cc.

                                                            {
  const SkPoint view_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize view_size = SkSize::Make(8.0f, 8.0f);
  const int64_t view_id = 42;
  auto platform_view =
      std::make_shared<PlatformViewLayer>(view_offset, view_size, view_id);
 
  auto layer_clip = SkPath().addRect(kEmptyRect);
  auto clip = std::make_shared<ClipPathLayer>(layer_clip,
                                              Clip::kAntiAliasWithSaveLayer);
  clip->Add(platform_view);
 
  auto embedder = MockViewEmbedder();
  DisplayListBuilder fake_overlay_builder;
  embedder.AddCanvas(&fake_overlay_builder);
  preroll_context()->view_embedder = &embedder;
  paint_context().view_embedder = &embedder;
 
  clip->Preroll(preroll_context());
  EXPECT_EQ(embedder.prerolled_views(), std::vector<int64_t>({view_id}));
 
  clip->Paint(paint_context());
  EXPECT_EQ(embedder.painted_views(), std::vector<int64_t>({view_id}));
}

◆ TEST_F() [20/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		FullyContainedChild
	)

Definition at line 145 of file clip_path_layer_unittests.cc.

                                               {
  const SkMatrix initial_matrix = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeXYWH(1.0, 2.0, 2.0, 2.0);
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkPath child_path =
      SkPath().addRect(child_bounds).addOval(child_bounds.makeInset(0.1, 0.1));
  const SkPath layer_path =
      SkPath().addRect(layer_bounds).addOval(layer_bounds.makeInset(0.1, 0.1));
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ClipPathLayer>(layer_path, Clip::kHardEdge);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_matrix);
  layer->Preroll(preroll_context());
 
  // Untouched
  EXPECT_EQ(preroll_context()->state_stack.device_cull_rect(), kGiantRect);
  EXPECT_TRUE(preroll_context()->state_stack.is_empty());
 
  EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->paint_bounds(), mock_layer->paint_bounds());
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_cull_rect(), layer_bounds);
  EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
  EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(layer_path)}));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipPath)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipPath(layer_path);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, child_paint);
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [21/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		LayerCached
	)

Definition at line 504 of file clip_path_layer_unittests.cc.

                                       {
  auto path1 = SkPath().addRect({10, 10, 30, 30});
  auto mock1 = MockLayer::MakeOpacityCompatible(path1);
  auto layer_clip = SkPath()
                        .addRect(SkRect::MakeLTRB(5, 5, 25, 25))
                        .addOval(SkRect::MakeLTRB(20, 20, 40, 50));
  auto layer = std::make_shared<ClipPathLayer>(layer_clip,
                                               Clip::kAntiAliasWithSaveLayer);
  layer->Add(mock1);
 
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  SkMatrix cache_ctm = initial_transform;
  DisplayListBuilder cache_canvas;
  cache_canvas.Transform(cache_ctm);
 
  use_mock_raster_cache();
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
 
  const auto* clip_cache_item = layer->raster_cache_item();
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
  EXPECT_EQ(clip_cache_item->cache_state(),
            RasterCacheItem::CacheState::kCurrent);
  DlPaint paint;
  EXPECT_TRUE(raster_cache()->Draw(clip_cache_item->GetId().value(),
                                   cache_canvas, &paint));
}

◆ TEST_F() [22/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		OpacityInheritancePainting
	)

Definition at line 399 of file clip_path_layer_unittests.cc.

                                                      {
  auto path1 = SkPath().addRect({10, 10, 30, 30});
  auto mock1 = MockLayer::MakeOpacityCompatible(path1);
  auto path2 = SkPath().addRect({40, 40, 50, 50});
  auto mock2 = MockLayer::MakeOpacityCompatible(path2);
  auto layer_clip = SkPath()
                        .addRect(SkRect::MakeLTRB(5, 5, 25, 25))
                        .addOval(SkRect::MakeLTRB(45, 45, 55, 55));
  auto clip_path_layer =
      std::make_shared<ClipPathLayer>(layer_clip, Clip::kAntiAlias);
  clip_path_layer->Add(mock1);
  clip_path_layer->Add(mock2);
 
  // ClipRectLayer will pass through compatibility from multiple
  // non-overlapping compatible children
  PrerollContext* context = preroll_context();
  clip_path_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
 
  int opacity_alpha = 0x7F;
  SkPoint offset = SkPoint::Make(10, 10);
  auto opacity_layer = std::make_shared<OpacityLayer>(opacity_alpha, offset);
  opacity_layer->Add(clip_path_layer);
  opacity_layer->Preroll(context);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 
  DisplayListBuilder expected_builder;
  /* OpacityLayer::Paint() */ {
    expected_builder.Save();
    {
      expected_builder.Translate(offset.fX, offset.fY);
      /* ClipRectLayer::Paint() */ {
        expected_builder.Save();
        expected_builder.ClipPath(layer_clip, ClipOp::kIntersect, true);
        /* child layer1 paint */ {
          expected_builder.DrawPath(path1, DlPaint().setAlpha(opacity_alpha));
        }
        /* child layer2 paint */ {
          expected_builder.DrawPath(path2, DlPaint().setAlpha(opacity_alpha));
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
 
  opacity_layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [23/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		OpacityInheritanceSaveLayerPainting
	)

Definition at line 450 of file clip_path_layer_unittests.cc.

                                                               {
  auto path1 = SkPath().addRect({10, 10, 30, 30});
  auto mock1 = MockLayer::MakeOpacityCompatible(path1);
  auto path2 = SkPath().addRect({20, 20, 40, 40});
  auto mock2 = MockLayer::MakeOpacityCompatible(path2);
  auto children_bounds = path1.getBounds();
  children_bounds.join(path2.getBounds());
  auto layer_clip = SkPath()
                        .addRect(SkRect::MakeLTRB(5, 5, 25, 25))
                        .addOval(SkRect::MakeLTRB(20, 20, 40, 50));
  auto clip_path_layer = std::make_shared<ClipPathLayer>(
      layer_clip, Clip::kAntiAliasWithSaveLayer);
  clip_path_layer->Add(mock1);
  clip_path_layer->Add(mock2);
 
  // ClipRectLayer will pass through compatibility from multiple
  // non-overlapping compatible children
  PrerollContext* context = preroll_context();
  clip_path_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags, Layer::kSaveLayerRenderFlags);
 
  int opacity_alpha = 0x7F;
  SkPoint offset = SkPoint::Make(10, 10);
  auto opacity_layer = std::make_shared<OpacityLayer>(opacity_alpha, offset);
  opacity_layer->Add(clip_path_layer);
  opacity_layer->Preroll(context);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 
  DisplayListBuilder expected_builder;
  /* OpacityLayer::Paint() */ {
    expected_builder.Save();
    {
      expected_builder.Translate(offset.fX, offset.fY);
      /* ClipRectLayer::Paint() */ {
        expected_builder.Save();
        expected_builder.ClipPath(layer_clip, ClipOp::kIntersect, true);
        expected_builder.SaveLayer(&children_bounds,
                                   &DlPaint().setAlpha(opacity_alpha));
        /* child layer1 paint */ {
          expected_builder.DrawPath(path1, DlPaint());
        }
        /* child layer2 paint */ {  //
          expected_builder.DrawPath(path2, DlPaint());
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
 
  opacity_layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(expected_builder.Build(), display_list()));
}

◆ TEST_F() [24/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		PaintingCulledLayerDies
	)

Definition at line 62 of file clip_path_layer_unittests.cc.

                                                   {
  const SkMatrix initial_matrix = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeXYWH(1.0, 2.0, 2.0, 2.0);
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkRect distant_bounds = SkRect::MakeXYWH(100.0, 100.0, 10.0, 10.0);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const SkPath layer_path = SkPath().addRect(layer_bounds);
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  auto layer = std::make_shared<ClipPathLayer>(layer_path, Clip::kHardEdge);
  layer->Add(mock_layer);
 
  // Cull these children
  preroll_context()->state_stack.set_preroll_delegate(distant_bounds,
                                                      initial_matrix);
  layer->Preroll(preroll_context());
 
  // Untouched
  EXPECT_EQ(preroll_context()->state_stack.device_cull_rect(), distant_bounds);
  EXPECT_TRUE(preroll_context()->state_stack.is_empty());
 
  EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_cull_rect(), kEmptyRect);
  EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
  EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(layer_path)}));
 
  auto mutator = paint_context().state_stack.save();
  mutator.clipRect(distant_bounds, false);
  EXPECT_FALSE(mock_layer->needs_painting(paint_context()));
  EXPECT_FALSE(layer->needs_painting(paint_context()));
  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
                            "needs_painting\\(context\\)");
}

◆ TEST_F() [25/925]

flutter::testing::TEST_F	(	ClipPathLayerTest	,
		PartiallyContainedChild
	)

Definition at line 189 of file clip_path_layer_unittests.cc.

                                                   {
  const SkMatrix initial_matrix = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect local_cull_bounds = SkRect::MakeXYWH(0.0, 0.0, 4.0, 5.5);
  const SkRect device_cull_bounds = initial_matrix.mapRect(local_cull_bounds);
  const SkRect child_bounds = SkRect::MakeXYWH(2.5, 5.0, 4.5, 4.0);
  const SkRect clip_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkPath child_path =
      SkPath().addRect(child_bounds).addOval(child_bounds.makeInset(0.1, 0.1));
  const SkPath clip_path =
      SkPath().addRect(clip_bounds).addOval(clip_bounds.makeInset(0.1, 0.1));
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ClipPathLayer>(clip_path, Clip::kHardEdge);
  layer->Add(mock_layer);
 
  SkRect clip_cull_rect = local_cull_bounds;
  ASSERT_TRUE(clip_cull_rect.intersect(clip_bounds));
  SkRect clip_layer_bounds = child_bounds;
  ASSERT_TRUE(clip_layer_bounds.intersect(clip_bounds));
 
  // Cull child
  preroll_context()->state_stack.set_preroll_delegate(device_cull_bounds,
                                                      initial_matrix);
  layer->Preroll(preroll_context());
 
  // Untouched
  EXPECT_EQ(preroll_context()->state_stack.device_cull_rect(),
            device_cull_bounds);
  EXPECT_EQ(preroll_context()->state_stack.local_cull_rect(),
            local_cull_bounds);
  EXPECT_TRUE(preroll_context()->state_stack.is_empty());
 
  EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->paint_bounds(), clip_layer_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_cull_rect(), clip_cull_rect);
  EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
  EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(clip_path)}));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ClipPath)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.ClipPath(clip_path);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, child_paint);
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [26/925]

flutter::testing::TEST_F	(	ClipRRectLayerTest	,
		NoSaveLayerShouldNotCache
	)

Definition at line 538 of file clip_rrect_layer_unittests.cc.

                                                      {
  auto path1 = SkPath().addRect({10, 10, 30, 30});
 
  auto mock1 = MockLayer::MakeOpacityCompatible(path1);
  SkRect clip_rect = SkRect::MakeWH(500, 500);
  SkRRect clip_rrect = SkRRect::MakeRectXY(clip_rect, 20, 20);
  auto layer = std::make_shared<ClipRRectLayer>(clip_rrect, Clip::kAntiAlias);
  layer->Add(mock1);
 
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  SkMatrix cache_ctm = initial_transform;
  SkCanvas cache_canvas;
  cache_canvas.setMatrix(cache_ctm);
 
  use_mock_raster_cache();
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
 
  const auto* clip_cache_item = layer->raster_cache_item();
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
 
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
}

◆ TEST_F() [27/925]

flutter::testing::TEST_F	(	ColorFilterLayerTest	,
		CacheChild
	)

Definition at line 257 of file color_filter_layer_unittests.cc.

                                         {
  auto layer_filter = DlSrgbToLinearGammaColorFilter::kInstance;
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  auto other_transform = SkMatrix::Scale(1.0, 2.0);
  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  DlPaint paint = DlPaint();
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  auto layer = std::make_shared<ColorFilterLayer>(layer_filter);
  layer->Add(mock_layer);
 
  SkMatrix cache_ctm = initial_transform;
  DisplayListBuilder cache_canvas;
  cache_canvas.Transform(cache_ctm);
  DisplayListBuilder other_canvas;
  other_canvas.Transform(other_transform);
 
  use_mock_raster_cache();
  const auto* cacheable_color_filter_item = layer->raster_cache_item();
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kNone);
  EXPECT_FALSE(cacheable_color_filter_item->GetId().has_value());
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kChildren);
  EXPECT_EQ(
      cacheable_color_filter_item->GetId().value(),
      RasterCacheKeyID(RasterCacheKeyID::LayerChildrenIds(layer.get()).value(),
                       RasterCacheKeyType::kLayerChildren));
  EXPECT_FALSE(raster_cache()->Draw(
      cacheable_color_filter_item->GetId().value(), other_canvas, &paint));
  EXPECT_TRUE(raster_cache()->Draw(cacheable_color_filter_item->GetId().value(),
                                   cache_canvas, &paint));
}

◆ TEST_F() [28/925]

flutter::testing::TEST_F	(	ColorFilterLayerTest	,
		CacheChildren
	)

Definition at line 298 of file color_filter_layer_unittests.cc.

                                            {
  auto layer_filter = DlSrgbToLinearGammaColorFilter::kInstance;
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  auto other_transform = SkMatrix::Scale(1.0, 2.0);
  const SkPath child_path1 = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  const SkPath child_path2 = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2);
  auto layer = std::make_shared<ColorFilterLayer>(layer_filter);
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
  DlPaint paint = DlPaint();
 
  SkMatrix cache_ctm = initial_transform;
  DisplayListBuilder cache_canvas;
  cache_canvas.Transform(cache_ctm);
  DisplayListBuilder other_canvas;
  other_canvas.Transform(other_transform);
 
  use_mock_raster_cache();
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  const auto* cacheable_color_filter_item = layer->raster_cache_item();
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
 
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kNone);
  EXPECT_FALSE(cacheable_color_filter_item->GetId().has_value());
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kChildren);
  EXPECT_EQ(
      cacheable_color_filter_item->GetId().value(),
      RasterCacheKeyID(RasterCacheKeyID::LayerChildrenIds(layer.get()).value(),
                       RasterCacheKeyType::kLayerChildren));
  EXPECT_FALSE(raster_cache()->Draw(
      cacheable_color_filter_item->GetId().value(), other_canvas, &paint));
  EXPECT_TRUE(raster_cache()->Draw(cacheable_color_filter_item->GetId().value(),
                                   cache_canvas, &paint));
}

◆ TEST_F() [29/925]

flutter::testing::TEST_F	(	ColorFilterLayerTest	,
		CacheColorFilterLayerSelf
	)

Definition at line 344 of file color_filter_layer_unittests.cc.

                                                        {
  auto layer_filter = DlSrgbToLinearGammaColorFilter::kInstance;
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  auto other_transform = SkMatrix::Scale(1.0, 2.0);
  const SkPath child_path1 = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  const SkPath child_path2 = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2);
  auto layer = std::make_shared<ColorFilterLayer>(layer_filter);
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
  DlPaint paint = DlPaint();
 
  SkMatrix cache_ctm = initial_transform;
  DisplayListBuilder cache_canvas;
  cache_canvas.Transform(cache_ctm);
  DisplayListBuilder other_canvas;
  other_canvas.Transform(other_transform);
 
  use_mock_raster_cache();
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  const auto* cacheable_color_filter_item = layer->raster_cache_item();
 
  // frame 1.
  layer->Preroll(preroll_context());
  layer->Paint(paint_context());
  // frame 2.
  layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  // ColorFilterLayer default cache children.
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kChildren);
  EXPECT_TRUE(raster_cache()->Draw(cacheable_color_filter_item->GetId().value(),
                                   cache_canvas, &paint));
  EXPECT_FALSE(raster_cache()->Draw(
      cacheable_color_filter_item->GetId().value(), other_canvas, &paint));
  layer->Paint(paint_context());
 
  // frame 3.
  layer->Preroll(preroll_context());
  layer->Paint(paint_context());
 
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  // frame1,2 cache the ColorFilterLayer's children layer, frame3 cache the
  // ColorFilterLayer
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)2);
 
  // ColorFilterLayer default cache itself.
  EXPECT_EQ(cacheable_color_filter_item->cache_state(),
            RasterCacheItem::CacheState::kCurrent);
  EXPECT_EQ(cacheable_color_filter_item->GetId(),
            RasterCacheKeyID(layer->unique_id(), RasterCacheKeyType::kLayer));
  EXPECT_TRUE(raster_cache()->Draw(cacheable_color_filter_item->GetId().value(),
                                   cache_canvas, &paint));
  EXPECT_FALSE(raster_cache()->Draw(
      cacheable_color_filter_item->GetId().value(), other_canvas, &paint));
}

◆ TEST_F() [30/925]

flutter::testing::TEST_F	(	CompositorOpenGLTest	,
		CreateBackingStore
	)

Definition at line 125 of file compositor_opengl_unittests.cc.

                                                 {
  UseHeadlessEngine();
 
  auto compositor = CompositorOpenGL{engine(), kMockResolver};
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
}

◆ TEST_F() [31/925]

flutter::testing::TEST_F	(	CompositorOpenGLTest	,
		InitializationFailure
	)

Definition at line 138 of file compositor_opengl_unittests.cc.

                                                    {
  UseHeadlessEngine();
 
  auto compositor = CompositorOpenGL{engine(), kMockResolver};
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(false));
  EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
}

◆ TEST_F() [32/925]

flutter::testing::TEST_F	(	CompositorOpenGLTest	,
		NoSurfaceIgnored
	)

Definition at line 188 of file compositor_opengl_unittests.cc.

                                               {
  UseEngineWithView(/*add_surface = */ false);
 
  auto compositor = CompositorOpenGL{engine(), kMockResolver};
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
 
  FlutterLayer layer = {};
  layer.type = kFlutterLayerContentTypeBackingStore;
  layer.backing_store = &backing_store;
  const FlutterLayer* layer_ptr = &layer;
 
  EXPECT_FALSE(compositor.Present(view(), &layer_ptr, 1));
 
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
}

◆ TEST_F() [33/925]

flutter::testing::TEST_F	(	CompositorOpenGLTest	,
		Present
	)

Definition at line 150 of file compositor_opengl_unittests.cc.

                                      {
  UseEngineWithView();
 
  auto compositor = CompositorOpenGL{engine(), kMockResolver};
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
 
  FlutterLayer layer = {};
  layer.type = kFlutterLayerContentTypeBackingStore;
  layer.backing_store = &backing_store;
  const FlutterLayer* layer_ptr = &layer;
 
  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
  EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
 
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
}

◆ TEST_F() [34/925]

flutter::testing::TEST_F	(	CompositorOpenGLTest	,
		PresentEmpty
	)

Definition at line 174 of file compositor_opengl_unittests.cc.

                                           {
  UseEngineWithView();
 
  auto compositor = CompositorOpenGL{engine(), kMockResolver};
 
  // The context will be bound twice: first to initialize the compositor, second
  // to clear the surface.
  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(true));
  EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(true));
  EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(true));
  EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
}

◆ TEST_F() [35/925]

flutter::testing::TEST_F	(	CompositorSoftwareTest	,
		CreateBackingStore
	)

Definition at line 70 of file compositor_software_unittests.cc.

                                                   {
  CompositorSoftware compositor;
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
}

◆ TEST_F() [36/925]

flutter::testing::TEST_F	(	CompositorSoftwareTest	,
		Present
	)

Definition at line 80 of file compositor_software_unittests.cc.

                                        {
  UseEngineWithView();
 
  CompositorSoftware compositor;
 
  FlutterBackingStoreConfig config = {};
  FlutterBackingStore backing_store = {};
 
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
 
  FlutterLayer layer = {};
  layer.type = kFlutterLayerContentTypeBackingStore;
  layer.backing_store = &backing_store;
  const FlutterLayer* layer_ptr = &layer;
 
  EXPECT_CALL(*view(), PresentSoftwareBitmap).WillOnce(Return(true));
  EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
 
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
}

◆ TEST_F() [37/925]

flutter::testing::TEST_F	(	CompositorSoftwareTest	,
		PresentEmpty
	)

Definition at line 101 of file compositor_software_unittests.cc.

                                             {
  UseEngineWithView();
 
  CompositorSoftware compositor;
 
  EXPECT_CALL(*view(), ClearSoftwareBitmap).WillOnce(Return(true));
  EXPECT_TRUE(compositor.Present(view(), nullptr, 0));
}

◆ TEST_F() [38/925]

flutter::testing::TEST_F	(	CompositorSoftwareTest	,
		PresentMultiLayers
	)

Definition at line 117 of file compositor_software_unittests.cc.

                                                   {
  UseEngineWithView();
 
  CompositorSoftware compositor;
 
  FlutterBackingStoreConfig config = {sizeof(config), {2, 2}};
  FlutterBackingStore backing_store0 = {sizeof(FlutterBackingStore), nullptr};
  FlutterBackingStore backing_store1 = {sizeof(FlutterBackingStore), nullptr};
 
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store0));
  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store1));
 
  uint32_t pixels0[4] = {0xff000000, 0xff0000ff, 0xff00ff00, 0xffffffff};
  uint32_t pixels1[4] = {0x7f0000ff, 0x00ffffff, 0x7fff0000, 0xff000000};
 
  std::memcpy(const_cast<void*>(backing_store0.software.allocation), pixels0,
              sizeof(uint32_t) * 4);
  std::memcpy(const_cast<void*>(backing_store1.software.allocation), pixels1,
              sizeof(uint32_t) * 4);
 
  FlutterLayer layer0 = {};
  layer0.type = kFlutterLayerContentTypeBackingStore;
  layer0.backing_store = &backing_store0;
  layer0.offset = {0, 0};
  layer0.size = {2, 2};
 
  FlutterLayer layer1 = layer0;
  layer1.backing_store = &backing_store1;
  const FlutterLayer* layer_ptr[2] = {&layer0, &layer1};
 
  EXPECT_CALL(*view(), PresentSoftwareBitmap)
      .WillOnce([&](const void* allocation, size_t row_bytes, size_t height) {
        auto pixel_data = static_cast<const uint32_t*>(allocation);
        EXPECT_EQ(row_bytes, 2 * sizeof(uint32_t));
        EXPECT_EQ(height, 2);
        EXPECT_EQ(pixel_data[0], 0xff00007f);
        EXPECT_EQ(pixel_data[1], 0xff0000ff);
        EXPECT_EQ(pixel_data[2], 0xff7f8000);
        EXPECT_EQ(pixel_data[3], 0xff000000);
        return true;
      });
  EXPECT_TRUE(compositor.Present(view(), layer_ptr, 2));
 
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store0));
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store1));
}

◆ TEST_F() [39/925]

flutter::testing::TEST_F	(	CompositorSoftwareTest	,
		PresentOffsetLayers
	)

Definition at line 167 of file compositor_software_unittests.cc.

                                                    {
  UseEngineWithView();
 
  CompositorSoftware compositor;
 
  FlutterBackingStoreConfig config0 = {sizeof(FlutterBackingStoreConfig),
                                       {1, 1}};
  FlutterBackingStore backing_store0 = {sizeof(FlutterBackingStore), nullptr};
  FlutterBackingStoreConfig config1 = {sizeof(FlutterBackingStoreConfig),
                                       {2, 1}};
  FlutterBackingStore backing_store1 = {sizeof(FlutterBackingStore), nullptr};
 
  ASSERT_TRUE(compositor.CreateBackingStore(config0, &backing_store0));
  ASSERT_TRUE(compositor.CreateBackingStore(config1, &backing_store1));
 
  uint32_t pixels0 = 0xff0000ff;
  uint32_t pixels1[2] = {0xffff0000, 0xffff0000};
 
  std::memcpy(const_cast<void*>(backing_store0.software.allocation), &pixels0,
              sizeof(uint32_t) * 1);
  std::memcpy(const_cast<void*>(backing_store1.software.allocation), pixels1,
              sizeof(uint32_t) * 2);
 
  FlutterLayer layer0 = {};
  layer0.type = kFlutterLayerContentTypeBackingStore;
  layer0.backing_store = &backing_store0;
  layer0.offset = {0, 0};
  layer0.size = {1, 1};
 
  FlutterLayer layer1 = layer0;
  layer1.backing_store = &backing_store1;
  layer1.offset = {0, 1};
  layer1.size = {2, 1};
  const FlutterLayer* layer_ptr[2] = {&layer0, &layer1};
 
  EXPECT_CALL(*view(), PresentSoftwareBitmap)
      .WillOnce([&](const void* allocation, size_t row_bytes, size_t height) {
        auto pixel_data = static_cast<const uint32_t*>(allocation);
        EXPECT_EQ(row_bytes, 2 * sizeof(uint32_t));
        EXPECT_EQ(height, 2);
        EXPECT_EQ(pixel_data[0], 0xff0000ff);
        EXPECT_EQ(pixel_data[1], 0xff000000);
        EXPECT_EQ(pixel_data[2], 0xffff0000);
        EXPECT_EQ(pixel_data[3], 0xffff0000);
        return true;
      });
  EXPECT_TRUE(compositor.Present(view(), layer_ptr, 2));
 
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store0));
  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store1));
}

◆ TEST_F() [40/925]

flutter::testing::TEST_F	(	ContainerLayerDiffTest	,
		LayerDeletion
	)

Definition at line 655 of file container_layer_unittests.cc.

                                              {
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(0, 0, 50, 50));
  auto path2 = SkPath().addRect(SkRect::MakeLTRB(100, 0, 150, 50));
  auto path3 = SkPath().addRect(SkRect::MakeLTRB(200, 0, 250, 50));
 
  auto c1 = CreateContainerLayer(std::make_shared<MockLayer>(path1));
  auto c2 = CreateContainerLayer(std::make_shared<MockLayer>(path2));
  auto c3 = CreateContainerLayer(std::make_shared<MockLayer>(path3));
 
  MockLayerTree t1;
  t1.root()->Add(c1);
  t1.root()->Add(c2);
  t1.root()->Add(c3);
 
  auto damage = DiffLayerTree(t1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 250, 50));
 
  MockLayerTree t2;
  t2.root()->Add(c2);
  t2.root()->Add(c3);
 
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 50, 50));
 
  MockLayerTree t3;
  t3.root()->Add(c1);
  t3.root()->Add(c3);
 
  damage = DiffLayerTree(t3, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(100, 0, 150, 50));
 
  MockLayerTree t4;
  t4.root()->Add(c1);
  t4.root()->Add(c2);
 
  damage = DiffLayerTree(t4, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
 
  MockLayerTree t5;
  t5.root()->Add(c1);
 
  damage = DiffLayerTree(t5, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(100, 0, 250, 50));
 
  MockLayerTree t6;
  t6.root()->Add(c2);
 
  damage = DiffLayerTree(t6, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 250, 50));
 
  MockLayerTree t7;
  t7.root()->Add(c3);
 
  damage = DiffLayerTree(t7, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 150, 50));
}

◆ TEST_F() [41/925]

flutter::testing::TEST_F	(	ContainerLayerDiffTest	,
		PictureInsertion
	)

Definition at line 618 of file container_layer_unittests.cc.

                                                 {
  auto pic1 = CreateDisplayList(SkRect::MakeLTRB(0, 0, 50, 50));
  auto pic2 = CreateDisplayList(SkRect::MakeLTRB(100, 0, 150, 50));
  auto pic3 = CreateDisplayList(SkRect::MakeLTRB(200, 0, 250, 50));
 
  MockLayerTree t1;
  t1.root()->Add(CreateDisplayListLayer(pic1));
  t1.root()->Add(CreateDisplayListLayer(pic2));
 
  auto damage = DiffLayerTree(t1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 150, 50));
 
  MockLayerTree t2;
  t2.root()->Add(CreateDisplayListLayer(pic3));
  t2.root()->Add(CreateDisplayListLayer(pic1));
  t2.root()->Add(CreateDisplayListLayer(pic2));
 
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
 
  MockLayerTree t3;
  t3.root()->Add(CreateDisplayListLayer(pic1));
  t3.root()->Add(CreateDisplayListLayer(pic3));
  t3.root()->Add(CreateDisplayListLayer(pic2));
 
  damage = DiffLayerTree(t3, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
 
  MockLayerTree t4;
  t4.root()->Add(CreateDisplayListLayer(pic1));
  t4.root()->Add(CreateDisplayListLayer(pic2));
  t4.root()->Add(CreateDisplayListLayer(pic3));
 
  damage = DiffLayerTree(t4, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
}

◆ TEST_F() [42/925]

flutter::testing::TEST_F	(	ContainerLayerDiffTest	,
		PictureLayerInsertion
	)

Definition at line 566 of file container_layer_unittests.cc.

                                                      {
  auto pic1 = CreateDisplayList(SkRect::MakeLTRB(0, 0, 50, 50));
  auto pic2 = CreateDisplayList(SkRect::MakeLTRB(100, 0, 150, 50));
  auto pic3 = CreateDisplayList(SkRect::MakeLTRB(200, 0, 250, 50));
 
  MockLayerTree t1;
 
  auto t1_c1 = CreateContainerLayer(CreateDisplayListLayer(pic1));
  t1.root()->Add(t1_c1);
 
  auto t1_c2 = CreateContainerLayer(CreateDisplayListLayer(pic2));
  t1.root()->Add(t1_c2);
 
  auto damage = DiffLayerTree(t1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 150, 50));
 
  // Add in the middle
 
  MockLayerTree t2;
  auto t2_c1 = CreateContainerLayer(CreateDisplayListLayer(pic1));
  t2_c1->AssignOldLayer(t1_c1.get());
  t2.root()->Add(t2_c1);
 
  t2.root()->Add(CreateDisplayListLayer(pic3));
 
  auto t2_c2 = CreateContainerLayer(CreateDisplayListLayer(pic2));
  t2_c2->AssignOldLayer(t1_c2.get());
  t2.root()->Add(t2_c2);
 
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
 
  // Add in the beginning
 
  t2 = MockLayerTree();
  t2.root()->Add(CreateDisplayListLayer(pic3));
  t2.root()->Add(t2_c1);
  t2.root()->Add(t2_c2);
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
 
  // Add at the end
 
  t2 = MockLayerTree();
  t2.root()->Add(t2_c1);
  t2.root()->Add(t2_c2);
  t2.root()->Add(CreateDisplayListLayer(pic3));
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 50));
}

◆ TEST_F() [43/925]

flutter::testing::TEST_F	(	ContainerLayerDiffTest	,
		ReplaceLayer
	)

Definition at line 712 of file container_layer_unittests.cc.

                                             {
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(0, 0, 50, 50));
  auto path2 = SkPath().addRect(SkRect::MakeLTRB(100, 0, 150, 50));
  auto path3 = SkPath().addRect(SkRect::MakeLTRB(200, 0, 250, 50));
 
  auto path1a = SkPath().addRect(SkRect::MakeLTRB(0, 100, 50, 150));
  auto path2a = SkPath().addRect(SkRect::MakeLTRB(100, 100, 150, 150));
  auto path3a = SkPath().addRect(SkRect::MakeLTRB(200, 100, 250, 150));
 
  auto c1 = CreateContainerLayer(std::make_shared<MockLayer>(path1));
  auto c2 = CreateContainerLayer(std::make_shared<MockLayer>(path2));
  auto c3 = CreateContainerLayer(std::make_shared<MockLayer>(path3));
 
  MockLayerTree t1;
  t1.root()->Add(c1);
  t1.root()->Add(c2);
  t1.root()->Add(c3);
 
  auto damage = DiffLayerTree(t1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 250, 50));
 
  MockLayerTree t2;
  t2.root()->Add(c1);
  t2.root()->Add(c2);
  t2.root()->Add(c3);
 
  damage = DiffLayerTree(t2, t1);
  EXPECT_TRUE(damage.frame_damage.isEmpty());
 
  MockLayerTree t3;
  t3.root()->Add(CreateContainerLayer({std::make_shared<MockLayer>(path1a)}));
  t3.root()->Add(c2);
  t3.root()->Add(c3);
 
  damage = DiffLayerTree(t3, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 50, 150));
 
  MockLayerTree t4;
  t4.root()->Add(c1);
  t4.root()->Add(CreateContainerLayer(std::make_shared<MockLayer>(path2a)));
  t4.root()->Add(c3);
 
  damage = DiffLayerTree(t4, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(100, 0, 150, 150));
 
  MockLayerTree t5;
  t5.root()->Add(c1);
  t5.root()->Add(c2);
  t5.root()->Add(CreateContainerLayer(std::make_shared<MockLayer>(path3a)));
 
  damage = DiffLayerTree(t5, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 0, 250, 150));
}

◆ TEST_F() [44/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		CollectionCacheableLayer
	)

Definition at line 528 of file container_layer_unittests.cc.

                                                     {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  DlPaint child_paint = DlPaint(DlColor::kGreen());
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
 
  auto mock_layer1 = std::make_shared<MockLayer>(SkPath(), child_paint);
  auto mock_cacheable_container_layer1 =
      std::make_shared<MockCacheableContainerLayer>();
  auto mock_container_layer = std::make_shared<ContainerLayer>();
  auto mock_cacheable_layer =
      std::make_shared<MockCacheableLayer>(child_path, child_paint);
  mock_cacheable_container_layer1->Add(mock_cacheable_layer);
 
  // ContainerLayer
  //   |- MockLayer
  //   |- MockCacheableContainerLayer
  //        |- MockCacheableLayer
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_cacheable_container_layer1);
  layer->Add(mock_layer1);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  // raster cache is null, so no entry
  ASSERT_EQ(preroll_context()->raster_cached_entries->size(),
            static_cast<const unsigned long>(0));
 
  use_mock_raster_cache();
  // preroll_context()->raster_cache = raster_cache();
  layer->Preroll(preroll_context());
  ASSERT_EQ(preroll_context()->raster_cached_entries->size(),
            static_cast<const unsigned long>(2));
}

◆ TEST_F() [45/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		LayerWithParentHasPlatformView
	)

Definition at line 25 of file container_layer_unittests.cc.

                                                           {
  auto layer = std::make_shared<ContainerLayer>();
 
  preroll_context()->has_platform_view = true;
  EXPECT_DEATH_IF_SUPPORTED(layer->Preroll(preroll_context()),
                            "!context->has_platform_view");
}

◆ TEST_F() [46/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		LayerWithParentHasTextureLayer
	)

Definition at line 33 of file container_layer_unittests.cc.

                                                           {
  auto layer = std::make_shared<ContainerLayer>();
 
  preroll_context()->has_texture_layer = true;
  EXPECT_DEATH_IF_SUPPORTED(layer->Preroll(preroll_context()),
                            "!context->has_texture_layer");
}

◆ TEST_F() [47/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		LayerWithParentHasTextureLayerNeedsResetFlag
	)

Definition at line 67 of file container_layer_unittests.cc.

                                                                         {
  SkPath child_path1;
  child_path1.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkPath child_path2;
  child_path2.addRect(8.0f, 2.0f, 16.5f, 14.5f);
  DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  DlPaint child_paint2 = DlPaint(DlColor::kGreen());
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  mock_layer1->set_fake_has_texture_layer(true);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
 
  auto root = std::make_shared<ContainerLayer>();
  auto container_layer1 = std::make_shared<ContainerLayer>();
  auto container_layer2 = std::make_shared<ContainerLayer>();
  root->Add(container_layer1);
  root->Add(container_layer2);
  container_layer1->Add(mock_layer1);
  container_layer2->Add(mock_layer2);
 
  EXPECT_EQ(preroll_context()->has_texture_layer, false);
  root->Preroll(preroll_context());
  EXPECT_EQ(preroll_context()->has_texture_layer, true);
  // The flag for holding texture layer from parent needs to be clear
  EXPECT_EQ(mock_layer2->parent_has_texture_layer(), false);
}

◆ TEST_F() [48/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		Multiple
	)

Definition at line 125 of file container_layer_unittests.cc.

                                     {
  SkPath child_path1;
  child_path1.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkPath child_path2;
  child_path2.addRect(8.0f, 2.0f, 16.5f, 14.5f);
  DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  mock_layer1->set_fake_has_platform_view(true);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  SkRect expected_total_bounds = child_path1.getBounds();
  expected_total_bounds.join(child_path2.getBounds());
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_TRUE(preroll_context()->has_platform_view);
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), layer->paint_bounds());
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(),
            kGiantRect);  // Siblings are independent
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Container)layer::Paint */ {
    /* mock_layer1::Paint */ {
      expected_builder.DrawPath(child_path1, child_paint1);
    }
    /* mock_layer2::Paint */ {
      expected_builder.DrawPath(child_path2, child_paint2);
    }
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [49/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		MultipleWithEmpty
	)

Definition at line 172 of file container_layer_unittests.cc.

                                              {
  SkPath child_path1;
  child_path1.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(SkPath(), child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->has_platform_view);
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), SkPath().getBounds());
  EXPECT_EQ(layer->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(layer->child_paint_bounds(), layer->paint_bounds());
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_FALSE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Container)layer::Paint */ {
    /* mock_layer1::Paint */ {
      expected_builder.DrawPath(child_path1, child_paint1);
    }
    // mock_layer2 not drawn due to needs_painting() returning false
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [50/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		NeedsSystemComposite
	)

Definition at line 211 of file container_layer_unittests.cc.

                                                 {
  SkPath child_path1;
  child_path1.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkPath child_path2;
  child_path2.addRect(8.0f, 2.0f, 16.5f, 14.5f);
  DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  mock_layer1->set_fake_has_platform_view(false);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  SkRect expected_total_bounds = child_path1.getBounds();
  expected_total_bounds.join(child_path2.getBounds());
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->has_platform_view);
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), layer->paint_bounds());
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer2->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Container)layer::Paint */ {
    /* mock_layer1::Paint */ {
      expected_builder.DrawPath(child_path1, child_paint1);
    }
    /* mock_layer2::Paint */ {
      expected_builder.DrawPath(child_path2, child_paint2);
    }
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [51/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		RasterCacheTest
	)

Definition at line 257 of file container_layer_unittests.cc.

                                            {
  // LTRB
  const SkPath child_path1 = SkPath().addRect(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path2 = SkPath().addRect(21.0f, 6.0f, 25.5f, 21.5f);
  const SkPath child_path3 = SkPath().addRect(26.0f, 6.0f, 30.5f, 21.5f);
  const DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  const DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  const DlPaint paint;
  auto cacheable_container_layer1 =
      MockCacheableContainerLayer::CacheLayerOrChildren();
  auto cacheable_container_layer2 =
      MockCacheableContainerLayer::CacheLayerOnly();
  auto cacheable_container_layer11 =
      MockCacheableContainerLayer::CacheLayerOrChildren();
 
  auto cacheable_layer111 =
      std::make_shared<MockCacheableLayer>(child_path3, paint);
  // if the frame had rendered 2 frames, we will cache the cacheable_layer21
  // layer
  auto cacheable_layer21 =
      std::make_shared<MockCacheableLayer>(child_path1, paint, 2);
 
  // clang-format off
//                                               layer
//                                                 |
//                 ________________________________ ________________________________
//                 |                               |                                |
//  cacheable_container_layer1                mock_layer2               cacheable_container_layer2
//                 |                                                                |
// cacheable_container_layer11                                             cacheable_layer21
//                 |
//        cacheable_layer111
  // clang-format on
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(SkPath(), child_paint2);
  auto mock_layer3 = std::make_shared<MockLayer>(child_path2, paint);
 
  cacheable_container_layer1->Add(mock_layer1);
  cacheable_container_layer1->Add(mock_layer3);
 
  cacheable_container_layer1->Add(cacheable_container_layer11);
  cacheable_container_layer11->Add(cacheable_layer111);
 
  cacheable_container_layer2->Add(cacheable_layer21);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(cacheable_container_layer1);
  layer->Add(mock_layer2);
  layer->Add(cacheable_container_layer2);
 
  DisplayListBuilder cache_canvas;
  cache_canvas.TransformReset();
 
  // Initial Preroll for check the layer paint bounds
  layer->Preroll(preroll_context());
 
  EXPECT_EQ(mock_layer1->paint_bounds(),
            SkRect::MakeLTRB(5.f, 6.f, 20.5f, 21.5f));
  EXPECT_EQ(mock_layer3->paint_bounds(),
            SkRect::MakeLTRB(21.0f, 6.0f, 25.5f, 21.5f));
  EXPECT_EQ(cacheable_layer111->paint_bounds(),
            SkRect::MakeLTRB(26.0f, 6.0f, 30.5f, 21.5f));
  EXPECT_EQ(cacheable_container_layer1->paint_bounds(),
            SkRect::MakeLTRB(5.f, 6.f, 30.5f, 21.5f));
 
  // the preroll context's raster cache is nullptr
  EXPECT_EQ(preroll_context()->raster_cached_entries->size(),
            static_cast<unsigned long>(0));
  {
    // frame1
    use_mock_raster_cache();
    preroll_context()->raster_cache->BeginFrame();
    layer->Preroll(preroll_context());
    preroll_context()->raster_cache->EvictUnusedCacheEntries();
    // Cache the cacheable entries
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
 
    EXPECT_EQ(preroll_context()->raster_cached_entries->size(),
              static_cast<unsigned long>(5));
 
    // cacheable_container_layer1 will cache his children
    EXPECT_EQ(cacheable_container_layer1->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kChildren);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer1->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
 
    EXPECT_EQ(cacheable_container_layer11->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kChildren);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_FALSE(raster_cache()->Draw(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        cache_canvas, &paint));
 
    // The cacheable_layer111 should be cached when rended 3 frames
    EXPECT_EQ(cacheable_layer111->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kNone);
    // render count < 2 don't cache it
    EXPECT_EQ(cacheable_container_layer2->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kNone);
    preroll_context()->raster_cache->EndFrame();
  }
 
  {
    // frame2
    // new frame the layer tree will create new PrerollContext, so in here we
    // clear the cached_entries
    preroll_context()->raster_cached_entries->clear();
    preroll_context()->raster_cache->BeginFrame();
    layer->Preroll(preroll_context());
    preroll_context()->raster_cache->EvictUnusedCacheEntries();
 
    // Cache the cacheable entries
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
    EXPECT_EQ(preroll_context()->raster_cached_entries->size(),
              static_cast<unsigned long>(5));
    EXPECT_EQ(cacheable_container_layer1->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kChildren);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer1->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
 
    EXPECT_EQ(cacheable_container_layer11->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kChildren);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_FALSE(raster_cache()->Draw(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        cache_canvas, &paint));
 
    EXPECT_EQ(cacheable_container_layer2->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kNone);
 
    // render count == 2 cache it
    EXPECT_EQ(cacheable_layer21->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kCurrent);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_layer21->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_TRUE(raster_cache()->Draw(
        cacheable_layer21->raster_cache_item()->GetId().value(), cache_canvas,
        &paint));
    preroll_context()->raster_cache->EndFrame();
  }
 
  {
    // frame3
    // new frame the layer tree will create new PrerollContext, so in here we
    // clear the cached_entries
    preroll_context()->raster_cache->BeginFrame();
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    preroll_context()->raster_cache->EvictUnusedCacheEntries();
    // Cache the cacheable entries
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
    EXPECT_EQ(preroll_context()->raster_cached_entries->size(),
              static_cast<unsigned long>(5));
    EXPECT_EQ(cacheable_container_layer1->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kCurrent);
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer1->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_FALSE(raster_cache()->Draw(
        cacheable_container_layer11->raster_cache_item()->GetId().value(),
        cache_canvas, &paint));
    // The 3td frame, we will cache the cacheable_layer111, but his ancestor has
    // been cached, so cacheable_layer111 Draw is false
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_layer111->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    EXPECT_FALSE(raster_cache()->Draw(
        cacheable_layer111->raster_cache_item()->GetId().value(), cache_canvas,
        &paint));
 
    // The third frame, we will cache the cacheable_container_layer2
    EXPECT_EQ(cacheable_container_layer2->raster_cache_item()->cache_state(),
              RasterCacheItem::CacheState::kCurrent);
 
    EXPECT_TRUE(raster_cache()->HasEntry(
        cacheable_layer21->raster_cache_item()->GetId().value(),
        SkMatrix::I()));
    preroll_context()->raster_cache->EndFrame();
  }
 
  {
    preroll_context()->raster_cache->BeginFrame();
    // frame4
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    preroll_context()->raster_cache->EvictUnusedCacheEntries();
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
    preroll_context()->raster_cache->EndFrame();
 
    // frame5
    preroll_context()->raster_cache->BeginFrame();
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
    preroll_context()->raster_cache->EndFrame();
 
    // frame6
    preroll_context()->raster_cache->BeginFrame();
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    LayerTree::TryToRasterCache(*(preroll_context()->raster_cached_entries),
                                &paint_context());
    preroll_context()->raster_cache->EndFrame();
  }
}

◆ TEST_F() [52/925]

flutter::testing::TEST_F	(	ContainerLayerTest	,
		Simple
	)

Definition at line 94 of file container_layer_unittests.cc.

                                   {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  DlPaint child_paint = DlPaint(DlColor::kGreen());
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
 
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->has_platform_view);
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->child_paint_bounds(), layer->paint_bounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
  EXPECT_EQ(mock_layer->parent_cull_rect(), kGiantRect);
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Container)layer::Paint */ {
    /* mock_layer::Paint */ {
      expected_builder.DrawPath(child_path, child_paint);
    }
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [53/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		ActivateSystemCursor
	)

Definition at line 97 of file cursor_handler_unittests.cc.

                                                {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  EXPECT_CALL(*window(), UpdateFlutterCursor("click")).Times(1);
 
  bool success = false;
  MethodResultFunctions<> result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
 
  SimulateCursorMessage(&messenger, kActivateSystemCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("device"), EncodableValue(0)},
                            {EncodableValue("kind"), EncodableValue("click")},
                        }),
                        &result_handler);
 
  EXPECT_TRUE(success);
}

◆ TEST_F() [54/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		ActivateSystemCursorRequiresView
	)

Definition at line 123 of file cursor_handler_unittests.cc.

                                                            {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  bool error = false;
  MethodResultFunctions<> result_handler(
      nullptr,
      [&error](const std::string& error_code, const std::string& error_message,
               const EncodableValue* value) {
        error = true;
        EXPECT_EQ(error_message,
                  "Cursor is not available in Windows headless mode");
      },
      nullptr);
 
  SimulateCursorMessage(&messenger, kActivateSystemCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("device"), EncodableValue(0)},
                            {EncodableValue("kind"), EncodableValue("click")},
                        }),
                        &result_handler);
 
  EXPECT_TRUE(error);
}

◆ TEST_F() [55/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		CreateCustomCursor
	)

Definition at line 150 of file cursor_handler_unittests.cc.

                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  // Create a 4x4 raw BGRA test cursor buffer.
  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
 
  bool success = false;
  MethodResultFunctions<> result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        EXPECT_EQ(std::get<std::string>(*result), "hello");
      },
      nullptr, nullptr);
 
  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                            {EncodableValue("buffer"), EncodableValue(buffer)},
                            {EncodableValue("width"), EncodableValue(4)},
                            {EncodableValue("height"), EncodableValue(4)},
                            {EncodableValue("hotX"), EncodableValue(0.0)},
                            {EncodableValue("hotY"), EncodableValue(0.0)},
                        }),
                        &result_handler);
 
  EXPECT_TRUE(success);
}

◆ TEST_F() [56/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		DeleteCustomCursor
	)

Definition at line 291 of file cursor_handler_unittests.cc.

                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  // Create a 4x4 raw BGRA test cursor buffer.
  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
 
  bool success = false;
  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
  MethodResultFunctions<> delete_result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
 
  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                            {EncodableValue("buffer"), EncodableValue(buffer)},
                            {EncodableValue("width"), EncodableValue(4)},
                            {EncodableValue("height"), EncodableValue(4)},
                            {EncodableValue("hotX"), EncodableValue(0.0)},
                            {EncodableValue("hotY"), EncodableValue(0.0)},
                        }),
                        &create_result_handler);
 
  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                        }),
                        &delete_result_handler);
 
  EXPECT_TRUE(success);
}

◆ TEST_F() [57/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		DeleteNonexistentCustomCursor
	)

Definition at line 329 of file cursor_handler_unittests.cc.

                                                         {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  bool success = false;
  MethodResultFunctions<> result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
 
  SimulateCursorMessage(&messenger, kDeleteCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("fake")},
                        }),
                        &result_handler);
 
  EXPECT_TRUE(success);
}

◆ TEST_F() [58/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		SetCustomCursor
	)

Definition at line 181 of file cursor_handler_unittests.cc.

                                           {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  // Create a 4x4 raw BGRA test cursor buffer.
  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
 
  bool success = false;
  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
  MethodResultFunctions<> set_result_handler(
      [&success](const EncodableValue* result) {
        success = true;
        EXPECT_EQ(result, nullptr);
      },
      nullptr, nullptr);
 
  EXPECT_CALL(*window(), SetFlutterCursor(/*cursor=*/NotNull())).Times(1);
 
  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                            {EncodableValue("buffer"), EncodableValue(buffer)},
                            {EncodableValue("width"), EncodableValue(4)},
                            {EncodableValue("height"), EncodableValue(4)},
                            {EncodableValue("hotX"), EncodableValue(0.0)},
                            {EncodableValue("hotY"), EncodableValue(0.0)},
                        }),
                        &create_result_handler);
 
  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                        }),
                        &set_result_handler);
 
  EXPECT_TRUE(success);
}

◆ TEST_F() [59/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		SetCustomCursorRequiresView
	)

Definition at line 221 of file cursor_handler_unittests.cc.

                                                       {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  // Create a 4x4 raw BGRA test cursor buffer.
  std::vector<uint8_t> buffer(4 * 4 * 4, 0);
 
  bool error = false;
  MethodResultFunctions<> create_result_handler(nullptr, nullptr, nullptr);
  MethodResultFunctions<> set_result_handler(
      nullptr,
      [&error](const std::string& error_code, const std::string& error_message,
               const EncodableValue* value) {
        error = true;
        EXPECT_EQ(error_message,
                  "Cursor is not available in Windows headless mode");
      },
      nullptr);
 
  SimulateCursorMessage(&messenger, kCreateCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                            {EncodableValue("buffer"), EncodableValue(buffer)},
                            {EncodableValue("width"), EncodableValue(4)},
                            {EncodableValue("height"), EncodableValue(4)},
                            {EncodableValue("hotX"), EncodableValue(0.0)},
                            {EncodableValue("hotY"), EncodableValue(0.0)},
                        }),
                        &create_result_handler);
 
  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                        }),
                        &set_result_handler);
 
  EXPECT_TRUE(error);
}

◆ TEST_F() [60/925]

flutter::testing::TEST_F	(	CursorHandlerTest	,
		SetNonexistentCustomCursor
	)

Definition at line 262 of file cursor_handler_unittests.cc.

                                                      {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  CursorHandler cursor_handler(&messenger, engine());
 
  bool error = false;
  MethodResultFunctions<> result_handler(
      nullptr,
      [&error](const std::string& error_code, const std::string& error_message,
               const EncodableValue* value) {
        error = true;
        EXPECT_EQ(
            error_message,
            "The custom cursor identified by the argument key cannot be found");
      },
      nullptr);
 
  EXPECT_CALL(*window(), SetFlutterCursor).Times(0);
 
  SimulateCursorMessage(&messenger, kSetCustomCursorMethod,
                        std::make_unique<EncodableValue>(EncodableMap{
                            {EncodableValue("name"), EncodableValue("hello")},
                        }),
                        &result_handler);
 
  EXPECT_TRUE(error);
}

◆ TEST_F() [61/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		CanCreateServiceIsolate
	)

Definition at line 400 of file dart_isolate_unittests.cc.

                                                 {
#if (FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_DEBUG) && \
    (FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_PROFILE)
  GTEST_SKIP();
#endif
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  fml::AutoResetWaitableEvent service_isolate_latch;
  auto settings = CreateSettingsForFixture();
  settings.enable_vm_service = true;
  settings.vm_service_port = 0;
  settings.vm_service_host = "127.0.0.1";
  settings.enable_service_port_fallback = true;
  settings.service_isolate_create_callback = [&service_isolate_latch]() {
    service_isolate_latch.Signal();
  };
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
 
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(task_runners);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = "main";
  auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
      vm_data->GetSettings(),              // settings
      vm_data->GetIsolateSnapshot(),       // isolate snapshot
      nullptr,                             // platform configuration
      DartIsolate::Flags{},                // flags
      nullptr,                             // root_isolate_create_callback
      settings.isolate_create_callback,    // isolate create callback
      settings.isolate_shutdown_callback,  // isolate shutdown callback
      "main",                              // dart entrypoint
      std::nullopt,                        // dart entrypoint library
      {},                                  // dart entrypoint arguments
      std::move(isolate_configuration),    // isolate configuration
      context                              // engine context
  );
 
  auto root_isolate = weak_isolate.lock();
  ASSERT_TRUE(root_isolate);
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
  service_isolate_latch.Wait();
  ASSERT_TRUE(root_isolate->Shutdown());
}

◆ TEST_F() [62/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		CanReceiveArguments
	)

Definition at line 374 of file dart_isolate_unittests.cc.

                                             {
  AddNativeCallback("NotifyNative",
                    CREATE_NATIVE_ENTRY(([this](Dart_NativeArguments args) {
                      ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(
                          Dart_GetNativeArgument(args, 0)));
                      Signal();
                    })));
 
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners,
                                      "testCanReceiveArguments", {"arg1"},
                                      GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  Wait();
}

◆ TEST_F() [63/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		CanRegisterNativeCallback
	)

Definition at line 252 of file dart_isolate_unittests.cc.

                                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  AddNativeCallback(
      "NotifyNative",
      CREATE_NATIVE_ENTRY(([this](Dart_NativeArguments args) { Signal(); })));
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners,
                                      "canRegisterNativeCallback", {},
                                      GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  Wait();
}

◆ TEST_F() [64/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		CanRunDartCodeCodeSynchronously
	)

Definition at line 158 of file dart_isolate_unittests.cc.

                                                         {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, GetDefaultKernelFilePath());
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  ASSERT_TRUE(isolate->RunInIsolateScope([]() -> bool {
    if (tonic::CheckAndHandleError(::Dart_Invoke(
            Dart_RootLibrary(), tonic::ToDart("sayHi"), 0, nullptr))) {
      return false;
    }
    return true;
  }));
}

◆ TEST_F() [65/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantFromBackgroundIsolate
	)

Definition at line 101 of file dart_plugin_registrant_unittests.cc.

                                                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  auto settings = CreateSettingsForFixture();
  auto did_throw_exception = false;
  settings.unhandled_exception_callback = [&](const std::string& error,
                                              const std::string& stack_trace) {
    did_throw_exception = true;
    return true;
  };
 
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
 
  auto kernel_path =
      fml::paths::JoinPaths({GetFixturesPath(), kKernelFileName});
  auto isolate = RunDartCodeInIsolate(
      vm_ref, settings, task_runners,
      "callDartPluginRegistrantFromBackgroundIsolate", {}, kernel_path);
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  latch.Wait();
 
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(messages[0],
            "_PluginRegistrant.register() was called on background isolate");
}

◆ TEST_F() [66/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantIsCalled
	)

Definition at line 562 of file dart_isolate_unittests.cc.

                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners,
                                      "mainForPluginRegistrantTest", {},
                                      GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  latch.Wait();
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(messages[0], "_PluginRegistrant.register() was called");
}

◆ TEST_F() [67/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantIsNotPresent
	)

Definition at line 28 of file no_dart_plugin_registrant_unittests.cc.

                                                          {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  auto settings = CreateSettingsForFixture();
  auto did_throw_exception = false;
  settings.unhandled_exception_callback = [&](const std::string& error,
                                              const std::string& stack_trace) {
    did_throw_exception = true;
    return true;
  };
 
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
 
  auto kernel_path =
      fml::paths::JoinPaths({GetFixturesPath(), kKernelFileName});
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, kernel_path);
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  latch.Wait();
 
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(messages[0], "main() was called");
  ASSERT_FALSE(did_throw_exception);
}

◆ TEST_F() [68/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantIsPresent
	)

Definition at line 54 of file dart_plugin_registrant_unittests.cc.

                                                       {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  auto settings = CreateSettingsForFixture();
  auto did_throw_exception = false;
  settings.unhandled_exception_callback = [&](const std::string& error,
                                              const std::string& stack_trace) {
    did_throw_exception = true;
    return true;
  };
 
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
 
  auto kernel_path =
      fml::paths::JoinPaths({GetFixturesPath(), kKernelFileName});
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners,
                           "mainForPluginRegistrantTest", {}, kernel_path);
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  latch.Wait();
 
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(messages[0], "_PluginRegistrant.register() was called");
}

◆ TEST_F() [69/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantNotFromBackgroundIsolate
	)

Definition at line 149 of file dart_plugin_registrant_unittests.cc.

                                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  auto settings = CreateSettingsForFixture();
  auto did_throw_exception = false;
  settings.unhandled_exception_callback = [&](const std::string& error,
                                              const std::string& stack_trace) {
    did_throw_exception = true;
    return true;
  };
 
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
 
  auto kernel_path =
      fml::paths::JoinPaths({GetFixturesPath(), kKernelFileName});
  auto isolate = RunDartCodeInIsolate(
      vm_ref, settings, task_runners,
      "dontCallDartPluginRegistrantFromBackgroundIsolate", {}, kernel_path);
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  latch.Wait();
 
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(
      messages[0],
      "_PluginRegistrant.register() was not called on background isolate");
}

◆ TEST_F() [70/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		DartPluginRegistrantWhenRegisteringBackgroundIsolate
	)

Definition at line 198 of file dart_plugin_registrant_unittests.cc.

                                                                              {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
  std::vector<std::string> messages;
  fml::AutoResetWaitableEvent latch;
 
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&latch, &messages](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        messages.push_back(message);
        latch.Signal();
      })));
 
  auto settings = CreateSettingsForFixture();
  auto did_throw_exception = false;
  settings.unhandled_exception_callback = [&](const std::string& error,
                                              const std::string& stack_trace) {
    did_throw_exception = true;
    return true;
  };
 
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
 
  auto kernel_path =
      fml::paths::JoinPaths({GetFixturesPath(), kKernelFileName});
  auto isolate = RunDartCodeInIsolate(
      vm_ref, settings, task_runners,
      "registerBackgroundIsolateCallsDartPluginRegistrant", {}, kernel_path);
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
 
  latch.Wait();
 
  ASSERT_EQ(messages.size(), 1u);
  ASSERT_EQ(messages[0],
            "_PluginRegistrant.register() was called on background isolate");
}

◆ TEST_F() [71/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		ImpellerFlagIsCorrectWhenFalse
	)

Definition at line 217 of file dart_isolate_unittests.cc.

                                                        {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  settings.enable_impeller = false;
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, GetDefaultKernelFilePath());
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  ASSERT_TRUE(isolate->RunInIsolateScope([settings]() -> bool {
    Dart_Handle dart_ui = ::Dart_LookupLibrary(tonic::ToDart("dart:ui"));
    if (tonic::CheckAndHandleError(dart_ui)) {
      return false;
    }
    Dart_Handle impeller_enabled =
        ::Dart_GetField(dart_ui, tonic::ToDart("_impellerEnabled"));
    if (tonic::CheckAndHandleError(impeller_enabled)) {
      return false;
    }
    bool result;
    if (tonic::CheckAndHandleError(
            Dart_BooleanValue(impeller_enabled, &result))) {
      return false;
    }
    return result == settings.enable_impeller;
  }));
}

◆ TEST_F() [72/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		ImpellerFlagIsCorrectWhenTrue
	)

Definition at line 182 of file dart_isolate_unittests.cc.

                                                       {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  settings.enable_impeller = true;
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, GetDefaultKernelFilePath());
 
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  ASSERT_TRUE(isolate->RunInIsolateScope([settings]() -> bool {
    Dart_Handle dart_ui = ::Dart_LookupLibrary(tonic::ToDart("dart:ui"));
    if (tonic::CheckAndHandleError(dart_ui)) {
      return false;
    }
    Dart_Handle impeller_enabled =
        ::Dart_GetField(dart_ui, tonic::ToDart("_impellerEnabled"));
    if (tonic::CheckAndHandleError(impeller_enabled)) {
      return false;
    }
    bool result;
    if (tonic::CheckAndHandleError(
            Dart_BooleanValue(impeller_enabled, &result))) {
      return false;
    }
    return result == settings.enable_impeller;
  }));
}

◆ TEST_F() [73/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		InvalidLoadingUnitFails
	)

Definition at line 509 of file dart_isolate_unittests.cc.

                                                 {
  if (!DartVM::IsRunningPrecompiledCode()) {
    FML_LOG(INFO) << "Split AOT does not work in JIT mode";
    return;
  }
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(task_runners);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = "main";
  auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
      vm_data->GetSettings(),              // settings
      vm_data->GetIsolateSnapshot(),       // isolate snapshot
      nullptr,                             // platform configuration
      DartIsolate::Flags{},                // flags
      nullptr,                             // root_isolate_create_callback
      settings.isolate_create_callback,    // isolate create callback
      settings.isolate_shutdown_callback,  // isolate shutdown callback
      "main",                              // dart entrypoint
      std::nullopt,                        // dart entrypoint library
      {},                                  // dart entrypoint arguments
      std::move(isolate_configuration),    // isolate configuration
      context                              // engine context
  );
 
  auto root_isolate = weak_isolate.lock();
  ASSERT_TRUE(root_isolate);
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
 
  auto isolate_data = std::make_unique<const fml::NonOwnedMapping>(
      split_aot_symbols_.vm_isolate_data, 0);
  auto isolate_instructions = std::make_unique<const fml::NonOwnedMapping>(
      split_aot_symbols_.vm_isolate_instrs, 0);
 
  // Invalid loading unit should fail gracefully with error message.
  ASSERT_FALSE(root_isolate->LoadLoadingUnit(3, std::move(isolate_data),
                                             std::move(isolate_instructions)));
  ASSERT_TRUE(root_isolate->Shutdown());
}

◆ TEST_F() [74/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		IsolateCanLoadAndRunDartCode
	)

Definition at line 126 of file dart_isolate_unittests.cc.

                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
}

◆ TEST_F() [75/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		IsolateCannotLoadAndRunUnknownDartEntrypoint
	)

Definition at line 142 of file dart_isolate_unittests.cc.

                                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  const auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "thisShouldNotExist",
                           {}, GetDefaultKernelFilePath());
  ASSERT_FALSE(isolate);
}

◆ TEST_F() [76/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		IsolateCreateCallbacksTakeInstanceSettingsInsteadOfVMSettings
	)

Definition at line 481 of file dart_isolate_unittests.cc.

                                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto vm_settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(vm_settings);
  auto instance_settings = vm_settings;
  size_t create_callback_count = 0u;
  instance_settings.root_isolate_create_callback =
      [&create_callback_count](const auto& isolate) {
        ASSERT_EQ(isolate.GetPhase(), DartIsolate::Phase::Ready);
        create_callback_count++;
        ASSERT_NE(::Dart_CurrentIsolate(), nullptr);
      };
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  {
    auto isolate = RunDartCodeInIsolate(vm_ref, instance_settings, task_runners,
                                        "main", {}, GetDefaultKernelFilePath());
    ASSERT_TRUE(isolate);
    ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  }
  ASSERT_EQ(create_callback_count, 1u);
}

◆ TEST_F() [77/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		IsolateShutdownCallbackIsInIsolateScope
	)

Definition at line 81 of file dart_isolate_unittests.cc.

                                                                 {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(task_runners);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = "main";
  auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
      vm_data->GetSettings(),              // settings
      vm_data->GetIsolateSnapshot(),       // isolate snapshot
      nullptr,                             // platform configuration
      DartIsolate::Flags{},                // flags
      nullptr,                             // root_isolate_create_callback
      settings.isolate_create_callback,    // isolate create callback
      settings.isolate_shutdown_callback,  // isolate shutdown callback
      "main",                              // dart entrypoint
      std::nullopt,                        // dart entrypoint library
      {},                                  // dart entrypoint arguments
      std::move(isolate_configuration),    // isolate configuration
      context                              // engine context
  );
  auto root_isolate = weak_isolate.lock();
  ASSERT_TRUE(root_isolate);
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
  size_t destruction_callback_count = 0;
  root_isolate->AddIsolateShutdownCallback([&destruction_callback_count]() {
    ASSERT_NE(Dart_CurrentIsolate(), nullptr);
    destruction_callback_count++;
  });
  ASSERT_TRUE(root_isolate->Shutdown());
  ASSERT_EQ(destruction_callback_count, 1u);
}

◆ TEST_F() [78/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateCreationAfterManagerShutdown
	)

Definition at line 971 of file dart_isolate_unittests.cc.

                                                                     {
  AddNativeCallback("PassMessage",
                    CREATE_NATIVE_ENTRY((
                        [](Dart_NativeArguments args) { FML_UNREACHABLE(); })));
 
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
 
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
 
  auto platform_thread = CreateNewThread();
  auto ui_thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  // label
                           platform_thread,       // platform
                           ui_thread,             // raster
                           ui_thread,             // ui
                           ui_thread              // io
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                           GetDefaultKernelFilePath(), {}, nullptr,
                           std::move(platform_configuration));
  ASSERT_TRUE(isolate);
  auto root_isolate = isolate->get();
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
 
  // Shut down the manager on the platform thread.
  fml::AutoResetWaitableEvent manager_shutdown_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread,
      fml::MakeCopyable([&manager_shutdown_latch, &client]() mutable {
        client.mgr->ShutdownPlatformIsolates();
        manager_shutdown_latch.Signal();
      }));
  manager_shutdown_latch.Wait();
 
  fml::AutoResetWaitableEvent ui_thread_latch;
  fml::TaskRunner::RunNowOrPostTask(
      ui_thread, fml::MakeCopyable([&]() mutable {
        ASSERT_TRUE(isolate->RunInIsolateScope([root_isolate]() {
          Dart_Handle lib = Dart_RootLibrary();
          Dart_Handle entry_point =
              Dart_GetField(lib, tonic::ToDart("mainForPlatformIsolates"));
          char* error = nullptr;
          Dart_Isolate platform_isolate =
              root_isolate->CreatePlatformIsolate(entry_point, &error);
 
          // Failed to create a platform isolate, but we've still re-entered the
          // root isolate.
          EXPECT_FALSE(error);
          EXPECT_FALSE(platform_isolate);
          EXPECT_EQ(Dart_CurrentIsolate(), root_isolate->isolate());
 
          return true;
        }));
        ui_thread_latch.Signal();
      }));
  ui_thread_latch.Wait();
 
  // root isolate will be auto-shutdown
}

◆ TEST_F() [79/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateCreationAndShutdown
	)

Definition at line 740 of file dart_isolate_unittests.cc.

                                                            {
  fml::AutoResetWaitableEvent message_latch;
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("Platform isolate is ready", message);
        message_latch.Signal();
      })));
 
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
  Dart_Isolate platform_isolate = nullptr;
 
  {
    ASSERT_FALSE(DartVMRef::IsInstanceRunning());
    auto settings = CreateSettingsForFixture();
    auto vm_ref = DartVMRef::Create(settings);
    ASSERT_TRUE(vm_ref);
    auto vm_data = vm_ref.GetVMData();
    ASSERT_TRUE(vm_data);
 
    auto platform_thread = CreateNewThread();
    auto ui_thread = CreateNewThread();
    TaskRunners task_runners(GetCurrentTestName(),  // label
                             platform_thread,       // platform
                             ui_thread,             // raster
                             ui_thread,             // ui
                             ui_thread              // io
    );
    auto isolate =
        RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                             GetDefaultKernelFilePath(), {}, nullptr,
                             std::move(platform_configuration));
    ASSERT_TRUE(isolate);
    auto root_isolate = isolate->get();
    ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
    EXPECT_FALSE(
        client.mgr->IsRegisteredForTestingOnly(root_isolate->isolate()));
 
    // Post a task to the platform_thread that just waits, to delay execution of
    // the platform isolate until we're ready.
    fml::AutoResetWaitableEvent platform_thread_latch;
    fml::TaskRunner::RunNowOrPostTask(
        platform_thread, fml::MakeCopyable([&platform_thread_latch]() mutable {
          platform_thread_latch.Wait();
        }));
 
    fml::AutoResetWaitableEvent ui_thread_latch;
    fml::TaskRunner::RunNowOrPostTask(
        ui_thread, fml::MakeCopyable([&]() mutable {
          ASSERT_TRUE(
              isolate->RunInIsolateScope([root_isolate, &platform_isolate]() {
                Dart_Handle lib = Dart_RootLibrary();
                Dart_Handle entry_point = Dart_GetField(
                    lib, tonic::ToDart("mainForPlatformIsolates"));
                char* error = nullptr;
                platform_isolate =
                    root_isolate->CreatePlatformIsolate(entry_point, &error);
 
                EXPECT_FALSE(error);
                EXPECT_TRUE(platform_isolate);
                EXPECT_EQ(Dart_CurrentIsolate(), root_isolate->isolate());
                return true;
              }));
          ui_thread_latch.Signal();
        }));
 
    ui_thread_latch.Wait();
    ASSERT_TRUE(platform_isolate);
    EXPECT_TRUE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
 
    // Allow the platform isolate to run.
    platform_thread_latch.Signal();
 
    // Wait for a message from the platform isolate.
    message_latch.Wait();
 
    // root isolate will be auto-shutdown
  }
  EXPECT_FALSE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
}

◆ TEST_F() [80/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateEarlyShutdown
	)

Definition at line 825 of file dart_isolate_unittests.cc.

                                                      {
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
 
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
 
  auto platform_thread = CreateNewThread();
  auto ui_thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  // label
                           platform_thread,       // platform
                           ui_thread,             // raster
                           ui_thread,             // ui
                           ui_thread              // io
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                           GetDefaultKernelFilePath(), {}, nullptr,
                           std::move(platform_configuration));
  ASSERT_TRUE(isolate);
  auto root_isolate = isolate->get();
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
  EXPECT_FALSE(client.mgr->IsRegisteredForTestingOnly(root_isolate->isolate()));
 
  fml::AutoResetWaitableEvent ui_thread_latch;
  Dart_Isolate platform_isolate = nullptr;
  fml::TaskRunner::RunNowOrPostTask(
      ui_thread, fml::MakeCopyable([&]() mutable {
        ASSERT_TRUE(
            isolate->RunInIsolateScope([root_isolate, &platform_isolate]() {
              Dart_Handle lib = Dart_RootLibrary();
              Dart_Handle entry_point =
                  Dart_GetField(lib, tonic::ToDart("emptyMain"));
              char* error = nullptr;
              platform_isolate =
                  root_isolate->CreatePlatformIsolate(entry_point, &error);
 
              EXPECT_FALSE(error);
              EXPECT_TRUE(platform_isolate);
              EXPECT_EQ(Dart_CurrentIsolate(), root_isolate->isolate());
 
              return true;
            }));
        ui_thread_latch.Signal();
      }));
 
  ui_thread_latch.Wait();
  ASSERT_TRUE(platform_isolate);
  EXPECT_TRUE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
 
  // Post a task to the platform thread to shut down the platform isolate.
  fml::AutoResetWaitableEvent platform_thread_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread,
      fml::MakeCopyable([&platform_thread_latch, platform_isolate]() mutable {
        Dart_EnterIsolate(platform_isolate);
        Dart_ShutdownIsolate();
        platform_thread_latch.Signal();
      }));
  platform_thread_latch.Wait();
 
  // The platform isolate should be shut down.
  EXPECT_FALSE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
 
  // root isolate will be auto-shutdown
}

◆ TEST_F() [81/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateMainThrowsError
	)

Definition at line 1125 of file dart_isolate_unittests.cc.

                                                        {
  AddNativeCallback("PassMessage",
                    CREATE_NATIVE_ENTRY((
                        [](Dart_NativeArguments args) { FML_UNREACHABLE(); })));
 
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
 
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
 
  auto platform_thread = CreateNewThread();
  auto ui_thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  // label
                           platform_thread,       // platform
                           ui_thread,             // raster
                           ui_thread,             // ui
                           ui_thread              // io
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                           GetDefaultKernelFilePath(), {}, nullptr,
                           std::move(platform_configuration));
  ASSERT_TRUE(isolate);
  auto root_isolate = isolate->get();
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
 
  Dart_Isolate platform_isolate = nullptr;
  fml::AutoResetWaitableEvent ui_thread_latch;
  fml::TaskRunner::RunNowOrPostTask(
      ui_thread, fml::MakeCopyable([&]() mutable {
        ASSERT_TRUE(
            isolate->RunInIsolateScope([root_isolate, &platform_isolate]() {
              Dart_Handle lib = Dart_RootLibrary();
              Dart_Handle entry_point = Dart_GetField(
                  lib, tonic::ToDart("mainForPlatformIsolatesThrowError"));
              char* error = nullptr;
              platform_isolate =
                  root_isolate->CreatePlatformIsolate(entry_point, &error);
 
              EXPECT_FALSE(error);
              EXPECT_TRUE(platform_isolate);
              EXPECT_EQ(Dart_CurrentIsolate(), root_isolate->isolate());
 
              return true;
            }));
        ui_thread_latch.Signal();
      }));
  ui_thread_latch.Wait();
  ASSERT_TRUE(platform_isolate);
  EXPECT_TRUE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
 
  // Post a task to the platform_thread that runs after the platform isolate's
  // entry point, and wait for it to run.
  fml::AutoResetWaitableEvent epilogue_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread, fml::MakeCopyable([&epilogue_latch]() mutable {
        epilogue_latch.Signal();
      }));
  epilogue_latch.Wait();
 
  // root isolate will be auto-shutdown
}

◆ TEST_F() [82/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateManagerShutdownBeforeMainRuns
	)

Definition at line 1039 of file dart_isolate_unittests.cc.

                                                                      {
  AddNativeCallback("PassMessage",
                    CREATE_NATIVE_ENTRY((
                        [](Dart_NativeArguments args) { FML_UNREACHABLE(); })));
 
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
 
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
 
  auto platform_thread = CreateNewThread();
  auto ui_thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  // label
                           platform_thread,       // platform
                           ui_thread,             // raster
                           ui_thread,             // ui
                           ui_thread              // io
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                           GetDefaultKernelFilePath(), {}, nullptr,
                           std::move(platform_configuration));
  ASSERT_TRUE(isolate);
  auto root_isolate = isolate->get();
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
 
  Dart_Isolate platform_isolate = nullptr;
 
  // Post a task to the platform_thread that just waits, to delay execution of
  // the platform isolate until we're ready, and shutdown the manager just
  // before it runs.
  fml::AutoResetWaitableEvent platform_thread_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread, fml::MakeCopyable([&platform_thread_latch, &client,
                                          &platform_isolate]() mutable {
        platform_thread_latch.Wait();
        client.mgr->ShutdownPlatformIsolates();
        EXPECT_TRUE(platform_isolate);
        EXPECT_FALSE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
      }));
 
  fml::AutoResetWaitableEvent ui_thread_latch;
  fml::TaskRunner::RunNowOrPostTask(
      ui_thread, fml::MakeCopyable([&]() mutable {
        ASSERT_TRUE(
            isolate->RunInIsolateScope([root_isolate, &platform_isolate]() {
              Dart_Handle lib = Dart_RootLibrary();
              Dart_Handle entry_point =
                  Dart_GetField(lib, tonic::ToDart("mainForPlatformIsolates"));
              char* error = nullptr;
              platform_isolate =
                  root_isolate->CreatePlatformIsolate(entry_point, &error);
 
              EXPECT_FALSE(error);
              EXPECT_TRUE(platform_isolate);
              EXPECT_EQ(Dart_CurrentIsolate(), root_isolate->isolate());
 
              return true;
            }));
        ui_thread_latch.Signal();
      }));
  ui_thread_latch.Wait();
  ASSERT_TRUE(platform_isolate);
  EXPECT_TRUE(client.mgr->IsRegisteredForTestingOnly(platform_isolate));
 
  // Allow the platform isolate to run, but its main is never run.
  platform_thread_latch.Signal();
 
  // Post a task to the platform_thread that runs after the platform isolate's
  // entry point, and wait for it to run.
  fml::AutoResetWaitableEvent epilogue_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread, fml::MakeCopyable([&epilogue_latch]() mutable {
        epilogue_latch.Signal();
      }));
  epilogue_latch.Wait();
 
  // root isolate will be auto-shutdown
}

◆ TEST_F() [83/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		PlatformIsolateSendAndReceive
	)

Definition at line 897 of file dart_isolate_unittests.cc.

                                                       {
  fml::AutoResetWaitableEvent message_latch;
  AddNativeCallback(
      "PassMessage",
      CREATE_NATIVE_ENTRY(([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("Platform isolate received: Hello from root isolate!",
                  message);
        message_latch.Signal();
      })));
 
  FakePlatformConfigurationClient client;
  auto platform_configuration =
      std::make_unique<PlatformConfiguration>(&client);
 
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
 
  auto platform_thread = CreateNewThread();
  auto ui_thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  // label
                           platform_thread,       // platform
                           ui_thread,             // raster
                           ui_thread,             // ui
                           ui_thread              // io
  );
  auto isolate =
      RunDartCodeInIsolate(vm_ref, settings, task_runners, "emptyMain", {},
                           GetDefaultKernelFilePath(), {}, nullptr,
                           std::move(platform_configuration));
  ASSERT_TRUE(isolate);
  auto root_isolate = isolate->get();
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
 
  fml::AutoResetWaitableEvent ui_thread_latch;
  Dart_Isolate platform_isolate = nullptr;
  fml::TaskRunner::RunNowOrPostTask(
      ui_thread, fml::MakeCopyable([&]() mutable {
        ASSERT_TRUE(isolate->RunInIsolateScope([root_isolate,
                                                &platform_isolate]() {
          Dart_Handle lib = Dart_RootLibrary();
          Dart_Handle entry_point = Dart_Invoke(
              lib, tonic::ToDart("createEntryPointForPlatIsoSendAndRecvTest"),
              0, nullptr);
          char* error = nullptr;
          platform_isolate =
              root_isolate->CreatePlatformIsolate(entry_point, &error);
          EXPECT_FALSE(error);
          return true;
        }));
        ui_thread_latch.Signal();
      }));
  ui_thread_latch.Wait();
 
  // Wait for a message from the platform isolate.
  message_latch.Wait();
 
  // Post a task to the platform_thread that runs after the platform isolate's
  // entry point and all messages, and wait for it to run.
  fml::AutoResetWaitableEvent epilogue_latch;
  fml::TaskRunner::RunNowOrPostTask(
      platform_thread, fml::MakeCopyable([&epilogue_latch]() mutable {
        epilogue_latch.Signal();
      }));
  epilogue_latch.Wait();
 
  // root isolate will be auto-shutdown
}

◆ TEST_F() [84/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		RootIsolateCreateCallbackIsMadeOnceAndBeforeIsolateRunning
	)

Definition at line 454 of file dart_isolate_unittests.cc.

                                                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  size_t create_callback_count = 0u;
  settings.root_isolate_create_callback =
      [&create_callback_count](const auto& isolate) {
        ASSERT_EQ(isolate.GetPhase(), DartIsolate::Phase::Ready);
        create_callback_count++;
        ASSERT_NE(::Dart_CurrentIsolate(), nullptr);
      };
  auto vm_ref = DartVMRef::Create(settings);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  {
    auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                        {}, GetDefaultKernelFilePath());
    ASSERT_TRUE(isolate);
    ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  }
  ASSERT_EQ(create_callback_count, 1u);
}

◆ TEST_F() [85/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		RootIsolateCreationAndShutdown
	)

Definition at line 41 of file dart_isolate_unittests.cc.

                                                        {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
 
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(task_runners);
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = "main";
  auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
      vm_data->GetSettings(),              // settings
      vm_data->GetIsolateSnapshot(),       // isolate snapshot
      nullptr,                             // platform configuration
      DartIsolate::Flags{},                // flags
      nullptr,                             // root_isolate_create_callback
      settings.isolate_create_callback,    // isolate create callback
      settings.isolate_shutdown_callback,  // isolate shutdown callback
      "main",                              // dart entrypoint
      std::nullopt,                        // dart entrypoint library
      {},                                  // dart entrypoint arguments
      std::move(isolate_configuration),    // isolate configuration
      context                              // engine context
  );
  auto root_isolate = weak_isolate.lock();
  ASSERT_TRUE(root_isolate);
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
  ASSERT_TRUE(root_isolate->Shutdown());
}

◆ TEST_F() [86/925]

flutter::testing::TEST_F	(	DartIsolateTest	,
		SpawningAnIsolateDoesNotReloadKernel
	)

Definition at line 596 of file dart_isolate_unittests.cc.

                                                              {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
 
  size_t get_kernel_count = 0u;
  if (!DartVM::IsRunningPrecompiledCode()) {
    ASSERT_TRUE(settings.application_kernels);
    auto mappings = settings.application_kernels();
    ASSERT_EQ(mappings.size(), 1u);
 
    // This feels a little brittle, but the alternative seems to be making
    // DartIsolate have virtual methods so it can be mocked or exposing weird
    // test-only API on IsolateConfiguration.
    settings.application_kernels = fml::MakeCopyable(
        [&get_kernel_count,
         mapping = std::move(mappings.front())]() mutable -> Mappings {
          get_kernel_count++;
          EXPECT_EQ(get_kernel_count, 1u)
              << "Unexpectedly got more than one call for the kernel mapping.";
          EXPECT_TRUE(mapping);
          std::vector<std::unique_ptr<const fml::Mapping>> kernel_mappings;
          if (mapping) {
            kernel_mappings.emplace_back(std::move(mapping));
          }
          return kernel_mappings;
        });
  }
 
  std::shared_ptr<DartIsolate> root_isolate;
  {
    auto isolate_configuration =
        IsolateConfiguration::InferFromSettings(settings);
 
    UIDartState::Context context(task_runners);
    context.advisory_script_uri = "main.dart";
    context.advisory_script_entrypoint = "main";
    auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
        /*settings=*/vm_data->GetSettings(),
        /*isolate_snapshot=*/vm_data->GetIsolateSnapshot(),
        /*platform_configuration=*/nullptr,
        /*flags=*/DartIsolate::Flags{},
        /*root_isolate_create_callback=*/nullptr,
        /*isolate_create_callback=*/settings.isolate_create_callback,
        /*isolate_shutdown_callback=*/settings.isolate_shutdown_callback,
        /*dart_entrypoint=*/"main",
        /*dart_entrypoint_library=*/std::nullopt,
        /*dart_entrypoint_args=*/{},
        /*isolate_configuration=*/std::move(isolate_configuration),
        /*context=*/context);
    root_isolate = weak_isolate.lock();
  }
  ASSERT_TRUE(root_isolate);
  ASSERT_EQ(root_isolate->GetPhase(), DartIsolate::Phase::Running);
  if (!DartVM::IsRunningPrecompiledCode()) {
    ASSERT_EQ(get_kernel_count, 1u);
  }
 
  {
    auto isolate_configuration = IsolateConfiguration::InferFromSettings(
        /*settings=*/settings,
        /*asset_manager=*/nullptr,
        /*io_worker=*/nullptr,
        /*launch_type=*/IsolateLaunchType::kExistingGroup);
 
    UIDartState::Context context(task_runners);
    context.advisory_script_uri = "main.dart";
    context.advisory_script_entrypoint = "main";
    auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
        /*settings=*/vm_data->GetSettings(),
        /*isolate_snapshot=*/vm_data->GetIsolateSnapshot(),
        /*platform_configuration=*/nullptr,
        /*flags=*/DartIsolate::Flags{},
        /*root_isolate_create_callback=*/nullptr,
        /*isolate_create_callback=*/settings.isolate_create_callback,
        /*isolate_shutdown_callback=*/settings.isolate_shutdown_callback,
        /*dart_entrypoint=*/"main",
        /*dart_entrypoint_library=*/std::nullopt,
        /*dart_entrypoint_args=*/{},
        /*isolate_configuration=*/std::move(isolate_configuration),
        /*context=*/context,
        /*spawning_isolate=*/root_isolate.get());
    auto spawned_isolate = weak_isolate.lock();
    ASSERT_TRUE(spawned_isolate);
    ASSERT_EQ(spawned_isolate->GetPhase(), DartIsolate::Phase::Running);
    if (!DartVM::IsRunningPrecompiledCode()) {
      ASSERT_EQ(get_kernel_count, 1u);
    }
    ASSERT_TRUE(spawned_isolate->Shutdown());
  }
 
  ASSERT_TRUE(root_isolate->Shutdown());
}

◆ TEST_F() [87/925]

flutter::testing::TEST_F	(	DartLifecycleTest	,
		CanStartAndShutdownVM
	)

Definition at line 19 of file dart_lifecycle_unittests.cc.

                                                 {
  auto settings = CreateSettingsForFixture();
  settings.leak_vm = false;
  settings.enable_vm_service = false;
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  {
    auto vm_ref = DartVMRef::Create(settings);
    ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  }
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [88/925]

flutter::testing::TEST_F	(	DartLifecycleTest	,
		CanStartAndShutdownVMOverAndOver
	)

Definition at line 31 of file dart_lifecycle_unittests.cc.

                                                            {
  auto settings = CreateSettingsForFixture();
  settings.leak_vm = false;
  settings.enable_vm_service = false;
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto count = DartVM::GetVMLaunchCount();
  for (size_t i = 0; i < 10; i++) {
    auto vm_ref = DartVMRef::Create(settings);
    ASSERT_TRUE(DartVMRef::IsInstanceRunning());
    ASSERT_EQ(DartVM::GetVMLaunchCount(), count + 1);
    count = DartVM::GetVMLaunchCount();
  }
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [89/925]

flutter::testing::TEST_F	(	DartLifecycleTest	,
		DISABLED_ShuttingDownTheVMShutsDownAllIsolates
	)

Definition at line 88 of file dart_lifecycle_unittests.cc.

                                                                          {
  auto settings = CreateSettingsForFixture();
  settings.leak_vm = false;
  // Make sure the service protocol launches
  settings.enable_vm_service = true;
 
  auto thread_task_runner = CreateNewThread();
 
  for (size_t i = 0; i < 3; i++) {
    ASSERT_FALSE(DartVMRef::IsInstanceRunning());
 
    const auto last_launch_count = DartVM::GetVMLaunchCount();
 
    auto vm_ref = DartVMRef::Create(settings);
 
    ASSERT_TRUE(DartVMRef::IsInstanceRunning());
    ASSERT_EQ(last_launch_count + 1, DartVM::GetVMLaunchCount());
 
    const size_t isolate_count = 5;
 
    fml::CountDownLatch latch(isolate_count);
    auto vm_data = vm_ref.GetVMData();
    for (size_t i = 0; i < isolate_count; ++i) {
      thread_task_runner->PostTask(
          [vm_data, &settings, &latch, thread_task_runner]() {
            ASSERT_TRUE(CreateAndRunRootIsolate(settings, *vm_data.get(),
                                                thread_task_runner,
                                                "testIsolateShutdown"));
            latch.CountDown();
          });
    }
 
    latch.Wait();
  }
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [90/925]

flutter::testing::TEST_F	(	DartPersistentHandleTest	,
		ClearAfterShutdown
	)

Definition at line 49 of file dart_persistent_handle_unittest.cc.

                                                     {
  auto persistent_value = tonic::DartPersistentValue();
 
  fml::AutoResetWaitableEvent event;
  AddNativeCallback("GiveObjectToNative",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      auto handle = Dart_GetNativeArgument(args, 0);
 
                      auto dart_state = tonic::DartState::Current();
                      ASSERT_TRUE(dart_state);
                      ASSERT_TRUE(tonic::DartState::Current());
                      persistent_value.Set(dart_state, handle);
 
                      event.Signal();
                    }));
 
  ASSERT_TRUE(RunWithEntrypoint("callGiveObjectToNative"));
  event.Wait();
 
  running_isolate_->Shutdown();
 
  fml::AutoResetWaitableEvent clear;
  task_runners_.GetUITaskRunner()->PostTask([&] {
    persistent_value.Clear();
    clear.Signal();
  });
  clear.Wait();
}

◆ TEST_F() [91/925]

flutter::testing::TEST_F	(	DartSecondaryIsolateTest	,
		CanLaunchSecondaryIsolates
	)

Definition at line 300 of file dart_isolate_unittests.cc.

                                                             {
  AddNativeCallback("NotifyNative",
                    CREATE_NATIVE_ENTRY(([this](Dart_NativeArguments args) {
                      LatchCountDown();
                    })));
  AddNativeCallback(
      "PassMessage", CREATE_NATIVE_ENTRY(([this](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("Hello from code is secondary isolate.", message);
        LatchCountDown();
      })));
  auto settings = CreateSettingsForFixture();
  settings.root_isolate_shutdown_callback = [this]() {
    RootIsolateShutdownSignal();
  };
  settings.isolate_shutdown_callback = [this]() { ChildShutdownSignal(); };
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners,
                                      "testCanLaunchSecondaryIsolate", {},
                                      GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  ChildShutdownWait();  // wait for child isolate to shutdown first
  ASSERT_FALSE(RootIsolateIsSignaled());
  LatchWait();  // wait for last NotifyNative called by main isolate
  // root isolate will be auto-shutdown
}

◆ TEST_F() [92/925]

flutter::testing::TEST_F	(	DartState	,
		CurrentWithNullDataDoesNotSegfault
	)

Definition at line 16 of file dart_state_unittest.cc.

                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
  auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
  auto vm_ref = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
  Dart_IsolateFlags isolate_flags;
  Dart_IsolateFlagsInitialize(&isolate_flags);
  isolate_flags.null_safety =
      isolate_configuration->IsNullSafetyEnabled(*isolate_snapshot);
  isolate_flags.snapshot_is_dontneed_safe = isolate_snapshot->IsDontNeedSafe();
  char* error;
  Dart_CreateIsolateGroup(
      "main.dart", "main", vm_data->GetIsolateSnapshot()->GetDataMapping(),
      vm_data->GetIsolateSnapshot()->GetInstructionsMapping(), &isolate_flags,
      nullptr, nullptr, &error);
  ASSERT_FALSE(error) << error;
  ::free(error);
 
  ASSERT_FALSE(tonic::DartState::Current());
 
  Dart_ShutdownIsolate();
  ASSERT_TRUE(Dart_CurrentIsolate() == nullptr);
}

◆ TEST_F() [93/925]

flutter::testing::TEST_F	(	DartState	,
		IsShuttingDown
	)

Definition at line 52 of file dart_state_unittest.cc.

                                  {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  ASSERT_TRUE(vm_ref);
  auto vm_data = vm_ref.GetVMData();
  ASSERT_TRUE(vm_data);
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate_configuration =
      IsolateConfiguration::InferFromSettings(settings);
 
  UIDartState::Context context(std::move(task_runners));
  context.advisory_script_uri = "main.dart";
  context.advisory_script_entrypoint = "main";
  auto weak_isolate = DartIsolate::CreateRunningRootIsolate(
      vm_data->GetSettings(),              // settings
      vm_data->GetIsolateSnapshot(),       // isolate snapshot
      nullptr,                             // platform configuration
      DartIsolate::Flags{},                // flags
      nullptr,                             // root_isolate_create_callback
      settings.isolate_create_callback,    // isolate create callback
      settings.isolate_shutdown_callback,  // isolate shutdown callback
      "main",                              // dart entrypoint
      std::nullopt,                        // dart entrypoint library
      {},                                  // dart entrypoint arguments
      std::move(isolate_configuration),    // isolate configuration
      std::move(context)                   // engine context
  );
  auto root_isolate = weak_isolate.lock();
  ASSERT_TRUE(root_isolate);
 
  tonic::DartState* dart_state = root_isolate.get();
  ASSERT_FALSE(dart_state->IsShuttingDown());
 
  ASSERT_TRUE(root_isolate->Shutdown());
 
  ASSERT_TRUE(dart_state->IsShuttingDown());
}

◆ TEST_F() [94/925]

flutter::testing::TEST_F	(	DartVMTest	,
		DisableTimelineEventHandler
	)

Definition at line 49 of file dart_vm_unittests.cc.

                                                {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  fml::tracing::TraceSetTimelineEventHandler(nullptr);
  auto settings = CreateSettingsForFixture();
  settings.enable_timeline_event_handler = false;
  auto vm = DartVMRef::Create(settings);
  ASSERT_FALSE(fml::tracing::TraceHasTimelineEventHandler());
}

◆ TEST_F() [95/925]

flutter::testing::TEST_F	(	DartVMTest	,
		OldGenHeapSize
	)

Definition at line 39 of file dart_vm_unittests.cc.

                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  settings.old_gen_heap_size = 1024;
  auto vm = DartVMRef::Create(settings);
  // There is no way to introspect on the heap size so we just assert the vm was
  // created.
  ASSERT_TRUE(vm);
}

◆ TEST_F() [96/925]

flutter::testing::TEST_F	(	DartVMTest	,
		SimpleInitialization
	)

Definition at line 16 of file dart_vm_unittests.cc.

                                         {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto vm = DartVMRef::Create(CreateSettingsForFixture());
  ASSERT_TRUE(vm);
}

◆ TEST_F() [97/925]

flutter::testing::TEST_F	(	DartVMTest	,
		SimpleIsolateNameServer
	)

Definition at line 22 of file dart_vm_unittests.cc.

                                            {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto vm = DartVMRef::Create(CreateSettingsForFixture());
  ASSERT_TRUE(vm);
  ASSERT_TRUE(vm.GetVMData());
  auto ns = vm->GetIsolateNameServer();
  ASSERT_EQ(ns->LookupIsolatePortByName("foobar").port_id, ILLEGAL_PORT);
  ASSERT_FALSE(ns->RemoveIsolateNameMapping("foobar"));
  Dart_PortEx correct_portex = {123, 456};
  ASSERT_TRUE(ns->RegisterIsolatePortWithName(correct_portex, "foobar"));
  ASSERT_FALSE(ns->RegisterIsolatePortWithName(correct_portex, "foobar"));
  Dart_PortEx response = ns->LookupIsolatePortByName("foobar");
  ASSERT_EQ(response.port_id, correct_portex.port_id);
  ASSERT_EQ(response.origin_id, correct_portex.origin_id);
  ASSERT_TRUE(ns->RemoveIsolateNameMapping("foobar"));
}

◆ TEST_F() [98/925]

flutter::testing::TEST_F	(	DartVMTest	,
		TraceGetTimelineMicrosDoesNotGetClockWhenSystraceIsEnabled
	)

Definition at line 58 of file dart_vm_unittests.cc.

                                                                               {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  settings.trace_systrace = true;
  auto vm = DartVMRef::Create(settings);
  ASSERT_EQ(-1, fml::tracing::TraceGetTimelineMicros());
}

◆ TEST_F() [99/925]

flutter::testing::TEST_F	(	DartWeakPersistentHandle	,
		ClearImmediately
	)

Definition at line 52 of file dart_weak_persistent_handle_unittest.cc.

                                                   {
  auto weak_persistent_value = tonic::DartWeakPersistentValue();
 
  fml::AutoResetWaitableEvent event;
 
  AddNativeCallback(
      "GiveObjectToNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
 
        auto dart_state = tonic::DartState::Current();
        ASSERT_TRUE(dart_state);
        ASSERT_TRUE(tonic::DartState::Current());
        weak_persistent_value.Set(dart_state, handle, nullptr, 0, NopFinalizer);
 
        weak_persistent_value.Clear();
 
        event.Signal();
      }));
 
  ASSERT_TRUE(RunWithEntrypoint("callGiveObjectToNative"));
 
  event.Wait();
}

◆ TEST_F() [100/925]

flutter::testing::TEST_F	(	DartWeakPersistentHandle	,
		ClearLaterCc
	)

Definition at line 76 of file dart_weak_persistent_handle_unittest.cc.

                                               {
  auto weak_persistent_value = tonic::DartWeakPersistentValue();
 
  fml::AutoResetWaitableEvent event;
 
  AddNativeCallback(
      "GiveObjectToNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
 
        auto dart_state = tonic::DartState::Current();
        ASSERT_TRUE(dart_state);
        ASSERT_TRUE(tonic::DartState::Current());
        weak_persistent_value.Set(dart_state, handle, nullptr, 0, NopFinalizer);
 
        // Do not clear handle immediately.
 
        event.Signal();
      }));
 
  ASSERT_TRUE(RunWithEntrypoint("callGiveObjectToNative"));
 
  event.Wait();
 
  ASSERT_TRUE(RunInIsolateScope([&weak_persistent_value]() -> bool {
    // Clear on initiative of native.
    weak_persistent_value.Clear();
    return true;
  }));
}

◆ TEST_F() [101/925]

flutter::testing::TEST_F	(	DartWeakPersistentHandle	,
		ClearLaterDart
	)

Definition at line 106 of file dart_weak_persistent_handle_unittest.cc.

                                                 {
  auto weak_persistent_value = tonic::DartWeakPersistentValue();
 
  fml::AutoResetWaitableEvent event;
 
  AddNativeCallback(
      "GiveObjectToNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
 
        auto dart_state = tonic::DartState::Current();
        ASSERT_TRUE(dart_state);
        ASSERT_TRUE(tonic::DartState::Current());
        weak_persistent_value.Set(dart_state, handle, nullptr, 0, NopFinalizer);
 
        // Do not clear handle immediately.
      }));
 
  AddNativeCallback("SignalDone",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      // Clear on initiative of Dart.
                      weak_persistent_value.Clear();
 
                      event.Signal();
                    }));
 
  ASSERT_TRUE(RunWithEntrypoint("testClearLater"));
 
  event.Wait();
}

◆ TEST_F() [102/925]

flutter::testing::TEST_F	(	DartWeakPersistentHandle	,
		ClearOnShutdown
	)

Definition at line 140 of file dart_weak_persistent_handle_unittest.cc.

                                                  {
  fml::AutoResetWaitableEvent event;
 
  AddNativeCallback("GiveObjectToNative",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      auto handle = Dart_GetNativeArgument(args, 0);
 
                      auto dart_state = tonic::DartState::Current();
                      ASSERT_TRUE(dart_state);
                      ASSERT_TRUE(tonic::DartState::Current());
 
                      // The test is repeated, ensure the global var is
                      // cleared before use.
                      global_weak_persistent_value.Clear();
 
                      global_weak_persistent_value.Set(
                          dart_state, handle, nullptr, 0, NopFinalizer);
 
                      // Do not clear handle, so it is cleared on shutdown.
 
                      event.Signal();
                    }));
 
  ASSERT_TRUE(RunWithEntrypoint("callGiveObjectToNative"));
 
  event.Wait();
}

◆ TEST_F() [103/925]

flutter::testing::TEST_F	(	DiffContextTest	,
		ClipAlignment
	)

Definition at line 10 of file diff_context_unittests.cc.

                                       {
  MockLayerTree t1;
  t1.root()->Add(CreateDisplayListLayer(
      CreateDisplayList(SkRect::MakeLTRB(30, 30, 50, 50))));
  auto damage = DiffLayerTree(t1, MockLayerTree(), SkIRect::MakeEmpty(), 0, 0);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(30, 30, 50, 50));
  EXPECT_EQ(damage.buffer_damage, SkIRect::MakeLTRB(30, 30, 50, 50));
 
  damage = DiffLayerTree(t1, MockLayerTree(), SkIRect::MakeEmpty(), 1, 1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(30, 30, 50, 50));
  EXPECT_EQ(damage.buffer_damage, SkIRect::MakeLTRB(30, 30, 50, 50));
 
  damage = DiffLayerTree(t1, MockLayerTree(), SkIRect::MakeEmpty(), 8, 1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(24, 30, 56, 50));
  EXPECT_EQ(damage.buffer_damage, SkIRect::MakeLTRB(24, 30, 56, 50));
 
  damage = DiffLayerTree(t1, MockLayerTree(), SkIRect::MakeEmpty(), 1, 8);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(30, 24, 50, 56));
  EXPECT_EQ(damage.buffer_damage, SkIRect::MakeLTRB(30, 24, 50, 56));
 
  damage = DiffLayerTree(t1, MockLayerTree(), SkIRect::MakeEmpty(), 16, 16);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(16, 16, 64, 64));
  EXPECT_EQ(damage.buffer_damage, SkIRect::MakeLTRB(16, 16, 64, 64));
}

◆ TEST_F() [104/925]

flutter::testing::TEST_F	(	DisplayListLayerDiffTest	,
		DisplayListCompare
	)

Definition at line 403 of file display_list_layer_unittests.cc.

                                                     {
  MockLayerTree tree1;
  auto display_list1 =
      CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60), DlColor::kGreen());
  tree1.root()->Add(CreateDisplayListLayer(display_list1));
 
  auto damage = DiffLayerTree(tree1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 60, 60));
 
  MockLayerTree tree2;
  // same DL, same offset
  auto display_list2 =
      CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60), DlColor::kGreen());
  tree2.root()->Add(CreateDisplayListLayer(display_list2));
 
  damage = DiffLayerTree(tree2, tree1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeEmpty());
 
  MockLayerTree tree3;
  auto display_list3 =
      CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60), DlColor::kGreen());
  // add offset
  tree3.root()->Add(
      CreateDisplayListLayer(display_list3, SkPoint::Make(10, 10)));
 
  damage = DiffLayerTree(tree3, tree2);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 70, 70));
 
  MockLayerTree tree4;
  // different color
  auto display_list4 =
      CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60), DlColor::kRed());
  tree4.root()->Add(
      CreateDisplayListLayer(display_list4, SkPoint::Make(10, 10)));
 
  damage = DiffLayerTree(tree4, tree3);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(20, 20, 70, 70));
}

◆ TEST_F() [105/925]

flutter::testing::TEST_F	(	DisplayListLayerDiffTest	,
		FractionalTranslation
	)

Definition at line 377 of file display_list_layer_unittests.cc.

                                                        {
  auto display_list = CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60));
 
  MockLayerTree tree1;
  tree1.root()->Add(
      CreateDisplayListLayer(display_list, SkPoint::Make(0.5, 0.5)));
 
  auto damage =
      DiffLayerTree(tree1, MockLayerTree(), SkIRect::MakeEmpty(), 0, 0,
                    /*use_raster_cache=*/false);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 61, 61));
}

◆ TEST_F() [106/925]

flutter::testing::TEST_F	(	DisplayListLayerDiffTest	,
		FractionalTranslationWithRasterCache
	)

Definition at line 390 of file display_list_layer_unittests.cc.

                                                                       {
  auto display_list = CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60));
 
  MockLayerTree tree1;
  tree1.root()->Add(
      CreateDisplayListLayer(display_list, SkPoint::Make(0.5, 0.5)));
 
  auto damage =
      DiffLayerTree(tree1, MockLayerTree(), SkIRect::MakeEmpty(), 0, 0,
                    /*use_raster_cache=*/true);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(11, 11, 61, 61));
}

◆ TEST_F() [107/925]

flutter::testing::TEST_F	(	DisplayListLayerDiffTest	,
		SimpleDisplayList
	)

Definition at line 357 of file display_list_layer_unittests.cc.

                                                    {
  auto display_list = CreateDisplayList(SkRect::MakeLTRB(10, 10, 60, 60));
 
  MockLayerTree tree1;
  tree1.root()->Add(CreateDisplayListLayer(display_list));
 
  auto damage = DiffLayerTree(tree1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 60, 60));
 
  MockLayerTree tree2;
  tree2.root()->Add(CreateDisplayListLayer(display_list));
 
  damage = DiffLayerTree(tree2, tree1);
  EXPECT_TRUE(damage.frame_damage.isEmpty());
 
  MockLayerTree tree3;
  damage = DiffLayerTree(tree3, tree2);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 60, 60));
}

◆ TEST_F() [108/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		CachedIncompatibleDisplayListOpacityInheritance
	)

Definition at line 226 of file display_list_layer_unittests.cc.

                                                                              {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture1_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkRect picture2_bounds = SkRect::MakeLTRB(10.0f, 15.0f, 30.0f, 35.0f);
  DisplayListBuilder builder;
  builder.DrawRect(picture1_bounds, DlPaint());
  builder.DrawRect(picture2_bounds, DlPaint());
  auto display_list = builder.Build();
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      layer_offset, display_list, true, false);
  EXPECT_FALSE(display_list->can_apply_group_opacity());
 
  use_skia_raster_cache();
 
  auto context = preroll_context();
  display_list_layer->Preroll(preroll_context());
  EXPECT_EQ(context->renderable_state_flags, 0);
 
  // Pump the DisplayListLayer until it is ready to cache its DL
  display_list_layer->Preroll(preroll_context());
  display_list_layer->Preroll(preroll_context());
  display_list_layer->Preroll(preroll_context());
  LayerTree::TryToRasterCache(*preroll_context()->raster_cached_entries,
                              &paint_context(), false);
 
  int opacity_alpha = 0x7F;
  SkPoint opacity_offset = SkPoint::Make(10.2, 10.2);
  auto opacity_layer =
      std::make_shared<OpacityLayer>(opacity_alpha, opacity_offset);
  opacity_layer->Add(display_list_layer);
  opacity_layer->Preroll(context);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 
  auto display_list_bounds = picture1_bounds;
  display_list_bounds.join(picture2_bounds);
  auto save_layer_bounds =
      display_list_bounds.makeOffset(layer_offset.fX, layer_offset.fY);
  save_layer_bounds.roundOut(&save_layer_bounds);
  auto opacity_integral_matrix =
      RasterCacheUtil::GetIntegralTransCTM(SkMatrix::Translate(opacity_offset));
  SkMatrix layer_offset_matrix = opacity_integral_matrix;
  layer_offset_matrix.postTranslate(layer_offset.fX, layer_offset.fY);
  auto layer_offset_integral_matrix =
      RasterCacheUtil::GetIntegralTransCTM(layer_offset_matrix);
  DisplayListBuilder expected(SkRect::MakeWH(1000, 1000));
  /* opacity_layer::Paint() */ {
    expected.Save();
    {
      expected.Translate(opacity_offset.fX, opacity_offset.fY);
      expected.TransformReset();
      expected.Transform(opacity_integral_matrix);
      /* display_list_layer::Paint() */ {
        expected.Save();
        {
          expected.Translate(layer_offset.fX, layer_offset.fY);
          expected.TransformReset();
          expected.Transform(layer_offset_integral_matrix);
          context->raster_cache->Draw(display_list_layer->caching_key_id(),
                                      expected,
                                      &DlPaint().setAlpha(opacity_alpha));
        }
        expected.Restore();
      }
    }
    expected.Restore();
  }
 
  opacity_layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(expected.Build(), this->display_list()));
}

◆ TEST_F() [109/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		CachingDoesNotChangeCullRect
	)

Definition at line 101 of file display_list_layer_unittests.cc.

                                                           {
  const SkPoint layer_offset = SkPoint::Make(10, 10);
  DisplayListBuilder builder;
  builder.DrawRect({10, 10, 20, 20}, DlPaint());
  auto display_list = builder.Build();
  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
                                                  true, false);
 
  SkRect original_cull_rect = preroll_context()->state_stack.device_cull_rect();
  use_mock_raster_cache();
  layer->Preroll(preroll_context());
  ASSERT_EQ(preroll_context()->state_stack.device_cull_rect(),
            original_cull_rect);
}

◆ TEST_F() [110/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		DisplayListAccessCountDependsOnVisibility
	)

Definition at line 477 of file display_list_layer_unittests.cc.

                                                                        {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkRect missed_cull_rect = SkRect::MakeLTRB(100, 100, 200, 200);
  const SkRect hit_cull_rect = SkRect::MakeLTRB(0, 0, 200, 200);
  DisplayListBuilder builder;
  builder.DrawRect(picture_bounds, DlPaint());
  auto display_list = builder.Build();
  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
                                                  true, false);
 
  auto raster_cache_item = layer->raster_cache_item();
  use_mock_raster_cache();
 
  // First Preroll the DisplayListLayer a few times where it does not intersect
  // the cull rect. No caching progress should occur during this time, the
  // access_count should remain 0 because the DisplayList was never "visible".
  ASSERT_TRUE(preroll_context()->state_stack.is_empty());
  preroll_context()->state_stack.set_preroll_delegate(missed_cull_rect);
  for (int i = 0; i < 10; i++) {
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    ASSERT_EQ(raster_cache_item->cache_state(), RasterCacheItem::kNone);
    ASSERT_TRUE(raster_cache_item->GetId().has_value());
    ASSERT_EQ(preroll_context()->raster_cache->GetAccessCount(
                  raster_cache_item->GetId().value(), SkMatrix::I()),
              0);
    ASSERT_EQ(preroll_context()->raster_cached_entries->size(), size_t(1));
    ASSERT_EQ(preroll_context()->raster_cache->EstimatePictureCacheByteSize(),
              size_t(0));
    ASSERT_FALSE(raster_cache_item->TryToPrepareRasterCache(paint_context()));
    ASSERT_FALSE(raster_cache_item->Draw(paint_context(), nullptr));
  }
 
  // Next Preroll the DisplayListLayer once where it does intersect
  // the cull rect. No caching progress should occur during this time
  // since this is the first frame in which it was visible, but the
  // count should start incrementing.
  ASSERT_TRUE(preroll_context()->state_stack.is_empty());
  preroll_context()->state_stack.set_preroll_delegate(hit_cull_rect);
  preroll_context()->raster_cached_entries->clear();
  layer->Preroll(preroll_context());
  ASSERT_EQ(raster_cache_item->cache_state(), RasterCacheItem::kNone);
  ASSERT_TRUE(raster_cache_item->GetId().has_value());
  ASSERT_EQ(preroll_context()->raster_cache->GetAccessCount(
                raster_cache_item->GetId().value(), SkMatrix::I()),
            1);
  ASSERT_EQ(preroll_context()->raster_cached_entries->size(), size_t(1));
  ASSERT_EQ(preroll_context()->raster_cache->EstimatePictureCacheByteSize(),
            size_t(0));
  ASSERT_FALSE(raster_cache_item->TryToPrepareRasterCache(paint_context()));
  ASSERT_FALSE(raster_cache_item->Draw(paint_context(), nullptr));
 
  // Now we can Preroll the DisplayListLayer again with a cull rect that
  // it does not intersect and it should continue to count these operations
  // even though it is not visible. No actual caching should occur yet,
  // even though we will surpass its threshold.
  ASSERT_TRUE(preroll_context()->state_stack.is_empty());
  preroll_context()->state_stack.set_preroll_delegate(missed_cull_rect);
  for (int i = 0; i < 10; i++) {
    preroll_context()->raster_cached_entries->clear();
    layer->Preroll(preroll_context());
    ASSERT_EQ(raster_cache_item->cache_state(), RasterCacheItem::kNone);
    ASSERT_TRUE(raster_cache_item->GetId().has_value());
    ASSERT_EQ(preroll_context()->raster_cache->GetAccessCount(
                  raster_cache_item->GetId().value(), SkMatrix::I()),
              i + 2);
    ASSERT_EQ(preroll_context()->raster_cached_entries->size(), size_t(1));
    ASSERT_EQ(preroll_context()->raster_cache->EstimatePictureCacheByteSize(),
              size_t(0));
    ASSERT_FALSE(raster_cache_item->TryToPrepareRasterCache(paint_context()));
    ASSERT_FALSE(raster_cache_item->Draw(paint_context(), nullptr));
  }
 
  // Finally Preroll the DisplayListLayer again where it does intersect
  // the cull rect. Since we should have exhausted our access count
  // threshold in the loop above, these operations should result in the
  // DisplayList being cached.
  ASSERT_TRUE(preroll_context()->state_stack.is_empty());
  preroll_context()->state_stack.set_preroll_delegate(hit_cull_rect);
  preroll_context()->raster_cached_entries->clear();
  layer->Preroll(preroll_context());
  ASSERT_EQ(raster_cache_item->cache_state(), RasterCacheItem::kCurrent);
  ASSERT_TRUE(raster_cache_item->GetId().has_value());
  ASSERT_EQ(preroll_context()->raster_cache->GetAccessCount(
                raster_cache_item->GetId().value(), SkMatrix::I()),
            12);
  ASSERT_EQ(preroll_context()->raster_cached_entries->size(), size_t(1));
  ASSERT_EQ(preroll_context()->raster_cache->EstimatePictureCacheByteSize(),
            size_t(0));
  ASSERT_TRUE(raster_cache_item->TryToPrepareRasterCache(paint_context()));
  ASSERT_GT(preroll_context()->raster_cache->EstimatePictureCacheByteSize(),
            size_t(0));
  ASSERT_TRUE(raster_cache_item->Draw(paint_context(), nullptr));
}

◆ TEST_F() [111/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		IncompatibleDisplayListOpacityInheritance
	)

Definition at line 166 of file display_list_layer_unittests.cc.

                                                                        {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture1_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkRect picture2_bounds = SkRect::MakeLTRB(10.0f, 15.0f, 30.0f, 35.0f);
  DisplayListBuilder builder;
  builder.DrawRect(picture1_bounds, DlPaint());
  builder.DrawRect(picture2_bounds, DlPaint());
  auto display_list = builder.Build();
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      layer_offset, display_list, false, false);
  EXPECT_FALSE(display_list->can_apply_group_opacity());
 
  auto context = preroll_context();
  display_list_layer->Preroll(preroll_context());
  EXPECT_EQ(context->renderable_state_flags, 0);
 
  int opacity_alpha = 0x7F;
  SkPoint opacity_offset = SkPoint::Make(10, 10);
  auto opacity_layer =
      std::make_shared<OpacityLayer>(opacity_alpha, opacity_offset);
  opacity_layer->Add(display_list_layer);
  opacity_layer->Preroll(context);
  EXPECT_FALSE(opacity_layer->children_can_accept_opacity());
 
  DisplayListBuilder child_builder;
  child_builder.DrawRect(picture1_bounds, DlPaint());
  child_builder.DrawRect(picture2_bounds, DlPaint());
  auto child_display_list = child_builder.Build();
 
  auto display_list_bounds = picture1_bounds;
  display_list_bounds.join(picture2_bounds);
  auto save_layer_bounds =
      display_list_bounds.makeOffset(layer_offset.fX, layer_offset.fY);
  DisplayListBuilder expected_builder;
  /* opacity_layer::Paint() */ {
    expected_builder.Save();
    {
      expected_builder.Translate(opacity_offset.fX, opacity_offset.fY);
      expected_builder.SaveLayer(&save_layer_bounds,
                                 &DlPaint().setAlpha(opacity_alpha));
      {
        /* display_list_layer::Paint() */ {
          expected_builder.Save();
          {
            expected_builder.Translate(layer_offset.fX, layer_offset.fY);
            expected_builder.DrawDisplayList(child_display_list);
          }
          expected_builder.Restore();
        }
      }
      expected_builder.Restore();
    }
    expected_builder.Restore();
  }
 
  opacity_layer->Paint(display_list_paint_context());
  EXPECT_TRUE(
      DisplayListsEQ_Verbose(this->display_list(), expected_builder.Build()));
}

◆ TEST_F() [112/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		InvalidDisplayListDies
	)

Definition at line 62 of file display_list_layer_unittests.cc.

                                                     {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  auto layer = std::make_shared<DisplayListLayer>(
      layer_offset, sk_sp<DisplayList>(), false, false);
 
  // Crashes reading a nullptr.
  EXPECT_DEATH_IF_SUPPORTED(layer->Preroll(preroll_context()), "");
}

◆ TEST_F() [113/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		LayerTreeSnapshotsWhenEnabled
	)

Definition at line 442 of file display_list_layer_unittests.cc.

                                                            {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  DisplayListBuilder builder;
  builder.DrawRect(picture_bounds, DlPaint());
  auto display_list = builder.Build();
  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
                                                  false, false);
 
  layer->Preroll(preroll_context());
 
  enable_leaf_layer_tracing();
  layer->Paint(paint_context());
  disable_leaf_layer_tracing();
 
  auto& snapshot_store = layer_snapshot_store();
  EXPECT_EQ(1u, snapshot_store.Size());
}

◆ TEST_F() [114/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		NoLayerTreeSnapshotsWhenDisabledByDefault
	)

Definition at line 461 of file display_list_layer_unittests.cc.

                                                                        {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  DisplayListBuilder builder;
  builder.DrawRect(picture_bounds, DlPaint());
  auto display_list = builder.Build();
  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
                                                  false, false);
 
  layer->Preroll(preroll_context());
  layer->Paint(paint_context());
 
  auto& snapshot_store = layer_snapshot_store();
  EXPECT_EQ(0u, snapshot_store.Size());
}

◆ TEST_F() [115/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		OverflowCachedDisplayListOpacityInheritance
	)

Definition at line 573 of file display_list_layer_unittests.cc.

                                                                          {
  use_mock_raster_cache();
  PrerollContext* context = preroll_context();
  int per_frame =
      RasterCacheUtil::kDefaultPictureAndDisplayListCacheLimitPerFrame;
  int layer_count = per_frame + 1;
  SkPoint opacity_offset = {10, 10};
  auto opacity_layer = std::make_shared<OpacityLayer>(0.5f, opacity_offset);
  std::vector<std::shared_ptr<DisplayListLayer>> layers;
  for (int i = 0; i < layer_count; i++) {
    DisplayListBuilder builder(false);
    builder.DrawRect({0, 0, 100, 100}, DlPaint());
    builder.DrawRect({50, 50, 100, 100}, DlPaint());
    auto display_list = builder.Build();
    ASSERT_FALSE(display_list->can_apply_group_opacity());
    SkPoint offset = {i * 200.0f, 0};
 
    layers.push_back(
        std::make_shared<DisplayListLayer>(offset, display_list, true, false));
    opacity_layer->Add(layers.back());
  }
  for (size_t j = 0; j < context->raster_cache->access_threshold(); j++) {
    context->raster_cache->BeginFrame();
    for (int i = 0; i < layer_count; i++) {
      context->renderable_state_flags = 0;
      layers[i]->Preroll(context);
      ASSERT_EQ(context->renderable_state_flags, 0) << "pass " << (j + 1);
    }
  }
  opacity_layer->Preroll(context);
  ASSERT_FALSE(opacity_layer->children_can_accept_opacity());
  LayerTree::TryToRasterCache(*context->raster_cached_entries, &paint_context(),
                              false);
  context->raster_cached_entries->clear();
  context->raster_cache->BeginFrame();
  for (int i = 0; i < per_frame; i++) {
    context->renderable_state_flags = 0;
    layers[i]->Preroll(context);
    ASSERT_EQ(context->renderable_state_flags,
              LayerStateStack::kCallerCanApplyOpacity)
        << "layer " << (i + 1);
  }
  for (int i = per_frame; i < layer_count; i++) {
    context->renderable_state_flags = 0;
    layers[i]->Preroll(context);
    ASSERT_EQ(context->renderable_state_flags, 0) << "layer " << (i + 1);
  }
  opacity_layer->Preroll(context);
  ASSERT_FALSE(opacity_layer->children_can_accept_opacity());
  LayerTree::TryToRasterCache(*context->raster_cached_entries, &paint_context(),
                              false);
  context->raster_cached_entries->clear();
  context->raster_cache->BeginFrame();
  for (int i = 0; i < layer_count; i++) {
    context->renderable_state_flags = 0;
    layers[i]->Preroll(context);
    ASSERT_EQ(context->renderable_state_flags,
              LayerStateStack::kCallerCanApplyOpacity)
        << "layer " << (i + 1);
  }
  opacity_layer->Preroll(context);
  ASSERT_TRUE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [116/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		PaintBeforePrerollInvalidDisplayListDies
	)

Definition at line 23 of file display_list_layer_unittests.cc.

                                                                       {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  auto layer = std::make_shared<DisplayListLayer>(
      layer_offset, sk_sp<DisplayList>(), false, false);
 
  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()), "display_list_");
}

◆ TEST_F() [117/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		RasterCachePreservesRTree
	)

Definition at line 297 of file display_list_layer_unittests.cc.

                                                        {
  const SkRect picture1_bounds = SkRect::MakeXYWH(10, 10, 10, 10);
  const SkRect picture2_bounds = SkRect::MakeXYWH(15, 15, 10, 10);
  DisplayListBuilder builder(true);
  builder.DrawRect(picture1_bounds, DlPaint());
  builder.DrawRect(picture2_bounds, DlPaint());
  auto display_list = builder.Build();
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      SkPoint::Make(3, 3), display_list, true, false);
 
  use_skia_raster_cache();
 
  auto context = preroll_context();
  {
    auto mutator = context->state_stack.save();
    mutator.transform(SkMatrix::Scale(2.0, 2.0));
    display_list_layer->Preroll(preroll_context());
    EXPECT_EQ(context->renderable_state_flags, 0);
 
    // Pump the DisplayListLayer until it is ready to cache its DL
    display_list_layer->Preroll(preroll_context());
    display_list_layer->Preroll(preroll_context());
    display_list_layer->Preroll(preroll_context());
    LayerTree::TryToRasterCache(*preroll_context()->raster_cached_entries,
                                &paint_context(), false);
  }
 
  DisplayListBuilder expected_root_canvas(true);
  expected_root_canvas.Scale(2.0, 2.0);
  ASSERT_TRUE(context->raster_cache->Draw(display_list_layer->caching_key_id(),
                                          expected_root_canvas, nullptr,
                                          false));
  auto root_canvas_dl = expected_root_canvas.Build();
  const auto root_canvas_rects =
      root_canvas_dl->rtree()->searchAndConsolidateRects(kGiantRect, true);
  std::list<SkRect> root_canvas_rects_expected = {
      SkRect::MakeLTRB(26, 26, 56, 56),
  };
  EXPECT_EQ(root_canvas_rects_expected, root_canvas_rects);
 
  DisplayListBuilder expected_overlay_canvas(true);
  expected_overlay_canvas.Scale(2.0, 2.0);
  ASSERT_TRUE(context->raster_cache->Draw(display_list_layer->caching_key_id(),
                                          expected_overlay_canvas, nullptr,
                                          true));
  auto overlay_canvas_dl = expected_overlay_canvas.Build();
  const auto overlay_canvas_rects =
      overlay_canvas_dl->rtree()->searchAndConsolidateRects(kGiantRect, true);
 
  // Same bounds as root canvas, but preserves individual rects.
  std::list<SkRect> overlay_canvas_rects_expected = {
      SkRect::MakeLTRB(26, 26, 46, 36),
      SkRect::MakeLTRB(26, 36, 56, 46),
      SkRect::MakeLTRB(36, 46, 56, 56),
  };
  EXPECT_EQ(overlay_canvas_rects_expected, overlay_canvas_rects);
};

◆ TEST_F() [118/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		SimpleDisplayList
	)

Definition at line 72 of file display_list_layer_unittests.cc.

                                                {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  DisplayListBuilder builder;
  builder.DrawRect(picture_bounds, DlPaint());
  auto display_list = builder.Build();
  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
                                                  false, false);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(),
            picture_bounds.makeOffset(layer_offset.fX, layer_offset.fY));
  EXPECT_EQ(layer->display_list(), display_list.get());
  EXPECT_TRUE(layer->needs_painting(paint_context()));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (DisplayList)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Translate(layer_offset.fX, layer_offset.fY);
      expected_builder.DrawDisplayList(display_list);
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(
      DisplayListsEQ_Verbose(this->display_list(), expected_builder.Build()));
}

◆ TEST_F() [119/925]

flutter::testing::TEST_F	(	DisplayListLayerTest	,
		SimpleDisplayListOpacityInheritance
	)

Definition at line 116 of file display_list_layer_unittests.cc.

                                                                  {
  const SkPoint layer_offset = SkPoint::Make(1.5f, -0.5f);
  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  DisplayListBuilder builder;
  builder.DrawRect(picture_bounds, DlPaint());
  auto display_list = builder.Build();
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      layer_offset, display_list, false, false);
  EXPECT_TRUE(display_list->can_apply_group_opacity());
 
  auto context = preroll_context();
  display_list_layer->Preroll(preroll_context());
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
 
  int opacity_alpha = 0x7F;
  SkScalar opacity = opacity_alpha / 255.0;
  SkPoint opacity_offset = SkPoint::Make(10, 10);
  auto opacity_layer =
      std::make_shared<OpacityLayer>(opacity_alpha, opacity_offset);
  opacity_layer->Add(display_list_layer);
  opacity_layer->Preroll(context);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 
  DisplayListBuilder child_builder;
  child_builder.DrawRect(picture_bounds, DlPaint());
  auto child_display_list = child_builder.Build();
 
  DisplayListBuilder expected_builder;
  /* opacity_layer::Paint() */ {
    expected_builder.Save();
    {
      expected_builder.Translate(opacity_offset.fX, opacity_offset.fY);
      /* display_list_layer::Paint() */ {
        expected_builder.Save();
        {
          expected_builder.Translate(layer_offset.fX, layer_offset.fY);
          expected_builder.DrawDisplayList(child_display_list, opacity);
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
 
  opacity_layer->Paint(display_list_paint_context());
  EXPECT_TRUE(
      DisplayListsEQ_Verbose(this->display_list(), expected_builder.Build()));
}

◆ TEST_F() [120/925]

flutter::testing::TEST_F	(	DisplayListNopTest	,
		BlendModeAndColorAndFiltersByRendering
	)

Definition at line 4690 of file dl_rendering_unittests.cc.

                                                                   {
  auto test_mode_render = [this](DlBlendMode mode) {
    auto image_filter_nomtb = DlColorFilterImageFilter(color_filter_nomtb);
    auto image_filter_mtb = DlColorFilterImageFilter(color_filter_mtb);
    for (DlColor color : test_src_colors) {
      test_attributes_image(mode, color, nullptr, nullptr);
      test_attributes_image(mode, color, color_filter_nomtb.get(), nullptr);
      test_attributes_image(mode, color, color_filter_mtb.get(), nullptr);
      test_attributes_image(mode, color, nullptr, &image_filter_nomtb);
      test_attributes_image(mode, color, nullptr, &image_filter_mtb);
    }
  };
 
#define TEST_MODE(V) test_mode_render(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST_F() [121/925]

flutter::testing::TEST_F	(	DisplayListNopTest	,
		BlendModeAndColorByRendering
	)

Definition at line 4677 of file dl_rendering_unittests.cc.

                                                         {
  auto test_mode_render = [this](DlBlendMode mode) {
    // First check rendering a variety of colors onto image
    for (DlColor color : test_src_colors) {
      test_mode_color_via_rendering(mode, color);
    }
  };
 
#define TEST_MODE(V) test_mode_render(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST_F() [122/925]

flutter::testing::TEST_F	(	DisplayListNopTest	,
		BlendModeAndColorViaColorFilter
	)

Definition at line 4665 of file dl_rendering_unittests.cc.

                                                            {
  auto test_mode_filter = [this](DlBlendMode mode) {
    for (DlColor color : test_src_colors) {
      test_mode_color_via_filter(mode, color);
    }
  };
 
#define TEST_MODE(V) test_mode_filter(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST_F() [123/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		BlendColorFilterModifyTransparencyCheck
	)

Definition at line 4220 of file dl_rendering_unittests.cc.

                                                                      {
  auto test_mode_color = [](DlBlendMode mode, DlColor color) {
    std::stringstream desc_str;
    std::string mode_string = BlendModeToString(mode);
    desc_str << "blend[" << mode_string << ", " << color << "]";
    std::string desc = desc_str.str();
    DlBlendColorFilter filter(color, mode);
    if (filter.modifies_transparent_black()) {
      ASSERT_NE(DlBlendColorFilter::Make(color, mode), nullptr) << desc;
    }
 
    DlPaint paint(DlColor(0x7f7f7f7f));
    DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
    DisplayListBuilder builder1;
    builder1.Translate(kTestCenter.fX, kTestCenter.fY);
    builder1.Rotate(45);
    builder1.Translate(-kTestCenter.fX, -kTestCenter.fY);
    builder1.DrawRect(kRenderBounds, paint);
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    builder2.Translate(kTestCenter.fX, kTestCenter.fY);
    builder2.Rotate(45);
    builder2.Translate(-kTestCenter.fX, -kTestCenter.fY);
    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
    builder2.DrawRect(kRenderBounds, paint);
    builder2.Restore();
    auto display_list2 = builder2.Build();
 
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto env = std::make_unique<RenderEnvironment>(
          provider.get(), PixelFormat::kN32PremulPixelFormat);
      auto results1 = env->getResult(display_list1);
      auto results2 = env->getResult(display_list2);
      int modified_transparent_pixels =
          CanvasCompareTester::countModifiedTransparentPixels(results1.get(),
                                                              results2.get());
      EXPECT_EQ(filter.modifies_transparent_black(),
                modified_transparent_pixels != 0)
          << desc;
    }
  };
 
  auto test_mode = [&test_mode_color](DlBlendMode mode) {
    test_mode_color(mode, DlColor::kTransparent());
    test_mode_color(mode, DlColor::kWhite());
    test_mode_color(mode, DlColor::kWhite().modulateOpacity(0.5));
    test_mode_color(mode, DlColor::kBlack());
    test_mode_color(mode, DlColor::kBlack().modulateOpacity(0.5));
  };
 
#define TEST_MODE(V) test_mode(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST_F() [124/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		BlendColorFilterOpacityCommuteCheck
	)

Definition at line 4278 of file dl_rendering_unittests.cc.

                                                                  {
  auto test_mode_color = [](DlBlendMode mode, DlColor color) {
    std::stringstream desc_str;
    std::string mode_string = BlendModeToString(mode);
    desc_str << "blend[" << mode_string << ", " << color << "]";
    std::string desc = desc_str.str();
    DlBlendColorFilter filter(color, mode);
    if (filter.can_commute_with_opacity()) {
      // If it can commute with opacity, then it might also be a NOP,
      // so we won't necessarily get a non-null return from |::Make()|
    } else {
      ASSERT_NE(DlBlendColorFilter::Make(color, mode), nullptr) << desc;
    }
 
    DlPaint paint(DlColor(0x80808080));
    DlPaint opacity_save_paint = DlPaint().setOpacity(0.5);
    DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
    DisplayListBuilder builder1;
    builder1.SaveLayer(&kTestBounds2, &opacity_save_paint);
    builder1.SaveLayer(&kTestBounds2, &filter_save_paint);
    // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
    builder1.DrawRect(kRenderBounds, paint);
    builder1.Restore();
    builder1.Restore();
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
    builder2.SaveLayer(&kTestBounds2, &opacity_save_paint);
    // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
    builder2.DrawRect(kRenderBounds, paint);
    builder2.Restore();
    builder2.Restore();
    auto display_list2 = builder2.Build();
 
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto env = std::make_unique<RenderEnvironment>(
          provider.get(), PixelFormat::kN32PremulPixelFormat);
      auto results1 = env->getResult(display_list1);
      auto results2 = env->getResult(display_list2);
      if (filter.can_commute_with_opacity()) {
        CanvasCompareTester::compareToReference(
            results2.get(), results1.get(), desc, nullptr, nullptr,
            DlColor::kTransparent(), true, kTestWidth, kTestHeight, true);
      } else {
        CanvasCompareTester::quickCompareToReference(
            results1.get(), results2.get(), false, desc);
      }
    }
  };
 
  auto test_mode = [&test_mode_color](DlBlendMode mode) {
    test_mode_color(mode, DlColor::kTransparent());
    test_mode_color(mode, DlColor::kWhite());
    test_mode_color(mode, DlColor::kWhite().modulateOpacity(0.5));
    test_mode_color(mode, DlColor::kBlack());
    test_mode_color(mode, DlColor::kBlack().modulateOpacity(0.5));
  };
 
#define TEST_MODE(V) test_mode(DlBlendMode::V);
  FOR_EACH_BLEND_MODE_ENUM(TEST_MODE)
#undef TEST_MODE
}

◆ TEST_F() [125/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawAlphaColor
	)

Definition at line 2835 of file dl_rendering_unittests.cc.

                                             {
  // We use a non-opaque color to avoid obliterating any backdrop filter output
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawColor(0x7FFF00FF);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawColor(DlColor(0x7FFF00FF));
          },
          kDrawColorFlags));
}

◆ TEST_F() [126/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawArc
	)

Definition at line 3083 of file dl_rendering_unittests.cc.

                                      {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawArc(kRenderBounds, 60, 330, false, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawArc(kRenderBounds, 60, 330, false, ctx.paint);
          },
          kDrawArcNoCenterFlags));
}

◆ TEST_F() [127/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawArcCenter
	)

Definition at line 3095 of file dl_rendering_unittests.cc.

                                            {
  // Center arcs that inscribe nearly a whole circle except for a small
  // arc extent gap have 2 angles that may appear or disappear at the
  // various miter limits tested (0, 4, and 10).
  // The center angle here is 12 degrees which shows a miter
  // at limit=10, but not 0 or 4.
  // The arcs at the corners where it turns in towards the
  // center show miters at 4 and 10, but not 0.
  // Limit == 0, neither corner does a miter
  // Limit == 4, only the edge "turn-in" corners miter
  // Limit == 10, edge and center corners all miter
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawArc(kRenderBounds, 60, 360 - 12, true, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawArc(kRenderBounds, 60, 360 - 12, true, ctx.paint);
          },
          kDrawArcWithCenterFlags)
          .set_draw_arc_center());
}

◆ TEST_F() [128/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawAtlasLinear
	)

Definition at line 3596 of file dl_rendering_unittests.cc.

                                              {
  const SkRSXform xform[] = {
      // clang-format off
      { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
      { 0.0f,  1.2f, kRenderRight, kRenderTop},
      {-1.2f,  0.0f, kRenderRight, kRenderBottom},
      { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
      // clang-format on
  };
  const SkRect tex[] = {
      // clang-format off
      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
      // clang-format on
  };
  const SkColor sk_colors[] = {
      SK_ColorBLUE,
      SK_ColorGREEN,
      SK_ColorYELLOW,
      SK_ColorMAGENTA,
  };
  const DlColor dl_colors[] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::kYellow(),
      DlColor::kMagenta(),
  };
  const DlImageSampling dl_sampling = DlImageSampling::kLinear;
  const SkSamplingOptions sk_sampling = SkImageSampling::kLinear;
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawAtlas(ctx.image.get(), xform, tex, sk_colors, 2,
                                  SkBlendMode::kSrcOver, sk_sampling,  //
                                  nullptr, &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawAtlas(ctx.image, xform, tex, dl_colors, 2,
                                  DlBlendMode::kSrcOver, dl_sampling,  //
                                  nullptr, &ctx.paint);
          },
          kDrawAtlasWithPaintFlags));
}

◆ TEST_F() [129/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawAtlasNearest
	)

Definition at line 3504 of file dl_rendering_unittests.cc.

                                               {
  const SkRSXform xform[] = {
      // clang-format off
      { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
      { 0.0f,  1.2f, kRenderRight, kRenderTop},
      {-1.2f,  0.0f, kRenderRight, kRenderBottom},
      { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
      // clang-format on
  };
  const SkRect tex[] = {
      // clang-format off
      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
      // clang-format on
  };
  const SkColor sk_colors[] = {
      SK_ColorBLUE,
      SK_ColorGREEN,
      SK_ColorYELLOW,
      SK_ColorMAGENTA,
  };
  const DlColor dl_colors[] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::kYellow(),
      DlColor::kMagenta(),
  };
  const DlImageSampling dl_sampling = DlImageSampling::kNearestNeighbor;
  const SkSamplingOptions sk_sampling = SkImageSampling::kNearestNeighbor;
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawAtlas(ctx.image.get(), xform, tex, sk_colors, 4,
                                  SkBlendMode::kSrcOver, sk_sampling, nullptr,
                                  &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawAtlas(ctx.image, xform, tex, dl_colors, 4,
                                  DlBlendMode::kSrcOver, dl_sampling, nullptr,
                                  &ctx.paint);
          },
          kDrawAtlasWithPaintFlags));
}

◆ TEST_F() [130/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawAtlasNearestNoPaint
	)

Definition at line 3550 of file dl_rendering_unittests.cc.

                                                      {
  const SkRSXform xform[] = {
      // clang-format off
      { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
      { 0.0f,  1.2f, kRenderRight, kRenderTop},
      {-1.2f,  0.0f, kRenderRight, kRenderBottom},
      { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
      // clang-format on
  };
  const SkRect tex[] = {
      // clang-format off
      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
      // clang-format on
  };
  const SkColor sk_colors[] = {
      SK_ColorBLUE,
      SK_ColorGREEN,
      SK_ColorYELLOW,
      SK_ColorMAGENTA,
  };
  const DlColor dl_colors[] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::kYellow(),
      DlColor::kMagenta(),
  };
  const DlImageSampling dl_sampling = DlImageSampling::kNearestNeighbor;
  const SkSamplingOptions sk_sampling = SkImageSampling::kNearestNeighbor;
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawAtlas(ctx.image.get(), xform, tex, sk_colors, 4,
                                  SkBlendMode::kSrcOver, sk_sampling,  //
                                  nullptr, nullptr);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawAtlas(ctx.image, xform, tex, dl_colors, 4,
                                  DlBlendMode::kSrcOver, dl_sampling,  //
                                  nullptr, nullptr);
          },
          kDrawAtlasFlags));
}

◆ TEST_F() [131/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawCircle
	)

Definition at line 3005 of file dl_rendering_unittests.cc.

                                         {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawCircle(kTestCenter, kRenderRadius, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawCircle(kTestCenter, kRenderRadius, ctx.paint);
          },
          kDrawCircleFlags));
}

◆ TEST_F() [132/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawDiagonalDashedLines
	)

Definition at line 2927 of file dl_rendering_unittests.cc.

                                                      {
  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderTop);
  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderBottom);
  SkPoint p3 = SkPoint::Make(kRenderLeft, kRenderBottom);
  SkPoint p4 = SkPoint::Make(kRenderRight, kRenderTop);
  // Adding some edge center to edge center diagonals to better fill
  // out the RRect Clip so bounds checking sees less empty bounds space.
  SkPoint p5 = SkPoint::Make(kRenderCenterX, kRenderTop);
  SkPoint p6 = SkPoint::Make(kRenderRight, kRenderCenterY);
  SkPoint p7 = SkPoint::Make(kRenderLeft, kRenderCenterY);
  SkPoint p8 = SkPoint::Make(kRenderCenterX, kRenderBottom);
 
  // Full diagonals are 100x100 which are 140 in length
  // Dashing them with 25 on, 5 off means that the last
  // dash goes from 120 to 145 which means both ends of the
  // diagonals will be in an "on" dash for maximum bounds
 
  // Edge to edge diagonals are 50x50 which are 70 in length
  // Dashing them with 25 on, 5 off means that the last
  // dash goes from 60 to 85 which means both ends of the
  // edge diagonals will be in a dash segment
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            SkScalar intervals[2] = {25.0f, 5.0f};
            p.setPathEffect(SkDashPathEffect::Make(intervals, 2.0f, 0.0f));
            ctx.canvas->drawLine(p1, p2, p);
            ctx.canvas->drawLine(p3, p4, p);
            ctx.canvas->drawLine(p5, p6, p);
            ctx.canvas->drawLine(p7, p8, p);
          },
          [=](const DlRenderContext& ctx) {                           //
            ctx.canvas->DrawDashedLine(ToDlPoint(p1), ToDlPoint(p2),  //
                                       25.0f, 5.0f, ctx.paint);
            ctx.canvas->DrawDashedLine(ToDlPoint(p3), ToDlPoint(p4),  //
                                       25.0f, 5.0f, ctx.paint);
            ctx.canvas->DrawDashedLine(ToDlPoint(p5), ToDlPoint(p6),  //
                                       25.0f, 5.0f, ctx.paint);
            ctx.canvas->DrawDashedLine(ToDlPoint(p7), ToDlPoint(p8),  //
                                       25.0f, 5.0f, ctx.paint);
          },
          kDrawLineFlags)
          .set_draw_line());
}

◆ TEST_F() [133/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawDiagonalLines
	)

Definition at line 2848 of file dl_rendering_unittests.cc.

                                                {
  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderTop);
  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderBottom);
  SkPoint p3 = SkPoint::Make(kRenderLeft, kRenderBottom);
  SkPoint p4 = SkPoint::Make(kRenderRight, kRenderTop);
  // Adding some edge center to edge center diagonals to better fill
  // out the RRect Clip so bounds checking sees less empty bounds space.
  SkPoint p5 = SkPoint::Make(kRenderCenterX, kRenderTop);
  SkPoint p6 = SkPoint::Make(kRenderRight, kRenderCenterY);
  SkPoint p7 = SkPoint::Make(kRenderLeft, kRenderCenterY);
  SkPoint p8 = SkPoint::Make(kRenderCenterX, kRenderBottom);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            ctx.canvas->drawLine(p1, p2, p);
            ctx.canvas->drawLine(p3, p4, p);
            ctx.canvas->drawLine(p5, p6, p);
            ctx.canvas->drawLine(p7, p8, p);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawLine(p1, p2, ctx.paint);
            ctx.canvas->DrawLine(p3, p4, ctx.paint);
            ctx.canvas->DrawLine(p5, p6, ctx.paint);
            ctx.canvas->DrawLine(p7, p8, ctx.paint);
          },
          kDrawLineFlags)
          .set_draw_line());
}

◆ TEST_F() [134/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawDisplayList
	)

Definition at line 3661 of file dl_rendering_unittests.cc.

                                              {
  sk_sp<DisplayList> display_list = makeTestDisplayList();
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            DlSkCanvasAdapter(ctx.canvas).DrawDisplayList(display_list);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawDisplayList(display_list);
          },
          kDrawDisplayListFlags)
          .set_draw_display_list());
}

◆ TEST_F() [135/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawDRRect
	)

Definition at line 3031 of file dl_rendering_unittests.cc.

                                         {
  SkRRect outer = SkRRect::MakeRectXY(kRenderBounds, kRenderCornerRadius,
                                      kRenderCornerRadius);
  SkRect inner_bounds = kRenderBounds.makeInset(30.0, 30.0);
  SkRRect inner = SkRRect::MakeRectXY(inner_bounds, kRenderCornerRadius,
                                      kRenderCornerRadius);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawDRRect(outer, inner, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawDRRect(outer, inner, ctx.paint);
          },
          kDrawDRRectFlags));
}

◆ TEST_F() [136/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawHorizontalLine
	)

Definition at line 2883 of file dl_rendering_unittests.cc.

                                                 {
  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderCenterY);
  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderCenterY);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            ctx.canvas->drawLine(p1, p2, p);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawLine(p1, p2, ctx.paint);
          },
          kDrawHVLineFlags)
          .set_draw_line()
          .set_horizontal_line());
}

◆ TEST_F() [137/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageLinear
	)

Definition at line 3387 of file dl_rendering_unittests.cc.

                                              {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImage(ctx.image, kRenderLeft, kRenderTop,
                                  SkImageSampling::kLinear, &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImage(ctx.image,
                                  SkPoint::Make(kRenderLeft, kRenderTop),
                                  DlImageSampling::kLinear, &ctx.paint);
          },
          kDrawImageWithPaintFlags));
}

◆ TEST_F() [138/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageNearest
	)

Definition at line 3355 of file dl_rendering_unittests.cc.

                                               {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImage(ctx.image, kRenderLeft, kRenderTop,
                                  SkImageSampling::kNearestNeighbor,
                                  &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImage(ctx.image,  //
                                  SkPoint::Make(kRenderLeft, kRenderTop),
                                  DlImageSampling::kNearestNeighbor,
                                  &ctx.paint);
          },
          kDrawImageWithPaintFlags));
}

◆ TEST_F() [139/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageNearestNoPaint
	)

Definition at line 3372 of file dl_rendering_unittests.cc.

                                                      {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImage(ctx.image, kRenderLeft, kRenderTop,
                                  SkImageSampling::kNearestNeighbor, nullptr);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImage(ctx.image,
                                  SkPoint::Make(kRenderLeft, kRenderTop),
                                  DlImageSampling::kNearestNeighbor, nullptr);
          },
          kDrawImageFlags));
}

◆ TEST_F() [140/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageNineLinear
	)

Definition at line 3488 of file dl_rendering_unittests.cc.

                                                  {
  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
                                      SkFilterMode::kLinear, &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImageNine(ctx.image, src, dst,
                                      DlFilterMode::kLinear, &ctx.paint);
          },
          kDrawImageNineWithPaintFlags));
}

◆ TEST_F() [141/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageNineNearest
	)

Definition at line 3456 of file dl_rendering_unittests.cc.

                                                   {
  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
                                      SkFilterMode::kNearest, &ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImageNine(ctx.image, src, dst,
                                      DlFilterMode::kNearest, &ctx.paint);
          },
          kDrawImageNineWithPaintFlags));
}

◆ TEST_F() [142/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageNineNearestNoPaint
	)

Definition at line 3472 of file dl_rendering_unittests.cc.

                                                          {
  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
                                      SkFilterMode::kNearest, nullptr);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImageNine(ctx.image, src, dst,
                                      DlFilterMode::kNearest, nullptr);
          },
          kDrawImageNineFlags));
}

◆ TEST_F() [143/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageRectLinear
	)

Definition at line 3438 of file dl_rendering_unittests.cc.

                                                  {
  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageRect(
                ctx.image, src, dst, SkImageSampling::kLinear,  //
                &ctx.paint, SkCanvas::kFast_SrcRectConstraint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawImageRect(
                ctx.image, src, dst, DlImageSampling::kLinear,  //
                &ctx.paint, DlCanvas::SrcRectConstraint::kFast);
          },
          kDrawImageRectWithPaintFlags));
}

◆ TEST_F() [144/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageRectNearest
	)

Definition at line 3402 of file dl_rendering_unittests.cc.

                                                   {
  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageRect(
                ctx.image, src, dst, SkImageSampling::kNearestNeighbor,
                &ctx.paint, SkCanvas::kFast_SrcRectConstraint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImageRect(
                ctx.image, src, dst, DlImageSampling::kNearestNeighbor,
                &ctx.paint, DlCanvas::SrcRectConstraint::kFast);
          },
          kDrawImageRectWithPaintFlags));
}

◆ TEST_F() [145/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawImageRectNearestNoPaint
	)

Definition at line 3420 of file dl_rendering_unittests.cc.

                                                          {
  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawImageRect(
                ctx.image, src, dst, SkImageSampling::kNearestNeighbor,  //
                nullptr, SkCanvas::kFast_SrcRectConstraint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawImageRect(
                ctx.image, src, dst, DlImageSampling::kNearestNeighbor,  //
                nullptr, DlCanvas::SrcRectConstraint::kFast);
          },
          kDrawImageRectFlags));
}

◆ TEST_F() [146/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawOpaqueColor
	)

Definition at line 2810 of file dl_rendering_unittests.cc.

                                              {
  // We use a non-opaque color to avoid obliterating any backdrop filter output
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            // DrawColor is not tested against attributes because it is supposed
            // to ignore them. So, if the paint has an alpha, it is because we
            // are doing a saveLayer+backdrop test and we need to not flood over
            // the backdrop output with a solid color. So, we perform an alpha
            // drawColor for that case only.
            SkColor color = SkColorSetA(SK_ColorMAGENTA, ctx.paint.getAlpha());
            ctx.canvas->drawColor(color);
          },
          [=](const DlRenderContext& ctx) {
            // DrawColor is not tested against attributes because it is supposed
            // to ignore them. So, if the paint has an alpha, it is because we
            // are doing a saveLayer+backdrop test and we need to not flood over
            // the backdrop output with a solid color. So, we transfer the alpha
            // from the paint for that case only.
            ctx.canvas->DrawColor(
                DlColor::kMagenta().withAlpha(ctx.paint.getAlpha()));
          },
          kDrawColorFlags));
}

◆ TEST_F() [147/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawOval
	)

Definition at line 2991 of file dl_rendering_unittests.cc.

                                       {
  SkRect rect = kRenderBounds.makeInset(0, 10);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawOval(rect, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawOval(rect, ctx.paint);
          },
          kDrawOvalFlags));
}

◆ TEST_F() [148/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawPaint
	)

Definition at line 2798 of file dl_rendering_unittests.cc.

                                        {
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawPaint(ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawPaint(ctx.paint);
          },
          kDrawPaintFlags));
}

◆ TEST_F() [149/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawPath
	)

Definition at line 3048 of file dl_rendering_unittests.cc.

                                       {
  SkPath path;
 
  // unclosed lines to show some caps
  path.moveTo(kRenderLeft + 15, kRenderTop + 15);
  path.lineTo(kRenderRight - 15, kRenderBottom - 15);
  path.moveTo(kRenderLeft + 15, kRenderBottom - 15);
  path.lineTo(kRenderRight - 15, kRenderTop + 15);
 
  path.addRect(kRenderBounds);
 
  // miter diamonds horizontally and vertically to show miters
  path.moveTo(kVerticalMiterDiamondPoints[0]);
  for (int i = 1; i < kVerticalMiterDiamondPointCount; i++) {
    path.lineTo(kVerticalMiterDiamondPoints[i]);
  }
  path.close();
  path.moveTo(kHorizontalMiterDiamondPoints[0]);
  for (int i = 1; i < kHorizontalMiterDiamondPointCount; i++) {
    path.lineTo(kHorizontalMiterDiamondPoints[i]);
  }
  path.close();
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawPath(path, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawPath(path, ctx.paint);
          },
          kDrawPathFlags)
          .set_draw_path());
}

◆ TEST_F() [150/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawPointsAsLines
	)

Definition at line 3171 of file dl_rendering_unittests.cc.

                                                {
  const SkScalar x0 = kRenderLeft + 1;
  const SkScalar x1 = kRenderLeft + 16;
  const SkScalar x2 = kRenderRight - 16;
  const SkScalar x3 = kRenderRight - 1;
 
  const SkScalar y0 = kRenderTop;
  const SkScalar y1 = kRenderTop + 16;
  const SkScalar y2 = kRenderBottom - 16;
  const SkScalar y3 = kRenderBottom;
 
  // clang-format off
  const SkPoint points[] = {
      // Outer box
      {x0, y0}, {x3, y0},
      {x3, y0}, {x3, y3},
      {x3, y3}, {x0, y3},
      {x0, y3}, {x0, y0},
 
      // Diagonals
      {x0, y0}, {x3, y3}, {x3, y0}, {x0, y3},
 
      // Inner box
      {x1, y1}, {x2, y1},
      {x2, y1}, {x2, y2},
      {x2, y2}, {x1, y2},
      {x1, y2}, {x1, y1},
  };
  // clang-format on
 
  const int count = sizeof(points) / sizeof(points[0]);
  ASSERT_TRUE((count & 1) == 0);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            auto mode = SkCanvas::kLines_PointMode;
            ctx.canvas->drawPoints(mode, count, points, p);
          },
          [=](const DlRenderContext& ctx) {
            auto mode = PointMode::kLines;
            ctx.canvas->DrawPoints(mode, count, points, ctx.paint);
          },
          kDrawPointsAsLinesFlags));
}

◆ TEST_F() [151/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawPointsAsPoints
	)

Definition at line 3118 of file dl_rendering_unittests.cc.

                                                 {
  // The +/- 16 points are designed to fall just inside the clips
  // that are tested against so we avoid lots of undrawn pixels
  // in the accumulated bounds.
  const SkScalar x0 = kRenderLeft;
  const SkScalar x1 = kRenderLeft + 16;
  const SkScalar x2 = (kRenderLeft + kRenderCenterX) * 0.5;
  const SkScalar x3 = kRenderCenterX + 0.1;
  const SkScalar x4 = (kRenderRight + kRenderCenterX) * 0.5;
  const SkScalar x5 = kRenderRight - 16;
  const SkScalar x6 = kRenderRight;
 
  const SkScalar y0 = kRenderTop;
  const SkScalar y1 = kRenderTop + 16;
  const SkScalar y2 = (kRenderTop + kRenderCenterY) * 0.5;
  const SkScalar y3 = kRenderCenterY + 0.1;
  const SkScalar y4 = (kRenderBottom + kRenderCenterY) * 0.5;
  const SkScalar y5 = kRenderBottom - 16;
  const SkScalar y6 = kRenderBottom;
 
  // clang-format off
  const SkPoint points[] = {
      {x0, y0}, {x1, y0}, {x2, y0}, {x3, y0}, {x4, y0}, {x5, y0}, {x6, y0},
      {x0, y1}, {x1, y1}, {x2, y1}, {x3, y1}, {x4, y1}, {x5, y1}, {x6, y1},
      {x0, y2}, {x1, y2}, {x2, y2}, {x3, y2}, {x4, y2}, {x5, y2}, {x6, y2},
      {x0, y3}, {x1, y3}, {x2, y3}, {x3, y3}, {x4, y3}, {x5, y3}, {x6, y3},
      {x0, y4}, {x1, y4}, {x2, y4}, {x3, y4}, {x4, y4}, {x5, y4}, {x6, y4},
      {x0, y5}, {x1, y5}, {x2, y5}, {x3, y5}, {x4, y5}, {x5, y5}, {x6, y5},
      {x0, y6}, {x1, y6}, {x2, y6}, {x3, y6}, {x4, y6}, {x5, y6}, {x6, y6},
  };
  // clang-format on
  const int count = sizeof(points) / sizeof(points[0]);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            auto mode = SkCanvas::kPoints_PointMode;
            ctx.canvas->drawPoints(mode, count, points, p);
          },
          [=](const DlRenderContext& ctx) {
            auto mode = PointMode::kPoints;
            ctx.canvas->DrawPoints(mode, count, points, ctx.paint);
          },
          kDrawPointsAsPointsFlags)
          .set_draw_line()
          .set_ignores_dashes());
}

◆ TEST_F() [152/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawPointsAsPolygon
	)

Definition at line 3221 of file dl_rendering_unittests.cc.

                                                  {
  const SkPoint points1[] = {
      // RenderBounds box with a diamond
      SkPoint::Make(kRenderLeft, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderBottom),
      SkPoint::Make(kRenderLeft, kRenderBottom),
      SkPoint::Make(kRenderLeft, kRenderTop),
      SkPoint::Make(kRenderCenterX, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderCenterY),
      SkPoint::Make(kRenderCenterX, kRenderBottom),
      SkPoint::Make(kRenderLeft, kRenderCenterY),
  };
  const int count1 = sizeof(points1) / sizeof(points1[0]);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            auto mode = SkCanvas::kPolygon_PointMode;
            ctx.canvas->drawPoints(mode, count1, points1, p);
          },
          [=](const DlRenderContext& ctx) {
            auto mode = PointMode::kPolygon;
            ctx.canvas->DrawPoints(mode, count1, points1, ctx.paint);
          },
          kDrawPointsAsPolygonFlags));
}

◆ TEST_F() [153/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawRect
	)

Definition at line 2978 of file dl_rendering_unittests.cc.

                                       {
  // Bounds are offset by 0.5 pixels to induce AA
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawRect(kRenderBounds.makeOffset(0.5, 0.5), ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawRect(kRenderBounds.makeOffset(0.5, 0.5), ctx.paint);
          },
          kDrawRectFlags));
}

◆ TEST_F() [154/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawRRect
	)

Definition at line 3017 of file dl_rendering_unittests.cc.

                                        {
  SkRRect rrect = SkRRect::MakeRectXY(kRenderBounds, kRenderCornerRadius,
                                      kRenderCornerRadius);
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            ctx.canvas->drawRRect(rrect, ctx.paint);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawRRect(rrect, ctx.paint);
          },
          kDrawRRectFlags));
}

◆ TEST_F() [155/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawShadow
	)

Definition at line 3722 of file dl_rendering_unittests.cc.

                                         {
  SkPath path;
  path.addRoundRect(
      {
          kRenderLeft + 10,
          kRenderTop,
          kRenderRight - 10,
          kRenderBottom - 20,
      },
      kRenderCornerRadius, kRenderCornerRadius);
  const DlColor color = DlColor::kDarkGrey();
  const SkScalar elevation = 5;
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
                                             false, 1.0);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawShadow(path, color, elevation, false, 1.0);
          },
          kDrawShadowFlags),
      CanvasCompareTester::DefaultTolerance.addBoundsPadding(3, 3));
}

◆ TEST_F() [156/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawShadowDpr
	)

Definition at line 3774 of file dl_rendering_unittests.cc.

                                            {
  SkPath path;
  path.addRoundRect(
      {
          kRenderLeft + 10,
          kRenderTop,
          kRenderRight - 10,
          kRenderBottom - 20,
      },
      kRenderCornerRadius, kRenderCornerRadius);
  const DlColor color = DlColor::kDarkGrey();
  const SkScalar elevation = 5;
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
                                             false, 1.5);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawShadow(path, color, elevation, false, 1.5);
          },
          kDrawShadowFlags),
      CanvasCompareTester::DefaultTolerance.addBoundsPadding(3, 3));
}

◆ TEST_F() [157/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawShadowTransparentOccluder
	)

Definition at line 3748 of file dl_rendering_unittests.cc.

                                                            {
  SkPath path;
  path.addRoundRect(
      {
          kRenderLeft + 10,
          kRenderTop,
          kRenderRight - 10,
          kRenderBottom - 20,
      },
      kRenderCornerRadius, kRenderCornerRadius);
  const DlColor color = DlColor::kDarkGrey();
  const SkScalar elevation = 5;
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
                                             true, 1.0);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawShadow(path, color, elevation, true, 1.0);
          },
          kDrawShadowFlags),
      CanvasCompareTester::DefaultTolerance.addBoundsPadding(3, 3));
}

◆ TEST_F() [158/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawTextBlob
	)

Definition at line 3675 of file dl_rendering_unittests.cc.

                                           {
  // TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
  // performance overlay can use Fuchsia's font manager instead of the empty
  // default.
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Rendering comparisons require a valid default font manager";
#else
  sk_sp<SkTextBlob> blob =
      CanvasCompareTester::MakeTextBlob("Testing", kRenderHeight * 0.33f);
#ifdef IMPELLER_SUPPORTS_RENDERING
  auto frame = impeller::MakeTextFrameFromTextBlobSkia(blob);
#endif  // IMPELLER_SUPPORTS_RENDERING
  SkScalar render_y_1_3 = kRenderTop + kRenderHeight * 0.3;
  SkScalar render_y_2_3 = kRenderTop + kRenderHeight * 0.6;
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            auto paint = ctx.paint;
            ctx.canvas->drawTextBlob(blob, kRenderLeft, render_y_1_3, paint);
            ctx.canvas->drawTextBlob(blob, kRenderLeft, render_y_2_3, paint);
            ctx.canvas->drawTextBlob(blob, kRenderLeft, kRenderBottom, paint);
          },
          [=](const DlRenderContext& ctx) {
            auto paint = ctx.paint;
            ctx.canvas->DrawTextBlob(blob, kRenderLeft, render_y_1_3, paint);
            ctx.canvas->DrawTextBlob(blob, kRenderLeft, render_y_2_3, paint);
            ctx.canvas->DrawTextBlob(blob, kRenderLeft, kRenderBottom, paint);
          },
#ifdef IMPELLER_SUPPORTS_RENDERING
          [=](const DlRenderContext& ctx) {
            auto paint = ctx.paint;
            ctx.canvas->DrawTextFrame(frame, kRenderLeft, render_y_1_3, paint);
            ctx.canvas->DrawTextFrame(frame, kRenderLeft, render_y_2_3, paint);
            ctx.canvas->DrawTextFrame(frame, kRenderLeft, kRenderBottom, paint);
          },
#endif  // IMPELLER_SUPPORTS_RENDERING
          kDrawTextBlobFlags)
          .set_draw_text_blob(),
      // From examining the bounds differential for the "Default" case, the
      // SkTextBlob adds a padding of ~32 on the left, ~30 on the right,
      // ~12 on top and ~8 on the bottom, so we add 33h & 13v allowed
      // padding to the tolerance
      CanvasCompareTester::DefaultTolerance.addBoundsPadding(33, 13));
  EXPECT_TRUE(blob->unique());
#endif  // OS_FUCHSIA
}

◆ TEST_F() [159/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawVerticalLine
	)

Definition at line 2905 of file dl_rendering_unittests.cc.

                                               {
  SkPoint p1 = SkPoint::Make(kRenderCenterX, kRenderTop);
  SkPoint p2 = SkPoint::Make(kRenderCenterY, kRenderBottom);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            // Skia requires kStroke style on horizontal and vertical
            // lines to get the bounds correct.
            // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
            SkPaint p = ctx.paint;
            p.setStyle(SkPaint::kStroke_Style);
            ctx.canvas->drawLine(p1, p2, p);
          },
          [=](const DlRenderContext& ctx) {  //
            ctx.canvas->DrawLine(p1, p2, ctx.paint);
          },
          kDrawHVLineFlags)
          .set_draw_line()
          .set_vertical_line());
}

◆ TEST_F() [160/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawVerticesWithColors
	)

Definition at line 3254 of file dl_rendering_unittests.cc.

                                                     {
  // Cover as many sides of the box with only 6 vertices:
  // +----------+
  // |xxxxxxxxxx|
  // |    xxxxxx|
  // |       xxx|
  // |xxx       |
  // |xxxxxx    |
  // |xxxxxxxxxx|
  // +----------|
  const SkPoint pts[6] = {
      // Upper-Right corner, full top, half right coverage
      SkPoint::Make(kRenderLeft, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderCenterY),
      // Lower-Left corner, full bottom, half left coverage
      SkPoint::Make(kRenderLeft, kRenderBottom),
      SkPoint::Make(kRenderLeft, kRenderCenterY),
      SkPoint::Make(kRenderRight, kRenderBottom),
  };
  const DlColor dl_colors[6] = {
      DlColor::kRed(),  DlColor::kBlue(),   DlColor::kGreen(),
      DlColor::kCyan(), DlColor::kYellow(), DlColor::kMagenta(),
  };
  const SkColor sk_colors[6] = {
      SK_ColorRED,  SK_ColorBLUE,   SK_ColorGREEN,
      SK_ColorCYAN, SK_ColorYELLOW, SK_ColorMAGENTA,
  };
  const std::shared_ptr<DlVertices> dl_vertices =
      DlVertices::Make(DlVertexMode::kTriangles, 6, pts, nullptr, dl_colors);
  const auto sk_vertices =
      SkVertices::MakeCopy(SkVertices::VertexMode::kTriangles_VertexMode, 6,
                           pts, nullptr, sk_colors);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {
            ctx.canvas->drawVertices(sk_vertices, SkBlendMode::kSrcOver,
                                     ctx.paint);
          },
          [=](const DlRenderContext& ctx) {
            ctx.canvas->DrawVertices(dl_vertices, DlBlendMode::kSrcOver,
                                     ctx.paint);
          },
          kDrawVerticesFlags));
}

◆ TEST_F() [161/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		DrawVerticesWithImage
	)

Definition at line 3301 of file dl_rendering_unittests.cc.

                                                    {
  // Cover as many sides of the box with only 6 vertices:
  // +----------+
  // |xxxxxxxxxx|
  // |    xxxxxx|
  // |       xxx|
  // |xxx       |
  // |xxxxxx    |
  // |xxxxxxxxxx|
  // +----------|
  const SkPoint pts[6] = {
      // Upper-Right corner, full top, half right coverage
      SkPoint::Make(kRenderLeft, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderTop),
      SkPoint::Make(kRenderRight, kRenderCenterY),
      // Lower-Left corner, full bottom, half left coverage
      SkPoint::Make(kRenderLeft, kRenderBottom),
      SkPoint::Make(kRenderLeft, kRenderCenterY),
      SkPoint::Make(kRenderRight, kRenderBottom),
  };
  const SkPoint tex[6] = {
      SkPoint::Make(kRenderWidth / 2.0, 0),
      SkPoint::Make(0, kRenderHeight),
      SkPoint::Make(kRenderWidth, kRenderHeight),
      SkPoint::Make(kRenderWidth / 2, kRenderHeight),
      SkPoint::Make(0, 0),
      SkPoint::Make(kRenderWidth, 0),
  };
  const std::shared_ptr<DlVertices> dl_vertices =
      DlVertices::Make(DlVertexMode::kTriangles, 6, pts, tex, nullptr);
  const auto sk_vertices = SkVertices::MakeCopy(
      SkVertices::VertexMode::kTriangles_VertexMode, 6, pts, tex, nullptr);
 
  CanvasCompareTester::RenderAll(  //
      TestParameters(
          [=](const SkRenderContext& ctx) {  //
            SkPaint v_paint = ctx.paint;
            if (v_paint.getShader() == nullptr) {
              v_paint.setShader(MakeColorSource(ctx.image));
            }
            ctx.canvas->drawVertices(sk_vertices, SkBlendMode::kSrcOver,
                                     v_paint);
          },
          [=](const DlRenderContext& ctx) {  //
            DlPaint v_paint = ctx.paint;
            if (v_paint.getColorSource() == nullptr) {
              v_paint.setColorSource(MakeColorSource(ctx.image));
            }
            ctx.canvas->DrawVertices(dl_vertices, DlBlendMode::kSrcOver,
                                     v_paint);
          },
          kDrawVerticesFlags));
}

◆ TEST_F() [162/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		MatrixColorFilterModifyTransparencyCheck
	)

Definition at line 4037 of file dl_rendering_unittests.cc.

                                                                       {
  auto test_matrix = [](int element, SkScalar value) {
    // clang-format off
    float matrix[] = {
        1, 0, 0, 0, 0,
        0, 1, 0, 0, 0,
        0, 0, 1, 0, 0,
        0, 0, 0, 1, 0,
    };
    // clang-format on
    std::string desc =
        "matrix[" + std::to_string(element) + "] = " + std::to_string(value);
    float original_value = matrix[element];
    matrix[element] = value;
    DlMatrixColorFilter filter(matrix);
    auto dl_filter = DlMatrixColorFilter::Make(matrix);
    bool is_identity = (dl_filter == nullptr || original_value == value);
 
    DlPaint paint(DlColor(0x7f7f7f7f));
    DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
    DisplayListBuilder builder1;
    builder1.Translate(kTestCenter.fX, kTestCenter.fY);
    builder1.Rotate(45);
    builder1.Translate(-kTestCenter.fX, -kTestCenter.fY);
    builder1.DrawRect(kRenderBounds, paint);
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    builder2.Translate(kTestCenter.fX, kTestCenter.fY);
    builder2.Rotate(45);
    builder2.Translate(-kTestCenter.fX, -kTestCenter.fY);
    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
    builder2.DrawRect(kRenderBounds, paint);
    builder2.Restore();
    auto display_list2 = builder2.Build();
 
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto env = std::make_unique<RenderEnvironment>(
          provider.get(), PixelFormat::kN32PremulPixelFormat);
      auto results1 = env->getResult(display_list1);
      auto results2 = env->getResult(display_list2);
      CanvasCompareTester::quickCompareToReference(
          results1.get(), results2.get(), is_identity,
          desc + " filter affects rendering");
      int modified_transparent_pixels =
          CanvasCompareTester::countModifiedTransparentPixels(results1.get(),
                                                              results2.get());
      EXPECT_EQ(filter.modifies_transparent_black(),
                modified_transparent_pixels != 0)
          << desc;
    }
  };
 
  // Tests identity (matrix[0] already == 1 in an identity filter)
  test_matrix(0, 1);
  // test_matrix(19, 1);
  for (int i = 0; i < 20; i++) {
    test_matrix(i, -0.25);
    test_matrix(i, 0);
    test_matrix(i, 0.25);
    test_matrix(i, 1);
    test_matrix(i, 1.25);
    test_matrix(i, SK_ScalarNaN);
    test_matrix(i, SK_ScalarInfinity);
    test_matrix(i, -SK_ScalarInfinity);
  }
}

◆ TEST_F() [163/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		MatrixColorFilterOpacityCommuteCheck
	)

Definition at line 4107 of file dl_rendering_unittests.cc.

                                                                   {
  auto test_matrix = [](int element, SkScalar value) {
    // clang-format off
    float matrix[] = {
        1, 0, 0, 0, 0,
        0, 1, 0, 0, 0,
        0, 0, 1, 0, 0,
        0, 0, 0, 1, 0,
    };
    // clang-format on
    std::string desc =
        "matrix[" + std::to_string(element) + "] = " + std::to_string(value);
    matrix[element] = value;
    auto filter = DlMatrixColorFilter::Make(matrix);
    EXPECT_EQ(std::isfinite(value), filter != nullptr);
 
    DlPaint paint(DlColor(0x80808080));
    DlPaint opacity_save_paint = DlPaint().setOpacity(0.5);
    DlPaint filter_save_paint = DlPaint().setColorFilter(filter);
 
    DisplayListBuilder builder1;
    builder1.SaveLayer(&kTestBounds2, &opacity_save_paint);
    builder1.SaveLayer(&kTestBounds2, &filter_save_paint);
    // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
    builder1.DrawRect(kRenderBounds, paint);
    builder1.Restore();
    builder1.Restore();
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
    builder2.SaveLayer(&kTestBounds2, &opacity_save_paint);
    // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
    builder2.DrawRect(kRenderBounds, paint);
    builder2.Restore();
    builder2.Restore();
    auto display_list2 = builder2.Build();
 
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto env = std::make_unique<RenderEnvironment>(
          provider.get(), PixelFormat::kN32PremulPixelFormat);
      auto results1 = env->getResult(display_list1);
      auto results2 = env->getResult(display_list2);
      if (!filter || filter->can_commute_with_opacity()) {
        CanvasCompareTester::compareToReference(
            results2.get(), results1.get(), desc, nullptr, nullptr,
            DlColor::kTransparent(), true, kTestWidth, kTestHeight, true);
      } else {
        CanvasCompareTester::quickCompareToReference(
            results1.get(), results2.get(), false, desc);
      }
    }
  };
 
  // Tests identity (matrix[0] already == 1 in an identity filter)
  test_matrix(0, 1);
  // test_matrix(19, 1);
  for (int i = 0; i < 20; i++) {
    test_matrix(i, -0.25);
    test_matrix(i, 0);
    test_matrix(i, 0.25);
    test_matrix(i, 1);
    test_matrix(i, 1.1);
    test_matrix(i, SK_ScalarNaN);
    test_matrix(i, SK_ScalarInfinity);
    test_matrix(i, -SK_ScalarInfinity);
  }
}

◆ TEST_F() [164/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		SaveLayerClippedContentStillFilters
	)

Definition at line 3800 of file dl_rendering_unittests.cc.

                                                                  {
  // draw rect is just outside of render bounds on the right
  const SkRect draw_rect = SkRect::MakeLTRB(  //
      kRenderRight + 1,                       //
      kRenderTop,                             //
      kTestBounds2.fRight,                    //
      kRenderBottom                           //
  );
  TestParameters test_params(
      [=](const SkRenderContext& ctx) {
        auto layer_filter =
            SkImageFilters::Blur(10.0f, 10.0f, SkTileMode::kDecal, nullptr);
        SkPaint layer_paint;
        layer_paint.setImageFilter(layer_filter);
        ctx.canvas->save();
        ctx.canvas->clipRect(kRenderBounds, SkClipOp::kIntersect, false);
        ctx.canvas->saveLayer(&kTestBounds2, &layer_paint);
        ctx.canvas->drawRect(draw_rect, ctx.paint);
        ctx.canvas->restore();
        ctx.canvas->restore();
      },
      [=](const DlRenderContext& ctx) {
        auto layer_filter =
            DlBlurImageFilter::Make(10.0f, 10.0f, DlTileMode::kDecal);
        DlPaint layer_paint;
        layer_paint.setImageFilter(layer_filter);
        ctx.canvas->Save();
        ctx.canvas->ClipRect(kRenderBounds, ClipOp::kIntersect, false);
        ctx.canvas->SaveLayer(&kTestBounds2, &layer_paint);
        ctx.canvas->DrawRect(draw_rect, ctx.paint);
        ctx.canvas->Restore();
        ctx.canvas->Restore();
      },
      kSaveLayerWithPaintFlags);
  CaseParameters case_params("Filtered SaveLayer with clipped content");
  BoundsTolerance tolerance = BoundsTolerance().addAbsolutePadding(6.0f, 6.0f);
 
  for (auto& back_end : CanvasCompareTester::TestBackends) {
    auto provider = CanvasCompareTester::GetProvider(back_end);
    RenderEnvironment env = RenderEnvironment::MakeN32(provider.get());
    env.init_ref(kEmptySkSetup, test_params.sk_renderer(),  //
                 kEmptyDlSetup, test_params.dl_renderer(),
                 test_params.imp_renderer());
    CanvasCompareTester::quickCompareToReference(env, "default");
    CanvasCompareTester::RenderWith(test_params, env, tolerance, case_params);
  }
}

◆ TEST_F() [165/925]

flutter::testing::TEST_F	(	DisplayListRendering	,
		SaveLayerConsolidation
	)

Definition at line 3848 of file dl_rendering_unittests.cc.

                                                     {
  float commutable_color_matrix[]{
      // clang-format off
      0, 1, 0, 0, 0,
      0, 0, 1, 0, 0,
      1, 0, 0, 0, 0,
      0, 0, 0, 1, 0,
      // clang-format on
  };
  float non_commutable_color_matrix[]{
      // clang-format off
      0, 1, 0, .1, 0,
      0, 0, 1, .1, 0,
      1, 0, 0, .1, 0,
      0, 0, 0, .7, 0,
      // clang-format on
  };
  SkMatrix contract_matrix;
  contract_matrix.setScale(0.9f, 0.9f, kRenderCenterX, kRenderCenterY);
 
  std::vector<SkScalar> opacities = {
      0,
      0.5f,
      SK_Scalar1,
  };
  std::vector<std::shared_ptr<DlColorFilter>> color_filters = {
      std::make_shared<DlBlendColorFilter>(DlColor::kCyan(),
                                           DlBlendMode::kSrcATop),
      std::make_shared<DlMatrixColorFilter>(commutable_color_matrix),
      std::make_shared<DlMatrixColorFilter>(non_commutable_color_matrix),
      DlSrgbToLinearGammaColorFilter::kInstance,
      DlLinearToSrgbGammaColorFilter::kInstance,
  };
  std::vector<std::shared_ptr<DlImageFilter>> image_filters = {
      std::make_shared<DlBlurImageFilter>(5.0f, 5.0f, DlTileMode::kDecal),
      std::make_shared<DlDilateImageFilter>(5.0f, 5.0f),
      std::make_shared<DlErodeImageFilter>(5.0f, 5.0f),
      std::make_shared<DlMatrixImageFilter>(contract_matrix,
                                            DlImageSampling::kLinear),
  };
 
  auto render_content = [](DisplayListBuilder& builder) {
    builder.DrawRect(
        SkRect{kRenderLeft, kRenderTop, kRenderCenterX, kRenderCenterY},
        DlPaint(DlColor::kYellow()));
    builder.DrawRect(
        SkRect{kRenderCenterX, kRenderTop, kRenderRight, kRenderCenterY},
        DlPaint(DlColor::kRed()));
    builder.DrawRect(
        SkRect{kRenderLeft, kRenderCenterY, kRenderCenterX, kRenderBottom},
        DlPaint(DlColor::kBlue()));
    builder.DrawRect(
        SkRect{kRenderCenterX, kRenderCenterY, kRenderRight, kRenderBottom},
        DlPaint(DlColor::kRed().modulateOpacity(0.5f)));
  };
 
  auto test_attributes_env =
      [render_content](DlPaint& paint1, DlPaint& paint2,
                       const DlPaint& paint_both, bool same, bool rev_same,
                       const std::string& desc1, const std::string& desc2,
                       const RenderEnvironment* env) {
        DisplayListBuilder nested_builder;
        nested_builder.SaveLayer(&kTestBounds2, &paint1);
        nested_builder.SaveLayer(&kTestBounds2, &paint2);
        render_content(nested_builder);
        auto nested_results = env->getResult(nested_builder.Build());
 
        DisplayListBuilder reverse_builder;
        reverse_builder.SaveLayer(&kTestBounds2, &paint2);
        reverse_builder.SaveLayer(&kTestBounds2, &paint1);
        render_content(reverse_builder);
        auto reverse_results = env->getResult(reverse_builder.Build());
 
        DisplayListBuilder combined_builder;
        combined_builder.SaveLayer(&kTestBounds2, &paint_both);
        render_content(combined_builder);
        auto combined_results = env->getResult(combined_builder.Build());
 
        // Set this boolean to true to test if combinations that are marked
        // as incompatible actually are compatible despite our predictions.
        // Some of the combinations that we treat as incompatible actually
        // are compatible with swapping the order of the operations, but
        // it would take a bit of new infrastructure to really identify
        // those combinations. The only hard constraint to test here is
        // when we claim that they are compatible and they aren't.
        const bool always = false;
 
        // In some circumstances, Skia can combine image filter evaluations
        // and elide a renderpass. In this case rounding and precision of inputs
        // to color filters may cause the output to differ by 1.
        if (always || same) {
          CanvasCompareTester::compareToReference(
              nested_results.get(), combined_results.get(),
              "nested " + desc1 + " then " + desc2, /*bounds=*/nullptr,
              /*tolerance=*/nullptr, DlColor::kTransparent(),
              /*fuzzyCompares=*/true, combined_results->width(),
              combined_results->height(), /*printMismatches=*/true);
        }
        if (always || rev_same) {
          CanvasCompareTester::compareToReference(
              reverse_results.get(), combined_results.get(),
              "nested " + desc2 + " then " + desc1, /*bounds=*/nullptr,
              /*tolerance=*/nullptr, DlColor::kTransparent(),
              /*fuzzyCompares=*/true, combined_results->width(),
              combined_results->height(), /*printMismatches=*/true);
        }
      };
 
  auto test_attributes = [test_attributes_env](DlPaint& paint1, DlPaint& paint2,
                                               const DlPaint& paint_both,
                                               bool same, bool rev_same,
                                               const std::string& desc1,
                                               const std::string& desc2) {
    for (auto& back_end : CanvasCompareTester::TestBackends) {
      auto provider = CanvasCompareTester::GetProvider(back_end);
      auto env = std::make_unique<RenderEnvironment>(
          provider.get(), PixelFormat::kN32PremulPixelFormat);
      test_attributes_env(paint1, paint2, paint_both,  //
                          same, rev_same, desc1, desc2, env.get());
    }
  };
 
  // CF then Opacity should always work.
  // The reverse sometimes works.
  for (size_t cfi = 0; cfi < color_filters.size(); cfi++) {
    auto color_filter = color_filters[cfi];
    std::string cf_desc = "color filter #" + std::to_string(cfi + 1);
    DlPaint nested_paint1 = DlPaint().setColorFilter(color_filter);
 
    for (size_t oi = 0; oi < opacities.size(); oi++) {
      SkScalar opacity = opacities[oi];
      std::string op_desc = "opacity " + std::to_string(opacity);
      DlPaint nested_paint2 = DlPaint().setOpacity(opacity);
 
      DlPaint combined_paint = nested_paint1;
      combined_paint.setOpacity(opacity);
 
      bool op_then_cf_works = opacity <= 0.0 || opacity >= 1.0 ||
                              color_filter->can_commute_with_opacity();
 
      test_attributes(nested_paint1, nested_paint2, combined_paint, true,
                      op_then_cf_works, cf_desc, op_desc);
    }
  }
 
  // Opacity then IF should always work.
  // The reverse can also work for some values of opacity.
  // The reverse should also theoretically work for some IFs, but we
  // get some rounding errors that are more than just trivial.
  for (size_t oi = 0; oi < opacities.size(); oi++) {
    SkScalar opacity = opacities[oi];
    std::string op_desc = "opacity " + std::to_string(opacity);
    DlPaint nested_paint1 = DlPaint().setOpacity(opacity);
 
    for (size_t ifi = 0; ifi < image_filters.size(); ifi++) {
      auto image_filter = image_filters[ifi];
      std::string if_desc = "image filter #" + std::to_string(ifi + 1);
      DlPaint nested_paint2 = DlPaint().setImageFilter(image_filter);
 
      DlPaint combined_paint = nested_paint1;
      combined_paint.setImageFilter(image_filter);
 
      bool if_then_op_works = opacity <= 0.0 || opacity >= 1.0;
      test_attributes(nested_paint1, nested_paint2, combined_paint, true,
                      if_then_op_works, op_desc, if_desc);
    }
  }
 
  // CF then IF should always work.
  // The reverse might work, but we lack the infrastructure to check it.
  for (size_t cfi = 0; cfi < color_filters.size(); cfi++) {
    auto color_filter = color_filters[cfi];
    std::string cf_desc = "color filter #" + std::to_string(cfi + 1);
    DlPaint nested_paint1 = DlPaint().setColorFilter(color_filter);
 
    for (size_t ifi = 0; ifi < image_filters.size(); ifi++) {
      auto image_filter = image_filters[ifi];
      std::string if_desc = "image filter #" + std::to_string(ifi + 1);
      DlPaint nested_paint2 = DlPaint().setImageFilter(image_filter);
 
      DlPaint combined_paint = nested_paint1;
      combined_paint.setImageFilter(image_filter);
 
      test_attributes(nested_paint1, nested_paint2, combined_paint, true, false,
                      cf_desc, if_desc);
    }
  }
}

◆ TEST_F() [166/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		AllBlendModeNops
	)

Definition at line 770 of file display_list_unittests.cc.

                                          {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setBlendMode(DlBlendMode::kSrcOver);
  sk_sp<DisplayList> dl = builder.Build();
  ASSERT_EQ(dl->bytes(false), sizeof(DisplayList));
  ASSERT_EQ(dl->bytes(true), sizeof(DisplayList));
  ASSERT_EQ(dl->op_count(false), 0u);
  ASSERT_EQ(dl->op_count(true), 0u);
  EXPECT_EQ(dl->total_depth(), 0u);
}

◆ TEST_F() [167/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BackdropDetectionEmptyDisplayList
	)

Definition at line 4246 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder;
  EXPECT_FALSE(builder.Build()->root_has_backdrop_filter());
}

◆ TEST_F() [168/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BackdropDetectionNestedSaveLayer
	)

Definition at line 4276 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {
    // first inner content does have backdrop filter
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10), DlPaint());
    builder.SaveLayer(nullptr, nullptr, &kTestBlurImageFilter1);
    {
      // second inner content has no backdrop filter
      builder.DrawRect(SkRect::MakeLTRB(10, 10, 20, 20), DlPaint());
    }
    builder.Restore();
  }
  builder.Restore();
  auto dl = builder.Build();
 
  EXPECT_FALSE(dl->root_has_backdrop_filter());
  SaveLayerExpector expector({
      SaveLayerOptions::kNoAttributes.with_contains_backdrop_filter(),
      SaveLayerOptions::kNoAttributes.with_can_distribute_opacity(),
  });
  dl->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [169/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BackdropDetectionSimpleRect
	)

Definition at line 4251 of file display_list_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10), DlPaint());
  EXPECT_FALSE(builder.Build()->root_has_backdrop_filter());
}

◆ TEST_F() [170/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BackdropDetectionSimpleSaveLayer
	)

Definition at line 4257 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr, &kTestBlurImageFilter1);
  {
    // inner content has no backdrop filter
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10), DlPaint());
  }
  builder.Restore();
  auto dl = builder.Build();
 
  EXPECT_TRUE(dl->root_has_backdrop_filter());
  // The saveLayer itself, though, does not have the contains backdrop
  // flag set because its content does not contain a saveLayer with backdrop
  SaveLayerExpector expector(
      SaveLayerOptions::kNoAttributes.with_can_distribute_opacity());
  dl->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [171/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderBoundsTransformComparedToSkia
	)

Definition at line 449 of file display_list_unittests.cc.

                                                              {
  const SkRect frame_rect = SkRect::MakeLTRB(10, 10, 100, 100);
  DisplayListBuilder builder(frame_rect);
  SkPictureRecorder recorder;
  SkCanvas* canvas = recorder.beginRecording(frame_rect);
  ASSERT_EQ(builder.GetDestinationClipBounds(),
            SkRect::Make(canvas->getDeviceClipBounds()));
  ASSERT_EQ(builder.GetLocalClipBounds().makeOutset(1, 1),
            canvas->getLocalClipBounds());
  ASSERT_EQ(builder.GetTransform(), canvas->getTotalMatrix());
}

◆ TEST_F() [172/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderCanBeReused
	)

Definition at line 255 of file display_list_unittests.cc.

                                            {
  DisplayListBuilder builder(kTestBounds);
  builder.DrawRect(kTestBounds, DlPaint());
  auto dl = builder.Build();
  builder.DrawRect(kTestBounds, DlPaint());
  auto dl2 = builder.Build();
  ASSERT_TRUE(dl->Equals(dl2));
}

◆ TEST_F() [173/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderClipBoundsAfterClipPath
	)

Definition at line 494 of file display_list_unittests.cc.

                                                        {
  SkRect cull_rect = SkRect::MakeWH(100, 100);
  SkPath clip_path = SkPath().addRect(10, 10, 15, 15).addRect(15, 15, 20, 20);
  SkRect clip_bounds = SkRect::MakeLTRB(10, 10, 20, 20);
  DisplayListBuilder builder(cull_rect);
  builder.ClipPath(clip_path, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [174/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderClipBoundsAfterClipRect
	)

Definition at line 475 of file display_list_unittests.cc.

                                                        {
  SkRect cull_rect = SkRect::MakeWH(100, 100);
  SkRect clip_rect = SkRect::MakeLTRB(10, 10, 20, 20);
  SkRect clip_bounds = SkRect::MakeLTRB(10, 10, 20, 20);
  DisplayListBuilder builder(cull_rect);
  builder.ClipRect(clip_rect, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [175/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderClipBoundsAfterClipRRect
	)

Definition at line 484 of file display_list_unittests.cc.

                                                         {
  SkRect cull_rect = SkRect::MakeWH(100, 100);
  SkRect clip_rect = SkRect::MakeLTRB(10, 10, 20, 20);
  SkRRect clip_rrect = SkRRect::MakeRectXY(clip_rect, 2, 2);
  SkRect clip_bounds = SkRect::MakeLTRB(10, 10, 20, 20);
  DisplayListBuilder builder(cull_rect);
  builder.ClipRRect(clip_rrect, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [176/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderInitialClipBounds
	)

Definition at line 461 of file display_list_unittests.cc.

                                                  {
  SkRect cull_rect = SkRect::MakeWH(100, 100);
  SkRect clip_bounds = SkRect::MakeWH(100, 100);
  DisplayListBuilder builder(cull_rect);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [177/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderInitialClipBoundsNaN
	)

Definition at line 468 of file display_list_unittests.cc.

                                                     {
  SkRect cull_rect = SkRect::MakeWH(SK_ScalarNaN, SK_ScalarNaN);
  SkRect clip_bounds = SkRect::MakeEmpty();
  DisplayListBuilder builder(cull_rect);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [178/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuilderInitialClipBoundsNonZero
	)

Definition at line 503 of file display_list_unittests.cc.

                                                         {
  SkRect cull_rect = SkRect::MakeLTRB(10, 10, 100, 100);
  SkRect clip_bounds = SkRect::MakeLTRB(10, 10, 100, 100);
  DisplayListBuilder builder(cull_rect);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [179/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuildRestoresAttributes
	)

Definition at line 391 of file display_list_unittests.cc.

                                                 {
  SkRect cull_rect = SkRect::MakeLTRB(-10.0f, -10.0f, 500.0f, 500.0f);
  DisplayListBuilder builder(cull_rect);
  DlOpReceiver& receiver = ToReceiver(builder);
 
  receiver.setAntiAlias(true);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setInvertColors(true);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setColor(DlColor::kRed());
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setBlendMode(DlBlendMode::kColorBurn);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setDrawStyle(DlDrawStyle::kStrokeAndFill);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setStrokeWidth(300.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setStrokeMiter(300.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setStrokeCap(DlStrokeCap::kRound);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setStrokeJoin(DlStrokeJoin::kRound);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setColorSource(&kTestSource1);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setColorFilter(&kTestMatrixColorFilter1);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setImageFilter(&kTestBlurImageFilter1);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  receiver.setMaskFilter(&kTestMaskFilter1);
  builder.Build();
  check_defaults(builder, cull_rect);
}

◆ TEST_F() [180/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuildRestoresClip
	)

Definition at line 374 of file display_list_unittests.cc.

                                           {
  SkRect cull_rect = SkRect::MakeLTRB(-10.0f, -10.0f, 500.0f, 500.0f);
  DisplayListBuilder builder(cull_rect);
 
  builder.ClipRect({0.0f, 0.0f, 10.0f, 10.0f});
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.ClipRRect(SkRRect::MakeRectXY({0.0f, 0.0f, 5.0f, 5.0f}, 2.0f, 2.0f));
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.ClipPath(SkPath().addOval({0.0f, 0.0f, 10.0f, 10.0f}));
  builder.Build();
  check_defaults(builder, cull_rect);
}

◆ TEST_F() [181/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		BuildRestoresTransform
	)

Definition at line 313 of file display_list_unittests.cc.

                                                {
  SkRect cull_rect = SkRect::MakeLTRB(-10.0f, -10.0f, 500.0f, 500.0f);
  DisplayListBuilder builder(cull_rect);
 
  builder.Translate(10.0f, 10.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Scale(10.0f, 10.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Skew(0.1f, 0.1f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Rotate(45.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Transform(SkMatrix::Scale(10.0f, 10.0f));
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Transform2DAffine(1.0f, 0.0f, 12.0f,  //
                            0.0f, 1.0f, 35.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.Transform(SkM44(SkMatrix::Scale(10.0f, 10.0f)));
  builder.Build();
  check_defaults(builder, cull_rect);
 
  builder.TransformFullPerspective(1.0f, 0.0f, 0.0f, 12.0f,  //
                                   0.0f, 1.0f, 0.0f, 35.0f,  //
                                   0.0f, 0.0f, 1.0f, 5.0f,   //
                                   0.0f, 0.0f, 0.0f, 1.0f);
  builder.Build();
  check_defaults(builder, cull_rect);
}

◆ TEST_F() [182/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathAffectsClipBounds
	)

Definition at line 2013 of file display_list_unittests.cc.

                                                   {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
  receiver.clipPath(clip, ClipOp::kIntersect, false);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, false);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_clip_bounds = SkRect::MakeLTRB(4.1, 4.65, 11.2, 13.85);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_clip_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [183/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathAffectsClipBoundsWithMatrix
	)

Definition at line 2093 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds = SkRect::MakeLTRB(0, 0, 10, 10);
  SkPath clip1 = SkPath().addCircle(2.5, 2.5, 2.5).addCircle(7.5, 7.5, 2.5);
  SkPath clip2 = SkPath().addCircle(12.5, 12.5, 2.5).addCircle(17.5, 17.5, 2.5);
 
  receiver.save();
  receiver.clipPath(clip1, ClipOp::kIntersect, false);
  receiver.translate(10, 0);
  receiver.clipPath(clip1, ClipOp::kIntersect, false);
  ASSERT_TRUE(builder.GetDestinationClipBounds().isEmpty());
  receiver.restore();
 
  receiver.save();
  receiver.clipPath(clip1, ClipOp::kIntersect, false);
  receiver.translate(-10, -10);
  receiver.clipPath(clip2, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
  receiver.restore();
}

◆ TEST_F() [184/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathDoAAAffectsClipBounds
	)

Definition at line 2053 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  SkRect clip_expanded_bounds = SkRect::MakeLTRB(8, 9, 23, 28);
  receiver.clipPath(clip, ClipOp::kIntersect, true);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, true);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_expanded_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_expanded_bounds = SkRect::MakeLTRB(4, 4.5, 11.5, 14);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_expanded_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [185/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathNonCulling
	)

Definition at line 4603 of file display_list_unittests.cc.

                                            {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  SkPath path;
  path.moveTo(0.0f, 0.0f);
  path.lineTo(1000.0f, 0.0f);
  path.lineTo(0.0f, 1000.0f);
  path.close();
 
  // Double checking that the path does indeed contain the clip. But,
  // sadly, the Builder will not check paths for coverage to this level
  // of detail. (In particular, path containment of the corners is not
  // authoritative of true containment, but we know in this case that
  // a triangle contains a rect if it contains all 4 corners...)
  ASSERT_TRUE(path.contains(clip.fLeft, clip.fTop));
  ASSERT_TRUE(path.contains(clip.fRight, clip.fTop));
  ASSERT_TRUE(path.contains(clip.fRight, clip.fBottom));
  ASSERT_TRUE(path.contains(clip.fLeft, clip.fBottom));
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipPath(path, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(path, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [186/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathRectCulling
	)

Definition at line 4632 of file display_list_unittests.cc.

                                             {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  SkPath path;
  path.addRect(clip.makeOutset(1.0f, 1.0f));
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipPath(path, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [187/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathRectNonCulling
	)

Definition at line 4647 of file display_list_unittests.cc.

                                                {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto smaller_clip = clip.makeInset(1.0f, 1.0f);
  SkPath path;
  path.addRect(smaller_clip);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipPath(path, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  // Builder will not cull this clip, but it will turn it into a ClipRect
  expector.addExpectation(smaller_clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [188/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathRRectCulling
	)

Definition at line 4665 of file display_list_unittests.cc.

                                              {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto rrect = SkRRect::MakeRectXY(clip.makeOutset(2.0f, 2.0f), 2.0f, 2.0f);
  SkPath path;
  path.addRRect(rrect);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipPath(path, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [189/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathRRectNonCulling
	)

Definition at line 4681 of file display_list_unittests.cc.

                                                 {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto rrect = SkRRect::MakeRectXY(clip.makeOutset(2.0f, 2.0f), 12.0f, 12.0f);
  SkPath path;
  path.addRRect(rrect);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipPath(path, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  // Builder will not cull this clip, but it will turn it into a ClipRRect
  expector.addExpectation(rrect, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [190/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathTriggersDeferredSave
	)

Definition at line 2789 of file display_list_unittests.cc.

                                                      {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.clipPath(kTestPath1, ClipOp::kIntersect, true);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.clipPath(kTestPath1, ClipOp::kIntersect, true);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  receiver2.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [191/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipPathWithInvertFillTypeDoesNotAffectClipBounds
	)

Definition at line 2171 of file display_list_unittests.cc.

                                                                           {
  SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
  DisplayListBuilder builder(cull_rect);
  DlOpReceiver& receiver = ToReceiver(builder);
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  clip.setFillType(SkPathFillType::kInverseWinding);
  receiver.clipPath(clip, ClipOp::kIntersect, false);
 
  ASSERT_EQ(builder.GetLocalClipBounds(), cull_rect);
  ASSERT_EQ(builder.GetDestinationClipBounds(), cull_rect);
}

◆ TEST_F() [192/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClippedSaveLayerContentAccountsForFilter
	)

Definition at line 543 of file display_list_unittests.cc.

                                                                  {
  SkRect cull_rect = SkRect::MakeLTRB(0.0f, 0.0f, 300.0f, 300.0f);
  SkRect clip_rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect draw_rect = SkRect::MakeLTRB(50.0f, 140.0f, 99.0f, 160.0f);
  auto filter = DlBlurImageFilter::Make(10.0f, 10.0f, DlTileMode::kDecal);
  DlPaint layer_paint = DlPaint().setImageFilter(filter);
 
  ASSERT_FALSE(clip_rect.intersects(draw_rect));
  ASSERT_TRUE(cull_rect.contains(clip_rect));
  ASSERT_TRUE(cull_rect.contains(draw_rect));
 
  DisplayListBuilder builder;
  builder.Save();
  {
    builder.ClipRect(clip_rect, ClipOp::kIntersect, false);
    builder.SaveLayer(&cull_rect, &layer_paint);
    {  //
      builder.DrawRect(draw_rect, DlPaint());
    }
    builder.Restore();
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->op_count(), 6u);
  EXPECT_EQ(display_list->total_depth(), 2u);
 
  SkRect result_rect = draw_rect.makeOutset(30.0f, 30.0f);
  ASSERT_TRUE(result_rect.intersect(clip_rect));
  ASSERT_EQ(result_rect, SkRect::MakeLTRB(100.0f, 110.0f, 129.0f, 190.0f));
  EXPECT_EQ(display_list->bounds(), result_rect);
}

◆ TEST_F() [193/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectAffectsClipBounds
	)

Definition at line 1810 of file display_list_unittests.cc.

                                                   {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  receiver.clipRect(clip_bounds, ClipOp::kIntersect, false);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, false);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_clip_bounds = SkRect::MakeLTRB(5.1, 5.65, 10.2, 12.85);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_clip_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [194/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectAffectsClipBoundsWithMatrix
	)

Definition at line 1889 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds_1 = SkRect::MakeLTRB(0, 0, 10, 10);
  SkRect clip_bounds_2 = SkRect::MakeLTRB(10, 10, 20, 20);
  receiver.save();
  receiver.clipRect(clip_bounds_1, ClipOp::kIntersect, false);
  receiver.translate(10, 0);
  receiver.clipRect(clip_bounds_1, ClipOp::kIntersect, false);
  ASSERT_TRUE(builder.GetDestinationClipBounds().isEmpty());
  receiver.restore();
 
  receiver.save();
  receiver.clipRect(clip_bounds_1, ClipOp::kIntersect, false);
  receiver.translate(-10, -10);
  receiver.clipRect(clip_bounds_2, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds_1);
  receiver.restore();
}

◆ TEST_F() [195/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectCulling
	)

Definition at line 4472 of file display_list_unittests.cc.

                                         {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipRect(clip.makeOutset(1.0f, 1.0f), ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [196/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectCullingPixel6a
	)

Definition at line 4448 of file display_list_unittests.cc.

                                                {
  // These particular values create bit errors if we use the path that
  // tests for inclusion in local space, but work OK if we use a forward
  // path that tests for inclusion in device space, due to the fact that
  // the extra matrix inversion is just enough math to cause the transform
  // to place the local space cull corners just outside the original rect.
  // The test in device space only works under a simple scale, such as we
  // use for DPR adjustments (and which are not always inversion friendly).
 
  auto frame = SkRect::MakeLTRB(0.0f, 0.0f, 1080.0f, 2400.0f);
  DlScalar DPR = 2.625f;
  auto clip = SkRect::MakeLTRB(0.0f, 0.0f, 1080.0f / DPR, 2400.0f / DPR);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(frame, ClipOp::kIntersect, false);
  cull_builder.Scale(DPR, DPR);
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(frame, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [197/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectDoAAAffectsClipBounds
	)

Definition at line 1849 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  SkRect clip_expanded_bounds = SkRect::MakeLTRB(10, 11, 21, 26);
  receiver.clipRect(clip_bounds, ClipOp::kIntersect, true);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, true);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_expanded_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_expanded_bounds = SkRect::MakeLTRB(5, 5.5, 10.5, 13);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_expanded_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [198/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectNestedCulling
	)

Definition at line 4500 of file display_list_unittests.cc.

                                               {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto larger_clip = clip.makeOutset(1.0f, 1.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.Save();
  cull_builder.ClipRect(larger_clip, ClipOp::kIntersect, false);
  cull_builder.Restore();
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [199/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectNestedCullingComplex
	)

Definition at line 4534 of file display_list_unittests.cc.

                                                      {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto smaller_clip = clip.makeInset(1.0f, 1.0f);
  auto smallest_clip = clip.makeInset(2.0f, 2.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.Save();
  cull_builder.ClipRect(smallest_clip, ClipOp::kIntersect, false);
  cull_builder.ClipRect(smaller_clip, ClipOp::kIntersect, false);
  cull_builder.Restore();
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(smallest_clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [200/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectNestedNonCulling
	)

Definition at line 4516 of file display_list_unittests.cc.

                                                  {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto larger_clip = clip.makeOutset(1.0f, 1.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.Save();
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.Restore();
  // Should not be culled because we have restored the prior clip
  cull_builder.ClipRect(larger_clip, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(larger_clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [201/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectNestedNonCullingComplex
	)

Definition at line 4553 of file display_list_unittests.cc.

                                                         {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto smaller_clip = clip.makeInset(1.0f, 1.0f);
  auto smallest_clip = clip.makeInset(2.0f, 2.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.Save();
  cull_builder.ClipRect(smallest_clip, ClipOp::kIntersect, false);
  cull_builder.Restore();
  // Would not be culled if it was inside the clip
  cull_builder.ClipRect(smaller_clip, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(smallest_clip, ClipOp::kIntersect, false);
  expector.addExpectation(smaller_clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [202/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectNonCulling
	)

Definition at line 4485 of file display_list_unittests.cc.

                                            {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto smaller_clip = clip.makeInset(1.0f, 1.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipRect(smaller_clip, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(smaller_clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [203/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRectTriggersDeferredSave
	)

Definition at line 2721 of file display_list_unittests.cc.

                                                      {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.clipRect(SkRect::MakeLTRB(0, 0, 100, 100), ClipOp::kIntersect,
                     true);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.clipRect(SkRect::MakeLTRB(0, 0, 100, 100), ClipOp::kIntersect,
                     true);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  receiver2.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [204/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectAffectsClipBounds
	)

Definition at line 1909 of file display_list_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  SkRRect clip = SkRRect::MakeRectXY(clip_bounds, 3, 2);
  receiver.clipRRect(clip, ClipOp::kIntersect, false);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, false);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_clip_bounds = SkRect::MakeLTRB(5.1, 5.65, 10.2, 12.85);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_clip_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [205/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectAffectsClipBoundsWithMatrix
	)

Definition at line 1990 of file display_list_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds_1 = SkRect::MakeLTRB(0, 0, 10, 10);
  SkRect clip_bounds_2 = SkRect::MakeLTRB(10, 10, 20, 20);
  SkRRect clip1 = SkRRect::MakeRectXY(clip_bounds_1, 3, 2);
  SkRRect clip2 = SkRRect::MakeRectXY(clip_bounds_2, 3, 2);
 
  receiver.save();
  receiver.clipRRect(clip1, ClipOp::kIntersect, false);
  receiver.translate(10, 0);
  receiver.clipRRect(clip1, ClipOp::kIntersect, false);
  ASSERT_TRUE(builder.GetDestinationClipBounds().isEmpty());
  receiver.restore();
 
  receiver.save();
  receiver.clipRRect(clip1, ClipOp::kIntersect, false);
  receiver.translate(-10, -10);
  receiver.clipRRect(clip2, ClipOp::kIntersect, false);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds_1);
  receiver.restore();
}

◆ TEST_F() [206/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectCulling
	)

Definition at line 4574 of file display_list_unittests.cc.

                                          {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto rrect = SkRRect::MakeRectXY(clip.makeOutset(2.0f, 2.0f), 2.0f, 2.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipRRect(rrect, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [207/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectDoAAAffectsClipBounds
	)

Definition at line 1949 of file display_list_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  SkRect clip_expanded_bounds = SkRect::MakeLTRB(10, 11, 21, 26);
  SkRRect clip = SkRRect::MakeRectXY(clip_bounds, 3, 2);
  receiver.clipRRect(clip, ClipOp::kIntersect, true);
 
  // Save initial return values for testing restored values
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
 
  receiver.save();
  receiver.clipRect({0, 0, 15, 15}, ClipOp::kIntersect, true);
  // Both clip bounds have changed
  ASSERT_NE(builder.GetLocalClipBounds(), clip_expanded_bounds);
  ASSERT_NE(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  // Previous return values have not changed
  ASSERT_EQ(initial_local_bounds, clip_expanded_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
 
  receiver.save();
  receiver.scale(2, 2);
  SkRect scaled_expanded_bounds = SkRect::MakeLTRB(5, 5.5, 10.5, 13);
  ASSERT_EQ(builder.GetLocalClipBounds(), scaled_expanded_bounds);
  // Destination bounds are unaffected by transform
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_expanded_bounds);
  receiver.restore();
 
  // save/restore returned the values to their original values
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [208/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectNonCulling
	)

Definition at line 4588 of file display_list_unittests.cc.

                                             {
  auto clip = SkRect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f);
  auto rrect = SkRRect::MakeRectXY(clip.makeOutset(2.0f, 2.0f), 12.0f, 12.0f);
 
  DisplayListBuilder cull_builder;
  cull_builder.ClipRect(clip, ClipOp::kIntersect, false);
  cull_builder.ClipRRect(rrect, ClipOp::kIntersect, false);
  auto cull_dl = cull_builder.Build();
 
  CLIP_EXPECTOR(expector);
  expector.addExpectation(clip, ClipOp::kIntersect, false);
  expector.addExpectation(rrect, ClipOp::kIntersect, false);
  cull_dl->Dispatch(expector);
}

◆ TEST_F() [209/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ClipRRectTriggersDeferredSave
	)

Definition at line 2755 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.clipRRect(kTestRRect, ClipOp::kIntersect, true);
 
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.clipRRect(kTestRRect, ClipOp::kIntersect, true);
 
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  receiver2.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [210/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		CollapseMultipleNestedSaveRestore
	)

Definition at line 2438 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.save();
  receiver1.translate(10, 10);
  receiver1.scale(2, 2);
  receiver1.clipRect({10, 10, 20, 20}, ClipOp::kIntersect, false);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.translate(10, 10);
  receiver2.scale(2, 2);
  receiver2.clipRect({10, 10, 20, 20}, ClipOp::kIntersect, false);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [211/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		CollapseNestedSaveAndSaveLayerRestore
	)

Definition at line 2466 of file display_list_unittests.cc.

                                                               {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.scale(2, 2);
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.scale(2, 2);
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [212/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		CrossOfNonOverlappingOpsSupportGroupOpacity
	)

Definition at line 1222 of file display_list_unittests.cc.

                                                                     {
  DisplayListBuilder builder;
  builder.DrawRect(SkRect::MakeLTRB(200, 200, 300, 300), DlPaint());  // center
  builder.DrawRect(SkRect::MakeLTRB(100, 200, 200, 300), DlPaint());  // left
  builder.DrawRect(SkRect::MakeLTRB(200, 100, 300, 200), DlPaint());  // above
  builder.DrawRect(SkRect::MakeLTRB(300, 200, 400, 300), DlPaint());  // right
  builder.DrawRect(SkRect::MakeLTRB(200, 300, 300, 400), DlPaint());  // below
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [213/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		Defaults
	)

Definition at line 233 of file display_list_unittests.cc.

                                  {
  DisplayListBuilder builder;
  check_defaults(builder);
}

◆ TEST_F() [214/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DiffClipPathDoesNotAffectClipBounds
	)

Definition at line 2152 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkPath diff_clip = SkPath().addRect({0, 0, 15, 15});
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
  receiver.clipPath(clip, ClipOp::kIntersect, false);
 
  // Save initial return values for testing after kDifference clip
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.clipPath(diff_clip, ClipOp::kDifference, false);
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [215/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DiffClipPathWithInvertFillTypeAffectsClipBounds
	)

Definition at line 2183 of file display_list_unittests.cc.

                                                                         {
  SkRect cull_rect = SkRect::MakeLTRB(0, 0, 100.0, 100.0);
  DisplayListBuilder builder(cull_rect);
  DlOpReceiver& receiver = ToReceiver(builder);
  SkPath clip = SkPath().addCircle(10.2, 11.3, 2).addCircle(20.4, 25.7, 2);
  clip.setFillType(SkPathFillType::kInverseWinding);
  SkRect clip_bounds = SkRect::MakeLTRB(8.2, 9.3, 22.4, 27.7);
  receiver.clipPath(clip, ClipOp::kDifference, false);
 
  ASSERT_EQ(builder.GetLocalClipBounds(), clip_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), clip_bounds);
}

◆ TEST_F() [216/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DiffClipRectDoesNotAffectClipBounds
	)

Definition at line 2115 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRect diff_clip = SkRect::MakeLTRB(0, 0, 15, 15);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  receiver.clipRect(clip_bounds, ClipOp::kIntersect, false);
 
  // Save initial return values for testing after kDifference clip
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.clipRect(diff_clip, ClipOp::kDifference, false);
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [217/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DiffClipRRectDoesNotAffectClipBounds
	)

Definition at line 2133 of file display_list_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  SkRRect diff_clip = SkRRect::MakeRectXY({0, 0, 15, 15}, 1, 1);
  SkRect clip_bounds = SkRect::MakeLTRB(10.2, 11.3, 20.4, 25.7);
  SkRRect clip = SkRRect::MakeRectXY({10.2, 11.3, 20.4, 25.7}, 3, 2);
  receiver.clipRRect(clip, ClipOp::kIntersect, false);
 
  // Save initial return values for testing after kDifference clip
  SkRect initial_local_bounds = builder.GetLocalClipBounds();
  SkRect initial_destination_bounds = builder.GetDestinationClipBounds();
  ASSERT_EQ(initial_local_bounds, clip_bounds);
  ASSERT_EQ(initial_destination_bounds, clip_bounds);
 
  receiver.clipRRect(diff_clip, ClipOp::kDifference, false);
  ASSERT_EQ(builder.GetLocalClipBounds(), initial_local_bounds);
  ASSERT_EQ(builder.GetDestinationClipBounds(), initial_destination_bounds);
}

◆ TEST_F() [218/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DisplayListFullPerspectiveTransformHandling
	)

Definition at line 1027 of file display_list_unittests.cc.

                                                                     {
  // SkM44 constructor takes row-major order
  SkM44 sk_matrix = SkM44(
      // clang-format off
       1,  2,  3,  4,
       5,  6,  7,  8,
       9, 10, 11, 12,
      13, 14, 15, 16
      // clang-format on
  );
 
  {  // First test ==
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    // receiver.transformFullPerspective takes row-major order
    receiver.transformFullPerspective(
        // clang-format off
         1,  2,  3,  4,
         5,  6,  7,  8,
         9, 10, 11, 12,
        13, 14, 15, 16
        // clang-format on
    );
    sk_sp<DisplayList> display_list = builder.Build();
    sk_sp<SkSurface> surface =
        SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10));
    SkCanvas* canvas = surface->getCanvas();
    // We can't use DlSkCanvas.DrawDisplayList as that method protects
    // the canvas against mutations from the display list being drawn.
    auto dispatcher = DlSkCanvasDispatcher(surface->getCanvas());
    display_list->Dispatch(dispatcher);
    SkM44 dl_matrix = canvas->getLocalToDevice();
    ASSERT_EQ(sk_matrix, dl_matrix);
  }
  {  // Next test !=
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    // receiver.transformFullPerspective takes row-major order
    receiver.transformFullPerspective(
        // clang-format off
         1,  5,  9, 13,
         2,  6,  7, 11,
         3,  7, 11, 15,
         4,  8, 12, 16
        // clang-format on
    );
    sk_sp<DisplayList> display_list = builder.Build();
    sk_sp<SkSurface> surface =
        SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10));
    SkCanvas* canvas = surface->getCanvas();
    // We can't use DlSkCanvas.DrawDisplayList as that method protects
    // the canvas against mutations from the display list being drawn.
    auto dispatcher = DlSkCanvasDispatcher(surface->getCanvas());
    display_list->Dispatch(dispatcher);
    SkM44 dl_matrix = canvas->getLocalToDevice();
    ASSERT_NE(sk_matrix, dl_matrix);
  }
}

◆ TEST_F() [219/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DisplayListSaveLayerBoundsWithAlphaFilter
	)

Definition at line 815 of file display_list_unittests.cc.

                                                                   {
  SkRect build_bounds = SkRect::MakeLTRB(-100, -100, 200, 200);
  SkRect save_bounds = SkRect::MakeWH(100, 100);
  SkRect rect = SkRect::MakeLTRB(30, 30, 70, 70);
  // clang-format off
  const float color_matrix[] = {
    0, 0, 0, 0, 0,
    0, 1, 0, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 0, 1, 0,
  };
  // clang-format on
  DlMatrixColorFilter base_color_filter(color_matrix);
  // clang-format off
  const float alpha_matrix[] = {
    0, 0, 0, 0, 0,
    0, 1, 0, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 0, 0, 1,
  };
  // clang-format on
  DlMatrixColorFilter alpha_color_filter(alpha_matrix);
  sk_sp<SkColorFilter> sk_alpha_color_filter =
      SkColorFilters::Matrix(alpha_matrix);
 
  {
    // No tricky stuff, just verifying drawing a rect produces rect bounds
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), rect);
  }
 
  {
    // Now checking that a normal color filter still produces rect bounds
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setColorFilter(&base_color_filter);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.setColorFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), rect);
  }
 
  {
    // Now checking how SkPictureRecorder deals with a color filter
    // that modifies alpha channels (save layer bounds are meaningless
    // under those circumstances)
    SkPictureRecorder recorder;
    SkRTreeFactory rtree_factory;
    SkCanvas* canvas = recorder.beginRecording(build_bounds, &rtree_factory);
    SkPaint p1;
    p1.setColorFilter(sk_alpha_color_filter);
    canvas->saveLayer(save_bounds, &p1);
    SkPaint p2;
    canvas->drawRect(rect, p2);
    canvas->restore();
    sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
    ASSERT_EQ(picture->cullRect(), build_bounds);
  }
 
  {
    // Now checking that DisplayList has the same behavior that we
    // saw in the SkPictureRecorder example above - returning the
    // cull rect of the DisplayListBuilder when it encounters a
    // save layer that modifies an unbounded region
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setColorFilter(&alpha_color_filter);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.setColorFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
 
  {
    // Verifying that the save layer bounds are not relevant
    // to the behavior in the previous example
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setColorFilter(&alpha_color_filter);
    receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
    receiver.setColorFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
 
  {
    // Making sure hiding a ColorFilter as an ImageFilter will
    // generate the same behavior as setting it as a ColorFilter
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    DlColorFilterImageFilter color_filter_image_filter(base_color_filter);
    receiver.setImageFilter(&color_filter_image_filter);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.setImageFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), rect);
  }
 
  {
    // Making sure hiding a problematic ColorFilter as an ImageFilter
    // will generate the same behavior as setting it as a ColorFilter
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    DlColorFilterImageFilter color_filter_image_filter(alpha_color_filter);
    receiver.setImageFilter(&color_filter_image_filter);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.setImageFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
 
  {
    // Same as above (ImageFilter hiding ColorFilter) with no save bounds
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    DlColorFilterImageFilter color_filter_image_filter(alpha_color_filter);
    receiver.setImageFilter(&color_filter_image_filter);
    receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
    receiver.setImageFilter(nullptr);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
 
  {
    // Testing behavior with an unboundable blend mode
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setBlendMode(DlBlendMode::kClear);
    receiver.saveLayer(&save_bounds, SaveLayerOptions::kWithAttributes);
    receiver.setBlendMode(DlBlendMode::kSrcOver);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
 
  {
    // Same as previous with no save bounds
    DisplayListBuilder builder(build_bounds);
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setBlendMode(DlBlendMode::kClear);
    receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
    receiver.setBlendMode(DlBlendMode::kSrcOver);
    receiver.drawRect(rect);
    receiver.restore();
    sk_sp<DisplayList> display_list = builder.Build();
    ASSERT_EQ(display_list->bounds(), build_bounds);
  }
}

◆ TEST_F() [220/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DisplayListsWithVaryingOpComparisons
	)

Definition at line 782 of file display_list_unittests.cc.

                                                              {
  sk_sp<DisplayList> default_dl = Build(allGroups.size(), 0);
  ASSERT_TRUE(default_dl->Equals(*default_dl)) << "Default == itself";
  for (size_t gi = 0; gi < allGroups.size(); gi++) {
    DisplayListInvocationGroup& group = allGroups[gi];
    sk_sp<DisplayList> missing_dl = Build(gi, group.variants.size());
    auto desc = "[Group " + group.op_name + " omitted]";
    ASSERT_TRUE(missing_dl->Equals(*missing_dl)) << desc << " == itself";
    ASSERT_FALSE(missing_dl->Equals(*default_dl)) << desc << " != Default";
    ASSERT_FALSE(default_dl->Equals(*missing_dl)) << "Default != " << desc;
    for (size_t vi = 0; vi < group.variants.size(); vi++) {
      auto desc = "[Group " + group.op_name + " variant " +
                  std::to_string(vi + 1) + "]";
      sk_sp<DisplayList> variant_dl = Build(gi, vi);
      ASSERT_TRUE(variant_dl->Equals(*variant_dl)) << desc << " == itself";
      if (vi == 0) {
        ASSERT_TRUE(variant_dl->Equals(*default_dl)) << desc << " == Default";
        ASSERT_TRUE(default_dl->Equals(*variant_dl)) << "Default == " << desc;
      } else {
        ASSERT_FALSE(variant_dl->Equals(*default_dl)) << desc << " != Default";
        ASSERT_FALSE(default_dl->Equals(*variant_dl)) << "Default != " << desc;
      }
      if (group.variants[vi].is_empty()) {
        ASSERT_TRUE(variant_dl->Equals(*missing_dl)) << desc << " != omitted";
        ASSERT_TRUE(missing_dl->Equals(*variant_dl)) << "omitted != " << desc;
      } else {
        ASSERT_FALSE(variant_dl->Equals(*missing_dl)) << desc << " != omitted";
        ASSERT_FALSE(missing_dl->Equals(*variant_dl)) << "omitted != " << desc;
      }
    }
  }
}

◆ TEST_F() [221/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DisplayListTransformResetHandling
	)

Definition at line 1086 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.scale(20.0, 20.0);
  receiver.transformReset();
  auto display_list = builder.Build();
  ASSERT_NE(display_list, nullptr);
  sk_sp<SkSurface> surface =
      SkSurfaces::Raster(SkImageInfo::MakeN32Premul(10, 10));
  SkCanvas* canvas = surface->getCanvas();
  // We can't use DlSkCanvas.DrawDisplayList as that method protects
  // the canvas against mutations from the display list being drawn.
  auto dispatcher = DlSkCanvasDispatcher(surface->getCanvas());
  display_list->Dispatch(dispatcher);
  ASSERT_TRUE(canvas->getTotalMatrix().isIdentity());
}

◆ TEST_F() [222/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawDisplayListForwardsBackdropFlag
	)

Definition at line 4316 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder child_builder;
  DlBlurImageFilter backdrop(2.0f, 2.0f, DlTileMode::kDecal);
  child_builder.SaveLayer(nullptr, nullptr, &backdrop);
  child_builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                         DlPaint().setBlendMode(DlBlendMode::kMultiply));
  child_builder.Restore();
  auto child_dl = child_builder.Build();
  EXPECT_EQ(child_dl->max_root_blend_mode(), DlBlendMode::kSrcOver);
  EXPECT_TRUE(child_dl->root_has_backdrop_filter());
 
  DisplayListBuilder parent_builder;
  parent_builder.DrawDisplayList(child_dl);
  auto parent_dl = parent_builder.Build();
  EXPECT_EQ(parent_dl->max_root_blend_mode(), DlBlendMode::kSrcOver);
  EXPECT_TRUE(parent_dl->root_has_backdrop_filter());
}

◆ TEST_F() [223/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawDisplayListForwardsMaxBlend
	)

Definition at line 4301 of file display_list_unittests.cc.

                                                         {
  DisplayListBuilder child_builder;
  child_builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                         DlPaint().setBlendMode(DlBlendMode::kMultiply));
  auto child_dl = child_builder.Build();
  EXPECT_EQ(child_dl->max_root_blend_mode(), DlBlendMode::kMultiply);
  EXPECT_FALSE(child_dl->root_has_backdrop_filter());
 
  DisplayListBuilder parent_builder;
  parent_builder.DrawDisplayList(child_dl);
  auto parent_dl = parent_builder.Build();
  EXPECT_EQ(parent_dl->max_root_blend_mode(), DlBlendMode::kMultiply);
  EXPECT_FALSE(parent_dl->root_has_backdrop_filter());
}

◆ TEST_F() [224/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawSaveDrawCannotInheritOpacity
	)

Definition at line 3154 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.DrawCircle({10, 10}, 5, DlPaint());
  builder.Save();
  builder.ClipRect({0, 0, 20, 20}, DlCanvas::ClipOp::kIntersect, false);
  builder.DrawRect({5, 5, 15, 15}, DlPaint());
  builder.Restore();
  auto display_list = builder.Build();
 
  ASSERT_FALSE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [225/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedOval
	)

Definition at line 3180 of file display_list_unittests.cc.

                                           {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    canvas.DrawOval(rect, paint);
  };
  check_inverted_bounds(renderer, "DrawOval");
}

◆ TEST_F() [226/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedOvalPath
	)

Definition at line 3194 of file display_list_unittests.cc.

                                               {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    canvas.DrawPath(SkPath().addOval(rect), paint);
  };
  check_inverted_bounds(renderer, "DrawOvalPath");
}

◆ TEST_F() [227/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedRect
	)

Definition at line 3166 of file display_list_unittests.cc.

                                           {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    canvas.DrawRect(rect, paint);
  };
  check_inverted_bounds(renderer, "DrawRect");
}

◆ TEST_F() [228/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedRectangularPath
	)

Definition at line 3187 of file display_list_unittests.cc.

                                                      {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    canvas.DrawPath(SkPath().addRect(rect), paint);
  };
  check_inverted_bounds(renderer, "DrawRectangularPath");
}

◆ TEST_F() [229/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedRoundRect
	)

Definition at line 3173 of file display_list_unittests.cc.

                                                {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    canvas.DrawRRect(SkRRect::MakeRectXY(rect, 2.0f, 2.0f), paint);
  };
  check_inverted_bounds(renderer, "DrawRoundRect");
}

◆ TEST_F() [230/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedRoundRectPathCCW
	)

Definition at line 3210 of file display_list_unittests.cc.

                                                       {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    SkPath path = SkPath()  //
                      .addRoundRect(rect, 2.0f, 2.0f, SkPathDirection::kCCW);
    canvas.DrawPath(path, paint);
  };
  check_inverted_bounds(renderer, "DrawRoundRectPath Counter-Clockwise");
}

◆ TEST_F() [231/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		DrawUnorderedRoundRectPathCW
	)

Definition at line 3201 of file display_list_unittests.cc.

                                                      {
  auto renderer = [](DlCanvas& canvas, DlPaint& paint, SkRect& rect) {
    SkPath path = SkPath()  //
                      .addRoundRect(rect, 2.0f, 2.0f, SkPathDirection::kCW);
    canvas.DrawPath(path, paint);
  };
  check_inverted_bounds(renderer, "DrawRoundRectPath Clockwise");
}

◆ TEST_F() [232/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		EmptyBuild
	)

Definition at line 238 of file display_list_unittests.cc.

                                    {
  DisplayListBuilder builder;
  auto dl = builder.Build();
  EXPECT_EQ(dl->op_count(), 0u);
  EXPECT_EQ(dl->bytes(), sizeof(DisplayList));
  EXPECT_EQ(dl->total_depth(), 0u);
}

◆ TEST_F() [233/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		EmptyRebuild
	)

Definition at line 246 of file display_list_unittests.cc.

                                      {
  DisplayListBuilder builder;
  auto dl1 = builder.Build();
  auto dl2 = builder.Build();
  auto dl3 = builder.Build();
  ASSERT_TRUE(dl1->Equals(dl2));
  ASSERT_TRUE(dl2->Equals(dl3));
}

◆ TEST_F() [234/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FlatDrawPointsProducesBounds
	)

Definition at line 2196 of file display_list_unittests.cc.

                                                      {
  SkPoint horizontal_points[2] = {{10, 10}, {20, 10}};
  SkPoint vertical_points[2] = {{10, 10}, {10, 20}};
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.drawPoints(PointMode::kPolygon, 2, horizontal_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
    EXPECT_TRUE(bounds.contains(20, 10));
    EXPECT_GE(bounds.width(), 10);
  }
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.drawPoints(PointMode::kPolygon, 2, vertical_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
    EXPECT_TRUE(bounds.contains(10, 20));
    EXPECT_GE(bounds.height(), 10);
  }
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.drawPoints(PointMode::kPoints, 1, horizontal_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
  }
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setStrokeWidth(2);
    receiver.drawPoints(PointMode::kPolygon, 2, horizontal_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
    EXPECT_TRUE(bounds.contains(20, 10));
    EXPECT_EQ(bounds, SkRect::MakeLTRB(9, 9, 21, 11));
  }
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setStrokeWidth(2);
    receiver.drawPoints(PointMode::kPolygon, 2, vertical_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
    EXPECT_TRUE(bounds.contains(10, 20));
    EXPECT_EQ(bounds, SkRect::MakeLTRB(9, 9, 11, 21));
  }
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.setStrokeWidth(2);
    receiver.drawPoints(PointMode::kPoints, 1, horizontal_points);
    SkRect bounds = builder.Build()->bounds();
    EXPECT_TRUE(bounds.contains(10, 10));
    EXPECT_EQ(bounds, SkRect::MakeLTRB(9, 9, 11, 11));
  }
}

◆ TEST_F() [235/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FloodingFilteredLayerPushesRestoreOpIndex
	)

Definition at line 4007 of file display_list_unittests.cc.

                                                                   {
  DisplayListBuilder builder(true);
  builder.ClipRect(SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f));
  // ClipRect does not contribute to rtree rects, no id needed
 
  DlPaint save_paint;
  // clang-format off
  const float matrix[] = {
    0.5f, 0.0f, 0.0f, 0.0f, 0.5f,
    0.5f, 0.0f, 0.0f, 0.0f, 0.5f,
    0.5f, 0.0f, 0.0f, 0.0f, 0.5f,
    0.5f, 0.0f, 0.0f, 0.0f, 0.5f
  };
  // clang-format on
  auto color_filter = DlMatrixColorFilter::Make(matrix);
  save_paint.setImageFilter(DlColorFilterImageFilter::Make(color_filter));
  builder.SaveLayer(nullptr, &save_paint);
  int save_layer_id = DisplayListBuilderTestingLastOpIndex(builder);
 
  builder.DrawRect(SkRect::MakeLTRB(120.0f, 120.0f, 125.0f, 125.0f), DlPaint());
  int draw_rect_id = DisplayListBuilderTestingLastOpIndex(builder);
 
  builder.Restore();
  int restore_id = DisplayListBuilderTestingLastOpIndex(builder);
 
  auto dl = builder.Build();
  std::vector<int> indices;
  dl->rtree()->search(SkRect::MakeLTRB(0.0f, 0.0f, 500.0f, 500.0f), &indices);
  ASSERT_EQ(indices.size(), 3u);
  EXPECT_EQ(dl->rtree()->id(indices[0]), save_layer_id);
  EXPECT_EQ(dl->rtree()->id(indices[1]), draw_rect_id);
  EXPECT_EQ(dl->rtree()->id(indices[2]), restore_id);
}

◆ TEST_F() [236/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FloodingSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3769 of file display_list_unittests.cc.

                                                                        {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint save_paint;
  auto color_filter =
      DlBlendColorFilter::Make(DlColor::kRed(), DlBlendMode::kSrc);
  ASSERT_TRUE(color_filter->modifies_transparent_black());
  save_paint.setColorFilter(color_filter);
  SkRect clip_rect = rect.makeOutset(100.0f, 100.0f);
  ASSERT_NE(clip_rect, rect);
  ASSERT_TRUE(clip_rect.contains(rect));
 
  DisplayListBuilder builder;
  builder.ClipRect(clip_rect);
  builder.SaveLayer(nullptr, &save_paint);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [237/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FlutterSvgIssue661BoundsWereEmpty
	)

Definition at line 1558 of file display_list_unittests.cc.

                                                           {
  // See https://github.com/dnfield/flutter_svg/issues/661
 
  SkPath path1;
  path1.setFillType(SkPathFillType::kWinding);
  path1.moveTo(25.54f, 37.52f);
  path1.cubicTo(20.91f, 37.52f, 16.54f, 33.39f, 13.62f, 30.58f);
  path1.lineTo(13, 30);
  path1.lineTo(12.45f, 29.42f);
  path1.cubicTo(8.39f, 25.15f, 1.61f, 18, 8.37f, 11.27f);
  path1.cubicTo(10.18f, 9.46f, 12.37f, 9.58f, 14.49f, 11.58f);
  path1.cubicTo(15.67f, 12.71f, 17.05f, 14.69f, 17.07f, 16.58f);
  path1.cubicTo(17.0968f, 17.458f, 16.7603f, 18.3081f, 16.14f, 18.93f);
  path1.cubicTo(15.8168f, 19.239f, 15.4653f, 19.5169f, 15.09f, 19.76f);
  path1.cubicTo(14.27f, 20.33f, 14.21f, 20.44f, 14.27f, 20.62f);
  path1.cubicTo(15.1672f, 22.3493f, 16.3239f, 23.9309f, 17.7f, 25.31f);
  path1.cubicTo(19.0791f, 26.6861f, 20.6607f, 27.8428f, 22.39f, 28.74f);
  path1.cubicTo(22.57f, 28.8f, 22.69f, 28.74f, 23.25f, 27.92f);
  path1.cubicTo(23.5f, 27.566f, 23.778f, 27.231f, 24.08f, 26.92f);
  path1.cubicTo(24.7045f, 26.3048f, 25.5538f, 25.9723f, 26.43f, 26);
  path1.cubicTo(28.29f, 26, 30.27f, 27.4f, 31.43f, 28.58f);
  path1.cubicTo(33.43f, 30.67f, 33.55f, 32.9f, 31.74f, 34.7f);
  path1.cubicTo(30.1477f, 36.4508f, 27.906f, 37.4704f, 25.54f, 37.52f);
  path1.close();
  path1.moveTo(11.17f, 12.23f);
  path1.cubicTo(10.6946f, 12.2571f, 10.2522f, 12.4819f, 9.95f, 12.85f);
  path1.cubicTo(5.12f, 17.67f, 8.95f, 22.5f, 14.05f, 27.85f);
  path1.lineTo(14.62f, 28.45f);
  path1.lineTo(15.16f, 28.96f);
  path1.cubicTo(20.52f, 34.06f, 25.35f, 37.89f, 30.16f, 33.06f);
  path1.cubicTo(30.83f, 32.39f, 31.25f, 31.56f, 29.81f, 30.06f);
  path1.cubicTo(28.9247f, 29.07f, 27.7359f, 28.4018f, 26.43f, 28.16f);
  path1.cubicTo(26.1476f, 28.1284f, 25.8676f, 28.2367f, 25.68f, 28.45f);
  path1.cubicTo(25.4633f, 28.6774f, 25.269f, 28.9252f, 25.1f, 29.19f);
  path1.cubicTo(24.53f, 30.01f, 23.47f, 31.54f, 21.54f, 30.79f);
  path1.lineTo(21.41f, 30.72f);
  path1.cubicTo(19.4601f, 29.7156f, 17.6787f, 28.4133f, 16.13f, 26.86f);
  path1.cubicTo(14.5748f, 25.3106f, 13.2693f, 23.5295f, 12.26f, 21.58f);
  path1.lineTo(12.2f, 21.44f);
  path1.cubicTo(11.45f, 19.51f, 12.97f, 18.44f, 13.8f, 17.88f);
  path1.cubicTo(14.061f, 17.706f, 14.308f, 17.512f, 14.54f, 17.3f);
  path1.cubicTo(14.7379f, 17.1067f, 14.8404f, 16.8359f, 14.82f, 16.56f);
  path1.cubicTo(14.5978f, 15.268f, 13.9585f, 14.0843f, 13, 13.19f);
  path1.cubicTo(12.5398f, 12.642f, 11.8824f, 12.2971f, 11.17f, 12.23f);
  path1.lineTo(11.17f, 12.23f);
  path1.close();
  path1.moveTo(27, 19.34f);
  path1.lineTo(24.74f, 19.34f);
  path1.cubicTo(24.7319f, 18.758f, 24.262f, 18.2881f, 23.68f, 18.28f);
  path1.lineTo(23.68f, 16.05f);
  path1.lineTo(23.7f, 16.05f);
  path1.cubicTo(25.5153f, 16.0582f, 26.9863f, 17.5248f, 27, 19.34f);
  path1.lineTo(27, 19.34f);
  path1.close();
  path1.moveTo(32.3f, 19.34f);
  path1.lineTo(30.07f, 19.34f);
  path1.cubicTo(30.037f, 15.859f, 27.171f, 13.011f, 23.69f, 13);
  path1.lineTo(23.69f, 10.72f);
  path1.cubicTo(28.415f, 10.725f, 32.3f, 14.615f, 32.3f, 19.34f);
  path1.close();
 
  SkPath path2;
  path2.setFillType(SkPathFillType::kWinding);
  path2.moveTo(37.5f, 19.33f);
  path2.lineTo(35.27f, 19.33f);
  path2.cubicTo(35.265f, 12.979f, 30.041f, 7.755f, 23.69f, 7.75f);
  path2.lineTo(23.69f, 5.52f);
  path2.cubicTo(31.264f, 5.525f, 37.495f, 11.756f, 37.5f, 19.33f);
  path2.close();
 
  DisplayListBuilder builder;
  DlPaint paint = DlPaint(DlColor::kWhite()).setAntiAlias(true);
  {
    builder.Save();
    builder.ClipRect({0, 0, 100, 100}, ClipOp::kIntersect, true);
    {
      builder.Save();
      builder.Transform2DAffine(2.17391, 0, -2547.83,  //
                                0, 2.04082, -500);
      {
        builder.Save();
        builder.ClipRect({1172, 245, 1218, 294}, ClipOp::kIntersect, true);
        {
          builder.SaveLayer(nullptr, nullptr, nullptr);
          {
            builder.Save();
            builder.Transform2DAffine(1.4375, 0, 1164.09,  //
                                      0, 1.53125, 236.548);
            builder.DrawPath(path1, paint);
            builder.Restore();
          }
          {
            builder.Save();
            builder.Transform2DAffine(1.4375, 0, 1164.09,  //
                                      0, 1.53125, 236.548);
            builder.DrawPath(path2, paint);
            builder.Restore();
          }
          builder.Restore();
        }
        builder.Restore();
      }
      builder.Restore();
    }
    builder.Restore();
  }
  sk_sp<DisplayList> display_list = builder.Build();
  // Prior to the fix, the bounds were empty.
  EXPECT_FALSE(display_list->bounds().isEmpty());
  // These are just inside and outside of the expected bounds, but
  // testing float values can be flaky wrt minor changes in the bounds
  // calculations. If these lines have to be revised too often as the DL
  // implementation is improved and maintained, then we can eliminate
  // this test and just rely on the "rounded out" bounds test that follows.
  SkRect min_bounds = SkRect::MakeLTRB(0, 0.00191, 99.983, 100);
  SkRect max_bounds = SkRect::MakeLTRB(0, 0.00189, 99.985, 100);
  ASSERT_TRUE(max_bounds.contains(min_bounds));
  EXPECT_TRUE(max_bounds.contains(display_list->bounds()));
  EXPECT_TRUE(display_list->bounds().contains(min_bounds));
 
  // This is the more practical result. The bounds are "almost" 0,0,100x100
  EXPECT_EQ(display_list->bounds().roundOut(), SkIRect::MakeWH(100, 100));
  EXPECT_EQ(display_list->op_count(), 19u);
  EXPECT_EQ(display_list->bytes(), sizeof(DisplayList) + 408u);
  EXPECT_EQ(display_list->total_depth(), 3u);
}

◆ TEST_F() [238/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FullRotationsAreNop
	)

Definition at line 754 of file display_list_unittests.cc.

                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.rotate(0);
  receiver.rotate(360);
  receiver.rotate(720);
  receiver.rotate(1080);
  receiver.rotate(1440);
  sk_sp<DisplayList> dl = builder.Build();
  ASSERT_EQ(dl->bytes(false), sizeof(DisplayList));
  ASSERT_EQ(dl->bytes(true), sizeof(DisplayList));
  ASSERT_EQ(dl->op_count(false), 0u);
  ASSERT_EQ(dl->op_count(true), 0u);
  EXPECT_EQ(dl->total_depth(), 0u);
}

◆ TEST_F() [239/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		FullTransformAffectsCurrentTransform
	)

Definition at line 1783 of file display_list_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.transformFullPerspective(3, 0, 4, 12.3,  //
                                    1, 5, 3, 14.5,  //
                                    0, 0, 7, 16.2,  //
                                    0, 0, 0, 1);
  SkMatrix matrix = SkMatrix::MakeAll(3, 0, 12.3,  //
                                      1, 5, 14.5,  //
                                      0, 0, 1);
  SkM44 m44 = SkM44(3, 0, 4, 12.3,  //
                    1, 5, 3, 14.5,  //
                    0, 0, 7, 16.2,  //
                    0, 0, 0, 1);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [240/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ImpellerPathPreferenceIsHonored
	)

Definition at line 3381 of file display_list_unittests.cc.

                                                         {
  class Tester : public virtual DlOpReceiver,
                 public IgnoreClipDispatchHelper,
                 public IgnoreDrawDispatchHelper,
                 public IgnoreAttributeDispatchHelper,
                 public IgnoreTransformDispatchHelper {
   public:
    explicit Tester(bool prefer_impeller_paths)
        : prefer_impeller_paths_(prefer_impeller_paths) {}
 
    bool PrefersImpellerPaths() const override {
      return prefer_impeller_paths_;
    }
 
    void drawPath(const SkPath& path) override { skia_draw_path_calls_++; }
 
    void drawPath(const CacheablePath& cache) override {
      impeller_draw_path_calls_++;
    }
 
    void clipPath(const SkPath& path, ClipOp op, bool is_aa) override {
      skia_clip_path_calls_++;
    }
 
    void clipPath(const CacheablePath& cache, ClipOp op, bool is_aa) override {
      impeller_clip_path_calls_++;
    }
 
    virtual void drawShadow(const SkPath& sk_path,
                            const DlColor color,
                            const SkScalar elevation,
                            bool transparent_occluder,
                            SkScalar dpr) override {
      skia_draw_shadow_calls_++;
    }
 
    virtual void drawShadow(const CacheablePath& cache,
                            const DlColor color,
                            const SkScalar elevation,
                            bool transparent_occluder,
                            SkScalar dpr) override {
      impeller_draw_shadow_calls_++;
    }
 
    int skia_draw_path_calls() const { return skia_draw_path_calls_; }
    int skia_clip_path_calls() const { return skia_draw_path_calls_; }
    int skia_draw_shadow_calls() const { return skia_draw_path_calls_; }
    int impeller_draw_path_calls() const { return impeller_draw_path_calls_; }
    int impeller_clip_path_calls() const { return impeller_draw_path_calls_; }
    int impeller_draw_shadow_calls() const { return impeller_draw_path_calls_; }
 
   private:
    const bool prefer_impeller_paths_;
    int skia_draw_path_calls_ = 0;
    int skia_clip_path_calls_ = 0;
    int skia_draw_shadow_calls_ = 0;
    int impeller_draw_path_calls_ = 0;
    int impeller_clip_path_calls_ = 0;
    int impeller_draw_shadow_calls_ = 0;
  };
 
  DisplayListBuilder builder;
  builder.DrawPath(SkPath::Rect(SkRect::MakeLTRB(0, 0, 100, 100)), DlPaint());
  builder.ClipPath(SkPath::Rect(SkRect::MakeLTRB(0, 0, 100, 100)),
                   ClipOp::kIntersect, true);
  builder.DrawShadow(SkPath::Rect(SkRect::MakeLTRB(20, 20, 80, 80)),
                     DlColor::kBlue(), 1.0f, true, 1.0f);
  auto display_list = builder.Build();
 
  {
    Tester skia_tester(false);
    display_list->Dispatch(skia_tester);
    EXPECT_EQ(skia_tester.skia_draw_path_calls(), 1);
    EXPECT_EQ(skia_tester.skia_clip_path_calls(), 1);
    EXPECT_EQ(skia_tester.skia_draw_shadow_calls(), 1);
    EXPECT_EQ(skia_tester.impeller_draw_path_calls(), 0);
    EXPECT_EQ(skia_tester.impeller_clip_path_calls(), 0);
    EXPECT_EQ(skia_tester.impeller_draw_shadow_calls(), 0);
  }
 
  {
    Tester impeller_tester(true);
    display_list->Dispatch(impeller_tester);
    EXPECT_EQ(impeller_tester.skia_draw_path_calls(), 0);
    EXPECT_EQ(impeller_tester.skia_clip_path_calls(), 0);
    EXPECT_EQ(impeller_tester.skia_draw_shadow_calls(), 0);
    EXPECT_EQ(impeller_tester.impeller_draw_path_calls(), 1);
    EXPECT_EQ(impeller_tester.impeller_clip_path_calls(), 1);
    EXPECT_EQ(impeller_tester.impeller_draw_shadow_calls(), 1);
  }
}

◆ TEST_F() [241/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		LineOfNonOverlappingOpsSupportGroupOpacity
	)

Definition at line 1213 of file display_list_unittests.cc.

                                                                    {
  DisplayListBuilder builder;
  for (int i = 0; i < 10; i++) {
    builder.DrawRect(SkRect::MakeXYWH(i * 30, 0, 30, 30), DlPaint());
  }
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [242/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeEmptyDisplayList
	)

Definition at line 4102 of file display_list_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  EXPECT_EQ(builder.Build()->max_root_blend_mode(), DlBlendMode::kClear);
}

◆ TEST_F() [243/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideComplexDeferredSaves
	)

Definition at line 4182 of file display_list_unittests.cc.

                                                                {
  DisplayListBuilder builder;
  builder.Save();
  {
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
    builder.Save();
    {
      // We want to use a blend mode that is greater than modulate here
      ASSERT_GT(DlBlendMode::kScreen, DlBlendMode::kModulate);
      builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                       DlPaint().setBlendMode(DlBlendMode::kScreen));
    }
    builder.Restore();
 
    // We want to use a blend mode that is smaller than modulate here
    ASSERT_LT(DlBlendMode::kSrc, DlBlendMode::kModulate);
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kSrc));
  }
  builder.Restore();
 
  // Double check that kScreen is the max blend mode
  auto expect = std::max(DlBlendMode::kModulate, DlBlendMode::kScreen);
  expect = std::max(expect, DlBlendMode::kSrc);
  ASSERT_EQ(expect, DlBlendMode::kScreen);
 
  EXPECT_EQ(builder.Build()->max_root_blend_mode(), DlBlendMode::kScreen);
}

◆ TEST_F() [244/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideComplexSaveLayers
	)

Definition at line 4212 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {
    // outer save layer has Modulate now and Src later - Modulate is larger
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
    builder.SaveLayer(nullptr, nullptr);
    {
      // inner save layer only has a Screen blend
      builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                       DlPaint().setBlendMode(DlBlendMode::kScreen));
    }
    builder.Restore();
 
    // We want to use a blend mode that is smaller than modulate here
    ASSERT_LT(DlBlendMode::kSrc, DlBlendMode::kModulate);
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kSrc));
  }
  builder.Restore();
 
  // Double check that kModulate is the max blend mode for the first
  // saveLayer operations
  auto expect = std::max(DlBlendMode::kModulate, DlBlendMode::kSrc);
  ASSERT_EQ(expect, DlBlendMode::kModulate);
 
  auto dl = builder.Build();
  EXPECT_EQ(dl->max_root_blend_mode(), DlBlendMode::kSrcOver);
  SaveLayerExpector expector({DlBlendMode::kModulate, DlBlendMode::kScreen});
  dl->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [245/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideDeferredSave
	)

Definition at line 4137 of file display_list_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.Save();
  {
    // Nothing to trigger the deferred save...
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
  }
  // Deferred save was not triggered, did it forward the max blend mode?
  builder.Restore();
  EXPECT_EQ(builder.Build()->max_root_blend_mode(), DlBlendMode::kModulate);
}

◆ TEST_F() [246/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideNonDefaultBlendedSaveLayer
	)

Definition at line 4165 of file display_list_unittests.cc.

                                                                      {
  DisplayListBuilder builder;
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kScreen);
  builder.SaveLayer(nullptr, &save_paint);
  {
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
  }
  builder.Restore();
  auto dl = builder.Build();
  EXPECT_EQ(dl->max_root_blend_mode(), DlBlendMode::kScreen);
  SaveLayerExpector expector(DlBlendMode::kModulate);
  dl->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [247/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideNonDeferredSave
	)

Definition at line 4123 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder;
  builder.Save();
  {
    // Trigger the deferred save
    builder.Scale(2.0f, 2.0f);
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
  }
  // Save was triggered, did it forward the max blend mode?
  builder.Restore();
  EXPECT_EQ(builder.Build()->max_root_blend_mode(), DlBlendMode::kModulate);
}

◆ TEST_F() [248/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeInsideSaveLayer
	)

Definition at line 4150 of file display_list_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kModulate));
  }
  builder.Restore();
  auto dl = builder.Build();
  EXPECT_EQ(dl->max_root_blend_mode(), DlBlendMode::kSrcOver);
  SaveLayerExpector expector(DlBlendMode::kModulate);
  dl->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [249/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		MaxBlendModeSimpleRect
	)

Definition at line 4107 of file display_list_unittests.cc.

                                                {
  auto test = [](DlBlendMode mode) {
    DisplayListBuilder builder;
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setAlpha(0x7f).setBlendMode(mode));
    DlBlendMode expect =
        (mode == DlBlendMode::kDst) ? DlBlendMode::kClear : mode;
    EXPECT_EQ(builder.Build()->max_root_blend_mode(), expect)  //
        << "testing " << mode;
  };
 
  for (int i = 0; i < static_cast<int>(DlBlendMode::kLastMode); i++) {
    test(static_cast<DlBlendMode>(i));
  }
}

◆ TEST_F() [250/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NestedDisplayListRTreesAreSparse
	)

prepare_rtree=

Definition at line 2374 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder nested_dl_builder(/**prepare_rtree=*/true);
  DlOpReceiver& nested_dl_receiver = ToReceiver(nested_dl_builder);
  nested_dl_receiver.drawRect({10, 10, 20, 20});
  nested_dl_receiver.drawRect({50, 50, 60, 60});
  auto nested_display_list = nested_dl_builder.Build();
 
  DisplayListBuilder builder(/**prepare_rtree=*/true);
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.drawDisplayList(nested_display_list);
  auto display_list = builder.Build();
 
  auto rtree = display_list->rtree();
  std::vector<SkRect> rects = {
      {10, 10, 20, 20},
      {50, 50, 60, 60},
  };
 
  // Hitting both sub-dl drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 51, 51), rects,
             std::vector<int>({0, 1}));
}

◆ TEST_F() [251/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NestedFloodingSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3795 of file display_list_unittests.cc.

                                                                              {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint save_paint;
  auto color_filter =
      DlBlendColorFilter::Make(DlColor::kRed(), DlBlendMode::kSrc);
  ASSERT_TRUE(color_filter->modifies_transparent_black());
  save_paint.setColorFilter(color_filter);
  SkRect clip_rect = rect.makeOutset(100.0f, 100.0f);
  ASSERT_NE(clip_rect, rect);
  ASSERT_TRUE(clip_rect.contains(rect));
 
  DisplayListBuilder builder;
  builder.ClipRect(clip_rect);
  builder.SaveLayer(nullptr, nullptr);
  {
    builder.SaveLayer(nullptr, &save_paint);
    {  //
      builder.DrawRect(rect, DlPaint());
    }
    builder.Restore();
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->bounds(), clip_rect);
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(clip_rect);
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [252/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NestedOpCountMetricsSameAsSkPicture
	)

Definition at line 982 of file display_list_unittests.cc.

                                                             {
  SkPictureRecorder recorder;
  recorder.beginRecording(SkRect::MakeWH(150, 100));
  SkCanvas* canvas = recorder.getRecordingCanvas();
  SkPaint paint;
  for (int y = 10; y <= 60; y += 10) {
    for (int x = 10; x <= 60; x += 10) {
      paint.setColor(((x + y) % 20) == 10 ? SK_ColorRED : SK_ColorBLUE);
      canvas->drawRect(SkRect::MakeXYWH(x, y, 80, 80), paint);
    }
  }
  SkPictureRecorder outer_recorder;
  outer_recorder.beginRecording(SkRect::MakeWH(150, 100));
  canvas = outer_recorder.getRecordingCanvas();
  canvas->drawPicture(recorder.finishRecordingAsPicture());
 
  auto picture = outer_recorder.finishRecordingAsPicture();
  ASSERT_EQ(picture->approximateOpCount(), 1);
  ASSERT_EQ(picture->approximateOpCount(true), 36);
 
  DisplayListBuilder builder(SkRect::MakeWH(150, 100));
  DlOpReceiver& receiver = ToReceiver(builder);
  for (int y = 10; y <= 60; y += 10) {
    for (int x = 10; x <= 60; x += 10) {
      receiver.setColor(((x + y) % 20) == 10 ? DlColor(SK_ColorRED)
                                             : DlColor(SK_ColorBLUE));
      receiver.drawRect(SkRect::MakeXYWH(x, y, 80, 80));
    }
  }
 
  DisplayListBuilder outer_builder(SkRect::MakeWH(150, 100));
  DlOpReceiver& outer_receiver = ToReceiver(outer_builder);
  outer_receiver.drawDisplayList(builder.Build());
  auto display_list = outer_builder.Build();
 
  ASSERT_EQ(display_list->op_count(), 1u);
  ASSERT_EQ(display_list->op_count(true), 36u);
  EXPECT_EQ(display_list->total_depth(), 37u);
 
  ASSERT_EQ(picture->approximateOpCount(),
            static_cast<int>(display_list->op_count()));
  ASSERT_EQ(picture->approximateOpCount(true),
            static_cast<int>(display_list->op_count(true)));
}

◆ TEST_F() [253/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NestedSaveLayersCanBothSupportOpacityOptimization
	)

Definition at line 1438 of file display_list_unittests.cc.

                                                                           {
  SaveLayerOptions expected1 =
      SaveLayerOptions::kWithAttributes.with_can_distribute_opacity();
  SaveLayerOptions expected2 =
      SaveLayerOptions::kNoAttributes.with_can_distribute_opacity();
  SaveLayerExpector expector({expected1, expected2});
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [254/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NestedSaveLayersMightInheritOpacity
	)

Definition at line 1414 of file display_list_unittests.cc.

                                                             {
  SaveLayerOptions expected1 =
      SaveLayerOptions::kWithAttributes.with_can_distribute_opacity();
  SaveLayerOptions expected2 = SaveLayerOptions::kWithAttributes;
  SaveLayerOptions expected3 =
      SaveLayerOptions::kWithAttributes.with_can_distribute_opacity();
  SaveLayerExpector expector({expected1, expected2, expected3});
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({10, 10, 20, 20});
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({15, 15, 25, 25});
  receiver.restore();
  receiver.restore();
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [255/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPClipDoesNotTriggerDeferredSave
	)

Definition at line 3009 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.clipRect(SkRect::MakeLTRB(0, SK_ScalarNaN, SK_ScalarNaN, 0),
                     ClipOp::kIntersect, true);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [256/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NopOperationsOmittedFromRecords
	)

Definition at line 3219 of file display_list_unittests.cc.

                                                         {
  auto run_tests = [](const std::string& name,
                      void init(DisplayListBuilder & builder, DlPaint & paint),
                      uint32_t expected_op_count = 0u,
                      uint32_t expected_total_depth = 0u) {
    auto run_one_test =
        [init](const std::string& name,
               void build(DisplayListBuilder & builder, DlPaint & paint),
               uint32_t expected_op_count = 0u,
               uint32_t expected_total_depth = 0u) {
          DisplayListBuilder builder;
          DlPaint paint;
          init(builder, paint);
          build(builder, paint);
          auto list = builder.Build();
          if (list->op_count() != expected_op_count) {
            FML_LOG(ERROR) << *list;
          }
          ASSERT_EQ(list->op_count(), expected_op_count) << name;
          EXPECT_EQ(list->total_depth(), expected_total_depth) << name;
          ASSERT_TRUE(list->bounds().isEmpty()) << name;
        };
    run_one_test(
        name + " DrawColor",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.DrawColor(paint.getColor(), paint.getBlendMode());
        },
        expected_op_count, expected_total_depth);
    run_one_test(
        name + " DrawPaint",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.DrawPaint(paint);
        },
        expected_op_count, expected_total_depth);
    run_one_test(
        name + " DrawRect",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.DrawRect({10, 10, 20, 20}, paint);
        },
        expected_op_count, expected_total_depth);
    run_one_test(
        name + " Other Draw Ops",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.DrawLine({10, 10}, {20, 20}, paint);
          builder.DrawOval({10, 10, 20, 20}, paint);
          builder.DrawCircle({50, 50}, 20, paint);
          builder.DrawRRect(SkRRect::MakeRectXY({10, 10, 20, 20}, 5, 5), paint);
          builder.DrawDRRect(SkRRect::MakeRectXY({5, 5, 100, 100}, 5, 5),
                             SkRRect::MakeRectXY({10, 10, 20, 20}, 5, 5),
                             paint);
          builder.DrawPath(kTestPath1, paint);
          builder.DrawArc({10, 10, 20, 20}, 45, 90, true, paint);
          SkPoint pts[] = {{10, 10}, {20, 20}};
          builder.DrawPoints(PointMode::kLines, 2, pts, paint);
          builder.DrawVertices(TestVertices1, DlBlendMode::kSrcOver, paint);
          builder.DrawImage(TestImage1, {10, 10}, DlImageSampling::kLinear,
                            &paint);
          builder.DrawImageRect(TestImage1, SkRect{0.0f, 0.0f, 10.0f, 10.0f},
                                SkRect{10.0f, 10.0f, 25.0f, 25.0f},
                                DlImageSampling::kLinear, &paint);
          builder.DrawImageNine(TestImage1, {10, 10, 20, 20},
                                {10, 10, 100, 100}, DlFilterMode::kLinear,
                                &paint);
          SkRSXform xforms[] = {{1, 0, 10, 10}, {0, 1, 10, 10}};
          SkRect rects[] = {{10, 10, 20, 20}, {10, 20, 30, 20}};
          builder.DrawAtlas(TestImage1, xforms, rects, nullptr, 2,
                            DlBlendMode::kSrcOver, DlImageSampling::kLinear,
                            nullptr, &paint);
          builder.DrawTextBlob(GetTestTextBlob(1), 10, 10, paint);
 
          // Dst mode eliminates most rendering ops except for
          // the following two, so we'll prune those manually...
          if (paint.getBlendMode() != DlBlendMode::kDst) {
            builder.DrawDisplayList(TestDisplayList1, paint.getOpacity());
            builder.DrawShadow(kTestPath1, paint.getColor(), 1, true, 1);
          }
        },
        expected_op_count, expected_total_depth);
    run_one_test(
        name + " SaveLayer",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.SaveLayer(nullptr, &paint, nullptr);
          builder.DrawRect({10, 10, 20, 20}, DlPaint());
          builder.Restore();
        },
        expected_op_count, expected_total_depth);
    run_one_test(
        name + " inside Save",
        [](DisplayListBuilder& builder, DlPaint& paint) {
          builder.Save();
          builder.DrawRect({10, 10, 20, 20}, paint);
          builder.Restore();
        },
        expected_op_count, expected_total_depth);
  };
  run_tests("transparent color",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              paint.setColor(DlColor::kTransparent());
            });
  run_tests("0 alpha",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              // The transparent test above already tested transparent
              // black (all 0s), we set White color here so we can test
              // the case of all 1s with a 0 alpha
              paint.setColor(DlColor::kWhite());
              paint.setAlpha(0);
            });
  run_tests("BlendMode::kDst",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              paint.setBlendMode(DlBlendMode::kDst);
            });
  run_tests("Empty rect clip",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              builder.ClipRect(SkRect::MakeEmpty(), ClipOp::kIntersect, false);
            });
  run_tests("Empty rrect clip",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              builder.ClipRRect(SkRRect::MakeEmpty(), ClipOp::kIntersect,
                                false);
            });
  run_tests("Empty path clip",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              builder.ClipPath(SkPath(), ClipOp::kIntersect, false);
            });
  run_tests("Transparent SaveLayer",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              DlPaint save_paint;
              save_paint.setColor(DlColor::kTransparent());
              builder.SaveLayer(nullptr, &save_paint);
            });
  run_tests("0 alpha SaveLayer",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              DlPaint save_paint;
              // The transparent test above already tested transparent
              // black (all 0s), we set White color here so we can test
              // the case of all 1s with a 0 alpha
              save_paint.setColor(DlColor::kWhite());
              save_paint.setAlpha(0);
              builder.SaveLayer(nullptr, &save_paint);
            });
  run_tests("Dst blended SaveLayer",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              DlPaint save_paint;
              save_paint.setBlendMode(DlBlendMode::kDst);
              builder.SaveLayer(nullptr, &save_paint);
            });
  run_tests(
      "Nop inside SaveLayer",
      [](DisplayListBuilder& builder, DlPaint& paint) {
        builder.SaveLayer(nullptr, nullptr);
        paint.setBlendMode(DlBlendMode::kDst);
      },
      2u, 1u);
  run_tests("DrawImage inside Culled SaveLayer",  //
            [](DisplayListBuilder& builder, DlPaint& paint) {
              DlPaint save_paint;
              save_paint.setColor(DlColor::kTransparent());
              builder.SaveLayer(nullptr, &save_paint);
              builder.DrawImage(TestImage1, {10, 10}, DlImageSampling::kLinear);
            });
}

◆ TEST_F() [257/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPRotationDoesNotTriggerDeferredSave
	)

Definition at line 2863 of file display_list_unittests.cc.

                                                               {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.rotate(360);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [258/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPScaleDoesNotTriggerDeferredSave
	)

Definition at line 2842 of file display_list_unittests.cc.

                                                            {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.scale(1.0, 1.0);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [259/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPSkewDoesNotTriggerDeferredSave
	)

Definition at line 2884 of file display_list_unittests.cc.

                                                           {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.skew(0, 0);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [260/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPTransform2DDoesNotTriggerDeferredSave
	)

Definition at line 2933 of file display_list_unittests.cc.

                                                                  {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transform2DAffine(1, 0, 0, 0, 1, 0);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [261/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPTransformDoesNotTriggerDeferredSave
	)

Definition at line 2905 of file display_list_unittests.cc.

                                                                {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                     0, 1, 0, 0,  //
                                     0, 0, 1, 0,  //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [262/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPTransformFullPerspectiveDoesNotTriggerDeferredSave
	)

Definition at line 2954 of file display_list_unittests.cc.

                                                                               {
  {
    DisplayListBuilder builder1;
    DlOpReceiver& receiver1 = ToReceiver(builder1);
    receiver1.save();
    receiver1.save();
    receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                       0, 1, 0, 0,  //
                                       0, 0, 1, 0,  //
                                       0, 0, 0, 1);
    receiver1.drawRect({0, 0, 100, 100});
    receiver1.restore();
    receiver1.drawRect({0, 0, 100, 100});
    receiver1.restore();
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    DlOpReceiver& receiver2 = ToReceiver(builder2);
    receiver2.drawRect({0, 0, 100, 100});
    receiver2.drawRect({0, 0, 100, 100});
    auto display_list2 = builder2.Build();
 
    ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
  }
 
  {
    DisplayListBuilder builder1;
    DlOpReceiver& receiver1 = ToReceiver(builder1);
    receiver1.save();
    receiver1.save();
    receiver1.transformFullPerspective(1, 0, 0, 0,  //
                                       0, 1, 0, 0,  //
                                       0, 0, 1, 0,  //
                                       0, 0, 0, 1);
    receiver1.transformReset();
    receiver1.drawRect({0, 0, 100, 100});
    receiver1.restore();
    receiver1.drawRect({0, 0, 100, 100});
    receiver1.restore();
    auto display_list1 = builder1.Build();
 
    DisplayListBuilder builder2;
    DlOpReceiver& receiver2 = ToReceiver(builder2);
    receiver2.save();
    receiver2.transformReset();
    receiver2.drawRect({0, 0, 100, 100});
    receiver2.restore();
    receiver2.drawRect({0, 0, 100, 100});
 
    auto display_list2 = builder2.Build();
 
    ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
  }
}

◆ TEST_F() [263/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		NOPTranslateDoesNotTriggerDeferredSave
	)

Definition at line 2821 of file display_list_unittests.cc.

                                                                {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.translate(0, 0);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.drawRect({0, 0, 100, 100});
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [264/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		OOBSaveLayerContentCulledWithBlurFilter
	)

Definition at line 576 of file display_list_unittests.cc.

                                                                 {
  SkRect cull_rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect draw_rect = SkRect::MakeLTRB(25.0f, 25.0f, 99.0f, 75.0f);
  auto filter = DlBlurImageFilter::Make(10.0f, 10.0f, DlTileMode::kDecal);
  DlPaint layer_paint = DlPaint().setImageFilter(filter);
 
  // We want a draw rect that is outside the layer bounds even though its
  // filtered output might be inside. The drawn rect should be culled by
  // the expectations of the layer bounds even though it is close enough
  // to be visible due to filtering.
  ASSERT_FALSE(cull_rect.intersects(draw_rect));
  SkRect mapped_rect;
  ASSERT_TRUE(filter->map_local_bounds(draw_rect, mapped_rect));
  ASSERT_TRUE(mapped_rect.intersects(cull_rect));
 
  DisplayListBuilder builder;
  builder.SaveLayer(&cull_rect, &layer_paint);
  {  //
    builder.DrawRect(draw_rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->op_count(), 2u);
  EXPECT_EQ(display_list->total_depth(), 1u);
 
  EXPECT_TRUE(display_list->bounds().isEmpty()) << display_list->bounds();
}

◆ TEST_F() [265/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		OOBSaveLayerContentCulledWithMatrixFilter
	)

Definition at line 605 of file display_list_unittests.cc.

                                                                   {
  SkRect cull_rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect draw_rect = SkRect::MakeLTRB(25.0f, 125.0f, 75.0f, 175.0f);
  auto filter = DlMatrixImageFilter::Make(SkMatrix::Translate(100.0f, 0.0f),
                                          DlImageSampling::kLinear);
  DlPaint layer_paint = DlPaint().setImageFilter(filter);
 
  // We want a draw rect that is outside the layer bounds even though its
  // filtered output might be inside. The drawn rect should be culled by
  // the expectations of the layer bounds even though it is close enough
  // to be visible due to filtering.
  ASSERT_FALSE(cull_rect.intersects(draw_rect));
  SkRect mapped_rect;
  ASSERT_TRUE(filter->map_local_bounds(draw_rect, mapped_rect));
  ASSERT_TRUE(mapped_rect.intersects(cull_rect));
 
  DisplayListBuilder builder;
  builder.SaveLayer(&cull_rect, &layer_paint);
  {  //
    builder.DrawRect(draw_rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->op_count(), 2u);
  EXPECT_EQ(display_list->total_depth(), 1u);
 
  EXPECT_TRUE(display_list->bounds().isEmpty()) << display_list->bounds();
}

◆ TEST_F() [266/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		OpacityIncompatibleRenderOpInsideDeferredSave
	)

Definition at line 4077 of file display_list_unittests.cc.

                                                                       {
  {
    // Without deferred save
    DisplayListBuilder builder;
    builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                     DlPaint().setBlendMode(DlBlendMode::kClear));
    EXPECT_FALSE(builder.Build()->can_apply_group_opacity());
  }
 
  {
    // With deferred save
    DisplayListBuilder builder;
    builder.Save();
    {
      // Nothing to trigger the deferred save...
      builder.DrawRect(SkRect::MakeLTRB(0, 0, 10, 10),
                       DlPaint().setBlendMode(DlBlendMode::kClear));
    }
    // Deferred save was not triggered, did it forward the incompatibility
    // flags?
    builder.Restore();
    EXPECT_FALSE(builder.Build()->can_apply_group_opacity());
  }
}

◆ TEST_F() [267/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		OverlappingOpsDoNotSupportGroupOpacity
	)

Definition at line 1204 of file display_list_unittests.cc.

                                                                {
  DisplayListBuilder builder;
  for (int i = 0; i < 10; i++) {
    builder.DrawRect(SkRect::MakeXYWH(i * 10, 0, 30, 30), DlPaint());
  }
  auto display_list = builder.Build();
  EXPECT_FALSE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [268/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RemoveUnnecessarySaveRestorePairs
	)

Definition at line 2397 of file display_list_unittests.cc.

                                                           {
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.drawRect({10, 10, 20, 20});
    receiver.save();  // This save op is unnecessary
    receiver.drawRect({50, 50, 60, 60});
    receiver.restore();
 
    DisplayListBuilder builder2;
    DlOpReceiver& receiver2 = ToReceiver(builder2);
    receiver2.drawRect({10, 10, 20, 20});
    receiver2.drawRect({50, 50, 60, 60});
    ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), builder2.Build()));
  }
 
  {
    DisplayListBuilder builder;
    DlOpReceiver& receiver = ToReceiver(builder);
    receiver.drawRect({10, 10, 20, 20});
    receiver.save();
    receiver.translate(1.0, 1.0);
    {
      receiver.save();  // unnecessary
      receiver.drawRect({50, 50, 60, 60});
      receiver.restore();
    }
 
    receiver.restore();
 
    DisplayListBuilder builder2;
    DlOpReceiver& receiver2 = ToReceiver(builder2);
    receiver2.drawRect({10, 10, 20, 20});
    receiver2.save();
    receiver2.translate(1.0, 1.0);
    { receiver2.drawRect({50, 50, 60, 60}); }
    receiver2.restore();
    ASSERT_TRUE(DisplayListsEQ_Verbose(builder.Build(), builder2.Build()));
  }
}

◆ TEST_F() [269/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RemoveUnnecessarySaveRestorePairsInSetPaint
	)

Definition at line 2488 of file display_list_unittests.cc.

                                                                     {
  SkRect build_bounds = SkRect::MakeLTRB(-100, -100, 200, 200);
  SkRect rect = SkRect::MakeLTRB(30, 30, 70, 70);
  // clang-format off
  const float alpha_matrix[] = {
      0, 0, 0, 0, 0,
      0, 1, 0, 0, 0,
      0, 0, 1, 0, 0,
      0, 0, 0, 0, 1,
  };
  // clang-format on
  DlMatrixColorFilter alpha_color_filter(alpha_matrix);
  // Making sure hiding a problematic ColorFilter as an ImageFilter
  // will generate the same behavior as setting it as a ColorFilter
 
  DlColorFilterImageFilter color_filter_image_filter(alpha_color_filter);
  {
    DisplayListBuilder builder(build_bounds);
    builder.Save();
    DlPaint paint;
    paint.setImageFilter(&color_filter_image_filter);
    builder.DrawRect(rect, paint);
    builder.Restore();
    sk_sp<DisplayList> display_list1 = builder.Build();
 
    DisplayListBuilder builder2(build_bounds);
    DlPaint paint2;
    paint2.setImageFilter(&color_filter_image_filter);
    builder2.DrawRect(rect, paint2);
    sk_sp<DisplayList> display_list2 = builder2.Build();
    ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
  }
 
  {
    DisplayListBuilder builder(build_bounds);
    builder.Save();
    builder.SaveLayer(&build_bounds);
    DlPaint paint;
    paint.setImageFilter(&color_filter_image_filter);
    builder.DrawRect(rect, paint);
    builder.Restore();
    builder.Restore();
    sk_sp<DisplayList> display_list1 = builder.Build();
 
    DisplayListBuilder builder2(build_bounds);
    builder2.SaveLayer(&build_bounds);
    DlPaint paint2;
    paint2.setImageFilter(&color_filter_image_filter);
    builder2.DrawRect(rect, paint2);
    builder2.Restore();
    sk_sp<DisplayList> display_list2 = builder2.Build();
    ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
  }
}

◆ TEST_F() [270/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ResetTransformTriggersDeferredSave
	)

Definition at line 2633 of file display_list_unittests.cc.

                                                            {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transformReset();
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.transformReset();
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [271/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RotateAffectsCurrentTransform
	)

Definition at line 1723 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.rotate(12.3);
  SkMatrix matrix = SkMatrix::RotateDeg(12.3);
  SkM44 m44 = SkM44(matrix);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [272/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RotatedSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3651 of file display_list_unittests.cc.

                                                                       {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.Rotate(45.0f);
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [273/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RTreeOfClippedSaveLayerFilterScene
	)

Definition at line 3031 of file display_list_unittests.cc.

                                                            {
  DisplayListBuilder builder(/*prepare_rtree=*/true);
  // blur filter with sigma=1 expands by 30 on all sides
  auto filter = DlBlurImageFilter(10.0, 10.0, DlTileMode::kClamp);
  DlPaint default_paint = DlPaint();
  DlPaint filter_paint = DlPaint().setImageFilter(&filter);
  builder.DrawRect({10, 10, 20, 20}, default_paint);
  builder.ClipRect({50, 50, 60, 60}, ClipOp::kIntersect, false);
  builder.SaveLayer(nullptr, &filter_paint);
  // the following rectangle will be expanded to 23,23,87,87
  // by the saveLayer filter during the restore operation
  // but it will then be clipped to 50,50,60,60
  builder.DrawRect({53, 53, 57, 57}, default_paint);
  builder.Restore();
  auto display_list = builder.Build();
  auto rtree = display_list->rtree();
  std::vector<SkRect> rects = {
      {10, 10, 20, 20},
      {50, 50, 60, 60},
  };
 
  // Missing all drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 10, 10), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(20, 20, 25, 25), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 50, 50), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(60, 60, 65, 65), rects, {});
 
  // Hitting just 1 of the drawRects
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 11, 11), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 25, 25), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 51, 51), rects, {1});
  TEST_RTREE(rtree, SkRect::MakeLTRB(59, 59, 65, 65), rects, {1});
 
  // Hitting both drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 51, 51), rects,
             std::vector<int>({0, 1}));
}

◆ TEST_F() [274/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RTreeOfSaveLayerFilterScene
	)

Definition at line 2338 of file display_list_unittests.cc.

                                                     {
  DisplayListBuilder builder(/*prepare_rtree=*/true);
  // blur filter with sigma=1 expands by 3 on all sides
  auto filter = DlBlurImageFilter(1.0, 1.0, DlTileMode::kClamp);
  DlPaint default_paint = DlPaint();
  DlPaint filter_paint = DlPaint().setImageFilter(&filter);
  builder.DrawRect({10, 10, 20, 20}, default_paint);
  builder.SaveLayer(nullptr, &filter_paint);
  // the following rectangle will be expanded to 50,50,60,60
  // by the saveLayer filter during the restore operation
  builder.DrawRect({53, 53, 57, 57}, default_paint);
  builder.Restore();
  auto display_list = builder.Build();
  auto rtree = display_list->rtree();
  std::vector<SkRect> rects = {
      {10, 10, 20, 20},
      {50, 50, 60, 60},
  };
 
  // Missing all drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 10, 10), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(20, 20, 25, 25), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 50, 50), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(60, 60, 65, 65), rects, {});
 
  // Hitting just 1 of the drawRects
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 11, 11), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 25, 25), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 51, 51), rects, {1});
  TEST_RTREE(rtree, SkRect::MakeLTRB(59, 59, 65, 65), rects, {1});
 
  // Hitting both drawRect calls
  auto expected_indices = std::vector<int>{0, 1};
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 51, 51), rects, expected_indices);
}

◆ TEST_F() [275/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RTreeOfSaveRestoreScene
	)

Definition at line 2307 of file display_list_unittests.cc.

                                                 {
  DisplayListBuilder builder(/*prepare_rtree=*/true);
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.drawRect({10, 10, 20, 20});
  receiver.save();
  receiver.drawRect({50, 50, 60, 60});
  receiver.restore();
  auto display_list = builder.Build();
  auto rtree = display_list->rtree();
  std::vector<SkRect> rects = {
      {10, 10, 20, 20},
      {50, 50, 60, 60},
  };
 
  // Missing all drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 10, 10), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(20, 20, 25, 25), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 50, 50), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(60, 60, 65, 65), rects, {});
 
  // Hitting just 1 of the drawRects
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 11, 11), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 25, 25), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 51, 51), rects, {1});
  TEST_RTREE(rtree, SkRect::MakeLTRB(59, 59, 65, 65), rects, {1});
 
  // Hitting both drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 51, 51), rects,
             std::vector<int>({0, 1}));
}

◆ TEST_F() [276/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RTreeOfSimpleScene
	)

Definition at line 2278 of file display_list_unittests.cc.

                                            {
  DisplayListBuilder builder(/*prepare_rtree=*/true);
  DlOpReceiver& receiver = ToReceiver(builder);
  std::vector<SkRect> rects = {
      {10, 10, 20, 20},
      {50, 50, 60, 60},
  };
  receiver.drawRect(rects[0]);
  receiver.drawRect(rects[1]);
  auto display_list = builder.Build();
  auto rtree = display_list->rtree();
 
  // Missing all drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 10, 10), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(20, 20, 25, 25), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 50, 50), rects, {});
  TEST_RTREE(rtree, SkRect::MakeLTRB(60, 60, 65, 65), rects, {});
 
  // Hitting just 1 of the drawRects
  TEST_RTREE(rtree, SkRect::MakeLTRB(5, 5, 11, 11), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 25, 25), rects, {0});
  TEST_RTREE(rtree, SkRect::MakeLTRB(45, 45, 51, 51), rects, {1});
  TEST_RTREE(rtree, SkRect::MakeLTRB(59, 59, 65, 65), rects, {1});
 
  // Hitting both drawRect calls
  TEST_RTREE(rtree, SkRect::MakeLTRB(19, 19, 51, 51), rects,
             std::vector<int>({0, 1}));
}

◆ TEST_F() [277/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		RTreeRenderCulling
	)

Definition at line 3069 of file display_list_unittests.cc.

                                            {
  DisplayListBuilder main_builder(true);
  DlOpReceiver& main_receiver = ToReceiver(main_builder);
  main_receiver.drawRect({0, 0, 10, 10});
  main_receiver.drawRect({20, 0, 30, 10});
  main_receiver.drawRect({0, 20, 10, 30});
  main_receiver.drawRect({20, 20, 30, 30});
  auto main = main_builder.Build();
 
  auto test = [main](SkIRect cull_rect, const sk_sp<DisplayList>& expected) {
    {  // Test SkIRect culling
      DisplayListBuilder culling_builder;
      main->Dispatch(ToReceiver(culling_builder), cull_rect);
 
      EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
    }
 
    {  // Test SkRect culling
      DisplayListBuilder culling_builder;
      main->Dispatch(ToReceiver(culling_builder), SkRect::Make(cull_rect));
 
      EXPECT_TRUE(DisplayListsEQ_Verbose(culling_builder.Build(), expected));
    }
  };
 
  {  // No rects
    SkIRect cull_rect = {11, 11, 19, 19};
 
    DisplayListBuilder expected_builder;
    auto expected = expected_builder.Build();
 
    test(cull_rect, expected);
  }
 
  {  // Rect 1
    SkIRect cull_rect = {9, 9, 19, 19};
 
    DisplayListBuilder expected_builder;
    DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
    expected_receiver.drawRect({0, 0, 10, 10});
    auto expected = expected_builder.Build();
 
    test(cull_rect, expected);
  }
 
  {  // Rect 2
    SkIRect cull_rect = {11, 9, 21, 19};
 
    DisplayListBuilder expected_builder;
    DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
    expected_receiver.drawRect({20, 0, 30, 10});
    auto expected = expected_builder.Build();
 
    test(cull_rect, expected);
  }
 
  {  // Rect 3
    SkIRect cull_rect = {9, 11, 19, 21};
 
    DisplayListBuilder expected_builder;
    DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
    expected_receiver.drawRect({0, 20, 10, 30});
    auto expected = expected_builder.Build();
 
    test(cull_rect, expected);
  }
 
  {  // Rect 4
    SkIRect cull_rect = {11, 11, 21, 21};
 
    DisplayListBuilder expected_builder;
    DlOpReceiver& expected_receiver = ToReceiver(expected_builder);
    expected_receiver.drawRect({20, 20, 30, 30});
    auto expected = expected_builder.Build();
 
    test(cull_rect, expected);
  }
 
  {  // All 4 rects
    SkIRect cull_rect = {9, 9, 21, 21};
 
    test(cull_rect, main);
  }
}

◆ TEST_F() [278/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveContentDepthTest
	)

Definition at line 3970 of file display_list_unittests.cc.

                                              {
  DisplayListBuilder child_builder;
  child_builder.DrawRect({10, 10, 20, 20}, DlPaint());  // depth 1
  auto child = child_builder.Build();
 
  DisplayListBuilder builder;
  builder.DrawRect({10, 10, 20, 20}, DlPaint());  // depth 1
 
  builder.Save();  // covers depth 1->9
  {
    builder.Translate(5, 5);  // triggers deferred save at depth 1
    builder.DrawRect({10, 10, 20, 20}, DlPaint());  // depth 2
 
    builder.DrawDisplayList(child, 1.0f);  // depth 3 (content) + 4 (self)
 
    builder.SaveLayer(nullptr, nullptr);  // covers depth 5->6
    {
      builder.DrawRect({12, 12, 22, 22}, DlPaint());  // depth 5
      builder.DrawRect({14, 14, 24, 24}, DlPaint());  // depth 6
    }
    builder.Restore();  // layer is restored with depth 6
 
    builder.DrawRect({16, 16, 26, 26}, DlPaint());  // depth 8
    builder.DrawRect({18, 18, 28, 28}, DlPaint());  // depth 9
  }
  builder.Restore();  // save is restored with depth 9
 
  builder.DrawRect({16, 16, 26, 26}, DlPaint());  // depth 10
  builder.DrawRect({18, 18, 28, 28}, DlPaint());  // depth 11
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->total_depth(), 11u);
 
  DepthExpector expector({8, 2});
  display_list->Dispatch(expector);
}

◆ TEST_F() [279/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsClipDetectionSimpleClippedRect
	)

Definition at line 3901 of file display_list_unittests.cc.

                                                                       {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect save_rect = SkRect::MakeLTRB(50.0f, 50.0f, 110.0f, 110.0f);
  SkRect content_rect = SkRect::MakeLTRB(100.0f, 100.0f, 110.0f, 110.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(&save_rect, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addSuppliedExpectation(content_rect, true);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [280/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsClipDetectionSimpleUnclippedRect
	)

Definition at line 3883 of file display_list_unittests.cc.

                                                                         {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect save_rect = SkRect::MakeLTRB(50.0f, 50.0f, 250.0f, 250.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(&save_rect, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addSuppliedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [281/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfFloodingColorFilter
	)

Definition at line 3855 of file display_list_unittests.cc.

                                                                         {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint draw_paint;
  auto color_filter =
      DlBlendColorFilter::Make(DlColor::kRed(), DlBlendMode::kSrc);
  ASSERT_TRUE(color_filter->modifies_transparent_black());
  draw_paint.setColorFilter(color_filter);
  SkRect clip_rect = rect.makeOutset(100.0f, 100.0f);
  ASSERT_NE(clip_rect, rect);
  ASSERT_TRUE(clip_rect.contains(rect));
 
  DisplayListBuilder builder;
  builder.ClipRect(clip_rect);
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, draw_paint);
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  // A color filter is implicitly clipped to the draw bounds so the layer
  // bounds will be the same as the draw bounds.
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [282/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfFloodingImageFilter
	)

Definition at line 3828 of file display_list_unittests.cc.

                                                                         {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint draw_paint;
  auto color_filter =
      DlBlendColorFilter::Make(DlColor::kRed(), DlBlendMode::kSrc);
  ASSERT_TRUE(color_filter->modifies_transparent_black());
  auto image_filter = DlColorFilterImageFilter::Make(color_filter);
  draw_paint.setImageFilter(image_filter);
  SkRect clip_rect = rect.makeOutset(100.0f, 100.0f);
  ASSERT_NE(clip_rect, rect);
  ASSERT_TRUE(clip_rect.contains(rect));
 
  DisplayListBuilder builder;
  builder.ClipRect(clip_rect);
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, draw_paint);
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(clip_rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [283/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfImageBlurredRect
	)

Definition at line 3575 of file display_list_unittests.cc.

                                                                      {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint draw_paint;
  auto image_filter = DlBlurImageFilter::Make(2.0f, 3.0f, DlTileMode::kDecal);
  draw_paint.setImageFilter(image_filter);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, draw_paint);
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect.makeOutset(6.0f, 9.0f));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [284/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfMaskBlurredRect
	)

Definition at line 3555 of file display_list_unittests.cc.

                                                                     {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint draw_paint;
  auto mask_filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 2.0f);
  draw_paint.setMaskFilter(mask_filter);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, draw_paint);
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect.makeOutset(6.0f, 6.0f));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [285/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfNestedSimpleRect
	)

Definition at line 3747 of file display_list_unittests.cc.

                                                                      {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.SaveLayer(nullptr, nullptr);
    {  //
      builder.DrawRect(rect, DlPaint());
    }
    builder.Restore();
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [286/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfRotatedSimpleRect
	)

Definition at line 3728 of file display_list_unittests.cc.

                                                                       {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.Rotate(45.0f);
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SkMatrix matrix = SkMatrix::RotateDeg(45.0f);
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(matrix.mapRect(rect));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [287/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfScaledSimpleRect
	)

Definition at line 3709 of file display_list_unittests.cc.

                                                                      {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.Scale(10.0f, 10.0f);
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(
      SkRect::MakeLTRB(1000.0f, 1000.0f, 2000.0f, 2000.0f));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [288/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3538 of file display_list_unittests.cc.

                                                                {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [289/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfStrokedRect
	)

Definition at line 3595 of file display_list_unittests.cc.

                                                                 {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  DlPaint draw_paint;
  draw_paint.setStrokeWidth(5.0f);
  draw_paint.setDrawStyle(DlDrawStyle::kStroke);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, draw_paint);
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect.makeOutset(2.5f, 2.5f));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [290/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsComputationOfTranslatedSimpleRect
	)

Definition at line 3691 of file display_list_unittests.cc.

                                                                          {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.Translate(10.0f, 10.0f);
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect.makeOffset(10.0f, 10.0f));
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [291/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerBoundsSnapshotsImageFilter
	)

Definition at line 1301 of file display_list_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({50, 50, 100, 100});
  // This image filter should be ignored since it was not set before saveLayer
  receiver.setImageFilter(&kTestBlurImageFilter1);
  receiver.restore();
  SkRect bounds = builder.Build()->bounds();
  EXPECT_EQ(bounds, SkRect::MakeLTRB(50, 50, 100, 100));
}

◆ TEST_F() [292/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerColorFilterDoesNotInheritOpacity
	)

Definition at line 1475 of file display_list_unittests.cc.

                                                                   {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.setColorFilter(&kTestMatrixColorFilter1);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setColorFilter(nullptr);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [293/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerColorFilterOnChildDoesNotInheritOpacity
	)

Definition at line 1526 of file display_list_unittests.cc.

                                                                          {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setColorFilter(&kTestMatrixColorFilter1);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [294/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerFalseSupportsGroupOpacityOverlappingChidren
	)

Definition at line 1233 of file display_list_unittests.cc.

                                                                              {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  for (int i = 0; i < 10; i++) {
    receiver.drawRect(SkRect::MakeXYWH(i * 10, 0, 30, 30));
  }
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [295/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerFalseSupportsGroupOpacityWithChildSrcBlend
	)

Definition at line 1279 of file display_list_unittests.cc.

                                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.drawRect({0, 0, 10, 10});
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [296/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerFalseWithSrcBlendSupportsGroupOpacity
	)

Definition at line 1257 of file display_list_unittests.cc.

                                                                        {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver.drawRect({0, 0, 10, 10});
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [297/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerImageFilterDoesNotInheritOpacity
	)

Definition at line 1458 of file display_list_unittests.cc.

                                                                   {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.setImageFilter(&kTestBlurImageFilter1);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setImageFilter(nullptr);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [298/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerImageFilterOnChildInheritsOpacity
	)

Definition at line 1509 of file display_list_unittests.cc.

                                                                    {
  SaveLayerOptions expected =
      SaveLayerOptions::kWithAttributes.with_can_distribute_opacity();
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setImageFilter(&kTestBlurImageFilter1);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [299/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerNoAttributesInheritsOpacity
	)

Definition at line 1383 of file display_list_unittests.cc.

                                                              {
  SaveLayerOptions expected =
      SaveLayerOptions::kNoAttributes.with_can_distribute_opacity();
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kNoAttributes);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [300/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerOneSimpleOpInheritsOpacity
	)

Definition at line 1367 of file display_list_unittests.cc.

                                                             {
  SaveLayerOptions expected =
      SaveLayerOptions::kWithAttributes.with_can_distribute_opacity();
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [301/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerSrcBlendDoesNotInheritOpacity
	)

Definition at line 1492 of file display_list_unittests.cc.

                                                                {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setBlendMode(DlBlendMode::kSrcOver);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [302/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerSrcBlendOnChildDoesNotInheritOpacity
	)

Definition at line 1542 of file display_list_unittests.cc.

                                                                       {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.drawRect({10, 10, 20, 20});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [303/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerTrueSupportsGroupOpacityOverlappingChidren
	)

Definition at line 1245 of file display_list_unittests.cc.

                                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  for (int i = 0; i < 10; i++) {
    receiver.drawRect(SkRect::MakeXYWH(i * 10, 0, 30, 30));
  }
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [304/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerTrueSupportsGroupOpacityWithChildSrcBlend
	)

Definition at line 1290 of file display_list_unittests.cc.

                                                                            {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.drawRect({0, 0, 10, 10});
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_TRUE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [305/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerTrueWithSrcBlendDoesNotSupportGroupOpacity
	)

Definition at line 1268 of file display_list_unittests.cc.

                                                                             {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setBlendMode(DlBlendMode::kSrc);
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({0, 0, 10, 10});
  receiver.restore();
  auto display_list = builder.Build();
  EXPECT_FALSE(display_list->can_apply_group_opacity());
}

◆ TEST_F() [306/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveLayerTwoOverlappingOpsDoesNotInheritOpacity
	)

Definition at line 1398 of file display_list_unittests.cc.

                                                                         {
  SaveLayerOptions expected = SaveLayerOptions::kWithAttributes;
  SaveLayerExpector expector(expected);
 
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.setColor(DlColor(SkColorSetARGB(127, 255, 255, 255)));
  receiver.saveLayer(nullptr, SaveLayerOptions::kWithAttributes);
  receiver.drawRect({10, 10, 20, 20});
  receiver.drawRect({15, 15, 25, 25});
  receiver.restore();
 
  builder.Build()->Dispatch(expector);
  EXPECT_TRUE(expector.all_expectations_checked());
}

◆ TEST_F() [307/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveRestoreRestoresClip
	)

Definition at line 354 of file display_list_unittests.cc.

                                                 {
  SkRect cull_rect = SkRect::MakeLTRB(-10.0f, -10.0f, 500.0f, 500.0f);
  DisplayListBuilder builder(cull_rect);
 
  builder.Save();
  builder.ClipRect({0.0f, 0.0f, 10.0f, 10.0f});
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.ClipRRect(SkRRect::MakeRectXY({0.0f, 0.0f, 5.0f, 5.0f}, 2.0f, 2.0f));
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.ClipPath(SkPath().addOval({0.0f, 0.0f, 10.0f, 10.0f}));
  builder.Restore();
  check_defaults(builder, cull_rect);
}

◆ TEST_F() [308/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SaveRestoreRestoresTransform
	)

Definition at line 264 of file display_list_unittests.cc.

                                                      {
  SkRect cull_rect = SkRect::MakeLTRB(-10.0f, -10.0f, 500.0f, 500.0f);
  DisplayListBuilder builder(cull_rect);
 
  builder.Save();
  builder.Translate(10.0f, 10.0f);
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Scale(10.0f, 10.0f);
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Skew(0.1f, 0.1f);
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Rotate(45.0f);
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Transform(SkMatrix::Scale(10.0f, 10.0f));
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Transform2DAffine(1.0f, 0.0f, 12.0f,  //
                            0.0f, 1.0f, 35.0f);
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.Transform(SkM44(SkMatrix::Scale(10.0f, 10.0f)));
  builder.Restore();
  check_defaults(builder, cull_rect);
 
  builder.Save();
  builder.TransformFullPerspective(1.0f, 0.0f, 0.0f, 12.0f,  //
                                   0.0f, 1.0f, 0.0f, 35.0f,  //
                                   0.0f, 0.0f, 1.0f, 5.0f,   //
                                   0.0f, 0.0f, 0.0f, 1.0f);
  builder.Restore();
  check_defaults(builder, cull_rect);
}

◆ TEST_F() [309/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ScaleAffectsCurrentTransform
	)

Definition at line 1704 of file display_list_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.scale(12.3, 14.5);
  SkMatrix matrix = SkMatrix::Scale(12.3, 14.5);
  SkM44 m44 = SkM44(matrix);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [310/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ScaledSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3633 of file display_list_unittests.cc.

                                                                      {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.Scale(10.0f, 10.0f);
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [311/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		ScaleTriggersDeferredSave
	)

Definition at line 2699 of file display_list_unittests.cc.

                                                   {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.scale(0.5, 0.5);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.scale(0.5, 0.5);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [312/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpDisplayListsAreEqualWithOrWithoutRtree
	)

Definition at line 728 of file display_list_unittests.cc.

                                                                        {
  for (auto& group : allGroups) {
    for (size_t i = 0; i < group.variants.size(); i++) {
      DisplayListBuilder builder1(/*prepare_rtree=*/false);
      DisplayListBuilder builder2(/*prepare_rtree=*/true);
      group.variants[i].Invoke(ToReceiver(builder1));
      group.variants[i].Invoke(ToReceiver(builder2));
      sk_sp<DisplayList> dl1 = builder1.Build();
      sk_sp<DisplayList> dl2 = builder2.Build();
 
      auto desc = group.op_name + "(variant " + std::to_string(i + 1) + " )";
      ASSERT_EQ(dl1->op_count(false), dl2->op_count(false)) << desc;
      ASSERT_EQ(dl1->bytes(false), dl2->bytes(false)) << desc;
      ASSERT_EQ(dl1->op_count(true), dl2->op_count(true)) << desc;
      ASSERT_EQ(dl1->bytes(true), dl2->bytes(true)) << desc;
      EXPECT_EQ(dl1->total_depth(), dl2->total_depth()) << desc;
      ASSERT_EQ(dl1->bounds(), dl2->bounds()) << desc;
      ASSERT_EQ(dl1->total_depth(), dl2->total_depth()) << desc;
      ASSERT_TRUE(DisplayListsEQ_Verbose(dl1, dl2)) << desc;
      ASSERT_TRUE(DisplayListsEQ_Verbose(dl2, dl2)) << desc;
      ASSERT_EQ(dl1->rtree().get(), nullptr) << desc;
      ASSERT_NE(dl2->rtree().get(), nullptr) << desc;
    }
  }
}

◆ TEST_F() [313/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpDisplayListsCompareToEachOther
	)

Definition at line 691 of file display_list_unittests.cc.

                                                                {
  for (auto& group : allGroups) {
    std::vector<sk_sp<DisplayList>> lists_a;
    std::vector<sk_sp<DisplayList>> lists_b;
    for (size_t i = 0; i < group.variants.size(); i++) {
      lists_a.push_back(Build(group.variants[i]));
      lists_b.push_back(Build(group.variants[i]));
    }
 
    for (size_t i = 0; i < lists_a.size(); i++) {
      sk_sp<DisplayList> listA = lists_a[i];
      for (size_t j = 0; j < lists_b.size(); j++) {
        sk_sp<DisplayList> listB = lists_b[j];
        auto desc = group.op_name + "(variant " + std::to_string(i + 1) +
                    " ==? variant " + std::to_string(j + 1) + ")";
        if (i == j ||
            (group.variants[i].is_empty() && group.variants[j].is_empty())) {
          // They are the same variant, or both variants are NOPs
          ASSERT_EQ(listA->op_count(false), listB->op_count(false)) << desc;
          ASSERT_EQ(listA->bytes(false), listB->bytes(false)) << desc;
          ASSERT_EQ(listA->op_count(true), listB->op_count(true)) << desc;
          ASSERT_EQ(listA->bytes(true), listB->bytes(true)) << desc;
          EXPECT_EQ(listA->total_depth(), listB->total_depth()) << desc;
          ASSERT_EQ(listA->bounds(), listB->bounds()) << desc;
          ASSERT_TRUE(listA->Equals(*listB)) << desc;
          ASSERT_TRUE(listB->Equals(*listA)) << desc;
        } else {
          // No assertion on op/byte counts or bounds
          // they may or may not be equal between variants
          ASSERT_FALSE(listA->Equals(*listB)) << desc;
          ASSERT_FALSE(listB->Equals(*listA)) << desc;
        }
      }
    }
  }
}

◆ TEST_F() [314/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpDisplayListsNotEqualEmpty
	)

Definition at line 648 of file display_list_unittests.cc.

                                                           {
  sk_sp<DisplayList> empty = DisplayListBuilder().Build();
  for (auto& group : allGroups) {
    for (size_t i = 0; i < group.variants.size(); i++) {
      sk_sp<DisplayList> dl = Build(group.variants[i]);
      auto desc =
          group.op_name + "(variant " + std::to_string(i + 1) + " != empty)";
      if (group.variants[i].is_empty()) {
        ASSERT_TRUE(DisplayListsEQ_Verbose(dl, empty));
        ASSERT_TRUE(empty->Equals(*dl)) << desc;
      } else {
        ASSERT_TRUE(DisplayListsNE_Verbose(dl, empty));
        ASSERT_FALSE(empty->Equals(*dl)) << desc;
      }
    }
  }
}

◆ TEST_F() [315/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpDisplayListsRecapturedAreEqual
	)

Definition at line 666 of file display_list_unittests.cc.

                                                                {
  for (auto& group : allGroups) {
    for (size_t i = 0; i < group.variants.size(); i++) {
      sk_sp<DisplayList> dl = Build(group.variants[i]);
      // Verify recapturing the replay of the display list is Equals()
      // when dispatching directly from the DL to another builder
      DisplayListBuilder copy_builder;
      DlOpReceiver& r = ToReceiver(copy_builder);
      dl->Dispatch(r);
      sk_sp<DisplayList> copy = copy_builder.Build();
      auto desc =
          group.op_name + "(variant " + std::to_string(i + 1) + " == copy)";
      DisplayListsEQ_Verbose(dl, copy);
      ASSERT_EQ(copy->op_count(false), dl->op_count(false)) << desc;
      ASSERT_EQ(copy->bytes(false), dl->bytes(false)) << desc;
      ASSERT_EQ(copy->op_count(true), dl->op_count(true)) << desc;
      ASSERT_EQ(copy->bytes(true), dl->bytes(true)) << desc;
      EXPECT_EQ(copy->total_depth(), dl->total_depth()) << desc;
      ASSERT_EQ(copy->bounds(), dl->bounds()) << desc;
      ASSERT_TRUE(copy->Equals(*dl)) << desc;
      ASSERT_TRUE(dl->Equals(*copy)) << desc;
    }
  }
}

◆ TEST_F() [316/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpSizes
	)

Definition at line 635 of file display_list_unittests.cc.

                                       {
  for (auto& group : allGroups) {
    for (size_t i = 0; i < group.variants.size(); i++) {
      auto& invocation = group.variants[i];
      sk_sp<DisplayList> dl = Build(invocation);
      auto desc = group.op_name + "(variant " + std::to_string(i + 1) + ")";
      EXPECT_EQ(dl->op_count(false), invocation.op_count()) << desc;
      EXPECT_EQ(dl->bytes(false), invocation.byte_count()) << desc;
      EXPECT_EQ(dl->total_depth(), invocation.depth_accumulated()) << desc;
    }
  }
}

◆ TEST_F() [317/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SingleOpsMightSupportGroupOpacityBlendMode
	)

Definition at line 1103 of file display_list_unittests.cc.

                                                                    {
  auto run_tests = [](const std::string& name,
                      void build(DlOpReceiver & receiver), bool expect_for_op,
                      bool expect_with_kSrc) {
    {
      // First test is the draw op, by itself
      // (usually supports group opacity)
      DisplayListBuilder builder;
      DlOpReceiver& receiver = ToReceiver(builder);
      build(receiver);
      auto display_list = builder.Build();
      EXPECT_EQ(display_list->can_apply_group_opacity(), expect_for_op)
          << "{" << std::endl
          << "  " << name << std::endl
          << "}";
    }
    {
      // Second test i the draw op with kSrc,
      // (usually fails group opacity)
      DisplayListBuilder builder;
      DlOpReceiver& receiver = ToReceiver(builder);
      receiver.setBlendMode(DlBlendMode::kSrc);
      build(receiver);
      auto display_list = builder.Build();
      EXPECT_EQ(display_list->can_apply_group_opacity(), expect_with_kSrc)
          << "{" << std::endl
          << "  receiver.setBlendMode(kSrc);" << std::endl
          << "  " << name << std::endl
          << "}";
    }
  };
 
#define RUN_TESTS(body) \
  run_tests(#body, [](DlOpReceiver& receiver) { body }, true, false)
#define RUN_TESTS2(body, expect) \
  run_tests(#body, [](DlOpReceiver& receiver) { body }, expect, expect)
 
  RUN_TESTS(receiver.drawPaint(););
  RUN_TESTS2(receiver.drawColor(DlColor(SK_ColorRED), DlBlendMode::kSrcOver);
             , true);
  RUN_TESTS2(receiver.drawColor(DlColor(SK_ColorRED), DlBlendMode::kSrc);
             , false);
  RUN_TESTS(receiver.drawLine({0, 0}, {10, 10}););
  RUN_TESTS(receiver.drawRect({0, 0, 10, 10}););
  RUN_TESTS(receiver.drawOval({0, 0, 10, 10}););
  RUN_TESTS(receiver.drawCircle({10, 10}, 5););
  RUN_TESTS(receiver.drawRRect(SkRRect::MakeRectXY({0, 0, 10, 10}, 2, 2)););
  RUN_TESTS(receiver.drawDRRect(SkRRect::MakeRectXY({0, 0, 10, 10}, 2, 2),
                                SkRRect::MakeRectXY({2, 2, 8, 8}, 2, 2)););
  RUN_TESTS(receiver.drawPath(
      SkPath().addOval({0, 0, 10, 10}).addOval({5, 5, 15, 15})););
  RUN_TESTS(receiver.drawArc({0, 0, 10, 10}, 0, math::kPi, true););
  RUN_TESTS2(
      receiver.drawPoints(PointMode::kPoints, TestPointCount, kTestPoints);
      , false);
  RUN_TESTS2(receiver.drawVertices(TestVertices1.get(), DlBlendMode::kSrc);
             , false);
  RUN_TESTS(receiver.drawImage(TestImage1, {0, 0}, kLinearSampling, true););
  RUN_TESTS2(receiver.drawImage(TestImage1, {0, 0}, kLinearSampling, false);
             , true);
  RUN_TESTS(receiver.drawImageRect(TestImage1, {10, 10, 20, 20}, {0, 0, 10, 10},
                                   kNearestSampling, true,
                                   DlCanvas::SrcRectConstraint::kFast););
  RUN_TESTS2(receiver.drawImageRect(TestImage1, {10, 10, 20, 20},
                                    {0, 0, 10, 10}, kNearestSampling, false,
                                    DlCanvas::SrcRectConstraint::kFast);
             , true);
  RUN_TESTS(receiver.drawImageNine(TestImage2, {20, 20, 30, 30}, {0, 0, 20, 20},
                                   DlFilterMode::kLinear, true););
  RUN_TESTS2(
      receiver.drawImageNine(TestImage2, {20, 20, 30, 30}, {0, 0, 20, 20},
                             DlFilterMode::kLinear, false);
      , true);
  static SkRSXform xforms[] = {{1, 0, 0, 0}, {0, 1, 0, 0}};
  static SkRect texs[] = {{10, 10, 20, 20}, {20, 20, 30, 30}};
  RUN_TESTS2(
      receiver.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                         DlBlendMode::kSrcIn, kNearestSampling, nullptr, true);
      , false);
  RUN_TESTS2(
      receiver.drawAtlas(TestImage1, xforms, texs, nullptr, 2,
                         DlBlendMode::kSrcIn, kNearestSampling, nullptr, false);
      , false);
  EXPECT_TRUE(TestDisplayList1->can_apply_group_opacity());
  RUN_TESTS2(receiver.drawDisplayList(TestDisplayList1);, true);
  {
    static DisplayListBuilder builder;
    builder.DrawRect({0, 0, 10, 10}, DlPaint());
    builder.DrawRect({5, 5, 15, 15}, DlPaint());
    static auto display_list = builder.Build();
    RUN_TESTS2(receiver.drawDisplayList(display_list);, false);
  }
  RUN_TESTS2(receiver.drawTextBlob(GetTestTextBlob(1), 0, 0);, false);
  RUN_TESTS2(
      receiver.drawShadow(kTestPath1, DlColor(SK_ColorBLACK), 1.0, false, 1.0);
      , false);
 
#undef RUN_TESTS2
#undef RUN_TESTS
}

◆ TEST_F() [318/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SkewAffectsCurrentTransform
	)

Definition at line 1742 of file display_list_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.skew(12.3, 14.5);
  SkMatrix matrix = SkMatrix::Skew(12.3, 14.5);
  SkM44 m44 = SkM44(matrix);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [319/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		SkewTriggersDeferredSave
	)

Definition at line 2655 of file display_list_unittests.cc.

                                                  {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.skew(10, 10);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.skew(10, 10);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [320/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		Transform2DTriggersDeferredSave
	)

Definition at line 2583 of file display_list_unittests.cc.

                                                         {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transform2DAffine(0, 1, 12, 1, 0, 33);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.transform2DAffine(0, 1, 12, 1, 0, 33);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [321/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformAffectsCurrentTransform
	)

Definition at line 1761 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.transform2DAffine(3, 0, 12.3,  //
                             1, 5, 14.5);
  SkMatrix matrix = SkMatrix::MakeAll(3, 0, 12.3,  //
                                      1, 5, 14.5,  //
                                      0, 0, 1);
  SkM44 m44 = SkM44(matrix);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [322/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformingFilterSaveLayerFloodedContentBounds
	)

Definition at line 4059 of file display_list_unittests.cc.

                                                                         {
  DisplayListBuilder builder;
  builder.ClipRect(SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f));
 
  DlPaint save_paint;
  auto image_filter = DlMatrixImageFilter::Make(
      SkMatrix::Translate(100.0f, 100.0f), DlImageSampling::kNearestNeighbor);
  save_paint.setImageFilter(image_filter);
  builder.SaveLayer(nullptr, &save_paint);
 
  builder.DrawColor(DlColor::kBlue(), DlBlendMode::kSrcOver);
 
  builder.Restore();
 
  auto dl = builder.Build();
  EXPECT_EQ(dl->bounds(), SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f));
}

◆ TEST_F() [323/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformingFilterSaveLayerSimpleContentBounds
	)

Definition at line 4041 of file display_list_unittests.cc.

                                                                        {
  DisplayListBuilder builder;
  builder.ClipRect(SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f));
 
  DlPaint save_paint;
  auto image_filter = DlMatrixImageFilter::Make(
      SkMatrix::Translate(100.0f, 100.0f), DlImageSampling::kNearestNeighbor);
  save_paint.setImageFilter(image_filter);
  builder.SaveLayer(nullptr, &save_paint);
 
  builder.DrawRect(SkRect::MakeLTRB(20.0f, 20.0f, 25.0f, 25.0f), DlPaint());
 
  builder.Restore();
 
  auto dl = builder.Build();
  EXPECT_EQ(dl->bounds(), SkRect::MakeLTRB(120.0f, 120.0f, 125.0f, 125.0f));
}

◆ TEST_F() [324/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformPerspectiveTriggersDeferredSave
	)

Definition at line 2605 of file display_list_unittests.cc.

                                                                  {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transformFullPerspective(0, 1, 0, 12,  //
                                     1, 0, 0, 33,  //
                                     3, 2, 5, 29,  //
                                     0, 0, 0, 12);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.transformFullPerspective(0, 1, 0, 12,  //
                                     1, 0, 0, 33,  //
                                     3, 2, 5, 29,  //
                                     0, 0, 0, 12);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [325/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformResetSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3669 of file display_list_unittests.cc.

                                                                              {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect rect_doubled = SkMatrix::Scale(2.0f, 2.0f).mapRect(rect);
 
  DisplayListBuilder builder;
  builder.Scale(10.0f, 10.0f);
  builder.SaveLayer(nullptr, nullptr);
  builder.TransformReset();
  builder.Scale(20.0f, 20.0f);
  // Net local transform for saveLayer is Scale(2, 2)
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect_doubled);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [326/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TransformTriggersDeferredSave
	)

Definition at line 2543 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.transformFullPerspective(1, 0, 0, 10,   //
                                     0, 1, 0, 100,  //
                                     0, 0, 1, 0,    //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.transformFullPerspective(1, 0, 0, 10,   //
                                     0, 1, 0, 100,  //
                                     0, 0, 1, 0,    //
                                     0, 0, 0, 1);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.transformFullPerspective(1, 0, 0, 10,   //
                                     0, 1, 0, 100,  //
                                     0, 0, 1, 0,    //
                                     0, 0, 0, 1);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  receiver2.save();
  receiver2.transformFullPerspective(1, 0, 0, 10,   //
                                     0, 1, 0, 100,  //
                                     0, 0, 1, 0,    //
                                     0, 0, 0, 1);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [327/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TranslateAffectsCurrentTransform
	)

Definition at line 1685 of file display_list_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  DlOpReceiver& receiver = ToReceiver(builder);
  receiver.translate(12.3, 14.5);
  SkMatrix matrix = SkMatrix::Translate(12.3, 14.5);
  SkM44 m44 = SkM44(matrix);
  SkM44 cur_m44 = builder.GetTransformFullPerspective();
  SkMatrix cur_matrix = builder.GetTransform();
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
  receiver.translate(10, 10);
  // CurrentTransform has changed
  ASSERT_NE(builder.GetTransformFullPerspective(), m44);
  ASSERT_NE(builder.GetTransform(), cur_matrix);
  // Previous return values have not
  ASSERT_EQ(cur_m44, m44);
  ASSERT_EQ(cur_matrix, matrix);
}

◆ TEST_F() [328/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TranslatedSaveLayerBoundsComputationOfSimpleRect
	)

Definition at line 3615 of file display_list_unittests.cc.

                                                                          {
  SkRect rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  DisplayListBuilder builder;
  builder.Translate(10.0f, 10.0f);
  builder.SaveLayer(nullptr, nullptr);
  {  //
    builder.DrawRect(rect, DlPaint());
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  SaveLayerBoundsExpector expector;
  expector.addComputedExpectation(rect);
  display_list->Dispatch(expector);
  EXPECT_TRUE(expector.all_bounds_checked());
}

◆ TEST_F() [329/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		TranslateTriggersDeferredSave
	)

Definition at line 2677 of file display_list_unittests.cc.

                                                       {
  DisplayListBuilder builder1;
  DlOpReceiver& receiver1 = ToReceiver(builder1);
  receiver1.save();
  receiver1.save();
  receiver1.translate(10, 10);
  receiver1.drawRect({0, 0, 100, 100});
  receiver1.restore();
  receiver1.restore();
  auto display_list1 = builder1.Build();
 
  DisplayListBuilder builder2;
  DlOpReceiver& receiver2 = ToReceiver(builder2);
  receiver2.save();
  receiver2.translate(10, 10);
  receiver2.drawRect({0, 0, 100, 100});
  receiver2.restore();
  auto display_list2 = builder2.Build();
 
  ASSERT_TRUE(DisplayListsEQ_Verbose(display_list1, display_list2));
}

◆ TEST_F() [330/925]

flutter::testing::TEST_F	(	DisplayListTest	,
		UnclippedSaveLayerContentAccountsForFilter
	)

Definition at line 510 of file display_list_unittests.cc.

                                                                    {
  SkRect cull_rect = SkRect::MakeLTRB(0.0f, 0.0f, 300.0f, 300.0f);
  SkRect clip_rect = SkRect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
  SkRect draw_rect = SkRect::MakeLTRB(50.0f, 140.0f, 101.0f, 160.0f);
  auto filter = DlBlurImageFilter::Make(10.0f, 10.0f, DlTileMode::kDecal);
  DlPaint layer_paint = DlPaint().setImageFilter(filter);
 
  ASSERT_TRUE(clip_rect.intersects(draw_rect));
  ASSERT_TRUE(cull_rect.contains(clip_rect));
  ASSERT_TRUE(cull_rect.contains(draw_rect));
 
  DisplayListBuilder builder;
  builder.Save();
  {
    builder.ClipRect(clip_rect, ClipOp::kIntersect, false);
    builder.SaveLayer(&cull_rect, &layer_paint);
    {  //
      builder.DrawRect(draw_rect, DlPaint());
    }
    builder.Restore();
  }
  builder.Restore();
  auto display_list = builder.Build();
 
  EXPECT_EQ(display_list->op_count(), 6u);
  EXPECT_EQ(display_list->total_depth(), 2u);
 
  SkRect result_rect = draw_rect.makeOutset(30.0f, 30.0f);
  ASSERT_TRUE(result_rect.intersect(clip_rect));
  ASSERT_EQ(result_rect, SkRect::MakeLTRB(100.0f, 110.0f, 131.0f, 190.0f));
  EXPECT_EQ(display_list->bounds(), result_rect);
}

◆ TEST_F() [331/925]

flutter::testing::TEST_F	(	EmbedderA11yTest	,
		A11yStringAttributes
	)

Definition at line 275 of file embedder_a11y_unittests.cc.

                                               {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "This test crashes on Fuchsia. https://fxbug.dev/87493 ";
#else
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent signal_native_latch;
 
  // Called by the Dart text fixture on the UI thread to signal that the C++
  // unittest should resume.
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(([&signal_native_latch](Dart_NativeArguments) {
        signal_native_latch.Signal();
      })));
 
  fml::AutoResetWaitableEvent semantics_update_latch;
  context.SetSemanticsUpdateCallback2(
      [&](const FlutterSemanticsUpdate2* update) {
        ASSERT_EQ(update->node_count, size_t(1));
        ASSERT_EQ(update->custom_action_count, size_t(0));
 
        auto node = update->nodes[0];
 
        // Verify label
        {
          ASSERT_EQ(std::string(node->label), "What is the meaning of life?");
          ASSERT_EQ(node->label_attribute_count, size_t(2));
 
          ASSERT_EQ(node->label_attributes[0]->start, size_t(0));
          ASSERT_EQ(node->label_attributes[0]->end, size_t(28));
          ASSERT_EQ(node->label_attributes[0]->type,
                    FlutterStringAttributeType::kLocale);
          ASSERT_EQ(std::string(node->label_attributes[0]->locale->locale),
                    "en");
 
          ASSERT_EQ(node->label_attributes[1]->start, size_t(0));
          ASSERT_EQ(node->label_attributes[1]->end, size_t(1));
          ASSERT_EQ(node->label_attributes[1]->type,
                    FlutterStringAttributeType::kSpellOut);
        }
 
        // Verify hint
        {
          ASSERT_EQ(std::string(node->hint), "It's a number");
          ASSERT_EQ(node->hint_attribute_count, size_t(2));
 
          ASSERT_EQ(node->hint_attributes[0]->start, size_t(0));
          ASSERT_EQ(node->hint_attributes[0]->end, size_t(1));
          ASSERT_EQ(node->hint_attributes[0]->type,
                    FlutterStringAttributeType::kLocale);
          ASSERT_EQ(std::string(node->hint_attributes[0]->locale->locale),
                    "en");
 
          ASSERT_EQ(node->hint_attributes[1]->start, size_t(2));
          ASSERT_EQ(node->hint_attributes[1]->end, size_t(3));
          ASSERT_EQ(node->hint_attributes[1]->type,
                    FlutterStringAttributeType::kLocale);
          ASSERT_EQ(std::string(node->hint_attributes[1]->locale->locale),
                    "fr");
        }
 
        // Verify value
        {
          ASSERT_EQ(std::string(node->value), "42");
          ASSERT_EQ(node->value_attribute_count, size_t(1));
 
          ASSERT_EQ(node->value_attributes[0]->start, size_t(0));
          ASSERT_EQ(node->value_attributes[0]->end, size_t(2));
          ASSERT_EQ(node->value_attributes[0]->type,
                    FlutterStringAttributeType::kLocale);
          ASSERT_EQ(std::string(node->value_attributes[0]->locale->locale),
                    "en-US");
        }
 
        // Verify increased value
        {
          ASSERT_EQ(std::string(node->increased_value), "43");
          ASSERT_EQ(node->increased_value_attribute_count, size_t(2));
 
          ASSERT_EQ(node->increased_value_attributes[0]->start, size_t(0));
          ASSERT_EQ(node->increased_value_attributes[0]->end, size_t(1));
          ASSERT_EQ(node->increased_value_attributes[0]->type,
                    FlutterStringAttributeType::kSpellOut);
 
          ASSERT_EQ(node->increased_value_attributes[1]->start, size_t(1));
          ASSERT_EQ(node->increased_value_attributes[1]->end, size_t(2));
          ASSERT_EQ(node->increased_value_attributes[1]->type,
                    FlutterStringAttributeType::kSpellOut);
        }
 
        // Verify decreased value
        {
          ASSERT_EQ(std::string(node->decreased_value), "41");
          ASSERT_EQ(node->decreased_value_attribute_count, size_t(0));
          ASSERT_EQ(node->decreased_value_attributes, nullptr);
        }
 
        semantics_update_latch.Signal();
      });
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("a11y_string_attributes");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // 1: Enable semantics.
  auto result = FlutterEngineUpdateSemanticsEnabled(engine.get(), true);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
 
  // 2: Wait for semantics update callback on platform (current) thread.
  signal_native_latch.Wait();
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  semantics_update_latch.Wait();
#endif  // OS_FUCHSIA
}

◆ TEST_F() [332/925]

flutter::testing::TEST_F	(	EmbedderA11yTest	,
		A11yTreeIsConsistentUsingV1Callbacks
	)

Definition at line 572 of file embedder_a11y_unittests.cc.

                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent signal_native_latch;
 
  // Called by the Dart text fixture on the UI thread to signal that the C++
  // unittest should resume.
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(([&signal_native_latch](Dart_NativeArguments) {
        signal_native_latch.Signal();
      })));
 
  // Called by test fixture on UI thread to pass data back to this test.
  NativeEntry notify_semantics_enabled_callback;
  context.AddNativeCallback(
      "NotifySemanticsEnabled",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_enabled_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_enabled_callback, nullptr);
            notify_semantics_enabled_callback(args);
          })));
 
  NativeEntry notify_accessibility_features_callback;
  context.AddNativeCallback(
      "NotifyAccessibilityFeatures",
      CREATE_NATIVE_ENTRY((
          [&notify_accessibility_features_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_accessibility_features_callback, nullptr);
            notify_accessibility_features_callback(args);
          })));
 
  NativeEntry notify_semantics_action_callback;
  context.AddNativeCallback(
      "NotifySemanticsAction",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_action_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_action_callback, nullptr);
            notify_semantics_action_callback(args);
          })));
 
  fml::AutoResetWaitableEvent semantics_node_latch;
  fml::AutoResetWaitableEvent semantics_action_latch;
 
  int node_batch_end_count = 0;
  int action_batch_end_count = 0;
 
  int node_count = 0;
  context.SetSemanticsNodeCallback([&](const FlutterSemanticsNode* node) {
    if (node->id == kFlutterSemanticsNodeIdBatchEnd) {
      ++node_batch_end_count;
      semantics_node_latch.Signal();
    } else {
      // Batches should be completed after all nodes are received.
      ASSERT_EQ(0, node_batch_end_count);
      ASSERT_EQ(0, action_batch_end_count);
 
      ++node_count;
      ASSERT_EQ(1.0, node->transform.scaleX);
      ASSERT_EQ(2.0, node->transform.skewX);
      ASSERT_EQ(3.0, node->transform.transX);
      ASSERT_EQ(4.0, node->transform.skewY);
      ASSERT_EQ(5.0, node->transform.scaleY);
      ASSERT_EQ(6.0, node->transform.transY);
      ASSERT_EQ(7.0, node->transform.pers0);
      ASSERT_EQ(8.0, node->transform.pers1);
      ASSERT_EQ(9.0, node->transform.pers2);
      ASSERT_EQ(std::strncmp(kTooltip, node->tooltip, sizeof(kTooltip) - 1), 0);
 
      if (node->id == 128) {
        ASSERT_EQ(0x3f3, node->platform_view_id);
      } else {
        ASSERT_EQ(0, node->platform_view_id);
      }
    }
  });
 
  int action_count = 0;
  context.SetSemanticsCustomActionCallback(
      [&](const FlutterSemanticsCustomAction* action) {
        if (action->id == kFlutterSemanticsCustomActionIdBatchEnd) {
          ++action_batch_end_count;
          semantics_action_latch.Signal();
        } else {
          // Batches should be completed after all actions are received.
          ASSERT_EQ(0, node_batch_end_count);
          ASSERT_EQ(0, action_batch_end_count);
 
          ++action_count;
        }
      });
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("a11y_main");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // 1: Wait for initial notifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch.Signal();
  };
  notify_semantics_enabled_latch.Wait();
 
  // Prepare notifyAccessibilityFeatures callback.
  fml::AutoResetWaitableEvent notify_features_latch;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_features_latch.Signal();
  };
 
  // 2: Enable semantics. Wait for notifySemanticsEnabled(true).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_2;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_semantics_enabled_latch_2.Signal();
  };
  auto result = FlutterEngineUpdateSemanticsEnabled(engine.get(), true);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_2.Wait();
 
  // 3: Wait for notifyAccessibilityFeatures (reduce_motion == false)
  notify_features_latch.Wait();
 
  // 4: Wait for notifyAccessibilityFeatures (reduce_motion == true)
  fml::AutoResetWaitableEvent notify_features_latch_2;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_features_latch_2.Signal();
  };
  result = FlutterEngineUpdateAccessibilityFeatures(
      engine.get(), kFlutterAccessibilityFeatureReduceMotion);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_features_latch_2.Wait();
 
  // 5: Wait for UpdateSemantics callback on platform (current) thread.
  signal_native_latch.Wait();
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  semantics_node_latch.Wait();
  semantics_action_latch.Wait();
  ASSERT_EQ(4, node_count);
  ASSERT_EQ(1, node_batch_end_count);
  ASSERT_EQ(1, action_count);
  ASSERT_EQ(1, action_batch_end_count);
 
  // 6: Dispatch a tap to semantics node 42. Wait for NotifySemanticsAction.
  fml::AutoResetWaitableEvent notify_semantics_action_latch;
  notify_semantics_action_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    int64_t node_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 0, exception);
    ASSERT_EQ(42, node_id);
 
    int64_t action_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 1, exception);
    ASSERT_EQ(static_cast<int32_t>(flutter::SemanticsAction::kTap), action_id);
 
    std::vector<int64_t> semantic_args =
        ::tonic::DartConverter<std::vector<int64_t>>::FromArguments(args, 2,
                                                                    exception);
    ASSERT_THAT(semantic_args, ElementsAre(2, 1));
    notify_semantics_action_latch.Signal();
  };
  std::vector<uint8_t> bytes({2, 1});
  result = FlutterEngineDispatchSemanticsAction(
      engine.get(), 42, kFlutterSemanticsActionTap, &bytes[0], bytes.size());
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_action_latch.Wait();
 
  // 7: Disable semantics. Wait for NotifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_3;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch_3.Signal();
  };
  result = FlutterEngineUpdateSemanticsEnabled(engine.get(), false);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_3.Wait();
}

◆ TEST_F() [333/925]

flutter::testing::TEST_F	(	EmbedderA11yTest	,
		A11yTreeIsConsistentUsingV2Callbacks
	)

Definition at line 395 of file embedder_a11y_unittests.cc.

                                                               {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "This test crashes on Fuchsia. https://fxbug.dev/87493 ";
#else
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent signal_native_latch;
 
  // Called by the Dart text fixture on the UI thread to signal that the C++
  // unittest should resume.
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(([&signal_native_latch](Dart_NativeArguments) {
        signal_native_latch.Signal();
      })));
 
  // Called by test fixture on UI thread to pass data back to this test.
  NativeEntry notify_semantics_enabled_callback;
  context.AddNativeCallback(
      "NotifySemanticsEnabled",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_enabled_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_enabled_callback, nullptr);
            notify_semantics_enabled_callback(args);
          })));
 
  NativeEntry notify_accessibility_features_callback;
  context.AddNativeCallback(
      "NotifyAccessibilityFeatures",
      CREATE_NATIVE_ENTRY((
          [&notify_accessibility_features_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_accessibility_features_callback, nullptr);
            notify_accessibility_features_callback(args);
          })));
 
  NativeEntry notify_semantics_action_callback;
  context.AddNativeCallback(
      "NotifySemanticsAction",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_action_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_action_callback, nullptr);
            notify_semantics_action_callback(args);
          })));
 
  fml::AutoResetWaitableEvent semantics_update_latch;
  context.SetSemanticsUpdateCallback([&](const FlutterSemanticsUpdate* update) {
    ASSERT_EQ(size_t(4), update->nodes_count);
    ASSERT_EQ(size_t(1), update->custom_actions_count);
 
    for (size_t i = 0; i < update->nodes_count; i++) {
      const FlutterSemanticsNode* node = update->nodes + i;
 
      ASSERT_EQ(1.0, node->transform.scaleX);
      ASSERT_EQ(2.0, node->transform.skewX);
      ASSERT_EQ(3.0, node->transform.transX);
      ASSERT_EQ(4.0, node->transform.skewY);
      ASSERT_EQ(5.0, node->transform.scaleY);
      ASSERT_EQ(6.0, node->transform.transY);
      ASSERT_EQ(7.0, node->transform.pers0);
      ASSERT_EQ(8.0, node->transform.pers1);
      ASSERT_EQ(9.0, node->transform.pers2);
      ASSERT_EQ(std::strncmp(kTooltip, node->tooltip, sizeof(kTooltip) - 1), 0);
 
      if (node->id == 128) {
        ASSERT_EQ(0x3f3, node->platform_view_id);
      } else {
        ASSERT_NE(kFlutterSemanticsNodeIdBatchEnd, node->id);
        ASSERT_EQ(0, node->platform_view_id);
      }
    }
 
    semantics_update_latch.Signal();
  });
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("a11y_main");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // 1: Wait for initial notifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch.Signal();
  };
  notify_semantics_enabled_latch.Wait();
 
  // Prepare notifyAccessibilityFeatures callback.
  fml::AutoResetWaitableEvent notify_features_latch;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_features_latch.Signal();
  };
 
  // 2: Enable semantics. Wait for notifySemanticsEnabled(true).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_2;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_semantics_enabled_latch_2.Signal();
  };
  auto result = FlutterEngineUpdateSemanticsEnabled(engine.get(), true);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_2.Wait();
 
  // 3: Wait for notifyAccessibilityFeatures (reduce_motion == false)
  notify_features_latch.Wait();
 
  // 4: Wait for notifyAccessibilityFeatures (reduce_motion == true)
  fml::AutoResetWaitableEvent notify_features_latch_2;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_features_latch_2.Signal();
  };
  result = FlutterEngineUpdateAccessibilityFeatures(
      engine.get(), kFlutterAccessibilityFeatureReduceMotion);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_features_latch_2.Wait();
 
  // 5: Wait for UpdateSemantics callback on platform (current) thread.
  signal_native_latch.Wait();
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  semantics_update_latch.Wait();
 
  // 6: Dispatch a tap to semantics node 42. Wait for NotifySemanticsAction.
  fml::AutoResetWaitableEvent notify_semantics_action_latch;
  notify_semantics_action_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    int64_t node_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 0, exception);
    ASSERT_EQ(42, node_id);
 
    int64_t action_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 1, exception);
    ASSERT_EQ(static_cast<int32_t>(flutter::SemanticsAction::kTap), action_id);
 
    std::vector<int64_t> semantic_args =
        ::tonic::DartConverter<std::vector<int64_t>>::FromArguments(args, 2,
                                                                    exception);
    ASSERT_THAT(semantic_args, ElementsAre(2, 1));
    notify_semantics_action_latch.Signal();
  };
  std::vector<uint8_t> bytes({2, 1});
  result = FlutterEngineDispatchSemanticsAction(
      engine.get(), 42, kFlutterSemanticsActionTap, &bytes[0], bytes.size());
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_action_latch.Wait();
 
  // 7: Disable semantics. Wait for NotifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_3;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch_3.Signal();
  };
  result = FlutterEngineUpdateSemanticsEnabled(engine.get(), false);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_3.Wait();
#endif  // OS_FUCHSIA
}

◆ TEST_F() [334/925]

flutter::testing::TEST_F	(	EmbedderA11yTest	,
		A11yTreeIsConsistentUsingV3Callbacks
	)

Definition at line 96 of file embedder_a11y_unittests.cc.

                                                               {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "This test crashes on Fuchsia. https://fxbug.dev/87493 ";
#else
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent signal_native_latch;
 
  // Called by the Dart text fixture on the UI thread to signal that the C++
  // unittest should resume.
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(([&signal_native_latch](Dart_NativeArguments) {
        signal_native_latch.Signal();
      })));
 
  // Called by test fixture on UI thread to pass data back to this test.
  NativeEntry notify_semantics_enabled_callback;
  context.AddNativeCallback(
      "NotifySemanticsEnabled",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_enabled_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_enabled_callback, nullptr);
            notify_semantics_enabled_callback(args);
          })));
 
  NativeEntry notify_accessibility_features_callback;
  context.AddNativeCallback(
      "NotifyAccessibilityFeatures",
      CREATE_NATIVE_ENTRY((
          [&notify_accessibility_features_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_accessibility_features_callback, nullptr);
            notify_accessibility_features_callback(args);
          })));
 
  NativeEntry notify_semantics_action_callback;
  context.AddNativeCallback(
      "NotifySemanticsAction",
      CREATE_NATIVE_ENTRY(
          ([&notify_semantics_action_callback](Dart_NativeArguments args) {
            ASSERT_NE(notify_semantics_action_callback, nullptr);
            notify_semantics_action_callback(args);
          })));
 
  fml::AutoResetWaitableEvent semantics_update_latch;
  context.SetSemanticsUpdateCallback2(
      [&](const FlutterSemanticsUpdate2* update) {
        ASSERT_EQ(size_t(4), update->node_count);
        ASSERT_EQ(size_t(1), update->custom_action_count);
 
        for (size_t i = 0; i < update->node_count; i++) {
          const FlutterSemanticsNode2* node = update->nodes[i];
 
          ASSERT_EQ(1.0, node->transform.scaleX);
          ASSERT_EQ(2.0, node->transform.skewX);
          ASSERT_EQ(3.0, node->transform.transX);
          ASSERT_EQ(4.0, node->transform.skewY);
          ASSERT_EQ(5.0, node->transform.scaleY);
          ASSERT_EQ(6.0, node->transform.transY);
          ASSERT_EQ(7.0, node->transform.pers0);
          ASSERT_EQ(8.0, node->transform.pers1);
          ASSERT_EQ(9.0, node->transform.pers2);
          ASSERT_EQ(std::strncmp(kTooltip, node->tooltip, sizeof(kTooltip) - 1),
                    0);
 
          if (node->id == 128) {
            ASSERT_EQ(0x3f3, node->platform_view_id);
          } else {
            ASSERT_NE(kFlutterSemanticsNodeIdBatchEnd, node->id);
            ASSERT_EQ(0, node->platform_view_id);
          }
        }
 
        semantics_update_latch.Signal();
      });
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("a11y_main");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // 1: Wait for initial notifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch.Signal();
  };
  notify_semantics_enabled_latch.Wait();
 
  // Prepare notifyAccessibilityFeatures callback.
  fml::AutoResetWaitableEvent notify_features_latch;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_features_latch.Signal();
  };
 
  // 2: Enable semantics. Wait for notifySemanticsEnabled(true).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_2;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_semantics_enabled_latch_2.Signal();
  };
  auto result = FlutterEngineUpdateSemanticsEnabled(engine.get(), true);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_2.Wait();
 
  // 3: Wait for notifyAccessibilityFeatures (reduce_motion == false)
  notify_features_latch.Wait();
 
  // 4: Wait for notifyAccessibilityFeatures (reduce_motion == true)
  fml::AutoResetWaitableEvent notify_features_latch_2;
  notify_accessibility_features_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_TRUE(enabled);
    notify_features_latch_2.Signal();
  };
  result = FlutterEngineUpdateAccessibilityFeatures(
      engine.get(), kFlutterAccessibilityFeatureReduceMotion);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_features_latch_2.Wait();
 
  // 5: Wait for UpdateSemantics callback on platform (current) thread.
  signal_native_latch.Wait();
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  semantics_update_latch.Wait();
 
  // 6: Dispatch a tap to semantics node 42. Wait for NotifySemanticsAction.
  fml::AutoResetWaitableEvent notify_semantics_action_latch;
  notify_semantics_action_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    int64_t node_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 0, exception);
    ASSERT_EQ(42, node_id);
 
    int64_t action_id =
        ::tonic::DartConverter<int64_t>::FromArguments(args, 1, exception);
    ASSERT_EQ(static_cast<int32_t>(flutter::SemanticsAction::kTap), action_id);
 
    std::vector<int64_t> semantic_args =
        ::tonic::DartConverter<std::vector<int64_t>>::FromArguments(args, 2,
                                                                    exception);
    ASSERT_THAT(semantic_args, ElementsAre(2, 1));
    notify_semantics_action_latch.Signal();
  };
  std::vector<uint8_t> bytes({2, 1});
  result = FlutterEngineDispatchSemanticsAction(
      engine.get(), 42, kFlutterSemanticsActionTap, &bytes[0], bytes.size());
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_action_latch.Wait();
 
  // 7: Disable semantics. Wait for NotifySemanticsEnabled(false).
  fml::AutoResetWaitableEvent notify_semantics_enabled_latch_3;
  notify_semantics_enabled_callback = [&](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    bool enabled =
        ::tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    ASSERT_FALSE(enabled);
    notify_semantics_enabled_latch_3.Signal();
  };
  result = FlutterEngineUpdateSemanticsEnabled(engine.get(), false);
  ASSERT_EQ(result, FlutterEngineResult::kSuccess);
  notify_semantics_enabled_latch_3.Wait();
#endif  // OS_FUCHSIA
}

◆ TEST_F() [335/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		AddViewSchedulesFrame
	)

Test that adding a view schedules a frame.

Definition at line 1319 of file embedder_unittests.cc.

                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("add_view_schedules_frame");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  fml::AutoResetWaitableEvent check_latch;
  context.AddNativeCallback(
      "SignalNativeCount",
      CREATE_NATIVE_ENTRY(
          [&check_latch](Dart_NativeArguments args) { check_latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Wait for the application to attach the listener.
  latch.Wait();
 
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 123;
 
  FlutterAddViewInfo info = {};
  info.struct_size = sizeof(FlutterAddViewInfo);
  info.view_id = 123;
  info.view_metrics = &metrics;
  info.add_view_callback = [](const FlutterAddViewResult* result) {
    EXPECT_TRUE(result->added);
  };
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &info), kSuccess);
 
  check_latch.Wait();
}

◆ TEST_F() [336/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ArcEndCapsAreDrawnCorrectly
	)

Definition at line 2912 of file embedder_gl_unittests.cc.

                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 1024));
  builder.SetCompositor();
  builder.SetDartEntrypoint("arc_end_caps_correct");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  const auto root_surface_transformation = SkMatrix()
                                               .preScale(1.0, -1.0)
                                               .preTranslate(1024.0, -800.0)
                                               .preRotate(90.0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto engine = builder.LaunchEngine();
 
  auto scene_image = context.GetNextSceneImage();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 1024;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("arc_end_caps.png", scene_image));
}

◆ TEST_F() [337/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		BackingStoresCorrespondToTheirViews
	)

Test that the backing store is created with the correct view ID, is used for the correct view, and is cached according to their views.

The test involves two frames:

The first frame renders the implicit view and the second view.
The second frame renders the implicit view and the third view.

The test verifies that:

Each backing store is created with a valid view ID.
Each backing store is presented for the view that it was created for.
Both frames render the expected sets of views.
By the end of frame 1, only 2 backing stores were created.
By the end of frame 2, only 3 backing stores were created. This ensures that the backing store for the 2nd view is not reused for the 3rd view.

Definition at line 1832 of file embedder_unittests.cc.

                                                          {
  constexpr FlutterViewId kSecondViewId = 123;
  constexpr FlutterViewId kThirdViewId = 456;
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetDartEntrypoint("render_all_views");
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
 
  EmbedderTestBackingStoreProducer producer(
      context.GetCompositor().GetGrContext(),
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  // The variables needed by the callbacks of the compositor.
  struct CompositorUserData {
    EmbedderTestBackingStoreProducer* producer;
    // Each latch is signaled when its corresponding view is presented.
    fml::AutoResetWaitableEvent latch_implicit;
    fml::AutoResetWaitableEvent latch_second;
    fml::AutoResetWaitableEvent latch_third;
    // Whether the respective view should be rendered in the frame.
    bool second_expected;
    bool third_expected;
    // The total number of backing stores created to verify caching.
    int backing_stores_created;
  };
  CompositorUserData compositor_user_data{
      .producer = &producer,
      .backing_stores_created = 0,
  };
 
  builder.GetCompositor() = FlutterCompositor{
      .struct_size = sizeof(FlutterCompositor),
      .user_data = reinterpret_cast<void*>(&compositor_user_data),
      .create_backing_store_callback =
          [](const FlutterBackingStoreConfig* config,
             FlutterBackingStore* backing_store_out, void* user_data) {
            // Verify that the backing store comes with the correct view ID.
            EXPECT_TRUE(config->view_id == 0 ||
                        config->view_id == kSecondViewId ||
                        config->view_id == kThirdViewId);
            auto compositor_user_data =
                reinterpret_cast<CompositorUserData*>(user_data);
            compositor_user_data->backing_stores_created += 1;
            bool result = compositor_user_data->producer->Create(
                config, backing_store_out);
            // The created backing store has a user_data that records the view
            // that the store is created for.
            backing_store_out->user_data =
                reinterpret_cast<void*>(config->view_id);
            return result;
          },
      .collect_backing_store_callback = [](const FlutterBackingStore* renderer,
                                           void* user_data) { return true; },
      .present_layers_callback = nullptr,
      .avoid_backing_store_cache = false,
      .present_view_callback =
          [](const FlutterPresentViewInfo* info) {
            EXPECT_EQ(info->layers_count, 1u);
            // Verify that the given layer's backing store has the same view ID
            // as the target view.
            int64_t store_view_id = reinterpret_cast<int64_t>(
                info->layers[0]->backing_store->user_data);
            EXPECT_EQ(store_view_id, info->view_id);
            auto compositor_user_data =
                reinterpret_cast<CompositorUserData*>(info->user_data);
            // Verify that the respective views are rendered.
            switch (info->view_id) {
              case 0:
                compositor_user_data->latch_implicit.Signal();
                break;
              case kSecondViewId:
                EXPECT_TRUE(compositor_user_data->second_expected);
                compositor_user_data->latch_second.Signal();
                break;
              case kThirdViewId:
                EXPECT_TRUE(compositor_user_data->third_expected);
                compositor_user_data->latch_third.Signal();
                break;
              default:
                FML_UNREACHABLE();
            }
            return true;
          },
  };
 
  compositor_user_data.second_expected = true;
  compositor_user_data.third_expected = false;
 
  /*=== First frame ===*/
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Give the implicit view a non-zero size so that it renders something.
  FlutterWindowMetricsEvent metrics_implicit = {
      .struct_size = sizeof(FlutterWindowMetricsEvent),
      .width = 800,
      .height = 600,
      .pixel_ratio = 1.0,
      .view_id = 0,
  };
  ASSERT_EQ(
      FlutterEngineSendWindowMetricsEvent(engine.get(), &metrics_implicit),
      kSuccess);
 
  // Add the second view.
  FlutterWindowMetricsEvent metrics_add = {
      .struct_size = sizeof(FlutterWindowMetricsEvent),
      .width = 800,
      .height = 600,
      .pixel_ratio = 1.0,
      .view_id = kSecondViewId,
  };
 
  FlutterAddViewInfo add_view_info = {};
  add_view_info.struct_size = sizeof(FlutterAddViewInfo);
  add_view_info.view_id = kSecondViewId;
  add_view_info.view_metrics = &metrics_add;
  add_view_info.add_view_callback = [](const FlutterAddViewResult* result) {
    ASSERT_TRUE(result->added);
  };
 
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_view_info), kSuccess);
 
  compositor_user_data.latch_implicit.Wait();
  compositor_user_data.latch_second.Wait();
 
  /*=== Second frame ===*/
 
  compositor_user_data.second_expected = false;
  compositor_user_data.third_expected = true;
  EXPECT_EQ(compositor_user_data.backing_stores_created, 2);
 
  // Remove the second view
  FlutterRemoveViewInfo remove_view_info = {};
  remove_view_info.struct_size = sizeof(FlutterRemoveViewInfo);
  remove_view_info.view_id = kSecondViewId;
  remove_view_info.remove_view_callback =
      [](const FlutterRemoveViewResult* result) {
        ASSERT_TRUE(result->removed);
      };
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &remove_view_info), kSuccess);
 
  // Add the third view.
  add_view_info.view_id = kThirdViewId;
  metrics_add.view_id = kThirdViewId;
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_view_info), kSuccess);
  // Adding the view should have scheduled a frame.
 
  compositor_user_data.latch_implicit.Wait();
  compositor_user_data.latch_third.Wait();
  EXPECT_EQ(compositor_user_data.backing_stores_created, 3);
}

◆ TEST_F() [338/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		BackToBackKeyEventResponsesCorrectlyInvoked
	)

Definition at line 3222 of file embedder_unittests.cc.

                                                                  {
  UniqueEngine engine;
  fml::AutoResetWaitableEvent sync_latch;
  fml::AutoResetWaitableEvent ready;
 
  // One of the threads that the callback will be posted to is the platform
  // thread. So we cannot wait for assertions to complete on the platform
  // thread. Create a new thread to manage the engine instance and wait for
  // assertions on the test thread.
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("key_data_echo");
    context.AddNativeCallback(
        "SignalNativeTest",
        CREATE_NATIVE_ENTRY(
            [&ready](Dart_NativeArguments args) { ready.Signal(); }));
 
    context.AddNativeCallback(
        "EchoKeyEvent", CREATE_NATIVE_ENTRY([](Dart_NativeArguments args) {}));
 
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
 
    sync_latch.Signal();
  });
  sync_latch.Wait();
  ready.Wait();
 
  // Dispatch a single event
  FlutterKeyEvent event{
      .struct_size = sizeof(FlutterKeyEvent),
      .timestamp = 1000,
      .type = kFlutterKeyEventTypeDown,
      .physical = 0x00070005,
      .logical = 0x00000000062,
      .character = nullptr,
      .synthesized = false,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
 
  // Dispatch two events back to back, using the same callback on different
  // user_data
  KeyEventUserData user_data2{
      .latch = std::make_shared<fml::AutoResetWaitableEvent>(),
      .returned = false,
  };
  KeyEventUserData user_data3{
      .latch = std::make_shared<fml::AutoResetWaitableEvent>(),
      .returned = false,
  };
  auto callback23 = [](bool handled, void* untyped_user_data) {
    KeyEventUserData* user_data =
        reinterpret_cast<KeyEventUserData*>(untyped_user_data);
    EXPECT_EQ(handled, false);
    user_data->returned = true;
    user_data->latch->Signal();
  };
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &event, callback23, &user_data2);
    FlutterEngineSendKeyEvent(engine.get(), &event, callback23, &user_data3);
  });
  user_data2.latch->Wait();
  user_data3.latch->Wait();
 
  EXPECT_TRUE(user_data2.returned);
  EXPECT_TRUE(user_data3.returned);
 
  fml::AutoResetWaitableEvent shutdown_latch;
  platform_task_runner->PostTask([&]() {
    engine.reset();
    shutdown_latch.Signal();
  });
  shutdown_latch.Wait();
}

◆ TEST_F() [339/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanAddView
	)

Test that a view can be added to a running engine.

Definition at line 1271 of file embedder_unittests.cc.

                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  std::string message;
  context.AddNativeCallback("SignalNativeMessage",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              message =
                                  tonic::DartConverter<std::string>::FromDart(
                                      Dart_GetNativeArgument(args, 0));
                              message_latch.Signal();
                            }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 123;
 
  FlutterAddViewInfo info = {};
  info.struct_size = sizeof(FlutterAddViewInfo);
  info.view_id = 123;
  info.view_metrics = &metrics;
  info.add_view_callback = [](const FlutterAddViewResult* result) {
    EXPECT_TRUE(result->added);
  };
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ("View IDs: [0, 123]", message);
}

◆ TEST_F() [340/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanCreateAndCollectAValidElfSource
	)

Definition at line 2387 of file embedder_unittests.cc.

                                                         {
  if (!DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
  FlutterEngineAOTDataSource data_in = {};
  FlutterEngineAOTData data_out = nullptr;
 
  // Collecting a null object should be allowed
  ASSERT_EQ(FlutterEngineCollectAOTData(data_out), kSuccess);
 
  const auto elf_path =
      fml::paths::JoinPaths({GetFixturesPath(), kDefaultAOTAppELFFileName});
 
  data_in.type = kFlutterEngineAOTDataSourceTypeElfPath;
  data_in.elf_path = elf_path.c_str();
 
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, &data_out), kSuccess);
  ASSERT_EQ(data_in.type, kFlutterEngineAOTDataSourceTypeElfPath);
  ASSERT_EQ(data_in.elf_path, elf_path.c_str());
  ASSERT_NE(data_out, nullptr);
 
  ASSERT_EQ(FlutterEngineCollectAOTData(data_out), kSuccess);
}

◆ TEST_F() [341/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanCreateAndCollectCallbacks
	)

Creates a platform message response callbacks, does NOT send them, and immediately collects the same.

Definition at line 330 of file embedder_unittests.cc.

                                                   {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("platform_messages_response");
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([](Dart_NativeArguments args) {}));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
  auto callback = [](const uint8_t* data, size_t size,
                     void* user_data) -> void {};
  auto result = FlutterPlatformMessageCreateResponseHandle(
      engine.get(), callback, nullptr, &response_handle);
  ASSERT_EQ(result, kSuccess);
  ASSERT_NE(response_handle, nullptr);
 
  result = FlutterPlatformMessageReleaseResponseHandle(engine.get(),
                                                       response_handle);
  ASSERT_EQ(result, kSuccess);
}

◆ TEST_F() [342/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanCreateEmbedderWithCustomRenderTaskRunner
	)

Asserts that embedders can provide a task runner for the render thread.

Definition at line 2065 of file embedder_gl_unittests.cc.

                                                                  {
  std::mutex engine_mutex;
  UniqueEngine engine;
  fml::AutoResetWaitableEvent task_latch;
  bool task_executed = false;
  EmbedderTestTaskRunner render_task_runner(
      CreateNewThread("custom_render_thread"), [&](FlutterTask task) {
        std::scoped_lock engine_lock(engine_mutex);
        if (engine.is_valid()) {
          ASSERT_EQ(FlutterEngineRunTask(engine.get(), &task), kSuccess);
          task_executed = true;
          task_latch.Signal();
        }
      });
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kOpenGLContext));
  builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetRenderTaskRunner(
      &render_task_runner.GetFlutterTaskRunnerDescription());
 
  {
    std::scoped_lock lock(engine_mutex);
    engine = builder.InitializeEngine();
  }
 
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  task_latch.Wait();
  ASSERT_TRUE(task_executed);
  ASSERT_EQ(FlutterEngineDeinitialize(engine.get()), kSuccess);
 
  {
    std::scoped_lock engine_lock(engine_mutex);
    engine.reset();
  }
}

◆ TEST_F() [343/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanCreateInitializedEngine
	)

Test that an engine can be initialized but not run.

Definition at line 1213 of file embedder_unittests.cc.

                                                 {
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
  builder.SetSoftwareRendererConfig();
  auto engine = builder.InitializeEngine();
  ASSERT_TRUE(engine.is_valid());
  engine.reset();
}

◆ TEST_F() [344/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanCreateOpenGLRenderingEngine
	)

Definition at line 54 of file embedder_gl_unittests.cc.

                                                     {
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kOpenGLContext));
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [345/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanDeinitializeAnEngine
	)

Test that an engine can be deinitialized.

Definition at line 1240 of file embedder_unittests.cc.

                                              {
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
  builder.SetSoftwareRendererConfig();
  auto engine = builder.InitializeEngine();
  ASSERT_TRUE(engine.is_valid());
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
  // Cannot re-run an already running engine.
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kInvalidArguments);
  ASSERT_EQ(FlutterEngineDeinitialize(engine.get()), kSuccess);
  // It is ok to deinitialize an engine multiple times.
  ASSERT_EQ(FlutterEngineDeinitialize(engine.get()), kSuccess);
 
  // Sending events to a deinitialized engine fails.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kInvalidArguments);
  engine.reset();
}

◆ TEST_F() [346/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanGetVulkanEmbedderContext
	)

Definition at line 49 of file embedder_gl_unittests.cc.

                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kVulkanContext);
  EmbedderConfigBuilder builder(context);
}

◆ TEST_F() [347/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanInvokeCustomEntrypoint
	)

Definition at line 91 of file embedder_unittests.cc.

                                                {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  static fml::AutoResetWaitableEvent latch;
  Dart_NativeFunction entrypoint = [](Dart_NativeArguments args) {
    latch.Signal();
  };
  context.AddNativeCallback("SayHiFromCustomEntrypoint", entrypoint);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("customEntrypoint");
  auto engine = builder.LaunchEngine();
  latch.Wait();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [348/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanInvokeCustomEntrypointMacro
	)

Definition at line 106 of file embedder_unittests.cc.

                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent latch1;
  fml::AutoResetWaitableEvent latch2;
  fml::AutoResetWaitableEvent latch3;
 
  // Can be defined separately.
  auto entry1 = [&latch1](Dart_NativeArguments args) {
    FML_LOG(INFO) << "In Callback 1";
    latch1.Signal();
  };
  auto native_entry1 = CREATE_NATIVE_ENTRY(entry1);
  context.AddNativeCallback("SayHiFromCustomEntrypoint1", native_entry1);
 
  // Can be wrapped in the args.
  auto entry2 = [&latch2](Dart_NativeArguments args) {
    FML_LOG(INFO) << "In Callback 2";
    latch2.Signal();
  };
  context.AddNativeCallback("SayHiFromCustomEntrypoint2",
                            CREATE_NATIVE_ENTRY(entry2));
 
  // Everything can be inline.
  context.AddNativeCallback(
      "SayHiFromCustomEntrypoint3",
      CREATE_NATIVE_ENTRY([&latch3](Dart_NativeArguments args) {
        FML_LOG(INFO) << "In Callback 3";
        latch3.Signal();
      }));
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("customEntrypoint1");
  auto engine = builder.LaunchEngine();
  latch1.Wait();
  latch2.Wait();
  latch3.Wait();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [349/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchAndShutdownWithAValidElfSource
	)

Definition at line 2412 of file embedder_unittests.cc.

                                                              {
  if (!DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent latch;
  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
 
  EmbedderConfigBuilder builder(
      context,
      EmbedderConfigBuilder::InitializationPreference::kAOTDataInitialize);
 
  builder.SetSoftwareRendererConfig();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Wait for the root isolate to launch.
  latch.Wait();
  engine.reset();
}

◆ TEST_F() [350/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchAndShutdownWithValidProjectArgs
	)

Definition at line 66 of file embedder_unittests.cc.

                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  fml::AutoResetWaitableEvent latch;
  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  // Wait for the root isolate to launch.
  latch.Wait();
  engine.reset();
}

◆ TEST_F() [351/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchEngineWithInvalidJITSnapshots
	)

The embedder must be able to run in JIT mode even when the specfied snapshots are invalid. It should be able to resolve them as it would when the snapshots are not specified.

Definition at line 2619 of file embedder_unittests.cc.

                                                             {
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // Explicitly define the locations of the JIT snapshots
  builder.GetProjectArgs().isolate_snapshot_data =
      reinterpret_cast<const uint8_t*>("invalid_snapshot_data");
  builder.GetProjectArgs().isolate_snapshot_instructions =
      reinterpret_cast<const uint8_t*>("invalid_snapshot_instructions");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kInvalidArguments);
}

◆ TEST_F() [352/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchEngineWithSomeSpecifiedJITSnapshots
	)

The embedder must be able to run in JIT mode when only some snapshots are specified.

Definition at line 2586 of file embedder_unittests.cc.

                                                                   {
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // Construct the location of valid JIT snapshots.
  const std::string src_path = GetSourcePath();
  const std::string vm_snapshot_data =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_DATA});
  const std::string vm_snapshot_instructions =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_INSTRUCTIONS});
 
  // Explicitly define the locations of the JIT snapshots
  builder.GetProjectArgs().vm_snapshot_data =
      reinterpret_cast<const uint8_t*>(vm_snapshot_data.c_str());
  builder.GetProjectArgs().vm_snapshot_instructions =
      reinterpret_cast<const uint8_t*>(vm_snapshot_instructions.c_str());
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [353/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchEngineWithSpecifiedJITSnapshots
	)

The embedder must be able to run explicitly specified snapshots in JIT mode (i.e. when those are present in known locations).

Definition at line 2546 of file embedder_unittests.cc.

                                                               {
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // Construct the location of valid JIT snapshots.
  const std::string src_path = GetSourcePath();
  const std::string vm_snapshot_data =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_DATA});
  const std::string vm_snapshot_instructions =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_INSTRUCTIONS});
  const std::string isolate_snapshot_data =
      fml::paths::JoinPaths({src_path, TEST_ISOLATE_SNAPSHOT_DATA});
  const std::string isolate_snapshot_instructions =
      fml::paths::JoinPaths({src_path, TEST_ISOLATE_SNAPSHOT_INSTRUCTIONS});
 
  // Explicitly define the locations of the JIT snapshots
  builder.GetProjectArgs().vm_snapshot_data =
      reinterpret_cast<const uint8_t*>(vm_snapshot_data.c_str());
  builder.GetProjectArgs().vm_snapshot_instructions =
      reinterpret_cast<const uint8_t*>(vm_snapshot_instructions.c_str());
  builder.GetProjectArgs().isolate_snapshot_data =
      reinterpret_cast<const uint8_t*>(isolate_snapshot_data.c_str());
  builder.GetProjectArgs().isolate_snapshot_instructions =
      reinterpret_cast<const uint8_t*>(isolate_snapshot_instructions.c_str());
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [354/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanLaunchEngineWithUnspecifiedJITSnapshots
	)

The embedder must be able to launch even when the snapshots are not explicitly defined in JIT mode. It must be able to resolve those snapshots.

Definition at line 2645 of file embedder_unittests.cc.

                                                                 {
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  ASSERT_EQ(builder.GetProjectArgs().vm_snapshot_data, nullptr);
  ASSERT_EQ(builder.GetProjectArgs().vm_snapshot_instructions, nullptr);
  ASSERT_EQ(builder.GetProjectArgs().isolate_snapshot_data, nullptr);
  ASSERT_EQ(builder.GetProjectArgs().isolate_snapshot_instructions, nullptr);
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [355/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CannotAddDuplicateViews
	)

Test that a view cannot be added if its ID already exists.

Definition at line 1445 of file embedder_unittests.cc.

                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  std::string message;
  context.AddNativeCallback("SignalNativeMessage",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              message =
                                  tonic::DartConverter<std::string>::FromDart(
                                      Dart_GetNativeArgument(args, 0));
                              message_latch.Signal();
                            }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  // Add view 123.
  struct Captures {
    std::atomic<int> count = 0;
    fml::AutoResetWaitableEvent failure_latch;
  };
  Captures captures;
 
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 123;
 
  FlutterAddViewInfo add_info = {};
  add_info.struct_size = sizeof(FlutterAddViewInfo);
  add_info.view_id = 123;
  add_info.view_metrics = &metrics;
  add_info.user_data = &captures;
  add_info.add_view_callback = [](const FlutterAddViewResult* result) {
    auto captures = reinterpret_cast<Captures*>(result->user_data);
 
    int count = captures->count.fetch_add(1);
 
    if (count == 0) {
      ASSERT_TRUE(result->added);
    } else {
      EXPECT_FALSE(result->added);
      captures->failure_latch.Signal();
    }
  };
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0, 123]");
  ASSERT_FALSE(captures.failure_latch.IsSignaledForTest());
 
  // Add view 123 a second time.
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_info), kSuccess);
  captures.failure_latch.Wait();
  ASSERT_EQ(captures.count, 2);
  ASSERT_FALSE(message_latch.IsSignaledForTest());
}

◆ TEST_F() [356/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CannotProvideMultipleSemanticsCallbacks
	)

Definition at line 34 of file embedder_a11y_unittests.cc.

                                                              {
  {
    EmbedderConfigBuilder builder(
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
    builder.SetSoftwareRendererConfig();
    builder.GetProjectArgs().update_semantics_callback =
        [](const FlutterSemanticsUpdate* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_callback2 =
        [](const FlutterSemanticsUpdate2* update, void* user_data) {};
    auto engine = builder.InitializeEngine();
    ASSERT_FALSE(engine.is_valid());
    engine.reset();
  }
 
  {
    EmbedderConfigBuilder builder(
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
    builder.SetSoftwareRendererConfig();
    builder.GetProjectArgs().update_semantics_callback2 =
        [](const FlutterSemanticsUpdate2* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_node_callback =
        [](const FlutterSemanticsNode* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_custom_action_callback =
        [](const FlutterSemanticsCustomAction* update, void* user_data) {};
    auto engine = builder.InitializeEngine();
    ASSERT_FALSE(engine.is_valid());
    engine.reset();
  }
 
  {
    EmbedderConfigBuilder builder(
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
    builder.SetSoftwareRendererConfig();
    builder.GetProjectArgs().update_semantics_callback =
        [](const FlutterSemanticsUpdate* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_node_callback =
        [](const FlutterSemanticsNode* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_custom_action_callback =
        [](const FlutterSemanticsCustomAction* update, void* user_data) {};
    auto engine = builder.InitializeEngine();
    ASSERT_FALSE(engine.is_valid());
    engine.reset();
  }
 
  {
    EmbedderConfigBuilder builder(
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
    builder.SetSoftwareRendererConfig();
    builder.GetProjectArgs().update_semantics_callback2 =
        [](const FlutterSemanticsUpdate2* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_callback =
        [](const FlutterSemanticsUpdate* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_node_callback =
        [](const FlutterSemanticsNode* update, void* user_data) {};
    builder.GetProjectArgs().update_semantics_custom_action_callback =
        [](const FlutterSemanticsCustomAction* update, void* user_data) {};
    auto engine = builder.InitializeEngine();
    ASSERT_FALSE(engine.is_valid());
    engine.reset();
  }
}

◆ TEST_F() [357/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CannotRemoveImplicitView
	)

The implicit view is a special view that the engine and framework assume can always be rendered to. Test that this view cannot be removed.

Definition at line 1425 of file embedder_unittests.cc.

                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterRemoveViewInfo info = {};
  info.struct_size = sizeof(FlutterRemoveViewInfo);
  info.view_id = kFlutterImplicitViewId;
  info.remove_view_callback = [](const FlutterRemoveViewResult* result) {
    FAIL();
  };
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &info), kInvalidArguments);
}

◆ TEST_F() [358/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CannotRemoveUnknownView
	)

Test that attempting to remove a view that does not exist fails as expected.

Definition at line 1582 of file embedder_unittests.cc.

                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
  FlutterRemoveViewInfo info = {};
  info.struct_size = sizeof(FlutterRemoveViewInfo);
  info.view_id = 123;
  info.user_data = &latch;
  info.remove_view_callback = [](const FlutterRemoveViewResult* result) {
    EXPECT_FALSE(result->removed);
    reinterpret_cast<fml::AutoResetWaitableEvent*>(result->user_data)->Signal();
  };
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &info), kSuccess);
  latch.Wait();
}

◆ TEST_F() [359/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanPostTaskToAllNativeThreads
	)

Definition at line 2221 of file embedder_unittests.cc.

                                                    {
  UniqueEngine engine;
  size_t worker_count = 0;
  fml::AutoResetWaitableEvent sync_latch;
 
  // One of the threads that the callback will be posted to is the platform
  // thread. So we cannot wait for assertions to complete on the platform
  // thread. Create a new thread to manage the engine instance and wait for
  // assertions on the test thread.
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
 
    engine = builder.LaunchEngine();
 
    ASSERT_TRUE(engine.is_valid());
 
    worker_count = ToEmbedderEngine(engine.get())
                       ->GetShell()
                       .GetDartVM()
                       ->GetConcurrentMessageLoop()
                       ->GetWorkerCount();
 
    sync_latch.Signal();
  });
 
  sync_latch.Wait();
 
  const auto engine_threads_count = worker_count + 4u;
 
  struct Captures {
    // Waits the adequate number of callbacks to fire.
    fml::CountDownLatch latch;
 
    // This class will be accessed from multiple threads concurrently to track
    // thread specific information that is later checked. All updates to fields
    // in this struct must be made with this mutex acquired.
 
    std::mutex captures_mutex;
    // Ensures that the expect number of distinct threads were serviced.
    std::set<std::thread::id> thread_ids;
 
    size_t platform_threads_count = 0;
    size_t render_threads_count = 0;
    size_t ui_threads_count = 0;
    size_t worker_threads_count = 0;
 
    explicit Captures(size_t count) : latch(count) {}
  };
 
  Captures captures(engine_threads_count);
 
  platform_task_runner->PostTask([&]() {
    ASSERT_EQ(FlutterEnginePostCallbackOnAllNativeThreads(
                  engine.get(),
                  [](FlutterNativeThreadType type, void* baton) {
                    auto captures = reinterpret_cast<Captures*>(baton);
                    {
                      std::scoped_lock lock(captures->captures_mutex);
                      switch (type) {
                        case kFlutterNativeThreadTypeRender:
                          captures->render_threads_count++;
                          break;
                        case kFlutterNativeThreadTypeWorker:
                          captures->worker_threads_count++;
                          break;
                        case kFlutterNativeThreadTypeUI:
                          captures->ui_threads_count++;
                          break;
                        case kFlutterNativeThreadTypePlatform:
                          captures->platform_threads_count++;
                          break;
                      }
                      captures->thread_ids.insert(std::this_thread::get_id());
                    }
                    captures->latch.CountDown();
                  },
                  &captures),
              kSuccess);
  });
 
  captures.latch.Wait();
  ASSERT_EQ(captures.thread_ids.size(), engine_threads_count);
  ASSERT_EQ(captures.platform_threads_count, 1u);
  ASSERT_EQ(captures.render_threads_count, 1u);
  ASSERT_EQ(captures.ui_threads_count, 1u);
  ASSERT_EQ(captures.worker_threads_count, worker_count + 1u /* for IO */);
  EXPECT_GE(captures.worker_threads_count - 1, 2u);
  EXPECT_LE(captures.worker_threads_count - 1, 4u);
 
  platform_task_runner->PostTask([&]() {
    engine.reset();
    sync_latch.Signal();
  });
  sync_latch.Wait();
 
  // The engine should have already been destroyed on the platform task runner.
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [360/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanQueryDartAOTMode
	)

Definition at line 2074 of file embedder_unittests.cc.

                                          {
  ASSERT_EQ(FlutterEngineRunsAOTCompiledDartCode(),
            flutter::DartVM::IsRunningPrecompiledCode());
}

◆ TEST_F() [361/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanReloadSystemFonts
	)

Definition at line 276 of file embedder_unittests.cc.

                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  auto result = FlutterEngineReloadSystemFonts(engine.get());
  ASSERT_EQ(result, kSuccess);
}

◆ TEST_F() [362/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRemoveView
	)

Test that a view that was added can be removed.

Definition at line 1364 of file embedder_unittests.cc.

                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  std::string message;
  context.AddNativeCallback("SignalNativeMessage",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              message =
                                  tonic::DartConverter<std::string>::FromDart(
                                      Dart_GetNativeArgument(args, 0));
                              message_latch.Signal();
                            }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  // Add view 123.
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 123;
 
  FlutterAddViewInfo add_info = {};
  add_info.struct_size = sizeof(FlutterAddViewInfo);
  add_info.view_id = 123;
  add_info.view_metrics = &metrics;
  add_info.add_view_callback = [](const FlutterAddViewResult* result) {
    ASSERT_TRUE(result->added);
  };
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0, 123]");
 
  // Remove view 123.
  FlutterRemoveViewInfo remove_info = {};
  remove_info.struct_size = sizeof(FlutterAddViewInfo);
  remove_info.view_id = 123;
  remove_info.remove_view_callback = [](const FlutterRemoveViewResult* result) {
    EXPECT_TRUE(result->removed);
  };
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &remove_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0]");
}

◆ TEST_F() [363/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderGradientWithCompositorOnNonRootLayerWithXform
	)

Definition at line 1814 of file embedder_gl_unittests.cc.

                                                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  // This must match the transformation provided in the
  // |CanRenderGradientWithoutCompositorWithXform| test to ensure that
  // transforms are consistent respected.
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient_on_non_root_backing_store");
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 800));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(200.0, 100.0);
          layer.offset = FlutterPointMake(0.0, 700.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer,
          GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            FML_CHECK(layer.size.width == 200);
            FML_CHECK(layer.size.height == 100);
            // This is occluded anyway. We just want to make sure we see this.
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  // Flutter still thinks it is 800 x 600.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("gradient_xform.png", rendered_scene));
}

◆ TEST_F() [364/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderGradientWithCompositorWithXform
	)

Definition at line 1643 of file embedder_gl_unittests.cc.

                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  // This must match the transformation provided in the
  // |CanRenderGradientWithoutCompositorWithXform| test to ensure that
  // transforms are consistent respected.
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient");
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 800));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  // Flutter still thinks it is 800 x 600.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("gradient_xform.png", rendered_scene));
}

◆ TEST_F() [365/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderGradientWithMetal
	)

Definition at line 38 of file embedder_metal_unittests.mm.

                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient");
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
 
  // TODO (https://github.com/flutter/flutter/issues/73590): re-enable once
  // we are able to figure out why this fails on the bots.
  // ASSERT_TRUE(ImageMatchesFixture("gradient_metal.png", rendered_scene));
}

◆ TEST_F() [366/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderGradientWithoutCompositorWithXform
	)

Definition at line 1581 of file embedder_gl_unittests.cc.

                                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  EmbedderConfigBuilder builder(context);
 
  const auto surface_size = SkISize::Make(600, 800);
 
  builder.SetDartEntrypoint("render_gradient");
  builder.SetOpenGLRendererConfig(surface_size);
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  // Flutter still thinks it is 800 x 600.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("gradient_xform.png", rendered_scene));
}

◆ TEST_F() [367/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderImplicitView
	)

Definition at line 644 of file embedder_unittests.cc.

                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("render_implicit_view");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::AutoResetWaitableEvent latch;
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(view_id, kFlutterImplicitViewId);
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
}

◆ TEST_F() [368/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderImplicitViewUsingPresentLayersCallback
	)

Definition at line 676 of file embedder_unittests.cc.

                                                                      {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor(/* avoid_backing_store_cache = */ false,
                        /* use_present_layers_callback = */ true);
  builder.SetDartEntrypoint("render_implicit_view");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::AutoResetWaitableEvent latch;
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(view_id, kFlutterImplicitViewId);
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
}

◆ TEST_F() [369/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderMultipleViews
	)

Test the engine can present to multiple views.

Definition at line 1755 of file embedder_unittests.cc.

                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetCompositor();
  builder.SetDartEntrypoint("render_all_views");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::AutoResetWaitableEvent latch0, latch123;
  context.GetCompositor().SetPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        switch (view_id) {
          case 0:
            latch0.Signal();
            break;
          case 123:
            latch123.Signal();
            break;
          default:
            FML_UNREACHABLE();
        }
      },
      /* one_shot= */ false);
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Give the implicit view a non-zero size so that it renders something.
  FlutterWindowMetricsEvent metrics0 = {};
  metrics0.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics0.width = 800;
  metrics0.height = 600;
  metrics0.pixel_ratio = 1.0;
  metrics0.view_id = 0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &metrics0),
            kSuccess);
 
  // Add view 123.
  FlutterWindowMetricsEvent metrics123 = {};
  metrics123.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics123.width = 800;
  metrics123.height = 600;
  metrics123.pixel_ratio = 1.0;
  metrics123.view_id = 123;
 
  FlutterAddViewInfo add_view_info = {};
  add_view_info.struct_size = sizeof(FlutterAddViewInfo);
  add_view_info.view_id = 123;
  add_view_info.view_metrics = &metrics123;
  add_view_info.add_view_callback = [](const FlutterAddViewResult* result) {
    ASSERT_TRUE(result->added);
  };
 
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_view_info), kSuccess);
 
  latch0.Wait();
  latch123.Wait();
}

◆ TEST_F() [370/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderSceneWithoutCustomCompositor
	)

Definition at line 1495 of file embedder_gl_unittests.cc.

                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("scene_without_custom_compositor.png",
                                  rendered_scene));
}

◆ TEST_F() [371/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderSceneWithoutCustomCompositorMetal
	)

Definition at line 242 of file embedder_metal_unittests.mm.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("scene_without_custom_compositor.png", rendered_scene));
}

◆ TEST_F() [372/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderSceneWithoutCustomCompositorWithTransformation
	)

Definition at line 1521 of file embedder_gl_unittests.cc.

                                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 800));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
 
  // Flutter still thinks it is 800 x 600.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture(
      "scene_without_custom_compositor_with_xform.png", rendered_scene));
}

◆ TEST_F() [373/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRenderWithImpellerOpenGL
	)

Definition at line 4749 of file embedder_gl_unittests.cc.

                                                  {
  EmbedderTestContextGL& context = static_cast<EmbedderTestContextGL&>(
      GetEmbedderContext(EmbedderTestContextType::kOpenGLContext));
  EmbedderConfigBuilder builder(context);
 
  bool present_called = false;
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&present_called](FlutterPresentInfo present_info) {
        present_called = true;
      });
 
  builder.AddCommandLineArgument("--enable-impeller");
  builder.SetDartEntrypoint("render_impeller_gl_test");
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Bind to an arbitrary FBO in order to verify that Impeller binds to the
  // provided FBO during rendering.
  typedef void (*glGenFramebuffersProc)(GLsizei n, GLuint* ids);
  typedef void (*glBindFramebufferProc)(GLenum target, GLuint framebuffer);
  auto glGenFramebuffers = reinterpret_cast<glGenFramebuffersProc>(
      context.GLGetProcAddress("glGenFramebuffers"));
  auto glBindFramebuffer = reinterpret_cast<glBindFramebufferProc>(
      context.GLGetProcAddress("glBindFramebuffer"));
  const flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  fml::AutoResetWaitableEvent raster_event;
  shell.GetTaskRunners().GetRasterTaskRunner()->PostTask([&] {
    GLuint fbo;
    glGenFramebuffers(1, &fbo);
    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    raster_event.Signal();
  });
  raster_event.Wait();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture(
      FixtureNameForBackend(EmbedderTestContextType::kOpenGLContext,
                            "impeller_gl_test.png"),
      rendered_scene));
 
  // The scene will be rendered by the compositor, and the surface present
  // callback should not be invoked.
  ASSERT_FALSE(present_called);
}

◆ TEST_F() [374/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanReuseViewIds
	)

Test that a removed view's ID can be reused to add a new view.

Definition at line 1517 of file embedder_unittests.cc.

                                      {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  std::string message;
  context.AddNativeCallback("SignalNativeMessage",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              message =
                                  tonic::DartConverter<std::string>::FromDart(
                                      Dart_GetNativeArgument(args, 0));
                              message_latch.Signal();
                            }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  // Add view 123.
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 123;
 
  FlutterAddViewInfo add_info = {};
  add_info.struct_size = sizeof(FlutterAddViewInfo);
  add_info.view_id = 123;
  add_info.view_metrics = &metrics;
  add_info.add_view_callback = [](const FlutterAddViewResult* result) {
    ASSERT_TRUE(result->added);
  };
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0, 123]");
 
  // Remove view 123.
  FlutterRemoveViewInfo remove_info = {};
  remove_info.struct_size = sizeof(FlutterAddViewInfo);
  remove_info.view_id = 123;
  remove_info.remove_view_callback = [](const FlutterRemoveViewResult* result) {
    ASSERT_TRUE(result->removed);
  };
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &remove_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0]");
 
  // Re-add view 123.
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_info), kSuccess);
  message_latch.Wait();
  ASSERT_EQ(message, "View IDs: [0, 123]");
}

◆ TEST_F() [375/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanRunInitializedEngine
	)

Test that an initialized engine can be run exactly once.

Definition at line 1225 of file embedder_unittests.cc.

                                              {
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
  builder.SetSoftwareRendererConfig();
  auto engine = builder.InitializeEngine();
  ASSERT_TRUE(engine.is_valid());
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
  // Cannot re-run an already running engine.
  ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kInvalidArguments);
  engine.reset();
}

◆ TEST_F() [376/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanScheduleFrame
	)

Definition at line 3365 of file embedder_unittests.cc.

                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("can_schedule_frame");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  fml::AutoResetWaitableEvent check_latch;
  context.AddNativeCallback(
      "SignalNativeCount",
      CREATE_NATIVE_ENTRY(
          [&check_latch](Dart_NativeArguments args) { check_latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Wait for the application to attach the listener.
  latch.Wait();
 
  ASSERT_EQ(FlutterEngineScheduleFrame(engine.get()), kSuccess);
 
  check_latch.Wait();
}

◆ TEST_F() [377/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSendLowMemoryNotification
	)

Definition at line 2203 of file embedder_unittests.cc.

                                                   {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  // TODO(chinmaygarde): The shell ought to have a mechanism for notification
  // dispatch that engine subsystems can register handlers to. This would allow
  // the raster cache and the secondary context caches to respond to
  // notifications. Once that is in place, this test can be updated to actually
  // ensure that the dispatched message is visible to engine subsystems.
  ASSERT_EQ(FlutterEngineNotifyLowMemoryWarning(engine.get()), kSuccess);
}

◆ TEST_F() [378/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSendPointer
	)

Send a pointer event to Dart and wait until the Dart code signals it received the event.

Definition at line 3480 of file embedder_unittests.cc.

                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("pointer_data_packet");
 
  fml::AutoResetWaitableEvent ready_latch, count_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
  context.AddNativeCallback(
      "SignalNativeCount",
      CREATE_NATIVE_ENTRY([&count_latch](Dart_NativeArguments args) {
        int count = tonic::DartConverter<int>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ(count, 1);
        count_latch.Signal();
      }));
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("PointerData(viewId: 0, x: 123.0, y: 456.0)", message);
        message_latch.Signal();
      }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  FlutterPointerEvent pointer_event = {};
  pointer_event.struct_size = sizeof(FlutterPointerEvent);
  pointer_event.phase = FlutterPointerPhase::kAdd;
  pointer_event.x = 123;
  pointer_event.y = 456;
  pointer_event.timestamp = static_cast<size_t>(1234567890);
  pointer_event.view_id = 0;
 
  FlutterEngineResult result =
      FlutterEngineSendPointerEvent(engine.get(), &pointer_event, 1);
  ASSERT_EQ(result, kSuccess);
 
  count_latch.Wait();
  message_latch.Wait();
}

◆ TEST_F() [379/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSendPointerEventWithViewId
	)

Send a pointer event to Dart and wait until the Dart code echos with the view ID.

Definition at line 3531 of file embedder_unittests.cc.

                                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("pointer_data_packet_view_id");
 
  fml::AutoResetWaitableEvent ready_latch, add_view_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("ViewID: 2", message);
        message_latch.Signal();
      }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  ready_latch.Wait();
 
  // Add view 2
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 800;
  metrics.height = 600;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = 2;
 
  FlutterAddViewInfo info = {};
  info.struct_size = sizeof(FlutterAddViewInfo);
  info.view_id = 2;
  info.view_metrics = &metrics;
  info.add_view_callback = [](const FlutterAddViewResult* result) {
    EXPECT_TRUE(result->added);
    fml::AutoResetWaitableEvent* add_view_latch =
        reinterpret_cast<fml::AutoResetWaitableEvent*>(result->user_data);
    add_view_latch->Signal();
  };
  info.user_data = &add_view_latch;
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &info), kSuccess);
  add_view_latch.Wait();
 
  // Send a pointer event for view 2
  FlutterPointerEvent pointer_event = {};
  pointer_event.struct_size = sizeof(FlutterPointerEvent);
  pointer_event.phase = FlutterPointerPhase::kAdd;
  pointer_event.x = 123;
  pointer_event.y = 456;
  pointer_event.timestamp = static_cast<size_t>(1234567890);
  pointer_event.view_id = 2;
 
  FlutterEngineResult result =
      FlutterEngineSendPointerEvent(engine.get(), &pointer_event, 1);
  ASSERT_EQ(result, kSuccess);
 
  message_latch.Wait();
}

◆ TEST_F() [380/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSetCustomLogMessageCallback
	)

Tests that setting a custom log callback works as expected and defaults to using tag "flutter".

Definition at line 535 of file embedder_unittests.cc.

                                                     {
  fml::AutoResetWaitableEvent callback_latch;
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetDartEntrypoint("custom_logger");
  builder.SetSoftwareRendererConfig();
  context.SetLogMessageCallback(
      [&callback_latch](const char* tag, const char* message) {
        EXPECT_EQ(std::string(tag), "flutter");
        EXPECT_EQ(std::string(message), "hello world");
        callback_latch.Signal();
      });
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  callback_latch.Wait();
}

◆ TEST_F() [381/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSetCustomLogTag
	)

Tests that setting a custom log tag works.

Definition at line 554 of file embedder_unittests.cc.

                                         {
  fml::AutoResetWaitableEvent callback_latch;
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetDartEntrypoint("custom_logger");
  builder.SetSoftwareRendererConfig();
  builder.SetLogTag("butterfly");
  context.SetLogMessageCallback(
      [&callback_latch](const char* tag, const char* message) {
        EXPECT_EQ(std::string(tag), "butterfly");
        EXPECT_EQ(std::string(message), "hello world");
        callback_latch.Signal();
      });
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  callback_latch.Wait();
}

◆ TEST_F() [382/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSetNextFrameCallback
	)

Definition at line 3393 of file embedder_unittests.cc.

                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("draw_solid_red");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Register the callback that is executed once the next frame is drawn.
  fml::AutoResetWaitableEvent callback_latch;
  VoidCallback callback = [](void* user_data) {
    fml::AutoResetWaitableEvent* callback_latch =
        static_cast<fml::AutoResetWaitableEvent*>(user_data);
 
    callback_latch->Signal();
  };
 
  auto result = FlutterEngineSetNextFrameCallback(engine.get(), callback,
                                                  &callback_latch);
  ASSERT_EQ(result, kSuccess);
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  callback_latch.Wait();
}

◆ TEST_F() [383/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSpecifyCustomPlatformTaskRunner
	)

Definition at line 204 of file embedder_unittests.cc.

                                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  fml::AutoResetWaitableEvent latch;
 
  // Run the test on its own thread with a message loop so that it can safely
  // pump its event loop while we wait for all the conditions to be checked.
  auto platform_task_runner = CreateNewThread("test_platform_thread");
  static std::mutex engine_mutex;
  static bool signaled_once = false;
  UniqueEngine engine;
 
  EmbedderTestTaskRunner test_task_runner(
      platform_task_runner, [&](FlutterTask task) {
        std::scoped_lock lock(engine_mutex);
        if (!engine.is_valid()) {
          return;
        }
        // There may be multiple tasks posted but we only need to check
        // assertions once.
        if (signaled_once) {
          FlutterEngineRunTask(engine.get(), &task);
          return;
        }
 
        signaled_once = true;
        ASSERT_TRUE(engine.is_valid());
        ASSERT_EQ(FlutterEngineRunTask(engine.get(), &task), kSuccess);
        latch.Signal();
      });
 
  platform_task_runner->PostTask([&]() {
    EmbedderConfigBuilder builder(context);
    const auto task_runner_description =
        test_task_runner.GetFlutterTaskRunnerDescription();
    builder.SetSoftwareRendererConfig();
    builder.SetPlatformTaskRunner(&task_runner_description);
    builder.SetDartEntrypoint("invokePlatformTaskRunner");
    std::scoped_lock lock(engine_mutex);
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
  });
 
  // Signaled when all the assertions are checked.
  latch.Wait();
  ASSERT_TRUE(engine.is_valid());
 
  // Since the engine was started on its own thread, it must be killed there as
  // well.
  fml::AutoResetWaitableEvent kill_latch;
  platform_task_runner->PostTask(fml::MakeCopyable([&]() mutable {
    std::scoped_lock lock(engine_mutex);
    engine.reset();
 
    // There may still be pending tasks on the platform thread that were queued
    // by the test_task_runner.  Signal the latch after these tasks have been
    // consumed.
    platform_task_runner->PostTask([&kill_latch] { kill_latch.Signal(); });
  }));
  kill_latch.Wait();
 
  ASSERT_TRUE(signaled_once);
  signaled_once = false;
}

◆ TEST_F() [384/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSuccessfullyPopulateSpecificJITSnapshotCallbacks
	)

PopulateJITSnapshotMappingCallbacks should successfully change the callbacks of the snapshots in the engine's settings when JIT snapshots are explicitly defined.

Definition at line 2448 of file embedder_unittests.cc.

                                                                          {
// TODO(#107263): Inconsistent snapshot paths in the Linux Fuchsia FEMU test.
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Inconsistent paths in Fuchsia.";
#else
 
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // Construct the location of valid JIT snapshots.
  const std::string src_path = GetSourcePath();
  const std::string vm_snapshot_data =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_DATA});
  const std::string vm_snapshot_instructions =
      fml::paths::JoinPaths({src_path, TEST_VM_SNAPSHOT_INSTRUCTIONS});
  const std::string isolate_snapshot_data =
      fml::paths::JoinPaths({src_path, TEST_ISOLATE_SNAPSHOT_DATA});
  const std::string isolate_snapshot_instructions =
      fml::paths::JoinPaths({src_path, TEST_ISOLATE_SNAPSHOT_INSTRUCTIONS});
 
  // Explicitly define the locations of the JIT snapshots
  builder.GetProjectArgs().vm_snapshot_data =
      reinterpret_cast<const uint8_t*>(vm_snapshot_data.c_str());
  builder.GetProjectArgs().vm_snapshot_instructions =
      reinterpret_cast<const uint8_t*>(vm_snapshot_instructions.c_str());
  builder.GetProjectArgs().isolate_snapshot_data =
      reinterpret_cast<const uint8_t*>(isolate_snapshot_data.c_str());
  builder.GetProjectArgs().isolate_snapshot_instructions =
      reinterpret_cast<const uint8_t*>(isolate_snapshot_instructions.c_str());
 
  auto engine = builder.LaunchEngine();
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  const Settings settings = shell.GetSettings();
 
  ASSERT_NE(settings.vm_snapshot_data(), nullptr);
  ASSERT_NE(settings.vm_snapshot_instr(), nullptr);
  ASSERT_NE(settings.isolate_snapshot_data(), nullptr);
  ASSERT_NE(settings.isolate_snapshot_instr(), nullptr);
  ASSERT_NE(settings.dart_library_sources_kernel(), nullptr);
#endif  // OS_FUCHSIA
}

◆ TEST_F() [385/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanSwapOutVulkanCalls
	)

Definition at line 98 of file embedder_vk_unittests.cc.

                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kVulkanContext);
  fml::AutoResetWaitableEvent latch;
  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
  EmbedderConfigBuilder builder(context);
  builder.SetVulkanRendererConfig(
      SkISize::Make(1024, 1024),
      [](void* user_data, FlutterVulkanInstanceHandle instance,
         const char* name) -> void* {
        if (StrcmpFixed(name, "vkGetInstanceProcAddr") == 0) {
          g_vulkan_proc_info.get_instance_proc_addr =
              reinterpret_cast<decltype(vkGetInstanceProcAddr)*>(
                  EmbedderTestContextVulkan::InstanceProcAddr(user_data,
                                                              instance, name));
          return reinterpret_cast<void*>(GetInstanceProcAddr);
        }
        return EmbedderTestContextVulkan::InstanceProcAddr(user_data, instance,
                                                           name);
      });
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  // Wait for the root isolate to launch.
  latch.Wait();
  engine.reset();
  EXPECT_TRUE(g_vulkan_proc_info.did_call_queue_submit);
}

◆ TEST_F() [386/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanTerminateCleanly
	)

Definition at line 147 of file embedder_unittests.cc.

                                          {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("terminateExitCodeHandler");
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [387/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CanUpdateLocales
	)

Definition at line 1988 of file embedder_unittests.cc.

                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("can_receive_locale_updates");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  fml::AutoResetWaitableEvent check_latch;
  context.AddNativeCallback(
      "SignalNativeCount",
      CREATE_NATIVE_ENTRY([&check_latch](Dart_NativeArguments args) {
        ASSERT_EQ(tonic::DartConverter<int>::FromDart(
                      Dart_GetNativeArgument(args, 0)),
                  2);
        check_latch.Signal();
      }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Wait for the application to attach the listener.
  latch.Wait();
 
  FlutterLocale locale1 = {};
  locale1.struct_size = sizeof(locale1);
  locale1.language_code = "";  // invalid
  locale1.country_code = "US";
  locale1.script_code = "";
  locale1.variant_code = nullptr;
 
  FlutterLocale locale2 = {};
  locale2.struct_size = sizeof(locale2);
  locale2.language_code = "zh";
  locale2.country_code = "CN";
  locale2.script_code = "Hans";
  locale2.variant_code = nullptr;
 
  std::vector<const FlutterLocale*> locales;
  locales.push_back(&locale1);
  locales.push_back(&locale2);
 
  ASSERT_EQ(
      FlutterEngineUpdateLocales(engine.get(), locales.data(), locales.size()),
      kInvalidArguments);
 
  // Fix the invalid code.
  locale1.language_code = "en";
 
  ASSERT_EQ(
      FlutterEngineUpdateLocales(engine.get(), locales.data(), locales.size()),
      kSuccess);
 
  check_latch.Wait();
}

◆ TEST_F() [388/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ClipsAreCorrectlyCalculated
	)

Definition at line 2946 of file embedder_gl_unittests.cc.

                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(400, 300));
  builder.SetCompositor();
  builder.SetDartEntrypoint("scene_builder_with_clips");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 400).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  fml::AutoResetWaitableEvent latch;
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        {
          FlutterPlatformView platform_view = *layers[0]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(300.0, 400.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[0], layer);
 
          bool clip_assertions_checked = false;
 
          // The total transformation on the stack upto the platform view.
          const auto total_xformation =
              GetTotalMutationTransformationMatrix(layers[0]->platform_view);
 
          FilterMutationsByType(
              layers[0]->platform_view,
              kFlutterPlatformViewMutationTypeClipRect,
              [&](const auto& mutation) {
                FlutterRect clip = mutation.clip_rect;
 
                // The test is only set up to supply one clip. Make sure it is
                // the one we expect.
                const auto rect_to_compare =
                    SkRect::MakeLTRB(10.0, 10.0, 390, 290);
                ASSERT_EQ(clip, FlutterRectMake(rect_to_compare));
 
                // This maps the clip from device space into surface space.
                SkRect mapped;
                ASSERT_TRUE(total_xformation.mapRect(&mapped, rect_to_compare));
                ASSERT_EQ(mapped, SkRect::MakeLTRB(10, 10, 290, 390));
                clip_assertions_checked = true;
              });
 
          ASSERT_TRUE(clip_assertions_checked);
        }
 
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 400;
  event.height = 300;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [389/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ComplexClipsAreCorrectlyCalculated
	)

Definition at line 3026 of file embedder_gl_unittests.cc.

                                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1024, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("scene_builder_with_complex_clips");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 1024).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  fml::AutoResetWaitableEvent latch;
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        {
          FlutterPlatformView platform_view = *layers[0]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(600.0, 1024.0);
          layer.offset = FlutterPointMake(0.0, -256.0);
 
          ASSERT_EQ(*layers[0], layer);
 
          const auto** mutations = platform_view.mutations;
 
          ASSERT_EQ(mutations[0]->type,
                    kFlutterPlatformViewMutationTypeTransformation);
          ASSERT_EQ(SkMatrixMake(mutations[0]->transformation),
                    root_surface_transformation);
 
          ASSERT_EQ(mutations[1]->type,
                    kFlutterPlatformViewMutationTypeClipRect);
          ASSERT_EQ(SkRectMake(mutations[1]->clip_rect),
                    SkRect::MakeLTRB(0.0, 0.0, 1024.0, 600.0));
 
          ASSERT_EQ(mutations[2]->type,
                    kFlutterPlatformViewMutationTypeTransformation);
          ASSERT_EQ(SkMatrixMake(mutations[2]->transformation),
                    SkMatrix::Translate(512.0, 0.0));
 
          ASSERT_EQ(mutations[3]->type,
                    kFlutterPlatformViewMutationTypeClipRect);
          ASSERT_EQ(SkRectMake(mutations[3]->clip_rect),
                    SkRect::MakeLTRB(0.0, 0.0, 512.0, 600.0));
 
          ASSERT_EQ(mutations[4]->type,
                    kFlutterPlatformViewMutationTypeTransformation);
          ASSERT_EQ(SkMatrixMake(mutations[4]->transformation),
                    SkMatrix::Translate(-256.0, 0.0));
 
          ASSERT_EQ(mutations[5]->type,
                    kFlutterPlatformViewMutationTypeClipRect);
          ASSERT_EQ(SkRectMake(mutations[5]->clip_rect),
                    SkRect::MakeLTRB(0.0, 0.0, 1024.0, 600.0));
        }
 
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [390/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorCanPostOnlyPlatformViews
	)

Definition at line 3344 of file embedder_gl_unittests.cc.

                                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(300, 200));
  builder.SetCompositor();
  builder.SetDartEntrypoint("compositor_can_post_only_platform_views");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::AutoResetWaitableEvent latch;
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer 0
        {
          FlutterPlatformView platform_view = *layers[0]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(300.0, 200.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 24;
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(300.0, 200.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
 
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 0u);
}

◆ TEST_F() [391/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorCanPostZeroLayersForPresentation
	)

Definition at line 3310 of file embedder_gl_unittests.cc.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(300, 200));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene_posts_zero_layers_to_compositor");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::AutoResetWaitableEvent latch;
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 0u);
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
 
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 0u);
}

◆ TEST_F() [392/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderKnownScene
	)

Test the layer structure and pixels rendered when using a custom compositor.

Definition at line 686 of file embedder_gl_unittests.cc.

                                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(5);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 5u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(30, 30, 80, 180),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        // Layer 3
        {
          FlutterPlatformView platform_view = *layers[3]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 2;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(40.0, 40.0);
 
          ASSERT_EQ(*layers[3], layer);
        }
 
        // Layer 4
        {
          FlutterBackingStore backing_store = *layers[4]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(50, 50, 100, 200),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[4], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer,
          GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          case 2: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorMAGENTA);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture("compositor.png", scene_image));
 
  // There should no present calls on the root surface.
  ASSERT_EQ(context.GetSurfacePresentCount(), 0u);
}

◆ TEST_F() [393/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderKnownSceneMetal
	)

Definition at line 316 of file embedder_metal_unittests.mm.

                                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
 
  builder.SetRenderTargetType(EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture);
 
  fml::CountDownLatch latch(5);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers, size_t layers_count) {
        ASSERT_EQ(layers_count, 5u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeMetal;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeMetal;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(30, 30, 80, 180),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        // Layer 3
        {
          FlutterPlatformView platform_view = *layers[3]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 2;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(40.0, 40.0);
 
          ASSERT_EQ(*layers[3], layer);
        }
 
        // Layer 4
        {
          FlutterBackingStore backing_store = *layers[4]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeMetal;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(50, 50, 100, 200),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[4], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer, GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect = SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          case 2: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorMAGENTA);
            paint.setAlpha(127);
            const auto& rect = SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false) << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  // Flutter still thinks it is 800 x 600. Only the root surface is rotated.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture("compositor.png", scene_image));
}

◆ TEST_F() [394/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurfaceWithRootSurfaceXformation
	)

Definition at line 2309 of file embedder_gl_unittests.cc.

                                                                                        {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 800));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_display_platform_view_with_pixel_ratio");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto rendered_scene = context.GetNextSceneImage();
  fml::CountDownLatch latch(1);
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(560.0, 800.0);
          layer.offset = FlutterPointMake(40.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 400 * 2.0;
  event.height = 300 * 2.0;
  event.pixel_ratio = 2.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture("dpr_xform.png", rendered_scene));
}

◆ TEST_F() [395/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderKnownSceneWithRootSurfaceTransformation
	)

Test the layer structure and pixels rendered when using a custom compositor with a root surface transformation.

Definition at line 1277 of file embedder_gl_unittests.cc.

                                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 800));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  // This must match the transformation provided in the
  // |CanRenderGradientWithoutCompositorWithXform| test to ensure that
  // transforms are consistent respected.
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  fml::CountDownLatch latch(5);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 5u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(150.0, 50.0);
          layer.offset = FlutterPointMake(20.0, 730.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(30, 720, 180, 770),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        // Layer 3
        {
          FlutterPlatformView platform_view = *layers[3]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 2;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(150.0, 50.0);
          layer.offset = FlutterPointMake(40.0, 710.0);
 
          ASSERT_EQ(*layers[3], layer);
        }
 
        // Layer 4
        {
          FlutterBackingStore backing_store = *layers[4]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(50, 700, 200, 750),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[4], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer,
          GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          case 2: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorMAGENTA);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  // Flutter still thinks it is 800 x 600. Only the root surface is rotated.
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture("compositor_root_surface_xformation.png",
                                  scene_image));
}

◆ TEST_F() [396/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderKnownSceneWithSoftwareCompositor
	)

Test the layer structure and pixels rendered when using a custom software compositor.

Definition at line 718 of file embedder_unittests.cc.

                                                                     {
#endif  // FML_OS_MACOSX && FML_ARCH_CPU_ARM64
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::CountDownLatch latch(5);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 5u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          backing_store.software.height = 600;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          backing_store.software.height = 600;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(30, 30, 80, 180),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        // Layer 3
        {
          FlutterPlatformView platform_view = *layers[3]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 2;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(40.0, 40.0);
 
          ASSERT_EQ(*layers[3], layer);
        }
 
        // Layer 4
        {
          FlutterBackingStore backing_store = *layers[4]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          backing_store.software.height = 600;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(50, 50, 100, 200),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[4], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer, GrDirectContext*
          /* don't use because software compositor */) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(
            layer, nullptr /* null because software compositor */);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          case 2: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorMAGENTA);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture("compositor_software.png", scene_image));
 
  // There should no present calls on the root surface.
  ASSERT_EQ(context.GetSurfacePresentCount(), 0u);
}

◆ TEST_F() [397/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderToOpenGLFramebuffer
	)

Must be able to render to a custom compositor whose render targets are fully complete OpenGL textures.

Definition at line 105 of file embedder_gl_unittests.cc.

                                                                      {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  fml::CountDownLatch latch(3);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [398/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderToOpenGLTexture
	)

Must be able to render using a custom compositor whose render targets for the individual layers are OpenGL textures.

Definition at line 444 of file embedder_gl_unittests.cc.

                                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(3);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [399/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderToSoftwareBuffer
	)

Must be able to render using a custom compositor whose render target for the individual layers are software buffers.

Definition at line 565 of file embedder_gl_unittests.cc.

                                                                   {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::CountDownLatch latch(3);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          ASSERT_FLOAT_EQ(
              backing_store.software.row_bytes * backing_store.software.height,
              800 * 4 * 600.0);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [400/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderWithPlatformLayerOnBottom
	)

Test the layer structure and pixels rendered when using a custom compositor and ensure that a redundant layer is not added.

Definition at line 1150 of file embedder_gl_unittests.cc.

                                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint(
      "can_composite_platform_views_with_platform_layer_on_bottom");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(3);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer,
          GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture(
      "compositor_with_platform_layer_on_bottom.png", scene_image));
 
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 1u);
}

◆ TEST_F() [401/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorMustBeAbleToRenderWithRootLayerOnly
	)

Test the layer structure and pixels rendered when using a custom compositor and a single layer.

Definition at line 1068 of file embedder_gl_unittests.cc.

                                                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint(
      "can_composite_platform_views_with_root_layer_only");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(3);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 1u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        latch.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(
      ImageMatchesFixture("compositor_with_root_layer_only.png", scene_image));
}

◆ TEST_F() [402/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorRenderTargetsAreInStableOrder
	)

Definition at line 3454 of file embedder_gl_unittests.cc.

                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(300, 200));
  builder.SetCompositor();
  builder.SetDartEntrypoint("render_targets_are_in_stable_order");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(2);
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              latch.CountDown();
                            }));
 
  size_t frame_count = 0;
  std::vector<void*> first_frame_backing_store_user_data;
  context.GetCompositor().SetPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 20u);
 
        if (first_frame_backing_store_user_data.empty()) {
          for (size_t i = 0; i < layers_count; ++i) {
            if (layers[i]->type == kFlutterLayerContentTypeBackingStore) {
              first_frame_backing_store_user_data.push_back(
                  layers[i]->backing_store->user_data);
            }
          }
          return;
        }
 
        ASSERT_EQ(first_frame_backing_store_user_data.size(), 10u);
 
        frame_count++;
        std::vector<void*> backing_store_user_data;
        for (size_t i = 0; i < layers_count; ++i) {
          if (layers[i]->type == kFlutterLayerContentTypeBackingStore) {
            backing_store_user_data.push_back(
                layers[i]->backing_store->user_data);
          }
        }
 
        ASSERT_EQ(backing_store_user_data.size(), 10u);
 
        ASSERT_EQ(first_frame_backing_store_user_data, backing_store_user_data);
 
        if (frame_count == 20) {
          latch.CountDown();
        }
      },
      false  // one shot
  );
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [403/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorRenderTargetsAreRecycled
	)

Definition at line 3408 of file embedder_gl_unittests.cc.

                                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(300, 200));
  builder.SetCompositor();
  builder.SetDartEntrypoint("render_targets_are_recycled");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(2);
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              latch.CountDown();
                            }));
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 20u);
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 10u);
  ASSERT_EQ(context.GetCompositor().GetBackingStoresCreatedCount(), 10u);
  ASSERT_EQ(context.GetCompositor().GetBackingStoresCollectedCount(), 0u);
  // Killing the engine should immediately collect all pending render targets.
  engine.reset();
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 0u);
  ASSERT_EQ(context.GetCompositor().GetBackingStoresCreatedCount(), 10u);
  ASSERT_EQ(context.GetCompositor().GetBackingStoresCollectedCount(), 10u);
}

◆ TEST_F() [404/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CompositorRenderTargetsNotRecycledWhenAvoidsCacheSet
	)

Definition at line 4263 of file embedder_gl_unittests.cc.

                                                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(300, 200));
  builder.SetCompositor(/*avoid_backing_store_cache=*/true);
  builder.SetDartEntrypoint("render_targets_are_recycled");
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  const unsigned num_frames = 8;
  const unsigned num_engine_layers = 10;
  const unsigned num_backing_stores = num_frames * num_engine_layers;
  fml::CountDownLatch latch(1 + num_frames);  // 1 for native test signal.
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              latch.CountDown();
                            }));
 
  context.GetCompositor().SetPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 20u);
        latch.CountDown();
      },
      /*one_shot=*/false);
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 300;
  event.height = 200;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
 
  ASSERT_EQ(context.GetCompositor().GetBackingStoresCreatedCount(),
            num_backing_stores);
  // Killing the engine should collect all the frames.
  engine.reset();
  ASSERT_EQ(context.GetCompositor().GetPendingBackingStoresCount(), 0u);
}

◆ TEST_F() [405/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CreateInvalidBackingstoreMetalTexture
	)

Definition at line 513 of file embedder_metal_unittests.mm.

                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
  EmbedderConfigBuilder builder(context);
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture);
  builder.SetDartEntrypoint("invalid_backingstore");
 
  class TestCollectOnce {
   public:
    // Collect() should only be called once
    void Collect() {
      ASSERT_FALSE(collected_);
      collected_ = true;
    }
 
   private:
    bool collected_ = false;
  };
  fml::AutoResetWaitableEvent latch;
 
  builder.GetCompositor().create_backing_store_callback =
      [](const FlutterBackingStoreConfig* config,  //
         FlutterBackingStore* backing_store_out,   //
         void* user_data                           //
      ) {
        backing_store_out->type = kFlutterBackingStoreTypeMetal;
        // Deliberately set this to be invalid
        backing_store_out->user_data = nullptr;
        backing_store_out->metal.texture.texture = 0;
        backing_store_out->metal.struct_size = sizeof(FlutterMetalBackingStore);
        backing_store_out->metal.texture.user_data = new TestCollectOnce();
        backing_store_out->metal.texture.destruction_callback = [](void* user_data) {
          reinterpret_cast<TestCollectOnce*>(user_data)->Collect();
        };
        return true;
      };
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
}

◆ TEST_F() [406/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CreateInvalidBackingstoreOpenGLFramebuffer
	)

Definition at line 4467 of file embedder_gl_unittests.cc.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
  builder.SetDartEntrypoint("invalid_backingstore");
 
  class TestCollectOnce {
   public:
    // Collect() should only be called once
    void Collect() {
      ASSERT_FALSE(collected_);
      collected_ = true;
    }
 
   private:
    bool collected_ = false;
  };
  fml::AutoResetWaitableEvent latch;
 
  builder.GetCompositor().create_backing_store_callback =
      [](const FlutterBackingStoreConfig* config,  //
         FlutterBackingStore* backing_store_out,   //
         void* user_data                           //
      ) {
        backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
        // Deliberately set this to be invalid
        backing_store_out->user_data = nullptr;
        backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
        backing_store_out->open_gl.framebuffer.target = 0;
        backing_store_out->open_gl.framebuffer.name = 0;
        static TestCollectOnce collect_once_user_data;
        collect_once_user_data = {};
        backing_store_out->open_gl.framebuffer.user_data =
            &collect_once_user_data;
        backing_store_out->open_gl.framebuffer.destruction_callback =
            [](void* user_data) {
              reinterpret_cast<TestCollectOnce*>(user_data)->Collect();
            };
        return true;
      };
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
}

◆ TEST_F() [407/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CreateInvalidBackingstoreOpenGLTexture
	)

Definition at line 4404 of file embedder_gl_unittests.cc.

                                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
  builder.SetDartEntrypoint("invalid_backingstore");
 
  class TestCollectOnce {
   public:
    // Collect() should only be called once
    void Collect() {
      ASSERT_FALSE(collected_);
      collected_ = true;
    }
 
   private:
    bool collected_ = false;
  };
  fml::AutoResetWaitableEvent latch;
 
  builder.GetCompositor().create_backing_store_callback =
      [](const FlutterBackingStoreConfig* config,  //
         FlutterBackingStore* backing_store_out,   //
         void* user_data                           //
      ) {
        backing_store_out->type = kFlutterBackingStoreTypeOpenGL;
        // Deliberately set this to be invalid
        backing_store_out->user_data = nullptr;
        backing_store_out->open_gl.type = kFlutterOpenGLTargetTypeTexture;
        backing_store_out->open_gl.texture.target = 0;
        backing_store_out->open_gl.texture.name = 0;
        backing_store_out->open_gl.texture.format = 0;
        static TestCollectOnce collect_once_user_data;
        collect_once_user_data = {};
        backing_store_out->open_gl.texture.user_data = &collect_once_user_data;
        backing_store_out->open_gl.texture.destruction_callback =
            [](void* user_data) {
              reinterpret_cast<TestCollectOnce*>(user_data)->Collect();
            };
        return true;
      };
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
  latch.Wait();
}

◆ TEST_F() [408/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		CustomCompositorMustWorkWithCustomTaskRunner
	)

Custom compositor must play nicely with a custom task runner. The raster thread merging mechanism must not interfere with the custom compositor.

Definition at line 900 of file embedder_gl_unittests.cc.

                                                                   {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views");
 
  auto platform_task_runner = CreateNewThread("test_platform_thread");
  static std::mutex engine_mutex;
  UniqueEngine engine;
  fml::AutoResetWaitableEvent sync_latch;
 
  EmbedderTestTaskRunner test_task_runner(
      platform_task_runner, [&](FlutterTask task) {
        std::scoped_lock lock(engine_mutex);
        if (!engine.is_valid()) {
          return;
        }
        ASSERT_EQ(FlutterEngineRunTask(engine.get(), &task), kSuccess);
      });
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(3);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  const auto task_runner_description =
      test_task_runner.GetFlutterTaskRunnerDescription();
 
  builder.SetPlatformTaskRunner(&task_runner_description);
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  platform_task_runner->PostTask([&]() {
    std::scoped_lock lock(engine_mutex);
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
 
    // Send a window metrics events so frames may be scheduled.
    FlutterWindowMetricsEvent event = {};
    event.struct_size = sizeof(event);
    event.width = 800;
    event.height = 600;
    event.pixel_ratio = 1.0;
    ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
              kSuccess);
    ASSERT_TRUE(engine.is_valid());
    sync_latch.Signal();
  });
  sync_latch.Wait();
 
  latch.Wait();
 
  platform_task_runner->PostTask([&]() {
    std::scoped_lock lock(engine_mutex);
    engine.reset();
    sync_latch.Signal();
  });
  sync_latch.Wait();
}

◆ TEST_F() [409/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		DartEntrypointArgs
	)

Definition at line 595 of file embedder_unittests.cc.

                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.AddDartEntrypointArgument("foo");
  builder.AddDartEntrypointArgument("bar");
  builder.SetDartEntrypoint("dart_entrypoint_args");
  fml::AutoResetWaitableEvent callback_latch;
  std::vector<std::string> callback_args;
  auto nativeArgumentsCallback = [&callback_args,
                                  &callback_latch](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    callback_args =
        tonic::DartConverter<std::vector<std::string>>::FromArguments(
            args, 0, exception);
    callback_latch.Signal();
  };
  context.AddNativeCallback("NativeArgumentsCallback",
                            CREATE_NATIVE_ENTRY(nativeArgumentsCallback));
  auto engine = builder.LaunchEngine();
  callback_latch.Wait();
  ASSERT_EQ(callback_args[0], "foo");
  ASSERT_EQ(callback_args[1], "bar");
}

◆ TEST_F() [410/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		DISABLED_CanLaunchAndShutdownMultipleTimes
	)

Definition at line 80 of file embedder_unittests.cc.

                                                                 {
  EmbedderConfigBuilder builder(
      GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
  builder.SetSoftwareRendererConfig();
  for (size_t i = 0; i < 3; ++i) {
    auto engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
    FML_LOG(INFO) << "Engine launch count: " << i + 1;
  }
}

◆ TEST_F() [411/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		EmptySceneIsAcceptable
	)

Definition at line 2856 of file embedder_gl_unittests.cc.

                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [412/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ExecutableNameNotNull
	)

Definition at line 156 of file embedder_unittests.cc.

                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  // Supply a callback to Dart for the test fixture to pass Platform.executable
  // back to us.
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "NotifyStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        const auto dart_string = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        EXPECT_EQ("/path/to/binary", dart_string);
        latch.Signal();
      }));
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("executableNameNotNull");
  builder.SetExecutableName("/path/to/binary");
  auto engine = builder.LaunchEngine();
  latch.Wait();
}

◆ TEST_F() [413/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ExternalTextureGLRefreshedTooOften
	)

Definition at line 4530 of file embedder_gl_unittests.cc.

                                                         {
  TestGLSurface surface(SkISize::Make(100, 100));
  auto context = surface.GetGrContext();
 
  typedef void (*glGenTexturesProc)(uint32_t n, uint32_t* textures);
  typedef void (*glFinishProc)();
 
  glGenTexturesProc glGenTextures;
  glFinishProc glFinish;
 
  glGenTextures = reinterpret_cast<glGenTexturesProc>(
      surface.GetProcAddress("glGenTextures"));
  glFinish = reinterpret_cast<glFinishProc>(surface.GetProcAddress("glFinish"));
 
  uint32_t name;
  glGenTextures(1, &name);
 
  bool resolve_called = false;
 
  EmbedderExternalTextureGL::ExternalTextureCallback callback(
      [&](int64_t, size_t, size_t) {
        resolve_called = true;
        auto res = std::make_unique<FlutterOpenGLTexture>();
        res->target = GL_TEXTURE_2D;
        res->name = name;
        res->format = GL_RGBA8;
        res->user_data = nullptr;
        res->destruction_callback = [](void*) {};
        res->width = res->height = 100;
        return res;
      });
  EmbedderExternalTextureGL texture(1, callback);
 
  auto skia_surface = surface.GetOnscreenSurface();
  DlSkCanvasAdapter canvas(skia_surface->getCanvas());
 
  Texture* texture_ = &texture;
  Texture::PaintContext ctx{
      .canvas = &canvas,
      .gr_context = context.get(),
  };
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
                  DlImageSampling::kLinear);
 
  EXPECT_TRUE(resolve_called);
  resolve_called = false;
 
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
                  DlImageSampling::kLinear);
 
  EXPECT_FALSE(resolve_called);
 
  texture_->MarkNewFrameAvailable();
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false,
                  DlImageSampling::kLinear);
 
  EXPECT_TRUE(resolve_called);
 
  glFinish();
}

◆ TEST_F() [414/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ExternalTextureMetal
	)

Definition at line 77 of file embedder_metal_unittests.mm.

                                           {
  EmbedderTestContextMetal& context = reinterpret_cast<EmbedderTestContextMetal&>(
      GetEmbedderContext(EmbedderTestContextType::kMetalContext));
 
  const auto texture_size = SkISize::Make(800, 600);
  const int64_t texture_id = 1;
 
  TestMetalContext* metal_context = context.GetTestMetalContext();
  TestMetalContext::TextureInfo texture_info = metal_context->CreateMetalTexture(texture_size);
 
  sk_sp<SkSurface> surface =
      GetSurfaceFromTexture(metal_context->GetSkiaContext(), texture_size, texture_info.texture);
  auto canvas = surface->getCanvas();
  canvas->clear(SK_ColorRED);
  metal_context->GetSkiaContext()->flushAndSubmit();
 
  std::vector<FlutterMetalTextureHandle> textures{texture_info.texture};
 
  context.SetExternalTextureCallback(
      [&](int64_t id, size_t w, size_t h, FlutterMetalExternalTexture* output) {
        EXPECT_TRUE(w == texture_size.width());
        EXPECT_TRUE(h == texture_size.height());
        EXPECT_TRUE(texture_id == id);
        output->num_textures = 1;
        output->height = h;
        output->width = w;
        output->pixel_format = FlutterMetalExternalTexturePixelFormat::kRGBA;
        output->textures = textures.data();
        return true;
      });
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_texture");
  builder.SetMetalRendererConfig(texture_size);
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ASSERT_EQ(FlutterEngineRegisterExternalTexture(engine.get(), texture_id), kSuccess);
 
  auto rendered_scene = context.GetNextSceneImage();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = texture_size.width();
  event.height = texture_size.height();
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture("external_texture_metal.png", rendered_scene));
}

◆ TEST_F() [415/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ExternalTextureMetalRefreshedTooOften
	)

Definition at line 568 of file embedder_metal_unittests.mm.

                                                            {
  EmbedderTestContextMetal& context = reinterpret_cast<EmbedderTestContextMetal&>(
      GetEmbedderContext(EmbedderTestContextType::kMetalContext));
 
  TestMetalContext* metal_context = context.GetTestMetalContext();
  auto metal_texture = metal_context->CreateMetalTexture(SkISize::Make(100, 100));
 
  std::vector<FlutterMetalTextureHandle> textures{metal_texture.texture};
 
  bool resolve_called = false;
 
  EmbedderExternalTextureMetal::ExternalTextureCallback callback([&](int64_t id, size_t, size_t) {
    resolve_called = true;
    auto res = std::make_unique<FlutterMetalExternalTexture>();
    res->struct_size = sizeof(FlutterMetalExternalTexture);
    res->width = res->height = 100;
    res->pixel_format = FlutterMetalExternalTexturePixelFormat::kRGBA;
    res->textures = textures.data();
    res->num_textures = 1;
    return res;
  });
  EmbedderExternalTextureMetal texture(1, callback);
 
  auto surface = TestMetalSurface::Create(*metal_context, SkISize::Make(100, 100));
  auto skia_surface = surface->GetSurface();
  DlSkCanvasAdapter canvas(skia_surface->getCanvas());
 
  Texture* texture_ = &texture;
  DlImageSampling sampling = DlImageSampling::kLinear;
  Texture::PaintContext ctx{
      .canvas = &canvas,
      .gr_context = surface->GetGrContext().get(),
  };
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
 
  EXPECT_TRUE(resolve_called);
  resolve_called = false;
 
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
 
  EXPECT_FALSE(resolve_called);
 
  texture_->MarkNewFrameAvailable();
 
  texture_->Paint(ctx, SkRect::MakeXYWH(0, 0, 100, 100), false, sampling);
 
  EXPECT_TRUE(resolve_called);
}

◆ TEST_F() [416/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		FrameInfoContainsValidWidthAndHeight
	)

Definition at line 3524 of file embedder_gl_unittests.cc.

                                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetDartEntrypoint("push_frames_over_and_over");
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 1024).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  static FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  static fml::CountDownLatch frame_latch(10);
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              /* Nothing to do. */
                            }));
 
  static_cast<EmbedderTestContextGL&>(context).SetGLGetFBOCallback(
      [](FlutterFrameInfo frame_info) {
        // width and height are rotated by 90 deg
        ASSERT_EQ(frame_info.size.width, event.height);
        ASSERT_EQ(frame_info.size.height, event.width);
 
        frame_latch.CountDown();
      });
 
  frame_latch.Wait();
}

◆ TEST_F() [417/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		IgnoresWindowMetricsEventForUnknownView
	)

Definition at line 3634 of file embedder_unittests.cc.

                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_view_id");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        // Message latch should only be signaled once as the bad
        // view metric should be dropped by the engine.
        ASSERT_FALSE(message_latch.IsSignaledForTest());
        ASSERT_EQ("Changed: [0]", message);
        message_latch.Signal();
      }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  // Send a window metric for a nonexistent view, which should be dropped by the
  // engine.
  FlutterWindowMetricsEvent bad_event = {};
  bad_event.struct_size = sizeof(FlutterWindowMetricsEvent);
  bad_event.width = 200;
  bad_event.height = 300;
  bad_event.pixel_ratio = 1.5;
  bad_event.view_id = 100;
 
  FlutterEngineResult result =
      FlutterEngineSendWindowMetricsEvent(engine.get(), &bad_event);
  ASSERT_EQ(result, kSuccess);
 
  // Send a window metric for a valid view. The engine notifies the Dart app.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(FlutterWindowMetricsEvent);
  event.width = 200;
  event.height = 300;
  event.pixel_ratio = 1.5;
  event.view_id = 0;
 
  result = FlutterEngineSendWindowMetricsEvent(engine.get(), &event);
  ASSERT_EQ(result, kSuccess);
 
  message_latch.Wait();
}

◆ TEST_F() [418/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ImplicitViewNotNull
	)

Definition at line 178 of file embedder_unittests.cc.

                                          {
  // TODO(loicsharma): Update this test when embedders can opt-out
  // of the implicit view.
  // See: https://github.com/flutter/flutter/issues/120306
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  bool implicitViewNotNull = false;
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "NotifyBoolValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        implicitViewNotNull = tonic::DartConverter<bool>::FromDart(
            Dart_GetNativeArgument(args, 0));
        latch.Signal();
      }));
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("implicitViewNotNull");
  auto engine = builder.LaunchEngine();
  latch.Wait();
 
  EXPECT_TRUE(implicitViewNotNull);
}

◆ TEST_F() [419/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		InvalidAOTDataSourcesMustReturnError
	)

Definition at line 2326 of file embedder_unittests.cc.

                                                           {
  if (!DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
  FlutterEngineAOTDataSource data_in = {};
  FlutterEngineAOTData data_out = nullptr;
 
  // Null source specified.
  ASSERT_EQ(FlutterEngineCreateAOTData(nullptr, &data_out), kInvalidArguments);
  ASSERT_EQ(data_out, nullptr);
 
  // Null data_out specified.
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, nullptr), kInvalidArguments);
 
  // Invalid FlutterEngineAOTDataSourceType type specified.
  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
  data_in.type = static_cast<FlutterEngineAOTDataSourceType>(-1);
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, &data_out), kInvalidArguments);
  ASSERT_EQ(data_out, nullptr);
 
  // Invalid ELF path specified.
  data_in.type = kFlutterEngineAOTDataSourceTypeElfPath;
  data_in.elf_path = nullptr;
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, &data_out), kInvalidArguments);
  ASSERT_EQ(data_in.type, kFlutterEngineAOTDataSourceTypeElfPath);
  ASSERT_EQ(data_in.elf_path, nullptr);
  ASSERT_EQ(data_out, nullptr);
 
  // Invalid ELF path specified.
  data_in.elf_path = "";
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, &data_out), kInvalidArguments);
  ASSERT_EQ(data_in.type, kFlutterEngineAOTDataSourceTypeElfPath);
  ASSERT_EQ(data_in.elf_path, "");
  ASSERT_EQ(data_out, nullptr);
 
  // Could not find VM snapshot data.
  data_in.elf_path = "/bin/true";
  ASSERT_EQ(FlutterEngineCreateAOTData(&data_in, &data_out), kInvalidArguments);
  ASSERT_EQ(data_in.type, kFlutterEngineAOTDataSourceTypeElfPath);
  ASSERT_EQ(data_in.elf_path, "/bin/true");
  ASSERT_EQ(data_out, nullptr);
}

◆ TEST_F() [420/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		InvalidFlutterWindowMetricsEvent
	)

Definition at line 2665 of file embedder_unittests.cc.

                                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 0.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
 
  // Pixel ratio must be positive.
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kInvalidArguments);
 
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = -1.0;
  event.physical_view_inset_right = -1.0;
  event.physical_view_inset_bottom = -1.0;
  event.physical_view_inset_left = -1.0;
 
  // Physical view insets must be non-negative.
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kInvalidArguments);
 
  event.physical_view_inset_top = 700;
  event.physical_view_inset_right = 900;
  event.physical_view_inset_bottom = 700;
  event.physical_view_inset_left = 900;
 
  // Top/bottom insets cannot be greater than height.
  // Left/right insets cannot be greater than width.
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kInvalidArguments);
}

◆ TEST_F() [421/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		InvalidPlatformMessages
	)

Tests that a null platform message cannot be send if the message_size isn't equals to 0.

Definition at line 512 of file embedder_unittests.cc.

                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterPlatformMessage platform_message = {};
  platform_message.struct_size = sizeof(FlutterPlatformMessage);
  platform_message.channel = "test_channel";
  platform_message.message = nullptr;
  platform_message.message_size = 1;
  platform_message.response_handle = nullptr;  // No response needed.
 
  auto result =
      FlutterEngineSendPlatformMessage(engine.get(), &platform_message);
  ASSERT_EQ(result, kInvalidArguments);
}

◆ TEST_F() [422/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		IsolateServiceIdSent
	)

Definition at line 287 of file embedder_unittests.cc.

                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  fml::AutoResetWaitableEvent latch;
 
  fml::Thread thread;
  UniqueEngine engine;
  std::string isolate_message;
 
  thread.GetTaskRunner()->PostTask([&]() {
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("main");
    builder.SetPlatformMessageCallback(
        [&](const FlutterPlatformMessage* message) {
          if (strcmp(message->channel, "flutter/isolate") == 0) {
            isolate_message = {reinterpret_cast<const char*>(message->message),
                               message->message_size};
            latch.Signal();
          }
        });
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
  });
 
  // Wait for the isolate ID message and check its format.
  latch.Wait();
  ASSERT_EQ(isolate_message.find("isolates/"), 0ul);
 
  // Since the engine was started on its own thread, it must be killed there as
  // well.
  fml::AutoResetWaitableEvent kill_latch;
  thread.GetTaskRunner()->PostTask(
      fml::MakeCopyable([&engine, &kill_latch]() mutable {
        engine.reset();
        kill_latch.Signal();
      }));
  kill_latch.Wait();
}

◆ TEST_F() [423/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		JITSnapshotCallbacksFailWithInvalidLocation
	)

PopulateJITSnapshotMappingCallbacks should still be able to successfully change the callbacks of the snapshots in the engine's settings when JIT snapshots are explicitly defined. However, if those snapshot locations are invalid, the callbacks should return a nullptr.

Definition at line 2504 of file embedder_unittests.cc.

                                                                  {
// TODO(#107263): Inconsistent snapshot paths in the Linux Fuchsia FEMU test.
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Inconsistent paths in Fuchsia.";
#else
 
  // This test is only relevant in JIT mode.
  if (DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
 
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // Explicitly define the locations of the invalid JIT snapshots
  builder.GetProjectArgs().vm_snapshot_data =
      reinterpret_cast<const uint8_t*>("invalid_vm_data");
  builder.GetProjectArgs().vm_snapshot_instructions =
      reinterpret_cast<const uint8_t*>("invalid_vm_instructions");
  builder.GetProjectArgs().isolate_snapshot_data =
      reinterpret_cast<const uint8_t*>("invalid_snapshot_data");
  builder.GetProjectArgs().isolate_snapshot_instructions =
      reinterpret_cast<const uint8_t*>("invalid_snapshot_instructions");
 
  auto engine = builder.LaunchEngine();
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  const Settings settings = shell.GetSettings();
 
  ASSERT_EQ(settings.vm_snapshot_data(), nullptr);
  ASSERT_EQ(settings.vm_snapshot_instr(), nullptr);
  ASSERT_EQ(settings.isolate_snapshot_data(), nullptr);
  ASSERT_EQ(settings.isolate_snapshot_instr(), nullptr);
#endif  // OS_FUCHSIA
}

◆ TEST_F() [424/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		KeyDataAreBuffered
	)

Definition at line 3028 of file embedder_unittests.cc.

                                         {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  std::vector<FlutterKeyEvent> echoed_events;
 
  auto native_echo_event = [&](Dart_NativeArguments args) {
    echoed_events.push_back(FlutterKeyEvent{
        .timestamp =
            static_cast<double>(tonic::DartConverter<uint64_t>::FromDart(
                Dart_GetNativeArgument(args, 1))),
        .type =
            UnserializeKeyEventType(tonic::DartConverter<uint64_t>::FromDart(
                Dart_GetNativeArgument(args, 0))),
        .physical = tonic::DartConverter<uint64_t>::FromDart(
            Dart_GetNativeArgument(args, 2)),
        .logical = tonic::DartConverter<uint64_t>::FromDart(
            Dart_GetNativeArgument(args, 3)),
        .synthesized = tonic::DartConverter<bool>::FromDart(
            Dart_GetNativeArgument(args, 5)),
        .device_type = UnserializeKeyEventDeviceType(
            tonic::DartConverter<uint64_t>::FromDart(
                Dart_GetNativeArgument(args, 6))),
    });
 
    message_latch->Signal();
  };
 
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  UniqueEngine engine;
  fml::AutoResetWaitableEvent ready;
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("key_data_late_echo");
    builder.SetPlatformMessageCallback(
        [&](const FlutterPlatformMessage* message) {
          FlutterEngineSendPlatformMessageResponse(
              engine.get(), message->response_handle, nullptr, 0);
        });
    context.AddNativeCallback(
        "SignalNativeTest",
        CREATE_NATIVE_ENTRY(
            [&ready](Dart_NativeArguments args) { ready.Signal(); }));
 
    context.AddNativeCallback("EchoKeyEvent",
                              CREATE_NATIVE_ENTRY(native_echo_event));
 
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
  });
  ready.Wait();
 
  FlutterKeyEvent sample_event{
      .struct_size = sizeof(FlutterKeyEvent),
      .type = kFlutterKeyEventTypeDown,
      .physical = 0x00070004,
      .logical = 0x00000000061,
      .character = "A",
      .synthesized = false,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
 
  // Send an event.
  sample_event.timestamp = 1.0l;
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &sample_event, nullptr, nullptr);
    message_latch->Signal();
  });
  message_latch->Wait();
 
  // Should not receive echos because the callback is not set yet.
  EXPECT_EQ(echoed_events.size(), 0u);
 
  // Send an empty message to 'test/starts_echo' to start echoing.
  FlutterPlatformMessageResponseHandle* response_handle = nullptr;
  FlutterPlatformMessageCreateResponseHandle(
      engine.get(), [](const uint8_t* data, size_t size, void* user_data) {},
      nullptr, &response_handle);
 
  FlutterPlatformMessage message{
      .struct_size = sizeof(FlutterPlatformMessage),
      .channel = "test/starts_echo",
      .message = nullptr,
      .message_size = 0,
      .response_handle = response_handle,
  };
 
  platform_task_runner->PostTask([&]() {
    FlutterEngineResult result =
        FlutterEngineSendPlatformMessage(engine.get(), &message);
    ASSERT_EQ(result, kSuccess);
 
    FlutterPlatformMessageReleaseResponseHandle(engine.get(), response_handle);
  });
 
  // message_latch->Wait();
  message_latch->Wait();
  // All previous events should be received now.
  EXPECT_EQ(echoed_events.size(), 1u);
 
  // Send a second event.
  sample_event.timestamp = 10.0l;
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &sample_event, nullptr, nullptr);
  });
  message_latch->Wait();
 
  // The event should be echoed, too.
  EXPECT_EQ(echoed_events.size(), 2u);
 
  fml::AutoResetWaitableEvent shutdown_latch;
  platform_task_runner->PostTask([&]() {
    engine.reset();
    shutdown_latch.Signal();
  });
  shutdown_latch.Wait();
}

◆ TEST_F() [425/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		KeyDataIsCorrectlySerialized
	)

Definition at line 2904 of file embedder_unittests.cc.

                                                   {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  uint64_t echoed_char;
  FlutterKeyEvent echoed_event;
  echoed_event.struct_size = sizeof(FlutterKeyEvent);
 
  auto native_echo_event = [&](Dart_NativeArguments args) {
    echoed_event.type =
        UnserializeKeyEventType(tonic::DartConverter<uint64_t>::FromDart(
            Dart_GetNativeArgument(args, 0)));
    echoed_event.timestamp =
        static_cast<double>(tonic::DartConverter<uint64_t>::FromDart(
            Dart_GetNativeArgument(args, 1)));
    echoed_event.physical = tonic::DartConverter<uint64_t>::FromDart(
        Dart_GetNativeArgument(args, 2));
    echoed_event.logical = tonic::DartConverter<uint64_t>::FromDart(
        Dart_GetNativeArgument(args, 3));
    echoed_char = tonic::DartConverter<uint64_t>::FromDart(
        Dart_GetNativeArgument(args, 4));
    echoed_event.synthesized =
        tonic::DartConverter<bool>::FromDart(Dart_GetNativeArgument(args, 5));
    echoed_event.device_type =
        UnserializeKeyEventDeviceType(tonic::DartConverter<uint64_t>::FromDart(
            Dart_GetNativeArgument(args, 6)));
 
    message_latch->Signal();
  };
 
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  UniqueEngine engine;
  fml::AutoResetWaitableEvent ready;
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("key_data_echo");
    builder.SetPlatformMessageCallback(
        [&](const FlutterPlatformMessage* message) {
          FlutterEngineSendPlatformMessageResponse(
              engine.get(), message->response_handle, nullptr, 0);
        });
    context.AddNativeCallback(
        "SignalNativeTest",
        CREATE_NATIVE_ENTRY(
            [&ready](Dart_NativeArguments args) { ready.Signal(); }));
 
    context.AddNativeCallback("EchoKeyEvent",
                              CREATE_NATIVE_ENTRY(native_echo_event));
 
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
  });
 
  ready.Wait();
 
  // A normal down event
  const FlutterKeyEvent down_event_upper_a{
      .struct_size = sizeof(FlutterKeyEvent),
      .timestamp = 1,
      .type = kFlutterKeyEventTypeDown,
      .physical = 0x00070004,
      .logical = 0x00000000061,
      .character = "A",
      .synthesized = false,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &down_event_upper_a, nullptr,
                              nullptr);
  });
  message_latch->Wait();
 
  ExpectKeyEventEq(echoed_event, down_event_upper_a);
  EXPECT_EQ(echoed_char, 0x41llu);
 
  // A repeat event with multi-byte character
  const FlutterKeyEvent repeat_event_wide_char{
      .struct_size = sizeof(FlutterKeyEvent),
      .timestamp = 1000,
      .type = kFlutterKeyEventTypeRepeat,
      .physical = 0x00070005,
      .logical = 0x00000000062,
      .character = "∆",
      .synthesized = false,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &repeat_event_wide_char, nullptr,
                              nullptr);
  });
  message_latch->Wait();
 
  ExpectKeyEventEq(echoed_event, repeat_event_wide_char);
  EXPECT_EQ(echoed_char, 0x2206llu);
 
  // An up event with no character, synthesized
  const FlutterKeyEvent up_event{
      .struct_size = sizeof(FlutterKeyEvent),
      .timestamp = 1000000,
      .type = kFlutterKeyEventTypeUp,
      .physical = 0x00070006,
      .logical = 0x00000000063,
      .character = nullptr,
      .synthesized = true,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
  platform_task_runner->PostTask([&]() {
    FlutterEngineSendKeyEvent(engine.get(), &up_event, nullptr, nullptr);
  });
  message_latch->Wait();
 
  ExpectKeyEventEq(echoed_event, up_event);
  EXPECT_EQ(echoed_char, 0llu);
 
  fml::AutoResetWaitableEvent shutdown_latch;
  platform_task_runner->PostTask([&]() {
    engine.reset();
    shutdown_latch.Signal();
  });
  shutdown_latch.Wait();
}

◆ TEST_F() [426/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		KeyDataResponseIsCorrectlyInvoked
	)

Definition at line 3148 of file embedder_unittests.cc.

                                                        {
  UniqueEngine engine;
  fml::AutoResetWaitableEvent sync_latch;
  fml::AutoResetWaitableEvent ready;
 
  // One of the threads that the key data callback will be posted to is the
  // platform thread. So we cannot wait for assertions to complete on the
  // platform thread. Create a new thread to manage the engine instance and wait
  // for assertions on the test thread.
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("key_data_echo");
    context.AddNativeCallback(
        "SignalNativeTest",
        CREATE_NATIVE_ENTRY(
            [&ready](Dart_NativeArguments args) { ready.Signal(); }));
    context.AddNativeCallback(
        "EchoKeyEvent", CREATE_NATIVE_ENTRY([](Dart_NativeArguments args) {}));
 
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
 
    sync_latch.Signal();
  });
  sync_latch.Wait();
  ready.Wait();
 
  // Dispatch a single event
  FlutterKeyEvent event{
      .struct_size = sizeof(FlutterKeyEvent),
      .timestamp = 1000,
      .type = kFlutterKeyEventTypeDown,
      .physical = 0x00070005,
      .logical = 0x00000000062,
      .character = nullptr,
      .device_type = kFlutterKeyEventDeviceTypeKeyboard,
  };
 
  KeyEventUserData user_data1{
      .latch = std::make_shared<fml::AutoResetWaitableEvent>(),
  };
  // Entrypoint `key_data_echo` returns `event.synthesized` as `handled`.
  event.synthesized = true;
  platform_task_runner->PostTask([&]() {
    // Test when the response callback is empty.
    // It should not cause a crash.
    FlutterEngineSendKeyEvent(engine.get(), &event, nullptr, nullptr);
 
    // Test when the response callback is non-empty.
    // It should be invoked (so that the latch can be unlocked.)
    FlutterEngineSendKeyEvent(
        engine.get(), &event,
        [](bool handled, void* untyped_user_data) {
          KeyEventUserData* user_data =
              reinterpret_cast<KeyEventUserData*>(untyped_user_data);
          EXPECT_EQ(handled, true);
          user_data->latch->Signal();
        },
        &user_data1);
  });
  user_data1.latch->Wait();
  fml::AutoResetWaitableEvent shutdown_latch;
  platform_task_runner->PostTask([&]() {
    engine.reset();
    shutdown_latch.Signal();
  });
  shutdown_latch.Wait();
}

◆ TEST_F() [427/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		LaunchFailsWhenMultiplePresentCallbacks
	)

Either present_layers_callback or present_view_callback must be provided, but not both, otherwise the engine must fail to launch instead of failing to render a frame at a later point in time.

Definition at line 86 of file embedder_gl_unittests.cc.

                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  builder.SetCompositor();
  builder.GetCompositor().present_layers_callback =
      [](const FlutterLayer** layers, size_t layers_count, void* user_data) {
        return true;
      };
  builder.GetCompositor().present_view_callback =
      [](const FlutterPresentViewInfo* info) { return true; };
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [428/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		LocalizationCallbacksCalled
	)

Definition at line 2047 of file embedder_unittests.cc.

                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  fml::AutoResetWaitableEvent latch;
  context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  // Wait for the root isolate to launch.
  latch.Wait();
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  std::vector<std::string> supported_locales;
  supported_locales.push_back("es");
  supported_locales.push_back("MX");
  supported_locales.push_back("");
  auto result = shell.GetPlatformView()->ComputePlatformResolvedLocales(
      supported_locales);
 
  ASSERT_EQ((*result).size(), supported_locales.size());  // 3
  ASSERT_EQ((*result)[0], supported_locales[0]);
  ASSERT_EQ((*result)[1], supported_locales[1]);
  ASSERT_EQ((*result)[2], supported_locales[2]);
 
  engine.reset();
}

◆ TEST_F() [429/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MetalCompositorMustBeAbleToRenderPlatformViews
	)

Definition at line 131 of file embedder_metal_unittests.mm.

                                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views");
 
  builder.SetRenderTargetType(EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture);
 
  fml::CountDownLatch latch(3);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers, size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeMetal;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeMetal;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(2, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [430/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MultipleDisplaysWithSameDisplayIdIsInvalid
	)

Definition at line 4217 of file embedder_gl_unittests.cc.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterEngineDisplay display_1;
  display_1.struct_size = sizeof(FlutterEngineDisplay);
  display_1.display_id = 1;
  display_1.single_display = false;
  display_1.refresh_rate = 20;
 
  FlutterEngineDisplay display_2;
  display_2.struct_size = sizeof(FlutterEngineDisplay);
  display_2.display_id = 1;
  display_2.single_display = false;
  display_2.refresh_rate = 60;
 
  std::vector<FlutterEngineDisplay> displays = {display_1, display_2};
 
  const FlutterEngineResult result = FlutterEngineNotifyDisplayUpdate(
      engine.get(), kFlutterEngineDisplaysUpdateTypeStartup, displays.data(),
      displays.size());
  ASSERT_NE(result, kSuccess);
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [431/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MultipleDisplaysWithSingleDisplayTrueIsInvalid
	)

Definition at line 4171 of file embedder_gl_unittests.cc.

                                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterEngineDisplay display_1;
  display_1.struct_size = sizeof(FlutterEngineDisplay);
  display_1.display_id = 1;
  display_1.single_display = true;
  display_1.refresh_rate = 20;
 
  FlutterEngineDisplay display_2;
  display_2.struct_size = sizeof(FlutterEngineDisplay);
  display_2.display_id = 2;
  display_2.single_display = true;
  display_2.refresh_rate = 60;
 
  std::vector<FlutterEngineDisplay> displays = {display_1, display_2};
 
  const FlutterEngineResult result = FlutterEngineNotifyDisplayUpdate(
      engine.get(), kFlutterEngineDisplaysUpdateTypeStartup, displays.data(),
      displays.size());
  ASSERT_NE(result, kSuccess);
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [432/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustNotRunWhenPopulateExistingDamageButNoOtherFBOCallback
	)

Definition at line 3636 of file embedder_gl_unittests.cc.

                                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  builder.GetRendererConfig().open_gl.fbo_callback = nullptr;
  builder.GetRendererConfig().open_gl.fbo_with_frame_info_callback = nullptr;
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [433/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustNotRunWithBothFBOCallbacksSet
	)

Definition at line 3567 of file embedder_gl_unittests.cc.

                                                        {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetOpenGLFBOCallBack();
 
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [434/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustNotRunWithBothPresentCallbacksSet
	)

Definition at line 3578 of file embedder_gl_unittests.cc.

                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetOpenGLPresentCallBack();
 
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [435/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustNotRunWithMultipleAOTSources
	)

Definition at line 2370 of file embedder_unittests.cc.

                                                       {
  if (!DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(
      context,
      EmbedderConfigBuilder::InitializationPreference::kMultiAOTInitialize);
 
  builder.SetSoftwareRendererConfig();
 
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [436/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustPreventEngineLaunchWhenRequiredCompositorArgsAreAbsent
	)

If an incorrectly configured compositor is set on the engine, the engine must fail to launch instead of failing to render a frame at a later point in time.

Definition at line 67 of file embedder_gl_unittests.cc.

                                                                   {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  builder.SetCompositor();
  builder.GetCompositor().create_backing_store_callback = nullptr;
  builder.GetCompositor().collect_backing_store_callback = nullptr;
  builder.GetCompositor().present_layers_callback = nullptr;
  builder.GetCompositor().present_view_callback = nullptr;
  auto engine = builder.LaunchEngine();
  ASSERT_FALSE(engine.is_valid());
}

◆ TEST_F() [437/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustRunWhenPopulateExistingDamageIsProvided
	)

Definition at line 3600 of file embedder_gl_unittests.cc.

                                                                  {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
 
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [438/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustRunWithPopulateExistingDamageAndFBOCallback
	)

Definition at line 3617 of file embedder_gl_unittests.cc.

                                                                      {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  builder.GetRendererConfig().open_gl.fbo_callback =
      [](void* context) -> uint32_t { return 0; };
  builder.GetRendererConfig().open_gl.fbo_with_frame_info_callback = nullptr;
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [439/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		MustStillRunWhenPopulateExistingDamageIsNotProvided
	)

Definition at line 3589 of file embedder_gl_unittests.cc.

                                                                          {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(1, 1));
  builder.GetRendererConfig().open_gl.populate_existing_damage = nullptr;
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [440/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		NoLayerCreatedForNoOverlayOnTopOfPlatformLayer
	)

Test the layer structure and pixels rendered when using a custom software compositor, with a no overlay

Definition at line 1077 of file embedder_unittests.cc.

                                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_no_overlay");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::CountDownLatch latch(4);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          backing_store.software.height = 600;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer, GrDirectContext*
          /* don't use because software compositor */) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(
            layer, nullptr /* null because software compositor */);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  // TODO(https://github.com/flutter/flutter/issues/53784): enable this on all
  // platforms.
#if !defined(FML_OS_LINUX)
  GTEST_SKIP() << "Skipping golden tests on non-Linux OSes";
#endif  // FML_OS_LINUX
  ASSERT_TRUE(ImageMatchesFixture(
      "compositor_platform_layer_with_no_overlay.png", scene_image));
 
  // There should no present calls on the root surface.
  ASSERT_EQ(context.GetSurfacePresentCount(), 0u);
}

◆ TEST_F() [441/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		NoLayerCreatedForTransparentOverlayOnTopOfPlatformLayer
	)

Test the layer structure and pixels rendered when using a custom software compositor, with a transparent overlay

Definition at line 940 of file embedder_unittests.cc.

                                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_transparent_overlay");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  fml::CountDownLatch latch(4);
 
  auto scene_image = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
          backing_store.software.height = 600;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(50.0, 150.0);
          layer.offset = FlutterPointMake(20.0, 20.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer, GrDirectContext*
          /* don't use because software compositor */) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(
            layer, nullptr /* null because software compositor */);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
            latch.CountDown();
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&latch](Dart_NativeArguments args) { latch.CountDown(); }));
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  // TODO(https://github.com/flutter/flutter/issues/53784): enable this on all
  // platforms.
#if !defined(FML_OS_LINUX)
  GTEST_SKIP() << "Skipping golden tests on non-Linux OSes";
#endif  // FML_OS_LINUX
  ASSERT_TRUE(ImageMatchesFixture(
      "compositor_platform_layer_with_no_overlay.png", scene_image));
 
  // There should no present calls on the root surface.
  ASSERT_EQ(context.GetSurfacePresentCount(), 0u);
}

◆ TEST_F() [442/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		NullPlatformMessagesCanBeSent
	)

Tests that a null platform message can be sent.

Definition at line 470 of file embedder_unittests.cc.

                                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("null_platform_messages");
 
  fml::AutoResetWaitableEvent ready, message;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready](Dart_NativeArguments args) { ready.Signal(); }));
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY(([&message](Dart_NativeArguments args) {
        auto received_message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("true", received_message);
        message.Signal();
      })));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
  ready.Wait();
 
  FlutterPlatformMessage platform_message = {};
  platform_message.struct_size = sizeof(FlutterPlatformMessage);
  platform_message.channel = "test_channel";
  platform_message.message = nullptr;
  platform_message.message_size = 0;
  platform_message.response_handle = nullptr;  // No response needed.
 
  auto result =
      FlutterEngineSendPlatformMessage(engine.get(), &platform_message);
  ASSERT_EQ(result, kSuccess);
  message.Wait();
}

◆ TEST_F() [443/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ObjectsCanBePostedViaPorts
	)

Definition at line 3111 of file embedder_gl_unittests.cc.

                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 1024));
  builder.SetDartEntrypoint("objects_can_be_posted");
 
  // Synchronously acquire the send port from the Dart end. We will be using
  // this to send message. The Dart end will just echo those messages back to us
  // for inspection.
  FlutterEngineDartPort port = 0;
  fml::AutoResetWaitableEvent event;
  context.AddNativeCallback("SignalNativeCount",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              port = tonic::DartConverter<int64_t>::FromDart(
                                  Dart_GetNativeArgument(args, 0));
                              event.Signal();
                            }));
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  event.Wait();
  ASSERT_NE(port, 0);
 
  using Trampoline = std::function<void(Dart_Handle message)>;
  Trampoline trampoline;
 
  context.AddNativeCallback("SendObjectToNativeCode",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              FML_CHECK(trampoline);
                              auto trampoline_copy = trampoline;
                              trampoline = nullptr;
                              trampoline_copy(Dart_GetNativeArgument(args, 0));
                            }));
 
  // Check null.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeNull;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_TRUE(Dart_IsNull(handle));
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check bool.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeBool;
    object.bool_value = true;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(handle));
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check int32.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeInt32;
    object.int32_value = 1988;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_EQ(tonic::DartConverter<int32_t>::FromDart(handle), 1988);
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check int64.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeInt64;
    object.int64_value = 1988;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_EQ(tonic::DartConverter<int64_t>::FromDart(handle), 1988);
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check double.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeDouble;
    object.double_value = 1988.0;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_DOUBLE_EQ(tonic::DartConverter<double>::FromDart(handle), 1988.0);
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check string.
  {
    const char* message = "Hello. My name is Inigo Montoya.";
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeString;
    object.string_value = message;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_EQ(tonic::DartConverter<std::string>::FromDart(handle),
                std::string{message});
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  // Check buffer (copied out).
  {
    std::vector<uint8_t> message;
    message.resize(1988);
 
    ASSERT_TRUE(MemsetPatternSetOrCheck(
        message, MemsetPatternOp::kMemsetPatternOpSetBuffer));
 
    FlutterEngineDartBuffer buffer = {};
 
    buffer.struct_size = sizeof(buffer);
    buffer.user_data = nullptr;
    buffer.buffer_collect_callback = nullptr;
    buffer.buffer = message.data();
    buffer.buffer_size = message.size();
 
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeBuffer;
    object.buffer_value = &buffer;
    trampoline = [&](Dart_Handle handle) {
      intptr_t length = 0;
      Dart_ListLength(handle, &length);
      ASSERT_EQ(length, 1988);
      // TODO(chinmaygarde); The std::vector<uint8_t> specialization for
      // DartConvertor in tonic is broken which is preventing the buffer
      // being checked here. Fix tonic and strengthen this check. For now, just
      // the buffer length is checked.
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  std::vector<uint8_t> message;
  fml::AutoResetWaitableEvent buffer_released_latch;
 
  // Check buffer (caller own buffer with zero copy transfer).
  {
    message.resize(1988);
 
    ASSERT_TRUE(MemsetPatternSetOrCheck(
        message, MemsetPatternOp::kMemsetPatternOpSetBuffer));
 
    FlutterEngineDartBuffer buffer = {};
 
    buffer.struct_size = sizeof(buffer);
    buffer.user_data = &buffer_released_latch;
    buffer.buffer_collect_callback = +[](void* user_data) {
      reinterpret_cast<fml::AutoResetWaitableEvent*>(user_data)->Signal();
    };
    buffer.buffer = message.data();
    buffer.buffer_size = message.size();
 
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeBuffer;
    object.buffer_value = &buffer;
    trampoline = [&](Dart_Handle handle) {
      intptr_t length = 0;
      Dart_ListLength(handle, &length);
      ASSERT_EQ(length, 1988);
      // TODO(chinmaygarde); The std::vector<uint8_t> specialization for
      // DartConvertor in tonic is broken which is preventing the buffer
      // being checked here. Fix tonic and strengthen this check. For now, just
      // the buffer length is checked.
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
 
  engine.reset();
 
  // We cannot determine when the VM will GC objects that might have external
  // typed data finalizers. Since we need to ensure that we correctly wired up
  // finalizers from the embedders, we force the VM to collect all objects but
  // just shutting it down.
  buffer_released_latch.Wait();
}

◆ TEST_F() [444/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ObjectsPostedViaPortsServicedOnSecondaryTaskHeap
	)

Definition at line 4354 of file embedder_gl_unittests.cc.

                                                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 1024));
  builder.SetDartEntrypoint("objects_can_be_posted");
 
  // Synchronously acquire the send port from the Dart end. We will be using
  // this to send message. The Dart end will just echo those messages back to us
  // for inspection.
  FlutterEngineDartPort port = 0;
  fml::AutoResetWaitableEvent event;
  context.AddNativeCallback("SignalNativeCount",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              port = tonic::DartConverter<int64_t>::FromDart(
                                  Dart_GetNativeArgument(args, 0));
                              event.Signal();
                            }));
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
  event.Wait();
  ASSERT_NE(port, 0);
 
  using Trampoline = std::function<void(Dart_Handle message)>;
  Trampoline trampoline;
 
  context.AddNativeCallback("SendObjectToNativeCode",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              FML_CHECK(trampoline);
                              auto trampoline_copy = trampoline;
                              trampoline = nullptr;
                              trampoline_copy(Dart_GetNativeArgument(args, 0));
                            }));
 
  // Send a boolean value and assert that it's received by the right heap.
  {
    FlutterEngineDartObject object = {};
    object.type = kFlutterEngineDartObjectTypeBool;
    object.bool_value = true;
    trampoline = [&](Dart_Handle handle) {
      ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(handle));
      auto task_grade = fml::MessageLoopTaskQueues::GetCurrentTaskSourceGrade();
      EXPECT_EQ(task_grade, fml::TaskSourceGrade::kDartEventLoop);
      event.Signal();
    };
    ASSERT_EQ(FlutterEnginePostDartObject(engine.get(), port, &object),
              kSuccess);
    event.Wait();
  }
}

◆ TEST_F() [445/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PlatformMessagesCanBeSentWithoutResponseHandles
	)

Tests that a platform message can be sent with no response handle. Instead of the platform message integrity checked via a response handle, a native callback with the response is invoked to assert integrity.

Definition at line 425 of file embedder_unittests.cc.

                                                                      {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("platform_messages_no_response");
 
  const std::string message_data = "Hello but don't call me back.";
 
  fml::AutoResetWaitableEvent ready, message;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready](Dart_NativeArguments args) { ready.Signal(); }));
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY(
          ([&message, &message_data](Dart_NativeArguments args) {
            auto received_message = tonic::DartConverter<std::string>::FromDart(
                Dart_GetNativeArgument(args, 0));
            ASSERT_EQ(received_message, message_data);
            message.Signal();
          })));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
  ready.Wait();
 
  FlutterPlatformMessage platform_message = {};
  platform_message.struct_size = sizeof(FlutterPlatformMessage);
  platform_message.channel = "test_channel";
  platform_message.message =
      reinterpret_cast<const uint8_t*>(message_data.data());
  platform_message.message_size = message_data.size();
  platform_message.response_handle = nullptr;  // No response needed.
 
  auto result =
      FlutterEngineSendPlatformMessage(engine.get(), &platform_message);
  ASSERT_EQ(result, kSuccess);
  message.Wait();
}

◆ TEST_F() [446/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PlatformMessagesCanReceiveResponse
	)

Sends platform messages to Dart code than simply echoes the contents of the message back to the embedder. The embedder registers a native callback to intercept that message.

Definition at line 360 of file embedder_unittests.cc.

                                                         {
  struct Captures {
    fml::AutoResetWaitableEvent latch;
    std::thread::id thread_id;
  };
  Captures captures;
 
  CreateNewThread()->PostTask([&]() {
    captures.thread_id = std::this_thread::get_id();
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetDartEntrypoint("platform_messages_response");
 
    fml::AutoResetWaitableEvent ready;
    context.AddNativeCallback(
        "SignalNativeTest",
        CREATE_NATIVE_ENTRY(
            [&ready](Dart_NativeArguments args) { ready.Signal(); }));
 
    auto engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
 
    static std::string kMessageData = "Hello from embedder.";
 
    FlutterPlatformMessageResponseHandle* response_handle = nullptr;
    auto callback = [](const uint8_t* data, size_t size,
                       void* user_data) -> void {
      ASSERT_EQ(size, kMessageData.size());
      ASSERT_EQ(strncmp(reinterpret_cast<const char*>(kMessageData.data()),
                        reinterpret_cast<const char*>(data), size),
                0);
      auto captures = reinterpret_cast<Captures*>(user_data);
      ASSERT_EQ(captures->thread_id, std::this_thread::get_id());
      captures->latch.Signal();
    };
    auto result = FlutterPlatformMessageCreateResponseHandle(
        engine.get(), callback, &captures, &response_handle);
    ASSERT_EQ(result, kSuccess);
 
    FlutterPlatformMessage message = {};
    message.struct_size = sizeof(FlutterPlatformMessage);
    message.channel = "test_channel";
    message.message = reinterpret_cast<const uint8_t*>(kMessageData.data());
    message.message_size = kMessageData.size();
    message.response_handle = response_handle;
 
    ready.Wait();
    result = FlutterEngineSendPlatformMessage(engine.get(), &message);
    ASSERT_EQ(result, kSuccess);
 
    result = FlutterPlatformMessageReleaseResponseHandle(engine.get(),
                                                         response_handle);
    ASSERT_EQ(result, kSuccess);
  });
 
  captures.latch.Wait();
}

◆ TEST_F() [447/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PlatformThreadIsolatesWithCustomPlatformTaskRunner
	)

Definition at line 3721 of file embedder_unittests.cc.

                                                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  static fml::AutoResetWaitableEvent latch;
 
  static std::thread::id ffi_call_thread_id;
  static void (*ffi_signal_native_test)() = []() -> void {
    ffi_call_thread_id = std::this_thread::get_id();
    latch.Signal();
  };
 
  Dart_FfiNativeResolver ffi_resolver = [](const char* name,
                                           uintptr_t args_n) -> void* {
    if (std::string_view(name) == "FFISignalNativeTest") {
      return reinterpret_cast<void*>(ffi_signal_native_test);
    }
    return nullptr;
  };
 
  // The test's Dart code will call this native function which overrides the
  // FFI resolver.  After that, the Dart code will invoke the FFI function
  // using runOnPlatformThread.
  context.AddNativeCallback(
      "SignalNativeTest", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        Dart_SetFfiNativeResolver(Dart_RootLibrary(), ffi_resolver);
      }));
 
  auto platform_task_runner = CreateNewThread("test_platform_thread");
 
  UniqueEngine engine;
 
  EmbedderTestTaskRunner test_task_runner(
      platform_task_runner, [&](FlutterTask task) {
        if (!engine.is_valid()) {
          return;
        }
        FlutterEngineRunTask(engine.get(), &task);
      });
 
  std::thread::id platform_thread_id;
  platform_task_runner->PostTask([&]() {
    platform_thread_id = std::this_thread::get_id();
 
    EmbedderConfigBuilder builder(context);
    const auto task_runner_description =
        test_task_runner.GetFlutterTaskRunnerDescription();
    builder.SetSoftwareRendererConfig();
    builder.SetPlatformTaskRunner(&task_runner_description);
    builder.SetDartEntrypoint("invokePlatformThreadIsolate");
    builder.AddCommandLineArgument("--enable-platform-isolates");
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
  });
 
  latch.Wait();
 
  fml::AutoResetWaitableEvent kill_latch;
  platform_task_runner->PostTask(fml::MakeCopyable([&]() mutable {
    engine.reset();
 
    platform_task_runner->PostTask([&kill_latch] { kill_latch.Signal(); });
  }));
  kill_latch.Wait();
 
  // Check that the FFI call was executed on the platform thread.
  ASSERT_EQ(platform_thread_id, ffi_call_thread_id);
}

◆ TEST_F() [448/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PlatformViewMutatorsAreValidWithPixelRatio
	)

Definition at line 2627 of file embedder_gl_unittests.cc.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("platform_view_mutators_with_pixel_ratio");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  fml::CountDownLatch latch(1);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 2
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
          platform_view.mutations_count = 3;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
 
          // There are no ordering guarantees.
          for (size_t i = 0; i < platform_view.mutations_count; i++) {
            FlutterPlatformViewMutation mutation = *platform_view.mutations[i];
            switch (mutation.type) {
              case kFlutterPlatformViewMutationTypeClipRoundedRect:
                mutation.clip_rounded_rect =
                    FlutterRoundedRectMake(SkRRect::MakeRectXY(
                        SkRect::MakeLTRB(5.0, 5.0, 400.0 - 5.0, 300.0 - 5.0),
                        7.0, 7.0));
                break;
              case kFlutterPlatformViewMutationTypeClipRect:
                mutation.type = kFlutterPlatformViewMutationTypeClipRect;
                mutation.clip_rect = FlutterRectMake(
                    SkRect::MakeXYWH(5.0, 5.0, 400.0 - 10.0, 300.0 - 10.0));
                break;
              case kFlutterPlatformViewMutationTypeOpacity:
                mutation.type = kFlutterPlatformViewMutationTypeOpacity;
                mutation.opacity = 128.0 / 255.0;
                break;
              case kFlutterPlatformViewMutationTypeTransformation:
                mutation.type = kFlutterPlatformViewMutationTypeTransformation;
                mutation.transformation =
                    FlutterTransformationMake(SkMatrix::Scale(2.0, 2.0));
                break;
            }
 
            ASSERT_EQ(*platform_view.mutations[i], mutation);
          }
        }
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 2.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [449/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PlatformViewMutatorsAreValidWithPixelRatioAndRootSurfaceTransformation
	)

Definition at line 2738 of file embedder_gl_unittests.cc.

                                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("platform_view_mutators_with_pixel_ratio");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  static const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  fml::CountDownLatch latch(1);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeTexture;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 600, 800),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 2
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
          platform_view.mutations_count = 4;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(600.0, 800.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
 
          // There are no ordering guarantees.
          for (size_t i = 0; i < platform_view.mutations_count; i++) {
            FlutterPlatformViewMutation mutation = *platform_view.mutations[i];
            switch (mutation.type) {
              case kFlutterPlatformViewMutationTypeClipRoundedRect:
                mutation.clip_rounded_rect =
                    FlutterRoundedRectMake(SkRRect::MakeRectXY(
                        SkRect::MakeLTRB(5.0, 5.0, 400.0 - 5.0, 300.0 - 5.0),
                        7.0, 7.0));
                break;
              case kFlutterPlatformViewMutationTypeClipRect:
                mutation.type = kFlutterPlatformViewMutationTypeClipRect;
                mutation.clip_rect = FlutterRectMake(
                    SkRect::MakeXYWH(5.0, 5.0, 400.0 - 10.0, 300.0 - 10.0));
                break;
              case kFlutterPlatformViewMutationTypeOpacity:
                mutation.type = kFlutterPlatformViewMutationTypeOpacity;
                mutation.opacity = 128.0 / 255.0;
                break;
              case kFlutterPlatformViewMutationTypeTransformation:
                mutation.type = kFlutterPlatformViewMutationTypeTransformation;
                mutation.transformation =
                    FlutterTransformationMake(root_surface_transformation);
 
                break;
            }
 
            ASSERT_EQ(*platform_view.mutations[i], mutation);
          }
        }
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 2.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [450/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PopulateExistingDamageReceivesInvalidID
	)

Definition at line 3990 of file embedder_gl_unittests.cc.

                                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  // Return a bad FBO ID on purpose.
  builder.GetRendererConfig().open_gl.fbo_with_frame_info_callback =
      [](void* context, const FlutterFrameInfo* frame_info) -> uint32_t {
    return 123;
  };
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              /* Nothing to do. */
                            }));
 
  const uint32_t window_fbo_id =
      static_cast<EmbedderTestContextGL&>(context).GetWindowFBOId();
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [window_fbo_id = window_fbo_id](intptr_t id,
                                          FlutterDamage* existing_damage) {
            ASSERT_NE(id, window_fbo_id);
            existing_damage->num_rects = 0;
            existing_damage->damage = nullptr;
          });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
}

◆ TEST_F() [451/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PopulateExistingDamageReceivesValidID
	)

Definition at line 3953 of file embedder_gl_unittests.cc.

                                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  const uint32_t window_fbo_id =
      static_cast<EmbedderTestContextGL&>(context).GetWindowFBOId();
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [window_fbo_id = window_fbo_id](intptr_t id,
                                          FlutterDamage* existing_damage) {
            ASSERT_EQ(id, window_fbo_id);
            existing_damage->num_rects = 0;
            existing_damage->damage = nullptr;
          });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
}

◆ TEST_F() [452/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoContainsValidFBOId
	)

Definition at line 3655 of file embedder_gl_unittests.cc.

                                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetDartEntrypoint("push_frames_over_and_over");
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 1024).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  static fml::CountDownLatch frame_latch(10);
 
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              /* Nothing to do. */
                            }));
 
  const uint32_t window_fbo_id =
      static_cast<EmbedderTestContextGL&>(context).GetWindowFBOId();
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [window_fbo_id = window_fbo_id](FlutterPresentInfo present_info) {
        ASSERT_EQ(present_info.fbo_id, window_fbo_id);
 
        frame_latch.CountDown();
      });
 
  frame_latch.Wait();
}

◆ TEST_F() [453/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoReceivesEmptyDamage
	)

Definition at line 3784 of file embedder_gl_unittests.cc.

                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  // Return no existing damage on purpose.
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [](const intptr_t id, FlutterDamage* existing_damage_ptr) {
            const size_t num_rects = 1;
            // The array must be valid after the callback returns.
            static FlutterRect existing_damage_rects[num_rects] = {
                FlutterRect{0, 0, 0, 0}};
            existing_damage_ptr->num_rects = num_rects;
            existing_damage_ptr->damage = existing_damage_rects;
          });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
 
  // First frame should be entirely rerendered.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
 
  // Because it's the same as the first frame, the second frame should not be
  // rerendered assuming there is no existing damage.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 0);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 0);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 0);
 
        latch.Signal();
      });
 
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [454/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoReceivesFullDamageWhenExistingDamageIsWholeScreen
	)

Definition at line 3698 of file embedder_gl_unittests.cc.

                                                                     {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  // Return existing damage as the entire screen on purpose.
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [](const intptr_t id, FlutterDamage* existing_damage_ptr) {
            const size_t num_rects = 1;
            // The array must be valid after the callback returns.
            static FlutterRect existing_damage_rects[num_rects] = {
                FlutterRect{0, 0, 800, 600}};
            existing_damage_ptr->num_rects = num_rects;
            existing_damage_ptr->damage = existing_damage_rects;
          });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
 
  // First frame should be entirely rerendered.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
 
  // Because it's the same as the first frame, the second frame damage should
  // be empty but, because there was a full existing buffer damage, the buffer
  // damage should be the entire screen.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 0);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 0);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [455/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoReceivesFullScreenDamageWhenPopulateExistingDamageIsNotProvided
	)

Definition at line 4591 of file embedder_gl_unittests.cc.

                                                                                {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage = nullptr;
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
 
  // First frame should be entirely rerendered.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
 
  // Since populate_existing_damage is not provided, the partial repaint
  // functionality is actually disabled. So, the next frame should be entirely
  // new frame.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [456/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoReceivesJoinedDamageWhenExistingDamageContainsMultipleRects
	)

Definition at line 4661 of file embedder_gl_unittests.cc.

                                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  // Return existing damage as the entire screen on purpose.
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [](const intptr_t id, FlutterDamage* existing_damage_ptr) {
            const size_t num_rects = 2;
            // The array must be valid after the callback returns.
            static FlutterRect existing_damage_rects[num_rects] = {
                FlutterRect{100, 150, 200, 250},
                FlutterRect{200, 250, 300, 350},
            };
            existing_damage_ptr->num_rects = num_rects;
            existing_damage_ptr->damage = existing_damage_rects;
          });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
 
  // First frame should be entirely rerendered.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
 
  // Because it's the same as the first frame, the second frame damage should
  // be empty but, because there was a full existing buffer damage, the buffer
  // damage should be the entire screen.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 0);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 0);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 100);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 150);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 300);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 350);
 
        latch.Signal();
      });
 
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [457/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PresentInfoReceivesPartialDamage
	)

Definition at line 3868 of file embedder_gl_unittests.cc.

                                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("render_gradient_retained");
  builder.GetRendererConfig().open_gl.populate_existing_damage =
      [](void* context, const intptr_t id,
         FlutterDamage* existing_damage) -> void {
    return reinterpret_cast<EmbedderTestContextGL*>(context)
        ->GLPopulateExistingDamage(id, existing_damage);
  };
 
  // Return existing damage as only part of the screen on purpose.
  static_cast<EmbedderTestContextGL&>(context)
      .SetGLPopulateExistingDamageCallback(
          [&](const intptr_t id, FlutterDamage* existing_damage_ptr) {
            const size_t num_rects = 1;
            // The array must be valid after the callback returns.
            static FlutterRect existing_damage_rects[num_rects] = {
                FlutterRect{200, 150, 400, 300}};
            existing_damage_ptr->num_rects = num_rects;
            existing_damage_ptr->damage = existing_damage_rects;
          });
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  fml::AutoResetWaitableEvent latch;
 
  // First frame should be entirely rerendered.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 800);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 600);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 0);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 800);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 600);
 
        latch.Signal();
      });
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
 
  // Because it's the same as the first frame, the second frame damage should be
  // empty but, because there was a partial existing damage, the buffer damage
  // should represent that partial damage area.
  static_cast<EmbedderTestContextGL&>(context).SetGLPresentCallback(
      [&](FlutterPresentInfo present_info) {
        const size_t num_rects = 1;
        ASSERT_EQ(present_info.frame_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.frame_damage.damage->left, 0);
        ASSERT_EQ(present_info.frame_damage.damage->top, 0);
        ASSERT_EQ(present_info.frame_damage.damage->right, 0);
        ASSERT_EQ(present_info.frame_damage.damage->bottom, 0);
 
        ASSERT_EQ(present_info.buffer_damage.num_rects, num_rects);
        ASSERT_EQ(present_info.buffer_damage.damage->left, 200);
        ASSERT_EQ(present_info.buffer_damage.damage->top, 150);
        ASSERT_EQ(present_info.buffer_damage.damage->right, 400);
        ASSERT_EQ(present_info.buffer_damage.damage->bottom, 300);
 
        latch.Signal();
      });
 
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [458/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PushingMutlipleFramesSetsUpNewRecordingCanvasWithCustomCompositor
	)

Definition at line 2433 of file embedder_gl_unittests.cc.

                                                                          {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetCompositor();
  builder.SetDartEntrypoint("push_frames_over_and_over");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLTexture);
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 1024).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  constexpr size_t frames_expected = 10;
  fml::CountDownLatch frame_latch(frames_expected);
  std::atomic_size_t frames_seen = 0;
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              frames_seen++;
                              frame_latch.CountDown();
                            }));
  frame_latch.Wait();
 
  ASSERT_GE(frames_seen, frames_expected);
 
  FlutterEngineShutdown(engine.release());
}

◆ TEST_F() [459/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		PushingMutlipleFramesSetsUpNewRecordingCanvasWithoutCustomCompositor
	)

Definition at line 2477 of file embedder_gl_unittests.cc.

                                                                             {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(600, 1024));
  builder.SetDartEntrypoint("push_frames_over_and_over");
 
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 1024).preRotate(-90, 0, 0);
 
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  constexpr size_t frames_expected = 10;
  fml::CountDownLatch frame_latch(frames_expected);
  std::atomic_size_t frames_seen = 0;
  context.AddNativeCallback("SignalNativeTest",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              frames_seen++;
                              frame_latch.CountDown();
                            }));
  frame_latch.Wait();
 
  ASSERT_GE(frames_seen, frames_expected);
 
  FlutterEngineShutdown(engine.release());
}

◆ TEST_F() [460/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		RasterCacheDisabledWithPlatformViews
	)

Layers in a hierarchy containing a platform view should not be cached. The other layers in the hierarchy should be, however.

Definition at line 225 of file embedder_gl_unittests.cc.

                                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_platform_views_with_opacity");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  fml::CountDownLatch setup(3);
  fml::CountDownLatch verify(1);
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(123.0, 456.0);
          layer.offset = FlutterPointMake(1.0, 2.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(3, 3, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        setup.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&setup](Dart_NativeArguments args) { setup.CountDown(); }));
 
  UniqueEngine engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  setup.Wait();
  const flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  shell.GetTaskRunners().GetRasterTaskRunner()->PostTask([&] {
    const flutter::RasterCache& raster_cache =
        shell.GetRasterizer()->compositor_context()->raster_cache();
    // 3 layers total, but one of them had the platform view. So the cache
    // should only have 2 entries.
    ASSERT_EQ(raster_cache.GetCachedEntriesCount(), 2u);
    verify.CountDown();
  });
 
  verify.Wait();
}

◆ TEST_F() [461/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		RasterCacheEnabled
	)

The RasterCache should normally be enabled.

Definition at line 358 of file embedder_gl_unittests.cc.

                                         {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_composite_with_opacity");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  fml::CountDownLatch setup(3);
  fml::CountDownLatch verify(1);
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 1u);
 
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.struct_size = sizeof(backing_store);
          backing_store.type = kFlutterBackingStoreTypeOpenGL;
          backing_store.did_update = true;
          backing_store.open_gl.type = kFlutterOpenGLTargetTypeFramebuffer;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0, 0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        setup.CountDown();
      });
 
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&setup](Dart_NativeArguments args) { setup.CountDown(); }));
 
  UniqueEngine engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  setup.Wait();
  const flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  shell.GetTaskRunners().GetRasterTaskRunner()->PostTask([&] {
    const flutter::RasterCache& raster_cache =
        shell.GetRasterizer()->compositor_context()->raster_cache();
    ASSERT_EQ(raster_cache.GetCachedEntriesCount(), 1u);
    verify.CountDown();
  });
 
  verify.Wait();
}

◆ TEST_F() [462/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		RegisterChannelListener
	)

Definition at line 3690 of file embedder_unittests.cc.

                                              {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  fml::AutoResetWaitableEvent latch;
  fml::AutoResetWaitableEvent latch2;
  bool listening = false;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments) { latch.Signal(); }));
  context.SetChannelUpdateCallback([&](const FlutterChannelUpdate* update) {
    EXPECT_STREQ(update->channel, "test/listen");
    EXPECT_TRUE(update->listening);
    listening = true;
    latch2.Signal();
  });
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("channel_listener_response");
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
  // Drain tasks posted to platform thread task runner.
  fml::MessageLoop::GetCurrent().RunExpiredTasksNow();
  latch2.Wait();
 
  ASSERT_TRUE(listening);
}

◆ TEST_F() [463/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		SceneWithNoRootContainerIsAcceptable
	)

Definition at line 2882 of file embedder_gl_unittests.cc.

                                                           {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
  builder.SetDartEntrypoint("scene_with_no_container");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  latch.Wait();
}

◆ TEST_F() [464/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		SetSingleDisplayConfigurationWithDisplayId
	)

Definition at line 4038 of file embedder_gl_unittests.cc.

                                                                 {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterEngineDisplay display;
  display.struct_size = sizeof(FlutterEngineDisplay);
  display.display_id = 1;
  display.refresh_rate = 20;
 
  std::vector<FlutterEngineDisplay> displays = {display};
 
  const FlutterEngineResult result = FlutterEngineNotifyDisplayUpdate(
      engine.get(), kFlutterEngineDisplaysUpdateTypeStartup, displays.data(),
      displays.size());
  ASSERT_EQ(result, kSuccess);
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  ASSERT_EQ(shell.GetMainDisplayRefreshRate(), display.refresh_rate);
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [465/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		SetSingleDisplayConfigurationWithoutDisplayId
	)

Definition at line 4080 of file embedder_gl_unittests.cc.

                                                                    {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterEngineDisplay display;
  display.struct_size = sizeof(FlutterEngineDisplay);
  display.single_display = true;
  display.refresh_rate = 20;
 
  std::vector<FlutterEngineDisplay> displays = {display};
 
  const FlutterEngineResult result = FlutterEngineNotifyDisplayUpdate(
      engine.get(), kFlutterEngineDisplaysUpdateTypeStartup, displays.data(),
      displays.size());
  ASSERT_EQ(result, kSuccess);
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  ASSERT_EQ(shell.GetMainDisplayRefreshRate(), display.refresh_rate);
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [466/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		SetValidMultiDisplayConfiguration
	)

Definition at line 4122 of file embedder_gl_unittests.cc.

                                                        {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("empty_scene");
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  auto engine = builder.LaunchEngine();
 
  ASSERT_TRUE(engine.is_valid());
 
  FlutterEngineDisplay display_1;
  display_1.struct_size = sizeof(FlutterEngineDisplay);
  display_1.display_id = 1;
  display_1.single_display = false;
  display_1.refresh_rate = 20;
 
  FlutterEngineDisplay display_2;
  display_2.struct_size = sizeof(FlutterEngineDisplay);
  display_2.display_id = 2;
  display_2.single_display = false;
  display_2.refresh_rate = 60;
 
  std::vector<FlutterEngineDisplay> displays = {display_1, display_2};
 
  const FlutterEngineResult result = FlutterEngineNotifyDisplayUpdate(
      engine.get(), kFlutterEngineDisplaysUpdateTypeStartup, displays.data(),
      displays.size());
  ASSERT_EQ(result, kSuccess);
 
  flutter::Shell& shell = ToEmbedderEngine(engine.get())->GetShell();
  ASSERT_EQ(shell.GetMainDisplayRefreshRate(), display_1.refresh_rate);
 
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  latch.Wait();
}

◆ TEST_F() [467/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		SnapshotRenderTargetScalesDownToDriverMax
	)

Definition at line 4311 of file embedder_gl_unittests.cc.

                                                                {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetOpenGLRendererConfig(SkISize::Make(800, 600));
  builder.SetCompositor();
 
  auto max_size = context.GetCompositor().GetGrContext()->maxRenderTargetSize();
 
  context.AddIsolateCreateCallback([&]() {
    Dart_Handle snapshot_large_scene = Dart_GetField(
        Dart_RootLibrary(), tonic::ToDart("snapshot_large_scene"));
    tonic::DartInvoke(snapshot_large_scene, {tonic::ToDart<int64_t>(max_size)});
  });
 
  fml::AutoResetWaitableEvent latch;
  context.AddNativeCallback(
      "SnapshotsCallback", CREATE_NATIVE_ENTRY(([&](Dart_NativeArguments args) {
        auto get_arg = [&args](int index) {
          Dart_Handle dart_image = Dart_GetNativeArgument(args, index);
          Dart_Handle internal_image =
              Dart_GetField(dart_image, tonic::ToDart("_image"));
          return tonic::DartConverter<flutter::CanvasImage*>::FromDart(
              internal_image);
        };
 
        CanvasImage* big_image = get_arg(0);
        ASSERT_EQ(big_image->width(), max_size);
        ASSERT_EQ(big_image->height(), max_size / 2);
 
        CanvasImage* small_image = get_arg(1);
        ASSERT_TRUE(ImageMatchesFixture("snapshot_large_scene.png",
                                        small_image->image()->skia_image()));
 
        latch.Signal();
      })));
 
  UniqueEngine engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [468/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		TextureDestructionCallbackCalledWithoutCustomCompositorMetal
	)

Definition at line 266 of file embedder_metal_unittests.mm.

                                                                                   {
  EmbedderTestContextMetal& context = reinterpret_cast<EmbedderTestContextMetal&>(
      GetEmbedderContext(EmbedderTestContextType::kMetalContext));
  EmbedderConfigBuilder builder(context);
  builder.SetMetalRendererConfig(SkISize::Make(800, 600));
  builder.SetDartEntrypoint("texture_destruction_callback_called_without_custom_compositor");
 
  struct CollectContext {
    int present_count = 0;
    int collect_count = 0;
    fml::AutoResetWaitableEvent latch;
  };
 
  auto collect_context = std::make_unique<CollectContext>();
  context.SetNextDrawableCallback([&context, &collect_context](const FlutterFrameInfo* frame_info) {
    auto texture_info = context.GetTestMetalSurface()->GetTextureInfo();
 
    FlutterMetalTexture texture;
    texture.struct_size = sizeof(FlutterMetalTexture);
    texture.texture_id = texture_info.texture_id;
    texture.texture = reinterpret_cast<FlutterMetalTextureHandle>(texture_info.texture);
    texture.user_data = collect_context.get();
    texture.destruction_callback = [](void* user_data) {
      CollectContext* callback_collect_context = reinterpret_cast<CollectContext*>(user_data);
      ASSERT_TRUE(callback_collect_context->present_count > 0);
      callback_collect_context->collect_count++;
      callback_collect_context->latch.Signal();
    };
    return texture;
  });
  context.SetPresentCallback([&context, &collect_context](int64_t texture_id) {
    collect_context->present_count++;
    return context.GetTestMetalContext()->Present(texture_id);
  });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event), kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  collect_context->latch.Wait();
  EXPECT_EQ(collect_context->collect_count, 1);
}

◆ TEST_F() [469/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		VerifyB141980393
	)

Definition at line 1957 of file embedder_gl_unittests.cc.

                                       {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kOpenGLContext);
 
  EmbedderConfigBuilder builder(context);
 
  // The Flutter application is 800 x 600 but rendering on a surface that is 600
  // x 800 achieved using a root surface transformation.
  const auto root_surface_transformation =
      SkMatrix().preTranslate(0, 800).preRotate(-90, 0, 0);
  const auto flutter_application_rect = SkRect::MakeWH(800, 600);
  const auto root_surface_rect =
      root_surface_transformation.mapRect(flutter_application_rect);
 
  ASSERT_DOUBLE_EQ(root_surface_rect.width(), 600.0);
  ASSERT_DOUBLE_EQ(root_surface_rect.height(), 800.0);
 
  // Configure the fixture for the surface transformation.
  context.SetRootSurfaceTransformation(root_surface_transformation);
 
  // Configure the Flutter project args for the root surface transformation.
  builder.SetOpenGLRendererConfig(
      SkISize::Make(root_surface_rect.width(), root_surface_rect.height()));
 
  // Use a compositor instead of rendering directly to the surface.
  builder.SetCompositor();
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kOpenGLFramebuffer);
 
  builder.SetDartEntrypoint("verify_b141980393");
 
  fml::AutoResetWaitableEvent latch;
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 1u);
 
        // Layer Root
        {
          FlutterPlatformView platform_view = *layers[0]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1337;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
 
          // From the Dart side. These dimensions match those specified in Dart
          // code and are free of root surface transformations.
          const double unxformed_top_margin = 31.0;
          const double unxformed_bottom_margin = 37.0;
          const auto unxformed_platform_view_rect = SkRect::MakeXYWH(
              0.0,                   // x
              unxformed_top_margin,  // y (top margin)
              800,                   // width
              600 - unxformed_top_margin - unxformed_bottom_margin  // height
          );
 
          // The platform views are in the coordinate space of the root surface
          // with top-left origin. The embedder has specified a transformation
          // to this surface which it must account for in the coordinates it
          // receives here.
          const auto xformed_platform_view_rect =
              root_surface_transformation.mapRect(unxformed_platform_view_rect);
 
          // Spell out the value that we are going to be checking below for
          // clarity.
          ASSERT_EQ(xformed_platform_view_rect,
                    SkRect::MakeXYWH(31.0,   // x
                                     0.0,    // y
                                     532.0,  // width
                                     800.0   // height
                                     ));
 
          // Verify that the engine is giving us the right size and offset.
          layer.offset = FlutterPointMake(xformed_platform_view_rect.x(),
                                          xformed_platform_view_rect.y());
          layer.size = FlutterSizeMake(xformed_platform_view_rect.width(),
                                       xformed_platform_view_rect.height());
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        latch.Signal();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
 
  // The Flutter application is 800 x 600 rendering on a surface 600 x 800
  // achieved via a root surface transformation.
  event.width = flutter_application_rect.width();
  event.height = flutter_application_rect.height();
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ TEST_F() [470/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		VerifyB143464703WithSoftwareBackend
	)

Definition at line 2079 of file embedder_unittests.cc.

                                                          {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig(SkISize::Make(1024, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("verify_b143464703");
 
  builder.SetRenderTargetType(
      EmbedderTestBackingStoreProducer::RenderTargetType::kSoftwareBuffer);
 
  // setup the screenshot promise.
  auto rendered_scene = context.GetNextSceneImage();
 
  fml::CountDownLatch latch(1);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.type = kFlutterBackingStoreTypeSoftware;
          backing_store.did_update = true;
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 1024, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(1024.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(1024.0, 540.0);
          layer.offset = FlutterPointMake(135.0, 60.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        latch.CountDown();
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [](const FlutterLayer& layer,
         GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(
            layer, nullptr /* null because software compositor */);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 42: {
            SkPaint paint;
            // See dart test for total order.
            paint.setColor(SK_ColorGREEN);
            paint.setAlpha(127);
            const auto& rect =
                SkRect::MakeWH(layer.size.width, layer.size.height);
            canvas->drawRect(rect, paint);
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 1024;
  event.height = 600;
  event.pixel_ratio = 1.0;
  event.physical_view_inset_top = 0.0;
  event.physical_view_inset_right = 0.0;
  event.physical_view_inset_bottom = 0.0;
  event.physical_view_inset_left = 0.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  // wait for scene to be rendered.
  latch.Wait();
 
  // TODO(https://github.com/flutter/flutter/issues/53784): enable this on all
  // platforms.
#if !defined(FML_OS_LINUX)
  GTEST_SKIP() << "Skipping golden tests on non-Linux OSes";
#endif  // FML_OS_LINUX
  ASSERT_TRUE(
      ImageMatchesFixture("verifyb143464703_soft_noxform.png", rendered_scene));
}

◆ TEST_F() [471/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		ViewOperationsOrdered
	)

View operations - adding, removing, sending window metrics - must execute in order even though they are asynchronous. This is necessary to ensure the embedder's and engine's states remain synchronized.

Definition at line 1608 of file embedder_unittests.cc.

                                            {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
 
  fml::AutoResetWaitableEvent ready_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  std::atomic<int> message_count = 0;
  context.AddNativeCallback("SignalNativeMessage",
                            CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                              message_count.fetch_add(1);
                            }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  // Enqueue multiple view operations at once:
  //
  // 1. Add view 123 - This must succeed.
  // 2. Add duplicate view 123 - This must fail asynchronously.
  // 3. Add second view 456 - This must succeed.
  // 4. Remove second view 456 - This must succeed.
  //
  // The engine must execute view operations asynchronously in serial order.
  // If step 2 succeeds instead of step 1, this indicates the engine did not
  // execute the view operations in the correct order. If step 4 fails,
  // this indicates the engine did not wait until the add second view completed.
  FlutterWindowMetricsEvent metrics123 = {};
  metrics123.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics123.width = 800;
  metrics123.height = 600;
  metrics123.pixel_ratio = 1.0;
  metrics123.view_id = 123;
 
  FlutterWindowMetricsEvent metrics456 = {};
  metrics456.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics456.width = 800;
  metrics456.height = 600;
  metrics456.pixel_ratio = 1.0;
  metrics456.view_id = 456;
 
  struct Captures {
    fml::AutoResetWaitableEvent add_first_view;
    fml::AutoResetWaitableEvent add_duplicate_view;
    fml::AutoResetWaitableEvent add_second_view;
    fml::AutoResetWaitableEvent remove_second_view;
  };
  Captures captures;
 
  // Add view 123.
  FlutterAddViewInfo add_view_info = {};
  add_view_info.struct_size = sizeof(FlutterAddViewInfo);
  add_view_info.view_id = 123;
  add_view_info.view_metrics = &metrics123;
  add_view_info.user_data = &captures;
  add_view_info.add_view_callback = [](const FlutterAddViewResult* result) {
    auto captures = reinterpret_cast<Captures*>(result->user_data);
 
    ASSERT_TRUE(result->added);
    ASSERT_FALSE(captures->add_first_view.IsSignaledForTest());
    ASSERT_FALSE(captures->add_duplicate_view.IsSignaledForTest());
    ASSERT_FALSE(captures->add_second_view.IsSignaledForTest());
    ASSERT_FALSE(captures->remove_second_view.IsSignaledForTest());
 
    captures->add_first_view.Signal();
  };
 
  // Add duplicate view 123.
  FlutterAddViewInfo add_duplicate_view_info = {};
  add_duplicate_view_info.struct_size = sizeof(FlutterAddViewInfo);
  add_duplicate_view_info.view_id = 123;
  add_duplicate_view_info.view_metrics = &metrics123;
  add_duplicate_view_info.user_data = &captures;
  add_duplicate_view_info.add_view_callback =
      [](const FlutterAddViewResult* result) {
        auto captures = reinterpret_cast<Captures*>(result->user_data);
 
        ASSERT_FALSE(result->added);
        ASSERT_TRUE(captures->add_first_view.IsSignaledForTest());
        ASSERT_FALSE(captures->add_duplicate_view.IsSignaledForTest());
        ASSERT_FALSE(captures->add_second_view.IsSignaledForTest());
        ASSERT_FALSE(captures->remove_second_view.IsSignaledForTest());
 
        captures->add_duplicate_view.Signal();
      };
 
  // Add view 456.
  FlutterAddViewInfo add_second_view_info = {};
  add_second_view_info.struct_size = sizeof(FlutterAddViewInfo);
  add_second_view_info.view_id = 456;
  add_second_view_info.view_metrics = &metrics456;
  add_second_view_info.user_data = &captures;
  add_second_view_info.add_view_callback =
      [](const FlutterAddViewResult* result) {
        auto captures = reinterpret_cast<Captures*>(result->user_data);
 
        ASSERT_TRUE(result->added);
        ASSERT_TRUE(captures->add_first_view.IsSignaledForTest());
        ASSERT_TRUE(captures->add_duplicate_view.IsSignaledForTest());
        ASSERT_FALSE(captures->add_second_view.IsSignaledForTest());
        ASSERT_FALSE(captures->remove_second_view.IsSignaledForTest());
 
        captures->add_second_view.Signal();
      };
 
  // Remove view 456.
  FlutterRemoveViewInfo remove_second_view_info = {};
  remove_second_view_info.struct_size = sizeof(FlutterRemoveViewInfo);
  remove_second_view_info.view_id = 456;
  remove_second_view_info.user_data = &captures;
  remove_second_view_info.remove_view_callback =
      [](const FlutterRemoveViewResult* result) {
        auto captures = reinterpret_cast<Captures*>(result->user_data);
 
        ASSERT_TRUE(result->removed);
        ASSERT_TRUE(captures->add_first_view.IsSignaledForTest());
        ASSERT_TRUE(captures->add_duplicate_view.IsSignaledForTest());
        ASSERT_TRUE(captures->add_second_view.IsSignaledForTest());
        ASSERT_FALSE(captures->remove_second_view.IsSignaledForTest());
 
        captures->remove_second_view.Signal();
      };
 
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_view_info), kSuccess);
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_duplicate_view_info),
            kSuccess);
  ASSERT_EQ(FlutterEngineAddView(engine.get(), &add_second_view_info),
            kSuccess);
  ASSERT_EQ(FlutterEngineRemoveView(engine.get(), &remove_second_view_info),
            kSuccess);
  captures.remove_second_view.Wait();
  captures.add_second_view.Wait();
  captures.add_duplicate_view.Wait();
  captures.add_first_view.Wait();
  ASSERT_EQ(message_count, 3);
}

◆ TEST_F() [472/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		VMAndIsolateSnapshotSizesAreRedundantInAOTMode
	)

These snapshots may be materialized from symbols and the size field may not be relevant. Since this information is redundant, engine launch should not be gated on a non-zero buffer size.

Definition at line 625 of file embedder_unittests.cc.

                                                                     {
  if (!DartVM::IsRunningPrecompiledCode()) {
    GTEST_SKIP();
    return;
  }
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
 
  // The fixture sets this up correctly. Intentionally mess up the args.
  builder.GetProjectArgs().vm_snapshot_data_size = 0;
  builder.GetProjectArgs().vm_snapshot_instructions_size = 0;
  builder.GetProjectArgs().isolate_snapshot_data_size = 0;
  builder.GetProjectArgs().isolate_snapshot_instructions_size = 0;
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
}

◆ TEST_F() [473/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		VMShutsDownWhenNoEnginesInProcess
	)

Asserts behavior of FlutterProjectArgs::shutdown_dart_vm_when_done (which is set to true by default in these unit-tests).

Definition at line 576 of file embedder_unittests.cc.

                                                        {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  const auto launch_count = DartVM::GetVMLaunchCount();
 
  {
    auto engine = builder.LaunchEngine();
    ASSERT_EQ(launch_count + 1u, DartVM::GetVMLaunchCount());
  }
 
  {
    auto engine = builder.LaunchEngine();
    ASSERT_EQ(launch_count + 2u, DartVM::GetVMLaunchCount());
  }
}

◆ TEST_F() [474/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		VsyncCallbackPostedIntoFuture
	)

Definition at line 3309 of file embedder_unittests.cc.

                                                    {
  UniqueEngine engine;
  fml::AutoResetWaitableEvent present_latch;
  fml::AutoResetWaitableEvent vsync_latch;
 
  // One of the threads that the callback (FlutterEngineOnVsync) will be posted
  // to is the platform thread. So we cannot wait for assertions to complete on
  // the platform thread. Create a new thread to manage the engine instance and
  // wait for assertions on the test thread.
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  platform_task_runner->PostTask([&]() {
    auto& context =
        GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
 
    context.SetVsyncCallback([&](intptr_t baton) {
      platform_task_runner->PostTask([baton = baton, &engine, &vsync_latch]() {
        FlutterEngineOnVsync(engine.get(), baton, NanosFromEpoch(16),
                             NanosFromEpoch(32));
        vsync_latch.Signal();
      });
    });
    context.AddNativeCallback(
        "SignalNativeTest", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
          present_latch.Signal();
        }));
 
    EmbedderConfigBuilder builder(context);
    builder.SetSoftwareRendererConfig();
    builder.SetupVsyncCallback();
    builder.SetDartEntrypoint("empty_scene");
    engine = builder.LaunchEngine();
    ASSERT_TRUE(engine.is_valid());
 
    // Send a window metrics events so frames may be scheduled.
    FlutterWindowMetricsEvent event = {};
    event.struct_size = sizeof(event);
    event.width = 800;
    event.height = 600;
    event.pixel_ratio = 1.0;
 
    ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
              kSuccess);
  });
 
  vsync_latch.Wait();
  present_latch.Wait();
 
  fml::AutoResetWaitableEvent shutdown_latch;
  platform_task_runner->PostTask([&]() {
    engine.reset();
    shutdown_latch.Signal();
  });
  shutdown_latch.Wait();
}

◆ TEST_F() [475/925]

flutter::testing::TEST_F	(	EmbedderTest	,
		WindowMetricsEventDefaultsToImplicitView
	)

Definition at line 3593 of file embedder_unittests.cc.

                                                               {
  auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
  EmbedderConfigBuilder builder(context);
  builder.SetSoftwareRendererConfig();
  builder.SetDartEntrypoint("window_metrics_event_view_id");
 
  fml::AutoResetWaitableEvent ready_latch, message_latch;
  context.AddNativeCallback(
      "SignalNativeTest",
      CREATE_NATIVE_ENTRY(
          [&ready_latch](Dart_NativeArguments args) { ready_latch.Signal(); }));
  context.AddNativeCallback(
      "SignalNativeMessage",
      CREATE_NATIVE_ENTRY([&message_latch](Dart_NativeArguments args) {
        auto message = tonic::DartConverter<std::string>::FromDart(
            Dart_GetNativeArgument(args, 0));
        ASSERT_EQ("Changed: [0]", message);
        message_latch.Signal();
      }));
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  ready_latch.Wait();
 
  FlutterWindowMetricsEvent event = {};
  // Simulate an event that comes from an old version of embedder.h that doesn't
  // have the view_id field.
  event.struct_size = offsetof(FlutterWindowMetricsEvent, view_id);
  event.width = 200;
  event.height = 300;
  event.pixel_ratio = 1.5;
  // Skip assigning event.view_id here to test the default behavior.
 
  FlutterEngineResult result =
      FlutterEngineSendWindowMetricsEvent(engine.get(), &event);
  ASSERT_EQ(result, kSuccess);
 
  message_latch.Wait();
}

◆ TEST_F() [476/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallClassMemberFunction
	)

Definition at line 320 of file ffi_native_unittest.cc.

                                                         {
  DoCallThroughTest<void, decltype(&MyNativeClass::MyTestFunction),
                    &MyNativeClass::MyTestFunction>(
      "MyNativeClass::MyTestFunction", "callMyTestFunction");
}

◆ TEST_F() [477/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallClassMemberMethod
	)

Definition at line 335 of file ffi_native_unittest.cc.

                                                       {
  DoCallThroughTest<MyNativeClass, decltype(&MyNativeClass::MyTestMethod),
                    &MyNativeClass::MyTestMethod>("MyNativeClass::MyTestMethod",
                                                  "callMyTestMethod");
}

◆ TEST_F() [478/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoBool
	)

Definition at line 158 of file ffi_native_unittest.cc.

                                              {
  DoCallThroughTest<void, decltype(&EchoBool), &EchoBool>("EchoBool",
                                                          "callEchoBool");
}

◆ TEST_F() [479/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoDouble
	)

Definition at line 198 of file ffi_native_unittest.cc.

                                                {
  DoCallThroughTest<void, decltype(&EchoDouble), &EchoDouble>("EchoDouble",
                                                              "callEchoDouble");
}

◆ TEST_F() [480/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoHandle
	)

Definition at line 217 of file ffi_native_unittest.cc.

                                                {
  DoCallThroughTest<void, decltype(&EchoHandle), &EchoHandle>("EchoHandle",
                                                              "callEchoHandle");
}

◆ TEST_F() [481/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoIntPtr
	)

Definition at line 175 of file ffi_native_unittest.cc.

                                                {
  DoCallThroughTest<void, decltype(&EchoIntPtr), &EchoIntPtr>("EchoIntPtr",
                                                              "callEchoIntPtr");
}

◆ TEST_F() [482/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoString
	)

Definition at line 234 of file ffi_native_unittest.cc.

                                                {
  DoCallThroughTest<void, decltype(&EchoString), &EchoString>("EchoString",
                                                              "callEchoString");
}

◆ TEST_F() [483/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoTypedList
	)

Definition at line 308 of file ffi_native_unittest.cc.

                                                   {
  DoCallThroughTest<void, decltype(&EchoTypedList), &EchoTypedList>(
      "EchoTypedList", "callEchoTypedList");
}

◆ TEST_F() [484/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoU16String
	)

Definition at line 251 of file ffi_native_unittest.cc.

                                                   {
  DoCallThroughTest<void, decltype(&EchoU16String), &EchoU16String>(
      "EchoU16String", "callEchoU16String");
}

◆ TEST_F() [485/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoVector
	)

Definition at line 268 of file ffi_native_unittest.cc.

                                                {
  DoCallThroughTest<void, decltype(&EchoVector), &EchoVector>("EchoVector",
                                                              "callEchoVector");
}

◆ TEST_F() [486/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallEchoWrappable
	)

Definition at line 285 of file ffi_native_unittest.cc.

                                                   {
  DoCallThroughTest<void, decltype(&EchoWrappable), &EchoWrappable>(
      "EchoWrappable", "callEchoWrappable");
}

◆ TEST_F() [487/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		FfiBindingCallNop
	)

Definition at line 142 of file ffi_native_unittest.cc.

                                         {
  DoCallThroughTest<void, decltype(&Nop), &Nop>("Nop", "callNop");
}

◆ TEST_F() [488/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseClassMemberFunction
	)

Definition at line 326 of file ffi_native_unittest.cc.

                                                    {
  DoSerialiseTest<void, decltype(&MyNativeClass::MyTestFunction),
                  &MyNativeClass::MyTestFunction>(
      /*leaf=*/false, "Int32", "int", "Pointer, Int32, Handle",
      "Pointer, int, Object");
}

◆ TEST_F() [489/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseClassMemberMethod
	)

Definition at line 341 of file ffi_native_unittest.cc.

                                                  {
  DoSerialiseTest<MyNativeClass, decltype(&MyNativeClass::MyTestMethod),
                  &MyNativeClass::MyTestMethod>(
      /*leaf=*/false, "Handle", "Object", "Pointer, Int64", "Pointer, int");
}

◆ TEST_F() [490/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoBool
	)

Definition at line 163 of file ffi_native_unittest.cc.

                                         {
  DoSerialiseTest<void, decltype(&EchoBool), &EchoBool>(
      /*leaf=*/true, "Bool", "bool", "Bool", "bool");
}

◆ TEST_F() [491/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoDouble
	)

Definition at line 203 of file ffi_native_unittest.cc.

                                           {
  DoSerialiseTest<void, decltype(&EchoDouble), &EchoDouble>(
      /*leaf=*/true, "Double", "double", "Double", "double");
}

◆ TEST_F() [492/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoHandle
	)

Definition at line 222 of file ffi_native_unittest.cc.

                                           {
  DoSerialiseTest<void, decltype(&EchoHandle), &EchoHandle>(
      /*leaf=*/false, "Handle", "Object", "Handle", "Object");
}

◆ TEST_F() [493/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoIntPtr
	)

Definition at line 180 of file ffi_native_unittest.cc.

                                           {
  if (sizeof(intptr_t) == 8) {
    DoSerialiseTest<void, decltype(&EchoIntPtr), &EchoIntPtr>(
        /*leaf=*/true, "Int64", "int", "Int64", "int");
  } else {
    EXPECT_EQ(sizeof(intptr_t), 4ul);
    DoSerialiseTest<void, decltype(&EchoIntPtr), &EchoIntPtr>(
        /*leaf=*/true, "Int32", "int", "Int32", "int");
  }
}

◆ TEST_F() [494/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoString
	)

Definition at line 239 of file ffi_native_unittest.cc.

                                           {
  DoSerialiseTest<void, decltype(&EchoString), &EchoString>(
      /*leaf=*/false, "Handle", "String", "Handle", "String");
}

◆ TEST_F() [495/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoTypedList
	)

Definition at line 313 of file ffi_native_unittest.cc.

                                              {
  DoSerialiseTest<void, decltype(&EchoTypedList), &EchoTypedList>(
      /*leaf=*/false, "Handle", "Object", "Handle", "Object");
}

◆ TEST_F() [496/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoU16String
	)

Definition at line 256 of file ffi_native_unittest.cc.

                                              {
  DoSerialiseTest<void, decltype(&EchoU16String), &EchoU16String>(
      /*leaf=*/false, "Handle", "String", "Handle", "String");
}

◆ TEST_F() [497/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoVector
	)

Definition at line 273 of file ffi_native_unittest.cc.

                                           {
  DoSerialiseTest<void, decltype(&EchoVector), &EchoVector>(
      /*leaf=*/false, "Handle", "List", "Handle", "List");
}

◆ TEST_F() [498/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseEchoWrappable
	)

Definition at line 290 of file ffi_native_unittest.cc.

                                              {
  if (sizeof(intptr_t) == 8) {
    DoSerialiseTest<void, decltype(&EchoWrappable), &EchoWrappable>(
        /*leaf=*/true, "Int64", "int", "Pointer", "Pointer");
  } else {
    EXPECT_EQ(sizeof(intptr_t), 4ul);
    DoSerialiseTest<void, decltype(&EchoWrappable), &EchoWrappable>(
        /*leaf=*/true, "Int32", "int", "Pointer", "Pointer");
  }
}

◆ TEST_F() [499/925]

flutter::testing::TEST_F	(	FfiNativeTest	,
		SerialiseNop
	)

Definition at line 146 of file ffi_native_unittest.cc.

                                    {
  DoSerialiseTest<void, decltype(&Nop), &Nop>(
      /*leaf=*/true, "Void", "void", "", "");
}

◆ TEST_F() [500/925]

flutter::testing::TEST_F	(	FileLoaderTest	,
		CanonicalizesFileUrlCorrectly
	)

Definition at line 16 of file file_loader_unittests.cc.

                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
  auto isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
  auto vm_ref = DartVMRef::Create(settings, vm_snapshot, isolate_snapshot);
  ASSERT_TRUE(vm_ref);
 
  TaskRunners task_runners(GetCurrentTestName(),    //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner(),  //
                           GetCurrentTaskRunner()   //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners, "main",
                                      {}, GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
 
  ASSERT_TRUE(isolate->RunInIsolateScope([]() {
    tonic::FileLoader file_loader;
    std::string original_url = "file:///Users/test/foo";
    Dart_Handle dart_url = tonic::StdStringToDart(original_url);
    auto canonicalized_url = file_loader.CanonicalizeURL(Dart_Null(), dart_url);
    EXPECT_TRUE(canonicalized_url);
    EXPECT_EQ(tonic::StdStringFromDart(canonicalized_url), original_url);
    return true;
  }));
}

◆ TEST_F() [501/925]

flutter::testing::TEST_F	(	FlutterChannelKeyResponderTest	,
		BasicKeyEvent
	)

Definition at line 75 of file FlutterChannelKeyResponderTest.mm.

                                                      {
  __block NSMutableArray<NSNumber*>* responses = [[NSMutableArray<NSNumber*> alloc] init];
  FakeMessageChannel* channel = [[FakeMessageChannel alloc] init];
  FlutterChannelKeyResponder* responder =
      [[FlutterChannelKeyResponder alloc] initWithChannel:channel];
 
  // Initial empty modifiers.
  //
  // This can happen when user opens window while modifier key is pressed and then releases the
  // modifier. No events should be sent, but the callback should still be called.
  // Regression test for https://github.com/flutter/flutter/issues/87339.
  channel.nextResponse = @{@"handled" : @YES};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", NO, 60)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  EXPECT_EQ([channel.messages count], 0u);
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([responses[0] boolValue], YES);
  [responses removeAllObjects];
 
  // Key down
  channel.nextResponse = @{@"handled" : @YES};
  [responder handleEvent:CreateKeyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", NO, 0)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keydown");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 0);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0x0);
  EXPECT_STREQ([[channel.messages lastObject][@"characters"] UTF8String], "a");
  EXPECT_STREQ([[channel.messages lastObject][@"charactersIgnoringModifiers"] UTF8String], "a");
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], YES);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // Key up
  channel.nextResponse = @{@"handled" : @NO};
  [responder handleEvent:CreateKeyEvent(NSEventTypeKeyUp, 0x100, @"a", @"a", NO, 0)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keyup");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 0);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0);
  EXPECT_STREQ([[channel.messages lastObject][@"characters"] UTF8String], "a");
  EXPECT_STREQ([[channel.messages lastObject][@"charactersIgnoringModifiers"] UTF8String], "a");
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], NO);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // LShift down
  channel.nextResponse = @{@"handled" : @YES};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0x20102, @"", @"", NO, 56)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keydown");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 56);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0x20002);
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], YES);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // RShift down
  channel.nextResponse = @{@"handled" : @NO};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0x20006, @"", @"", NO, 60)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keydown");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 60);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0x20006);
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], NO);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // LShift up
  channel.nextResponse = @{@"handled" : @NO};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0x20104, @"", @"", NO, 56)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keyup");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 56);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0x20004);
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], NO);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // RShift up
  channel.nextResponse = @{@"handled" : @NO};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0, @"", @"", NO, 60)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keyup");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 60);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0);
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], NO);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
 
  // RShift up again, should be ignored and not produce a keydown event, but the
  // callback should be called.
  channel.nextResponse = @{@"handled" : @NO};
  [responder handleEvent:CreateKeyEvent(NSEventTypeFlagsChanged, 0x100, @"", @"", NO, 60)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  EXPECT_EQ([channel.messages count], 0u);
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([responses[0] boolValue], YES);
}

◆ TEST_F() [502/925]

flutter::testing::TEST_F	(	FlutterChannelKeyResponderTest	,
		EmptyResponseIsTakenAsHandled
	)

Definition at line 228 of file FlutterChannelKeyResponderTest.mm.

                                                                      {
  __block NSMutableArray<NSNumber*>* responses = [[NSMutableArray<NSNumber*> alloc] init];
  FakeMessageChannel* channel = [[FakeMessageChannel alloc] init];
  FlutterChannelKeyResponder* responder =
      [[FlutterChannelKeyResponder alloc] initWithChannel:channel];
 
  channel.nextResponse = nil;
  [responder handleEvent:CreateKeyEvent(NSEventTypeKeyDown, 0x100, @"a", @"a", NO, 0)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keydown");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 0);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0);
  EXPECT_STREQ([[channel.messages lastObject][@"characters"] UTF8String], "a");
  EXPECT_STREQ([[channel.messages lastObject][@"charactersIgnoringModifiers"] UTF8String], "a");
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], YES);
}

◆ TEST_F() [503/925]

flutter::testing::TEST_F	(	FlutterChannelKeyResponderTest	,
		FollowsLayoutMap
	)

Definition at line 252 of file FlutterChannelKeyResponderTest.mm.

                                                         {
  __block NSMutableArray<NSNumber*>* responses = [[NSMutableArray<NSNumber*> alloc] init];
  FakeMessageChannel* channel = [[FakeMessageChannel alloc] init];
  FlutterChannelKeyResponder* responder =
      [[FlutterChannelKeyResponder alloc] initWithChannel:channel];
 
  NSMutableDictionary<NSNumber*, NSNumber*>* layoutMap =
      [NSMutableDictionary<NSNumber*, NSNumber*> dictionary];
  responder.layoutMap = layoutMap;
  // French layout
  layoutMap[@(kVK_ANSI_A)] = @(kLogicalKeyQ);
 
  channel.nextResponse = @{@"handled" : @YES};
  [responder handleEvent:CreateKeyEvent(NSEventTypeKeyDown, kVK_ANSI_A, @"q", @"q", NO, 0)
                callback:^(BOOL handled) {
                  [responses addObject:@(handled)];
                }];
 
  ASSERT_EQ([channel.messages count], 1u);
  EXPECT_STREQ([[channel.messages lastObject][@"keymap"] UTF8String], "macos");
  EXPECT_STREQ([[channel.messages lastObject][@"type"] UTF8String], "keydown");
  EXPECT_EQ([[channel.messages lastObject][@"keyCode"] intValue], 0);
  EXPECT_EQ([[channel.messages lastObject][@"modifiers"] intValue], 0x0);
  EXPECT_STREQ([[channel.messages lastObject][@"characters"] UTF8String], "q");
  EXPECT_STREQ([[channel.messages lastObject][@"charactersIgnoringModifiers"] UTF8String], "q");
  EXPECT_EQ([channel.messages lastObject][@"specifiedLogicalKey"], @(kLogicalKeyQ));
 
  ASSERT_EQ([responses count], 1u);
  EXPECT_EQ([[responses lastObject] boolValue], YES);
 
  [channel.messages removeAllObjects];
  [responses removeAllObjects];
}

◆ TEST_F() [504/925]

flutter::testing::TEST_F	(	FlutterEmbedderExternalTextureTest	,
		TestPopulateExternalTexture
	)

Definition at line 131 of file FlutterEmbedderExternalTextureTest.mm.

                                                                        {
  // Constants.
  const size_t width = 100;
  const size_t height = 100;
  const int64_t texture_id = 1;
 
  // Set up the surface.
  FlutterDarwinContextMetalSkia* darwinContextMetal =
      [[FlutterDarwinContextMetalSkia alloc] initWithDefaultMTLDevice];
  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  GrDirectContext* grContext = darwinContextMetal.mainContext.get();
  sk_sp<SkSurface> gpuSurface(SkSurfaces::RenderTarget(grContext, skgpu::Budgeted::kNo, info));
 
  // Create a texture.
  TestExternalTexture* testExternalTexture =
      [[TestExternalTexture alloc] initWidth:width
                                      height:height
                             pixelFormatType:kCVPixelFormatType_32BGRA];
  FlutterExternalTexture* textureHolder =
      [[FlutterExternalTexture alloc] initWithFlutterTexture:testExternalTexture
                                          darwinMetalContext:darwinContextMetal];
 
  // Callback to resolve the texture.
  EmbedderExternalTextureMetal::ExternalTextureCallback callback = [&](int64_t texture_id, size_t w,
                                                                       size_t h) {
    EXPECT_TRUE(w == width);
    EXPECT_TRUE(h == height);
 
    auto texture = std::make_unique<FlutterMetalExternalTexture>();
    [textureHolder populateTexture:texture.get()];
 
    EXPECT_TRUE(texture->num_textures == 1);
    EXPECT_TRUE(texture->textures != nullptr);
    EXPECT_TRUE(texture->pixel_format == FlutterMetalExternalTexturePixelFormat::kRGBA);
    return texture;
  };
 
  // Render the texture.
  std::unique_ptr<flutter::Texture> texture =
      std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
  SkRect bounds = SkRect::MakeWH(info.width(), info.height());
  DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
  flutter::Texture::PaintContext context{
      .canvas = &canvas,
      .gr_context = grContext,
  };
  texture->Paint(context, bounds, /*freeze=*/false, sampling);
 
  gpuSurface->makeImageSnapshot();
}

◆ TEST_F() [505/925]

flutter::testing::TEST_F	(	FlutterEmbedderExternalTextureTest	,
		TestPopulateExternalTextureYUVA
	)

Definition at line 183 of file FlutterEmbedderExternalTextureTest.mm.

                                                                            {
  // Constants.
  const size_t width = 100;
  const size_t height = 100;
  const int64_t texture_id = 1;
 
  // Set up the surface.
  FlutterDarwinContextMetalSkia* darwinContextMetal =
      [[FlutterDarwinContextMetalSkia alloc] initWithDefaultMTLDevice];
  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  GrDirectContext* grContext = darwinContextMetal.mainContext.get();
  sk_sp<SkSurface> gpuSurface(SkSurfaces::RenderTarget(grContext, skgpu::Budgeted::kNo, info));
 
  // Create a texture.
  TestExternalTexture* testExternalTexture =
      [[TestExternalTexture alloc] initWidth:width
                                      height:height
                             pixelFormatType:kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange];
  FlutterExternalTexture* textureHolder =
      [[FlutterExternalTexture alloc] initWithFlutterTexture:testExternalTexture
                                          darwinMetalContext:darwinContextMetal];
 
  // Callback to resolve the texture.
  EmbedderExternalTextureMetal::ExternalTextureCallback callback = [&](int64_t texture_id, size_t w,
                                                                       size_t h) {
    EXPECT_TRUE(w == width);
    EXPECT_TRUE(h == height);
 
    auto texture = std::make_unique<FlutterMetalExternalTexture>();
    [textureHolder populateTexture:texture.get()];
 
    EXPECT_TRUE(texture->num_textures == 2);
    EXPECT_TRUE(texture->textures != nullptr);
    EXPECT_TRUE(texture->pixel_format == FlutterMetalExternalTexturePixelFormat::kYUVA);
    EXPECT_TRUE(texture->yuv_color_space ==
                FlutterMetalExternalTextureYUVColorSpace::kBT601LimitedRange);
    return texture;
  };
 
  // Render the texture.
  std::unique_ptr<flutter::Texture> texture =
      std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
  SkRect bounds = SkRect::MakeWH(info.width(), info.height());
  DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
  flutter::Texture::PaintContext context{
      .canvas = &canvas,
      .gr_context = grContext,
  };
  texture->Paint(context, bounds, /*freeze=*/false, sampling);
 
  gpuSurface->makeImageSnapshot();
}

◆ TEST_F() [506/925]

flutter::testing::TEST_F	(	FlutterEmbedderExternalTextureTest	,
		TestPopulateExternalTextureYUVA2
	)

Definition at line 237 of file FlutterEmbedderExternalTextureTest.mm.

                                                                             {
  // Constants.
  const size_t width = 100;
  const size_t height = 100;
  const int64_t texture_id = 1;
 
  // Set up the surface.
  FlutterDarwinContextMetalSkia* darwinContextMetal =
      [[FlutterDarwinContextMetalSkia alloc] initWithDefaultMTLDevice];
  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  GrDirectContext* grContext = darwinContextMetal.mainContext.get();
  sk_sp<SkSurface> gpuSurface(SkSurfaces::RenderTarget(grContext, skgpu::Budgeted::kNo, info));
 
  // Create a texture.
  TestExternalTexture* testExternalTexture =
      [[TestExternalTexture alloc] initWidth:width
                                      height:height
                             pixelFormatType:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange];
  FlutterExternalTexture* textureHolder =
      [[FlutterExternalTexture alloc] initWithFlutterTexture:testExternalTexture
                                          darwinMetalContext:darwinContextMetal];
 
  // Callback to resolve the texture.
  EmbedderExternalTextureMetal::ExternalTextureCallback callback = [&](int64_t texture_id, size_t w,
                                                                       size_t h) {
    EXPECT_TRUE(w == width);
    EXPECT_TRUE(h == height);
 
    auto texture = std::make_unique<FlutterMetalExternalTexture>();
    [textureHolder populateTexture:texture.get()];
 
    EXPECT_TRUE(texture->num_textures == 2);
    EXPECT_TRUE(texture->textures != nullptr);
    EXPECT_TRUE(texture->pixel_format == FlutterMetalExternalTexturePixelFormat::kYUVA);
    EXPECT_TRUE(texture->yuv_color_space ==
                FlutterMetalExternalTextureYUVColorSpace::kBT601FullRange);
    return texture;
  };
 
  // Render the texture.
  std::unique_ptr<flutter::Texture> texture =
      std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
  SkRect bounds = SkRect::MakeWH(info.width(), info.height());
  DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
  flutter::Texture::PaintContext context{
      .canvas = &canvas,
      .gr_context = grContext,
  };
  texture->Paint(context, bounds, /*freeze=*/false, sampling);
 
  gpuSurface->makeImageSnapshot();
}

◆ TEST_F() [507/925]

flutter::testing::TEST_F	(	FlutterEmbedderExternalTextureTest	,
		TestPopulateUnsupportedExternalTexture
	)

Definition at line 291 of file FlutterEmbedderExternalTextureTest.mm.

                                                                                   {
  // Constants.
  const size_t width = 100;
  const size_t height = 100;
  const int64_t texture_id = 1;
 
  // Set up the surface.
  FlutterDarwinContextMetalSkia* darwinContextMetal =
      [[FlutterDarwinContextMetalSkia alloc] initWithDefaultMTLDevice];
  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  GrDirectContext* grContext = darwinContextMetal.mainContext.get();
  sk_sp<SkSurface> gpuSurface(SkSurfaces::RenderTarget(grContext, skgpu::Budgeted::kNo, info));
 
  // Create a texture.
  TestExternalTexture* testExternalTexture =
      [[TestExternalTexture alloc] initWidth:width
                                      height:height
                             pixelFormatType:kCVPixelFormatType_420YpCbCr8PlanarFullRange];
  FlutterExternalTexture* textureHolder =
      [[FlutterExternalTexture alloc] initWithFlutterTexture:testExternalTexture
                                          darwinMetalContext:darwinContextMetal];
 
  // Callback to resolve the texture.
  EmbedderExternalTextureMetal::ExternalTextureCallback callback = [&](int64_t texture_id, size_t w,
                                                                       size_t h) {
    EXPECT_TRUE(w == width);
    EXPECT_TRUE(h == height);
 
    auto texture = std::make_unique<FlutterMetalExternalTexture>();
    EXPECT_FALSE([textureHolder populateTexture:texture.get()]);
    return nullptr;
  };
 
  // Render the texture.
  std::unique_ptr<flutter::Texture> texture =
      std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
  SkRect bounds = SkRect::MakeWH(info.width(), info.height());
  DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
  flutter::Texture::PaintContext context{
      .canvas = &canvas,
      .gr_context = grContext,
  };
  texture->Paint(context, bounds, /*freeze=*/false, sampling);
}

◆ TEST_F() [508/925]

flutter::testing::TEST_F	(	FlutterEmbedderExternalTextureTest	,
		TestTextureResolution
	)

Definition at line 73 of file FlutterEmbedderExternalTextureTest.mm.

                                                                  {
  // Constants.
  const size_t width = 100;
  const size_t height = 100;
  const int64_t texture_id = 1;
 
  // Set up the surface.
  FlutterDarwinContextMetalSkia* darwinContextMetal =
      [[FlutterDarwinContextMetalSkia alloc] initWithDefaultMTLDevice];
  SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  GrDirectContext* grContext = darwinContextMetal.mainContext.get();
  sk_sp<SkSurface> gpuSurface(SkSurfaces::RenderTarget(grContext, skgpu::Budgeted::kNo, info));
 
  // Create a texture.
  MTLTextureDescriptor* textureDescriptor = [[MTLTextureDescriptor alloc] init];
  textureDescriptor.pixelFormat = MTLPixelFormatBGRA8Unorm;
  textureDescriptor.width = width;
  textureDescriptor.height = height;
  textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
  id<MTLTexture> mtlTexture =
      [darwinContextMetal.device newTextureWithDescriptor:textureDescriptor];
  std::vector<FlutterMetalTextureHandle> textures = {
      (__bridge FlutterMetalTextureHandle)mtlTexture,
  };
 
  // Callback to resolve the texture.
  EmbedderExternalTextureMetal::ExternalTextureCallback callback = [&](int64_t texture_id, size_t w,
                                                                       size_t h) {
    EXPECT_TRUE(w == width);
    EXPECT_TRUE(h == height);
 
    auto texture = std::make_unique<FlutterMetalExternalTexture>();
    texture->struct_size = sizeof(FlutterMetalExternalTexture);
    texture->num_textures = 1;
    texture->height = h;
    texture->width = w;
    texture->pixel_format = FlutterMetalExternalTexturePixelFormat::kRGBA;
    texture->textures = textures.data();
    return texture;
  };
 
  // Render the texture.
  std::unique_ptr<flutter::Texture> texture =
      std::make_unique<EmbedderExternalTextureMetal>(texture_id, callback);
  SkRect bounds = SkRect::MakeWH(info.width(), info.height());
  DlImageSampling sampling = DlImageSampling::kNearestNeighbor;
  DlSkCanvasAdapter canvas(gpuSurface->getCanvas());
  flutter::Texture::PaintContext context{
      .canvas = &canvas,
      .gr_context = grContext,
  };
  texture->Paint(context, bounds, /*freeze=*/false, sampling);
 
  ASSERT_TRUE(mtlTexture != nil);
 
  gpuSurface->makeImageSnapshot();
}

◆ TEST_F() [509/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		CanLaunch
	)

Definition at line 142 of file FlutterEngineTest.mm.

                                     {
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
  ASSERT_TRUE(engine.running);
}

◆ TEST_F() [510/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		CanLogToStdout
	)

Definition at line 205 of file FlutterEngineTest.mm.

                                          {
  // Block until completion of print statement.
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("SignalNativeTest",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
 
  // Replace stdout stream buffer with our own.
  StreamCapture stdout_capture(&std::cout);
 
  // Launch the test entrypoint.
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"canLogToStdout"]);
  ASSERT_TRUE(engine.running);
 
  latch.Wait();
 
  stdout_capture.Stop();
 
  // Verify hello world was written to stdout.
  EXPECT_TRUE(stdout_capture.GetOutput().find("Hello logging") != std::string::npos);
}

◆ TEST_F() [511/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		CanToggleAccessibility
	)

Definition at line 286 of file FlutterEngineTest.mm.

                                                  {
  FlutterEngine* engine = GetFlutterEngine();
  // Capture the update callbacks before the embedder API initializes.
  auto original_init = engine.embedderAPI.Initialize;
  std::function<void(const FlutterSemanticsUpdate2*, void*)> update_semantics_callback;
  engine.embedderAPI.Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&update_semantics_callback, &original_init](
                       size_t version, const FlutterRendererConfig* config,
                       const FlutterProjectArgs* args, void* user_data, auto engine_out) {
        update_semantics_callback = args->update_semantics_callback2;
        return original_init(version, config, args, user_data, engine_out);
      }));
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
  // Set up view controller.
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  // Enable the semantics.
  bool enabled_called = false;
  engine.embedderAPI.UpdateSemanticsEnabled =
      MOCK_ENGINE_PROC(UpdateSemanticsEnabled, ([&enabled_called](auto engine, bool enabled) {
                         enabled_called = enabled;
                         return kSuccess;
                       }));
  engine.semanticsEnabled = YES;
  EXPECT_TRUE(enabled_called);
  // Send flutter semantics updates.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.flags = static_cast<FlutterSemanticsFlag>(0);
  child1.actions = static_cast<FlutterSemanticsAction>(0);
  child1.text_selection_base = -1;
  child1.text_selection_extent = -1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
 
  FlutterSemanticsUpdate2 update;
  update.node_count = 2;
  FlutterSemanticsNode2* nodes[] = {&root, &child1};
  update.nodes = nodes;
  update.custom_action_count = 0;
  update_semantics_callback(&update, (__bridge void*)engine);
 
  // Verify the accessibility tree is attached to the flutter view.
  EXPECT_EQ([engine.viewController.flutterView.accessibilityChildren count], 1u);
  NSAccessibilityElement* native_root = engine.viewController.flutterView.accessibilityChildren[0];
  std::string root_label = [native_root.accessibilityLabel UTF8String];
  EXPECT_TRUE(root_label == "root");
  EXPECT_EQ(native_root.accessibilityRole, NSAccessibilityGroupRole);
  EXPECT_EQ([native_root.accessibilityChildren count], 1u);
  NSAccessibilityElement* native_child1 = native_root.accessibilityChildren[0];
  std::string child1_value = [native_child1.accessibilityValue UTF8String];
  EXPECT_TRUE(child1_value == "child 1");
  EXPECT_EQ(native_child1.accessibilityRole, NSAccessibilityStaticTextRole);
  EXPECT_EQ([native_child1.accessibilityChildren count], 0u);
  // Disable the semantics.
  bool semanticsEnabled = true;
  engine.embedderAPI.UpdateSemanticsEnabled =
      MOCK_ENGINE_PROC(UpdateSemanticsEnabled, ([&semanticsEnabled](auto engine, bool enabled) {
                         semanticsEnabled = enabled;
                         return kSuccess;
                       }));
  engine.semanticsEnabled = NO;
  EXPECT_FALSE(semanticsEnabled);
  // Verify the accessibility tree is removed from the view.
  EXPECT_EQ([engine.viewController.flutterView.accessibilityChildren count], 0u);
 
  [engine setViewController:nil];
}

◆ TEST_F() [512/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		CanToggleAccessibilityWhenHeadless
	)

Definition at line 380 of file FlutterEngineTest.mm.

                                                              {
  FlutterEngine* engine = GetFlutterEngine();
  // Capture the update callbacks before the embedder API initializes.
  auto original_init = engine.embedderAPI.Initialize;
  std::function<void(const FlutterSemanticsUpdate2*, void*)> update_semantics_callback;
  engine.embedderAPI.Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&update_semantics_callback, &original_init](
                       size_t version, const FlutterRendererConfig* config,
                       const FlutterProjectArgs* args, void* user_data, auto engine_out) {
        update_semantics_callback = args->update_semantics_callback2;
        return original_init(version, config, args, user_data, engine_out);
      }));
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
 
  // Enable the semantics without attaching a view controller.
  bool enabled_called = false;
  engine.embedderAPI.UpdateSemanticsEnabled =
      MOCK_ENGINE_PROC(UpdateSemanticsEnabled, ([&enabled_called](auto engine, bool enabled) {
                         enabled_called = enabled;
                         return kSuccess;
                       }));
  engine.semanticsEnabled = YES;
  EXPECT_TRUE(enabled_called);
  // Send flutter semantics updates.
  FlutterSemanticsNode2 root;
  root.id = 0;
  root.flags = static_cast<FlutterSemanticsFlag>(0);
  root.actions = static_cast<FlutterSemanticsAction>(0);
  root.text_selection_base = -1;
  root.text_selection_extent = -1;
  root.label = "root";
  root.hint = "";
  root.value = "";
  root.increased_value = "";
  root.decreased_value = "";
  root.tooltip = "";
  root.child_count = 1;
  int32_t children[] = {1};
  root.children_in_traversal_order = children;
  root.custom_accessibility_actions_count = 0;
 
  FlutterSemanticsNode2 child1;
  child1.id = 1;
  child1.flags = static_cast<FlutterSemanticsFlag>(0);
  child1.actions = static_cast<FlutterSemanticsAction>(0);
  child1.text_selection_base = -1;
  child1.text_selection_extent = -1;
  child1.label = "child 1";
  child1.hint = "";
  child1.value = "";
  child1.increased_value = "";
  child1.decreased_value = "";
  child1.tooltip = "";
  child1.child_count = 0;
  child1.custom_accessibility_actions_count = 0;
 
  FlutterSemanticsUpdate2 update;
  update.node_count = 2;
  FlutterSemanticsNode2* nodes[] = {&root, &child1};
  update.nodes = nodes;
  update.custom_action_count = 0;
  // This call updates semantics for the implicit view, which does not exist,
  // and therefore this call is invalid. But the engine should not crash.
  update_semantics_callback(&update, (__bridge void*)engine);
 
  // No crashes.
  EXPECT_EQ(engine.viewController, nil);
 
  // Disable the semantics.
  bool semanticsEnabled = true;
  engine.embedderAPI.UpdateSemanticsEnabled =
      MOCK_ENGINE_PROC(UpdateSemanticsEnabled, ([&semanticsEnabled](auto engine, bool enabled) {
                         semanticsEnabled = enabled;
                         return kSuccess;
                       }));
  engine.semanticsEnabled = NO;
  EXPECT_FALSE(semanticsEnabled);
  // Still no crashes
  EXPECT_EQ(engine.viewController, nil);
}

◆ TEST_F() [513/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		Compositor
	)

Definition at line 502 of file FlutterEngineTest.mm.

                                      {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test" project:project];
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  [viewController viewDidLoad];
  viewController.flutterView.frame = CGRectMake(0, 0, 800, 600);
 
  EXPECT_TRUE([engine runWithEntrypoint:@"canCompositePlatformViews"]);
 
  [engine.platformViewController registerViewFactory:[[TestPlatformViewFactory alloc] init]
                                              withId:@"factory_id"];
  [engine.platformViewController
      handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"create"
                                                         arguments:@{
                                                           @"id" : @(42),
                                                           @"viewType" : @"factory_id",
                                                         }]
                result:^(id result){
                }];
 
  [engine.testThreadSynchronizer blockUntilFrameAvailable];
 
  CALayer* rootLayer = viewController.flutterView.layer;
 
  // There are two layers with Flutter contents and one view
  EXPECT_EQ(rootLayer.sublayers.count, 2u);
  EXPECT_EQ(viewController.flutterView.subviews.count, 1u);
 
  // TODO(gw280): add support for screenshot tests in this test harness
 
  [engine shutDownEngine];
}

◆ TEST_F() [514/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		CompositorIgnoresUnknownView
	)

Definition at line 542 of file FlutterEngineTest.mm.

                                                        {
  FlutterEngine* engine = GetFlutterEngine();
  auto original_init = engine.embedderAPI.Initialize;
  ::FlutterCompositor compositor;
  engine.embedderAPI.Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&compositor, &original_init](
                       size_t version, const FlutterRendererConfig* config,
                       const FlutterProjectArgs* args, void* user_data, auto engine_out) {
        compositor = *args->compositor;
        return original_init(version, config, args, user_data, engine_out);
      }));
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
 
  EXPECT_TRUE([engine runWithEntrypoint:@"empty"]);
 
  FlutterBackingStoreConfig config = {
      .struct_size = sizeof(FlutterBackingStoreConfig),
      .size = FlutterSize{10, 10},
  };
  FlutterBackingStore backing_store = {};
  EXPECT_NE(compositor.create_backing_store_callback, nullptr);
  EXPECT_TRUE(
      compositor.create_backing_store_callback(&config, &backing_store, compositor.user_data));
 
  FlutterLayer layer{
      .type = kFlutterLayerContentTypeBackingStore,
      .backing_store = &backing_store,
  };
  std::vector<FlutterLayer*> layers = {&layer};
 
  FlutterPresentViewInfo info = {
      .struct_size = sizeof(FlutterPresentViewInfo),
      .view_id = 123,
      .layers = const_cast<const FlutterLayer**>(layers.data()),
      .layers_count = 1,
      .user_data = compositor.user_data,
  };
  EXPECT_NE(compositor.present_view_callback, nullptr);
  EXPECT_FALSE(compositor.present_view_callback(&info));
  EXPECT_TRUE(compositor.collect_backing_store_callback(&backing_store, compositor.user_data));
 
  (void)viewController;
  [engine shutDownEngine];
}

◆ TEST_F() [515/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		DartEntrypointArguments
	)

Definition at line 591 of file FlutterEngineTest.mm.

                                                   {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
 
  project.dartEntrypointArguments = @[ @"arg1", @"arg2" ];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test" project:project];
 
  bool called = false;
  auto original_init = engine.embedderAPI.Initialize;
  engine.embedderAPI.Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&called, &original_init](size_t version, const FlutterRendererConfig* config,
                                             const FlutterProjectArgs* args, void* user_data,
                                             FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        called = true;
        EXPECT_EQ(args->dart_entrypoint_argc, 2);
        NSString* arg1 = [[NSString alloc] initWithCString:args->dart_entrypoint_argv[0]
                                                  encoding:NSUTF8StringEncoding];
        NSString* arg2 = [[NSString alloc] initWithCString:args->dart_entrypoint_argv[1]
                                                  encoding:NSUTF8StringEncoding];
 
        EXPECT_TRUE([arg1 isEqualToString:@"arg1"]);
        EXPECT_TRUE([arg2 isEqualToString:@"arg2"]);
 
        return original_init(version, config, args, user_data, engine_out);
      }));
 
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
  EXPECT_TRUE(called);
}

◆ TEST_F() [516/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		DISABLED_BackgroundIsBlack
	)

Definition at line 227 of file FlutterEngineTest.mm.

                                                      {
  FlutterEngine* engine = GetFlutterEngine();
 
  // Latch to ensure the entire layer tree has been generated and presented.
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("SignalNativeTest", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      CALayer* rootLayer = engine.viewController.flutterView.layer;
                      EXPECT_TRUE(rootLayer.backgroundColor != nil);
                      if (rootLayer.backgroundColor != nil) {
                        NSColor* actualBackgroundColor =
                            [NSColor colorWithCGColor:rootLayer.backgroundColor];
                        EXPECT_EQ(actualBackgroundColor, [NSColor blackColor]);
                      }
                      latch.Signal();
                    }));
 
  // Launch the test entrypoint.
  EXPECT_TRUE([engine runWithEntrypoint:@"backgroundTest"]);
  ASSERT_TRUE(engine.running);
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  viewController.flutterView.frame = CGRectMake(0, 0, 800, 600);
 
  latch.Wait();
}

◆ TEST_F() [517/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		DISABLED_CanOverrideBackgroundColor
	)

Definition at line 256 of file FlutterEngineTest.mm.

                                                               {
  FlutterEngine* engine = GetFlutterEngine();
 
  // Latch to ensure the entire layer tree has been generated and presented.
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("SignalNativeTest", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      CALayer* rootLayer = engine.viewController.flutterView.layer;
                      EXPECT_TRUE(rootLayer.backgroundColor != nil);
                      if (rootLayer.backgroundColor != nil) {
                        NSColor* actualBackgroundColor =
                            [NSColor colorWithCGColor:rootLayer.backgroundColor];
                        EXPECT_EQ(actualBackgroundColor, [NSColor whiteColor]);
                      }
                      latch.Signal();
                    }));
 
  // Launch the test entrypoint.
  EXPECT_TRUE([engine runWithEntrypoint:@"backgroundTest"]);
  ASSERT_TRUE(engine.running);
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  viewController.flutterView.frame = CGRectMake(0, 0, 800, 600);
  viewController.flutterView.backgroundColor = [NSColor whiteColor];
 
  latch.Wait();
}

◆ TEST_F() [518/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		DisplaySizeIsInPhysicalPixel
	)

Definition at line 1218 of file FlutterEngineTest.mm.

                                                        {
  NSString* fixtures = @(testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  project.rootIsolateCreateCallback = FlutterEngineTest::IsolateCreateCallback;
  MockableFlutterEngine* engine = [[MockableFlutterEngine alloc] initWithName:@"foobar"
                                                                      project:project
                                                       allowHeadlessExecution:true];
  BOOL updated = NO;
  auto original_update_displays = engine.embedderAPI.NotifyDisplayUpdate;
  engine.embedderAPI.NotifyDisplayUpdate = MOCK_ENGINE_PROC(
      NotifyDisplayUpdate, ([&updated, &original_update_displays](
                                auto engine, auto update_type, auto* displays, auto display_count) {
        EXPECT_EQ(display_count, 1UL);
        EXPECT_EQ(displays->display_id, 10UL);
        EXPECT_EQ(displays->width, 60UL);
        EXPECT_EQ(displays->height, 80UL);
        EXPECT_EQ(displays->device_pixel_ratio, 2UL);
        updated = YES;
        return original_update_displays(engine, update_type, displays, display_count);
      }));
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
  EXPECT_TRUE(updated);
  [engine shutDownEngine];
  engine = nil;
}

◆ TEST_F() [519/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		FlutterBinaryMessengerDoesNotRetainEngine
	)

Definition at line 629 of file FlutterEngineTest.mm.

                                                                     {
  __weak FlutterEngine* weakEngine;
  id<FlutterBinaryMessenger> binaryMessenger = nil;
  @autoreleasepool {
    // Create a test engine.
    NSString* fixtures = @(flutter::testing::GetFixturesPath());
    FlutterDartProject* project = [[FlutterDartProject alloc]
        initWithAssetsPath:fixtures
               ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
    FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                        project:project
                                         allowHeadlessExecution:YES];
    weakEngine = engine;
    binaryMessenger = engine.binaryMessenger;
  }
 
  // Once the engine has been deallocated, verify the weak engine pointer is nil, and thus not
  // retained by the relay.
  EXPECT_NE(binaryMessenger, nil);
  EXPECT_EQ(weakEngine, nil);
}

◆ TEST_F() [520/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		FlutterTextureRegistryDoesNotReturnEngine
	)

Definition at line 653 of file FlutterEngineTest.mm.

                                                                     {
  __weak FlutterEngine* weakEngine;
  id<FlutterTextureRegistry> textureRegistry;
  @autoreleasepool {
    // Create a test engine.
    NSString* fixtures = @(flutter::testing::GetFixturesPath());
    FlutterDartProject* project = [[FlutterDartProject alloc]
        initWithAssetsPath:fixtures
               ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
    FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                        project:project
                                         allowHeadlessExecution:YES];
    id<FlutterPluginRegistrar> registrar = [engine registrarForPlugin:@"MyPlugin"];
    textureRegistry = registrar.textures;
  }
 
  // Once the engine has been deallocated, verify the weak engine pointer is nil, and thus not
  // retained via the texture registry.
  EXPECT_NE(textureRegistry, nil);
  EXPECT_EQ(weakEngine, nil);
}

◆ TEST_F() [521/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ForwardsPluginDelegateRegistration
	)

Definition at line 1131 of file FlutterEngineTest.mm.

                                                              {
  id<NSApplicationDelegate> previousDelegate = [[NSApplication sharedApplication] delegate];
  FakeLifecycleProvider* fakeAppDelegate = [[FakeLifecycleProvider alloc] init];
  [NSApplication sharedApplication].delegate = fakeAppDelegate;
 
  FakeAppDelegatePlugin* plugin = [[FakeAppDelegatePlugin alloc] init];
  FlutterEngine* engine = CreateMockFlutterEngine(nil);
 
  [[engine registrarForPlugin:@"TestPlugin"] addApplicationDelegate:plugin];
 
  EXPECT_TRUE([fakeAppDelegate hasDelegate:plugin]);
 
  [NSApplication sharedApplication].delegate = previousDelegate;
}

◆ TEST_F() [522/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HandleAccessibilityEvent
	)

Definition at line 1037 of file FlutterEngineTest.mm.

                                                    {
  __block BOOL announced = NO;
  id engineMock = CreateMockFlutterEngine(nil);
 
  OCMStub([engineMock announceAccessibilityMessage:[OCMArg any]
                                      withPriority:NSAccessibilityPriorityMedium])
      .andDo((^(NSInvocation* invocation) {
        announced = TRUE;
        [invocation retainArguments];
        NSString* message;
        [invocation getArgument:&message atIndex:2];
        EXPECT_EQ(message, @"error message");
      }));
 
  NSDictionary<NSString*, id>* annotatedEvent =
      @{@"type" : @"announce",
        @"data" : @{@"message" : @"error message"}};
 
  [engineMock handleAccessibilityEvent:annotatedEvent];
 
  EXPECT_TRUE(announced);
}

◆ TEST_F() [523/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HandleLifecycleStates
	)

Definition at line 1060 of file FlutterEngineTest.mm.

                                                                            {
  __block flutter::AppLifecycleState sentState;
  id engineMock = CreateMockFlutterEngine(nil);
 
  // Have to enumerate all the values because OCMStub can't capture
  // non-Objective-C object arguments.
  OCMStub([engineMock setApplicationState:flutter::AppLifecycleState::kDetached])
      .andDo((^(NSInvocation* invocation) {
        sentState = flutter::AppLifecycleState::kDetached;
      }));
  OCMStub([engineMock setApplicationState:flutter::AppLifecycleState::kResumed])
      .andDo((^(NSInvocation* invocation) {
        sentState = flutter::AppLifecycleState::kResumed;
      }));
  OCMStub([engineMock setApplicationState:flutter::AppLifecycleState::kInactive])
      .andDo((^(NSInvocation* invocation) {
        sentState = flutter::AppLifecycleState::kInactive;
      }));
  OCMStub([engineMock setApplicationState:flutter::AppLifecycleState::kHidden])
      .andDo((^(NSInvocation* invocation) {
        sentState = flutter::AppLifecycleState::kHidden;
      }));
  OCMStub([engineMock setApplicationState:flutter::AppLifecycleState::kPaused])
      .andDo((^(NSInvocation* invocation) {
        sentState = flutter::AppLifecycleState::kPaused;
      }));
 
  __block NSApplicationOcclusionState visibility = NSApplicationOcclusionStateVisible;
  id mockApplication = OCMPartialMock([NSApplication sharedApplication]);
  OCMStub((NSApplicationOcclusionState)[mockApplication occlusionState])
      .andDo(^(NSInvocation* invocation) {
        [invocation setReturnValue:&visibility];
      });
 
  NSNotification* willBecomeActive =
      [[NSNotification alloc] initWithName:NSApplicationWillBecomeActiveNotification
                                    object:nil
                                  userInfo:nil];
  NSNotification* willResignActive =
      [[NSNotification alloc] initWithName:NSApplicationWillResignActiveNotification
                                    object:nil
                                  userInfo:nil];
 
  NSNotification* didChangeOcclusionState;
  didChangeOcclusionState =
      [[NSNotification alloc] initWithName:NSApplicationDidChangeOcclusionStateNotification
                                    object:nil
                                  userInfo:nil];
 
  [engineMock handleDidChangeOcclusionState:didChangeOcclusionState];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kInactive);
 
  [engineMock handleWillBecomeActive:willBecomeActive];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kResumed);
 
  [engineMock handleWillResignActive:willResignActive];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kInactive);
 
  visibility = 0;
  [engineMock handleDidChangeOcclusionState:didChangeOcclusionState];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kHidden);
 
  [engineMock handleWillBecomeActive:willBecomeActive];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kHidden);
 
  [engineMock handleWillResignActive:willResignActive];
  EXPECT_EQ(sentState, flutter::AppLifecycleState::kHidden);
 
  [mockApplication stopMocking];
}

◆ TEST_F() [524/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HandlesTerminationRequest
	)

Definition at line 943 of file FlutterEngineTest.mm.

                                                     {
  id engineMock = CreateMockFlutterEngine(nil);
  __block NSString* nextResponse = @"exit";
  __block BOOL triedToTerminate = NO;
  FlutterEngineTerminationHandler* terminationHandler =
      [[FlutterEngineTerminationHandler alloc] initWithEngine:engineMock
                                                   terminator:^(id sender) {
                                                     triedToTerminate = TRUE;
                                                     // Don't actually terminate, of course.
                                                   }];
  OCMStub([engineMock terminationHandler]).andReturn(terminationHandler);
  id binaryMessengerMock = OCMProtocolMock(@protocol(FlutterBinaryMessenger));
  OCMStub(  // NOLINT(google-objc-avoid-throwing-exception)
      [engineMock binaryMessenger])
      .andReturn(binaryMessengerMock);
  OCMStub([engineMock sendOnChannel:@"flutter/platform"
                            message:[OCMArg any]
                        binaryReply:[OCMArg any]])
      .andDo((^(NSInvocation* invocation) {
        [invocation retainArguments];
        FlutterBinaryReply callback;
        NSData* returnedMessage;
        [invocation getArgument:&callback atIndex:4];
        if ([nextResponse isEqualToString:@"error"]) {
          FlutterError* errorResponse = [FlutterError errorWithCode:@"Error"
                                                            message:@"Failed"
                                                            details:@"Details"];
          returnedMessage =
              [[FlutterJSONMethodCodec sharedInstance] encodeErrorEnvelope:errorResponse];
        } else {
          NSDictionary* responseDict = @{@"response" : nextResponse};
          returnedMessage =
              [[FlutterJSONMethodCodec sharedInstance] encodeSuccessEnvelope:responseDict];
        }
        callback(returnedMessage);
      }));
  __block NSString* calledAfterTerminate = @"";
  FlutterResult appExitResult = ^(id result) {
    NSDictionary* resultDict = result;
    calledAfterTerminate = resultDict[@"response"];
  };
  FlutterMethodCall* methodExitApplication =
      [FlutterMethodCall methodCallWithMethodName:@"System.exitApplication"
                                        arguments:@{@"type" : @"cancelable"}];
 
  // Always terminate when the binding isn't ready (which is the default).
  triedToTerminate = NO;
  calledAfterTerminate = @"";
  nextResponse = @"cancel";
  [engineMock handleMethodCall:methodExitApplication result:appExitResult];
  EXPECT_STREQ([calledAfterTerminate UTF8String], "");
  EXPECT_TRUE(triedToTerminate);
 
  // Once the binding is ready, handle the request.
  terminationHandler.acceptingRequests = YES;
  triedToTerminate = NO;
  calledAfterTerminate = @"";
  nextResponse = @"exit";
  [engineMock handleMethodCall:methodExitApplication result:appExitResult];
  EXPECT_STREQ([calledAfterTerminate UTF8String], "exit");
  EXPECT_TRUE(triedToTerminate);
 
  triedToTerminate = NO;
  calledAfterTerminate = @"";
  nextResponse = @"cancel";
  [engineMock handleMethodCall:methodExitApplication result:appExitResult];
  EXPECT_STREQ([calledAfterTerminate UTF8String], "cancel");
  EXPECT_FALSE(triedToTerminate);
 
  // Check that it doesn't crash on error.
  triedToTerminate = NO;
  calledAfterTerminate = @"";
  nextResponse = @"error";
  [engineMock handleMethodCall:methodExitApplication result:appExitResult];
  EXPECT_STREQ([calledAfterTerminate UTF8String], "");
  EXPECT_TRUE(triedToTerminate);
}

◆ TEST_F() [525/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HasNonNullExecutableName
	)

Definition at line 148 of file FlutterEngineTest.mm.

                                                    {
  FlutterEngine* engine = GetFlutterEngine();
  std::string executable_name = [[engine executableName] UTF8String];
  ASSERT_FALSE(executable_name.empty());
 
  // Block until notified by the Dart test of the value of Platform.executable.
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("NotifyStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      const auto dart_string = tonic::DartConverter<std::string>::FromDart(
                          Dart_GetNativeArgument(args, 0));
                      EXPECT_EQ(executable_name, dart_string);
                      latch.Signal();
                    }));
 
  // Launch the test entrypoint.
  EXPECT_TRUE([engine runWithEntrypoint:@"executableNameNotNull"]);
 
  latch.Wait();
}

◆ TEST_F() [526/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HasStringsWhenPasteboardEmpty
	)

Definition at line 788 of file FlutterEngineTest.mm.

                                                         {
  id engineMock = CreateMockFlutterEngine(nil);
 
  // Call hasStrings and expect it to be false.
  __block bool calledAfterClear = false;
  __block bool valueAfterClear;
  FlutterResult resultAfterClear = ^(id result) {
    calledAfterClear = true;
    NSNumber* valueNumber = [result valueForKey:@"value"];
    valueAfterClear = [valueNumber boolValue];
  };
  FlutterMethodCall* methodCallAfterClear =
      [FlutterMethodCall methodCallWithMethodName:@"Clipboard.hasStrings" arguments:nil];
  [engineMock handleMethodCall:methodCallAfterClear result:resultAfterClear];
  EXPECT_TRUE(calledAfterClear);
  EXPECT_FALSE(valueAfterClear);
}

◆ TEST_F() [527/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		HasStringsWhenPasteboardFull
	)

Definition at line 806 of file FlutterEngineTest.mm.

                                                        {
  id engineMock = CreateMockFlutterEngine(@"some string");
 
  // Call hasStrings and expect it to be true.
  __block bool called = false;
  __block bool value;
  FlutterResult result = ^(id result) {
    called = true;
    NSNumber* valueNumber = [result valueForKey:@"value"];
    value = [valueNumber boolValue];
  };
  FlutterMethodCall* methodCall =
      [FlutterMethodCall methodCallWithMethodName:@"Clipboard.hasStrings" arguments:nil];
  [engineMock handleMethodCall:methodCall result:result];
  EXPECT_TRUE(called);
  EXPECT_TRUE(value);
}

◆ TEST_F() [528/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		IgnoresTerminationRequestIfNotFlutterAppDelegate
	)

Definition at line 1021 of file FlutterEngineTest.mm.

                                                                            {
  id<NSApplicationDelegate> previousDelegate = [[NSApplication sharedApplication] delegate];
  id<NSApplicationDelegate> plainDelegate = [[PlainAppDelegate alloc] init];
  [NSApplication sharedApplication].delegate = plainDelegate;
 
  // Creating the engine shouldn't fail here, even though the delegate isn't a
  // FlutterAppDelegate.
  CreateMockFlutterEngine(nil);
 
  // Asking to terminate the app should cancel.
  EXPECT_EQ([[[NSApplication sharedApplication] delegate] applicationShouldTerminate:NSApp],
            NSTerminateCancel);
 
  [NSApplication sharedApplication].delegate = previousDelegate;
}

◆ TEST_F() [529/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ManageControllersIfInitiatedByController
	)

Definition at line 880 of file FlutterEngineTest.mm.

                                                                    {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
 
  FlutterEngine* engine;
  FlutterViewController* viewController1;
 
  @autoreleasepool {
    // Create FVC1.
    viewController1 = [[FlutterViewController alloc] initWithProject:project];
    EXPECT_EQ(viewController1.viewIdentifier, 0ll);
 
    engine = viewController1.engine;
    engine.viewController = nil;
 
    // Create FVC2 based on the same engine.
    FlutterViewController* viewController2 = [[FlutterViewController alloc] initWithEngine:engine
                                                                                   nibName:nil
                                                                                    bundle:nil];
    EXPECT_EQ(engine.viewController, viewController2);
  }
  // FVC2 is deallocated but FVC1 is retained.
 
  EXPECT_EQ(engine.viewController, nil);
 
  engine.viewController = viewController1;
  EXPECT_EQ(engine.viewController, viewController1);
  EXPECT_EQ(viewController1.viewIdentifier, 0ll);
}

◆ TEST_F() [530/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ManageControllersIfInitiatedByEngine
	)

Definition at line 912 of file FlutterEngineTest.mm.

                                                                {
  // Don't create the engine with `CreateMockFlutterEngine`, because it adds
  // additional references to FlutterViewControllers, which is crucial to this
  // test case.
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"io.flutter"
                                                      project:nil
                                       allowHeadlessExecution:NO];
  FlutterViewController* viewController1;
 
  @autoreleasepool {
    viewController1 = [[FlutterViewController alloc] initWithEngine:engine nibName:nil bundle:nil];
    EXPECT_EQ(viewController1.viewIdentifier, 0ll);
    EXPECT_EQ(engine.viewController, viewController1);
 
    engine.viewController = nil;
 
    FlutterViewController* viewController2 = [[FlutterViewController alloc] initWithEngine:engine
                                                                                   nibName:nil
                                                                                    bundle:nil];
    EXPECT_EQ(viewController2.viewIdentifier, 0ll);
    EXPECT_EQ(engine.viewController, viewController2);
  }
  // FVC2 is deallocated but FVC1 is retained.
 
  EXPECT_EQ(engine.viewController, nil);
 
  engine.viewController = viewController1;
  EXPECT_EQ(engine.viewController, viewController1);
  EXPECT_EQ(viewController1.viewIdentifier, 0ll);
}

◆ TEST_F() [531/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		MessengerCleanupConnectionWorks
	)

Definition at line 731 of file FlutterEngineTest.mm.

                                                           {
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
 
  NSString* channel = @"_test_";
  NSData* channel_data = [channel dataUsingEncoding:NSUTF8StringEncoding];
 
  // Mock SendPlatformMessage so that if a message is sent to
  // "test/send_message", act as if the framework has sent an empty message to
  // the channel marked by the `sendOnChannel:message:` call's message.
  engine.embedderAPI.SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage, ([](auto engine_, auto message_) {
        if (strcmp(message_->channel, "test/send_message") == 0) {
          // The simplest message that is acceptable to a method channel.
          std::string message = R"|({"method": "a"})|";
          std::string channel(reinterpret_cast<const char*>(message_->message),
                              message_->message_size);
          reinterpret_cast<EmbedderEngine*>(engine_)
              ->GetShell()
              .GetPlatformView()
              ->HandlePlatformMessage(std::make_unique<PlatformMessage>(
                  channel.c_str(), fml::MallocMapping::Copy(message.c_str(), message.length()),
                  fml::RefPtr<PlatformMessageResponse>()));
        }
        return kSuccess;
      }));
 
  __block int record = 0;
 
  FlutterMethodChannel* channel1 =
      [FlutterMethodChannel methodChannelWithName:channel
                                  binaryMessenger:engine.binaryMessenger
                                            codec:[FlutterJSONMethodCodec sharedInstance]];
  [channel1 setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
    record += 1;
  }];
 
  [engine.binaryMessenger sendOnChannel:@"test/send_message" message:channel_data];
  EXPECT_EQ(record, 1);
 
  FlutterMethodChannel* channel2 =
      [FlutterMethodChannel methodChannelWithName:channel
                                  binaryMessenger:engine.binaryMessenger
                                            codec:[FlutterJSONMethodCodec sharedInstance]];
  [channel2 setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
    record += 10;
  }];
 
  [engine.binaryMessenger sendOnChannel:@"test/send_message" message:channel_data];
  EXPECT_EQ(record, 11);
 
  [channel1 setMethodCallHandler:nil];
 
  [engine.binaryMessenger sendOnChannel:@"test/send_message" message:channel_data];
  EXPECT_EQ(record, 21);
}

◆ TEST_F() [532/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		MessengerSend
	)

Definition at line 186 of file FlutterEngineTest.mm.

                                         {
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
 
  NSData* test_message = [@"a message" dataUsingEncoding:NSUTF8StringEncoding];
  bool called = false;
 
  engine.embedderAPI.SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage, ([&called, test_message](auto engine, auto message) {
        called = true;
        EXPECT_STREQ(message->channel, "test");
        EXPECT_EQ(memcmp(message->message, test_message.bytes, message->message_size), 0);
        return kSuccess;
      }));
 
  [engine.binaryMessenger sendOnChannel:@"test" message:test_message];
  EXPECT_TRUE(called);
}

◆ TEST_F() [533/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		NativeCallbacks
	)

Definition at line 486 of file FlutterEngineTest.mm.

                                           {
  fml::AutoResetWaitableEvent latch;
  bool latch_called = false;
  AddNativeCallback("SignalNativeTest", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      latch_called = true;
                      latch.Signal();
                    }));
 
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"nativeCallback"]);
  ASSERT_TRUE(engine.running);
 
  latch.Wait();
  ASSERT_TRUE(latch_called);
}

◆ TEST_F() [534/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		NotificationsUpdateDisplays
	)

Definition at line 1188 of file FlutterEngineTest.mm.

                                                       {
  BOOL updated = NO;
  FlutterEngine* engine = GetFlutterEngine();
  auto original_set_viewport_metrics = engine.embedderAPI.SendWindowMetricsEvent;
  engine.embedderAPI.SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&updated, &original_set_viewport_metrics](auto engine, auto* window_metrics) {
        updated = YES;
        return original_set_viewport_metrics(engine, window_metrics);
      }));
 
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
 
  updated = NO;
  [[NSNotificationCenter defaultCenter] postNotificationName:NSWindowDidChangeScreenNotification
                                                      object:nil];
  // No VC.
  EXPECT_FALSE(updated);
 
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  viewController.flutterView.frame = CGRectMake(0, 0, 800, 600);
 
  [[NSNotificationCenter defaultCenter] postNotificationName:NSWindowDidChangeScreenNotification
                                                      object:nil];
  EXPECT_TRUE(updated);
}

◆ TEST_F() [535/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ProducesAccessibilityTreeWhenAddingViews
	)

Definition at line 461 of file FlutterEngineTest.mm.

                                                                    {
  FlutterEngine* engine = GetFlutterEngine();
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
 
  // Enable the semantics without attaching a view controller.
  bool enabled_called = false;
  engine.embedderAPI.UpdateSemanticsEnabled =
      MOCK_ENGINE_PROC(UpdateSemanticsEnabled, ([&enabled_called](auto engine, bool enabled) {
                         enabled_called = enabled;
                         return kSuccess;
                       }));
  engine.semanticsEnabled = YES;
  EXPECT_TRUE(enabled_called);
 
  EXPECT_EQ(engine.viewController, nil);
 
  // Assign the view controller after enabling semantics
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  engine.viewController = viewController;
 
  EXPECT_NE(viewController.accessibilityBridge.lock(), nullptr);
}

◆ TEST_F() [536/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		PublishedValueNilForUnknownPlugin
	)

Definition at line 675 of file FlutterEngineTest.mm.

                                                             {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                      project:project
                                       allowHeadlessExecution:YES];
 
  EXPECT_EQ([engine valuePublishedByPlugin:@"NoSuchPlugin"], nil);
}

◆ TEST_F() [537/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		PublishedValueNSNullIfNoPublishedValue
	)

Definition at line 687 of file FlutterEngineTest.mm.

                                                                  {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                      project:project
                                       allowHeadlessExecution:YES];
  NSString* pluginName = @"MyPlugin";
  // Request the registarar to register the plugin as existing.
  [engine registrarForPlugin:pluginName];
 
  // The documented behavior is that a plugin that exists but hasn't published
  // anything returns NSNull, rather than nil, as on iOS.
  EXPECT_EQ([engine valuePublishedByPlugin:pluginName], [NSNull null]);
}

◆ TEST_F() [538/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		PublishedValueReturnsLastPublished
	)

Definition at line 704 of file FlutterEngineTest.mm.

                                                              {
  NSString* fixtures = @(flutter::testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test"
                                                      project:project
                                       allowHeadlessExecution:YES];
  NSString* pluginName = @"MyPlugin";
  id<FlutterPluginRegistrar> registrar = [engine registrarForPlugin:pluginName];
 
  NSString* firstValue = @"A published value";
  NSArray* secondValue = @[ @"A different published value" ];
 
  [registrar publish:firstValue];
  EXPECT_EQ([engine valuePublishedByPlugin:pluginName], firstValue);
 
  [registrar publish:secondValue];
  EXPECT_EQ([engine valuePublishedByPlugin:pluginName], secondValue);
}

◆ TEST_F() [539/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ResponseAfterEngineDied
	)

Definition at line 824 of file FlutterEngineTest.mm.

                                                   {
  FlutterEngine* engine = GetFlutterEngine();
  FlutterBasicMessageChannel* channel = [[FlutterBasicMessageChannel alloc]
         initWithName:@"foo"
      binaryMessenger:engine.binaryMessenger
                codec:[FlutterStandardMessageCodec sharedInstance]];
  __block BOOL didCallCallback = NO;
  [channel setMessageHandler:^(id message, FlutterReply callback) {
    ShutDownEngine();
    callback(nil);
    didCallCallback = YES;
  }];
  EXPECT_TRUE([engine runWithEntrypoint:@"sendFooMessage"]);
  engine = nil;
 
  while (!didCallCallback) {
    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
  }
}

◆ TEST_F() [540/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ResponseFromBackgroundThread
	)

Definition at line 844 of file FlutterEngineTest.mm.

                                                        {
  FlutterEngine* engine = GetFlutterEngine();
  FlutterBasicMessageChannel* channel = [[FlutterBasicMessageChannel alloc]
         initWithName:@"foo"
      binaryMessenger:engine.binaryMessenger
                codec:[FlutterStandardMessageCodec sharedInstance]];
  __block BOOL didCallCallback = NO;
  [channel setMessageHandler:^(id message, FlutterReply callback) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      callback(nil);
      dispatch_async(dispatch_get_main_queue(), ^{
        didCallCallback = YES;
      });
    });
  }];
  EXPECT_TRUE([engine runWithEntrypoint:@"sendFooMessage"]);
 
  while (!didCallCallback) {
    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
  }
}

◆ TEST_F() [541/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		RunWithEntrypointUpdatesDisplayConfig
	)

Definition at line 1167 of file FlutterEngineTest.mm.

                                                                 {
  BOOL updated = NO;
  FlutterEngine* engine = GetFlutterEngine();
  auto original_update_displays = engine.embedderAPI.NotifyDisplayUpdate;
  engine.embedderAPI.NotifyDisplayUpdate = MOCK_ENGINE_PROC(
      NotifyDisplayUpdate, ([&updated, &original_update_displays](
                                auto engine, auto update_type, auto* displays, auto display_count) {
        updated = YES;
        return original_update_displays(engine, update_type, displays, display_count);
      }));
 
  EXPECT_TRUE([engine runWithEntrypoint:@"main"]);
  EXPECT_TRUE(updated);
 
  updated = NO;
  [[NSNotificationCenter defaultCenter]
      postNotificationName:NSApplicationDidChangeScreenParametersNotification
                    object:nil];
  EXPECT_TRUE(updated);
}

◆ TEST_F() [542/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		Switches
	)

Definition at line 169 of file FlutterEngineTest.mm.

                                    {
  setenv("FLUTTER_ENGINE_SWITCHES", "2", 1);
  setenv("FLUTTER_ENGINE_SWITCH_1", "abc", 1);
  setenv("FLUTTER_ENGINE_SWITCH_2", "foo=\"bar, baz\"", 1);
 
  FlutterEngine* engine = GetFlutterEngine();
  std::vector<std::string> switches = engine.switches;
  ASSERT_EQ(switches.size(), 2UL);
  EXPECT_EQ(switches[0], "--abc");
  EXPECT_EQ(switches[1], "--foo=\"bar, baz\"");
 
  unsetenv("FLUTTER_ENGINE_SWITCHES");
  unsetenv("FLUTTER_ENGINE_SWITCH_1");
  unsetenv("FLUTTER_ENGINE_SWITCH_2");
}

◆ TEST_F() [543/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		ThreadSynchronizerNotBlockingRasterThreadAfterShutdown
	)

Definition at line 866 of file FlutterEngineTest.mm.

                                                                                  {
  FlutterThreadSynchronizer* threadSynchronizer = [[FlutterThreadSynchronizer alloc] init];
  [threadSynchronizer shutdown];
 
  std::thread rasterThread([&threadSynchronizer] {
    [threadSynchronizer performCommitForView:kImplicitViewId
                                        size:CGSizeMake(100, 100)
                                      notify:^{
                                      }];
  });
 
  rasterThread.join();
}

◆ TEST_F() [544/925]

flutter::testing::TEST_F	(	FlutterEngineTest	,
		UnregistersPluginsOnEngineDestruction
	)

Definition at line 1146 of file FlutterEngineTest.mm.

                                                                 {
  id<NSApplicationDelegate> previousDelegate = [[NSApplication sharedApplication] delegate];
  FakeLifecycleProvider* fakeAppDelegate = [[FakeLifecycleProvider alloc] init];
  [NSApplication sharedApplication].delegate = fakeAppDelegate;
 
  FakeAppDelegatePlugin* plugin = [[FakeAppDelegatePlugin alloc] init];
 
  @autoreleasepool {
    FlutterEngine* engine = [[FlutterEngine alloc] initWithName:@"test" project:nil];
 
    [[engine registrarForPlugin:@"TestPlugin"] addApplicationDelegate:plugin];
    EXPECT_TRUE([fakeAppDelegate hasDelegate:plugin]);
  }
 
  // When the engine is released, it should unregister any plugins it had
  // registered on its behalf.
  EXPECT_FALSE([fakeAppDelegate hasDelegate:plugin]);
 
  [NSApplication sharedApplication].delegate = previousDelegate;
}

◆ TEST_F() [545/925]

flutter::testing::TEST_F	(	FlutterMenuPluginTest	,
		TestSetMenu
	)

Definition at line 84 of file FlutterMenuPluginTest.mm.

                                           {
  // Build a simulation of the default main menu.
  NSMenu* mainMenu = [[NSMenu alloc] init];
  NSMenuItem* appNameMenu = [[NSMenuItem alloc] initWithTitle:NSLocalizedString(@"APP_NAME", nil)
                                                       action:nil
                                                keyEquivalent:@""];
  NSMenu* submenu =
      [[NSMenu alloc] initWithTitle:NSLocalizedString(@"Prexisting APP_NAME menu", nil)];
  [submenu addItem:[[NSMenuItem alloc] initWithTitle:NSLocalizedString(@"About APP_NAME", nil)
                                              action:nil
                                       keyEquivalent:@""]];
  appNameMenu.submenu = submenu;
  [mainMenu addItem:appNameMenu];
  [NSApp setMainMenu:mainMenu];
 
  FakePluginRegistrar* registrar = [[FakePluginRegistrar alloc] init];
  [FlutterMenuPlugin registerWithRegistrar:registrar];
  FlutterMenuPlugin* plugin = [registrar plugin];
 
  NSDictionary* testMenus = @{
    @"0" : @[
      @{
        @"id" : [NSNumber numberWithInt:1],
        @"label" : @"APP_NAME",
        @"enabled" : @(YES),
        @"children" : @[
          @{
            @"id" : [NSNumber numberWithInt:3],
            @"platformProvidedMenu" : @(static_cast<int>(flutter::PlatformProvidedMenu::kQuit)),
            @"enabled" : @(YES),
          },
          @{
            @"id" : [NSNumber numberWithInt:2],
            @"label" : @"APP_NAME Info",
            @"enabled" : @(YES),
            @"shortcutTrigger" : [NSNumber numberWithUnsignedLongLong:0x61],
            @"shortcutModifiers" : [NSNumber numberWithUnsignedInt:0],
          },
        ],
      },
      @{
        @"id" : [NSNumber numberWithInt:4],
        @"label" : @"Help for APP_NAME",
        @"enabled" : @(YES),
        @"children" : @[
          @{
            @"id" : [NSNumber numberWithInt:5],
            @"label" : @"Help me!",
            @"enabled" : @(YES),
          },
          @{
            @"id" : [NSNumber numberWithInt:6],
            @"label" : @"",
            @"enabled" : @(NO),
            @"isDivider" : @(YES),
          },
          @{
            @"id" : [NSNumber numberWithInt:7],
            @"label" : @"Search help",
            @"enabled" : @(NO),
          },
        ],
      },
    ],
  };
 
  __block id available = @NO;
  [plugin handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"Menu.isPluginAvailable"
                                                             arguments:nil]
                    result:^(id _Nullable result) {
                      available = result;
                    }];
 
  EXPECT_TRUE(available);
 
  [plugin handleMethodCall:[FlutterMethodCall methodCallWithMethodName:@"Menu.setMenus"
                                                             arguments:testMenus]
                    result:^(id _Nullable result){
                    }];
 
  EXPECT_EQ([NSApp.mainMenu numberOfItems], 2);
  NSMenuItem* firstMenu = [NSApp.mainMenu itemAtIndex:0];
  EXPECT_TRUE([[firstMenu title] isEqualToString:@"flutter_desktop_darwin_unittests"]);
  EXPECT_EQ([firstMenu tag], 1);
  EXPECT_TRUE([firstMenu isEnabled]);
  EXPECT_FALSE([firstMenu isHidden]);
  EXPECT_TRUE([[firstMenu keyEquivalent] isEqualToString:@"\0"]);
 
  EXPECT_EQ([[firstMenu submenu] numberOfItems], 1);
  NSMenuItem* firstItem = [[firstMenu submenu] itemAtIndex:0];
  EXPECT_TRUE([[firstItem title] isEqualToString:@"flutter_desktop_darwin_unittests Info"]);
  EXPECT_TRUE([[firstItem keyEquivalent] isEqualToString:@"a"]);
  EXPECT_TRUE([firstItem isEnabled]);
  EXPECT_FALSE([firstItem isHidden]);
  EXPECT_TRUE(
      [NSStringFromSelector([firstItem action]) isEqualToString:@"flutterMenuItemSelected:"]);
  EXPECT_EQ([firstItem tag], 2);
 
  NSMenuItem* secondMenu = [NSApp.mainMenu itemAtIndex:1];
  EXPECT_TRUE([[secondMenu title] isEqualToString:@"Help for flutter_desktop_darwin_unittests"]);
  EXPECT_EQ([secondMenu tag], 4);
  EXPECT_TRUE([secondMenu isEnabled]);
  EXPECT_FALSE([secondMenu isHidden]);
 
  EXPECT_EQ([[secondMenu submenu] numberOfItems], 3);
  NSMenuItem* secondMenuFirst = [[secondMenu submenu] itemAtIndex:0];
  EXPECT_TRUE([[secondMenuFirst title] isEqualToString:@"Help me!"]);
  EXPECT_TRUE([secondMenuFirst isEnabled]);
  EXPECT_FALSE([secondMenuFirst isHidden]);
  EXPECT_TRUE(
      [NSStringFromSelector([secondMenuFirst action]) isEqualToString:@"flutterMenuItemSelected:"]);
  EXPECT_EQ([secondMenuFirst tag], 5);
 
  NSMenuItem* secondMenuDivider = [[secondMenu submenu] itemAtIndex:1];
  EXPECT_TRUE([[secondMenuDivider title] isEqualToString:@""]);
  EXPECT_TRUE([[secondMenuDivider keyEquivalent] isEqualToString:@""]);
  EXPECT_FALSE([secondMenuDivider isEnabled]);
  EXPECT_FALSE([secondMenuDivider isHidden]);
  EXPECT_EQ([secondMenuDivider action], nil);
  EXPECT_EQ([secondMenuDivider tag], 0);
 
  NSMenuItem* secondMenuLast = [[secondMenu submenu] itemAtIndex:2];
  EXPECT_TRUE([[secondMenuLast title] isEqualToString:@"Search help"]);
  EXPECT_FALSE([secondMenuLast isEnabled]);
  EXPECT_FALSE([secondMenuLast isHidden]);
  EXPECT_TRUE(
      [NSStringFromSelector([secondMenuLast action]) isEqualToString:@"flutterMenuItemSelected:"]);
  EXPECT_EQ([secondMenuLast tag], 7);
}

◆ TEST_F() [546/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestCtrlTabKeyEventIsPropagated
	)

Definition at line 261 of file FlutterViewControllerTest.mm.

                                                                             {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testCtrlTabKeyEventIsPropagated:mockEngine]);
}

◆ TEST_F() [547/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestFlagsChangedEventsArePropagatedIfNotHandled
	)

Definition at line 272 of file FlutterViewControllerTest.mm.

                                                                                             {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc]
      testFlagsChangedEventsArePropagatedIfNotHandled:mockEngine]);
}

◆ TEST_F() [548/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		testFlutterViewIsConfigured
	)

Definition at line 314 of file FlutterViewControllerTest.mm.

                                                                         {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testFlutterViewIsConfigured:mockEngine]);
}

◆ TEST_F() [549/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestKeyboardIsRestartedOnEngineRestart
	)

Definition at line 278 of file FlutterViewControllerTest.mm.

                                                                                    {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testKeyboardIsRestartedOnEngineRestart:mockEngine]);
}

◆ TEST_F() [550/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestKeyEquivalentIsPassedToTextInputPlugin
	)

Definition at line 266 of file FlutterViewControllerTest.mm.

                                                                                        {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc]
      testKeyEquivalentIsPassedToTextInputPlugin:mockEngine]);
}

◆ TEST_F() [551/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestKeyEventsAreNotPropagatedIfHandled
	)

Definition at line 255 of file FlutterViewControllerTest.mm.

                                                                                    {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testKeyEventsAreNotPropagatedIfHandled:mockEngine]);
}

◆ TEST_F() [552/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestKeyEventsArePropagatedIfNotHandled
	)

Definition at line 249 of file FlutterViewControllerTest.mm.

                                                                                    {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testKeyEventsArePropagatedIfNotHandled:mockEngine]);
}

◆ TEST_F() [553/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestKeyEventsAreSentToFramework
	)

Definition at line 244 of file FlutterViewControllerTest.mm.

                                                                             {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testKeyEventsAreSentToFramework:mockEngine]);
}

◆ TEST_F() [554/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestModifierKeysAreSynthesizedOnMouseMove
	)

Definition at line 302 of file FlutterViewControllerTest.mm.

                                                                                       {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testModifierKeysAreSynthesizedOnMouseMove:mockEngine]);
}

◆ TEST_F() [555/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestmouseAndGestureEventsAreHandledSeparately
	)

Definition at line 290 of file FlutterViewControllerTest.mm.

                                                                                           {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] mouseAndGestureEventsAreHandledSeparately:mockEngine]);
}

◆ TEST_F() [556/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestMouseDownUpEventsSentToNextResponder
	)

Definition at line 296 of file FlutterViewControllerTest.mm.

                                                                                      {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testMouseDownUpEventsSentToNextResponder:mockEngine]);
}

◆ TEST_F() [557/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		TestTrackpadGesturesAreSentToFramework
	)

Definition at line 284 of file FlutterViewControllerTest.mm.

                                                                                    {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testTrackpadGesturesAreSentToFramework:mockEngine]);
}

◆ TEST_F() [558/925]

flutter::testing::TEST_F	(	FlutterViewControllerMockEngineTest	,
		testViewWillAppearCalledMultipleTimes
	)

Definition at line 308 of file FlutterViewControllerTest.mm.

                                                                                   {
  id mockEngine = GetMockEngine();
  ASSERT_TRUE(
      [[FlutterViewControllerTestObjC alloc] testViewWillAppearCalledMultipleTimes:mockEngine]);
}

◆ TEST_F() [559/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		CanSetMouseTrackingModeBeforeViewLoaded
	)

Definition at line 234 of file FlutterViewControllerTest.mm.

                                                                           {
  NSString* fixtures = @(testing::GetFixturesPath());
  FlutterDartProject* project = [[FlutterDartProject alloc]
      initWithAssetsPath:fixtures
             ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:project];
  viewController.mouseTrackingMode = kFlutterMouseTrackingModeInActiveApp;
  ASSERT_EQ(viewController.mouseTrackingMode, kFlutterMouseTrackingModeInActiveApp);
}

◆ TEST_F() [560/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		FlutterViewAcceptsFirstMouse
	)

Definition at line 203 of file FlutterViewControllerTest.mm.

                                                                {
  FlutterViewController* viewControllerMock = CreateMockViewController();
  [viewControllerMock loadView];
  EXPECT_EQ([viewControllerMock.flutterView acceptsFirstMouse:nil], YES);
}

◆ TEST_F() [561/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		HasViewThatHidesOtherViewsInAccessibility
	)

Definition at line 182 of file FlutterViewControllerTest.mm.

                                                                             {
  FlutterViewController* viewControllerMock = CreateMockViewController();
 
  [viewControllerMock loadView];
  auto subViews = [viewControllerMock.view subviews];
 
  EXPECT_EQ([subViews count], 1u);
  EXPECT_EQ(subViews[0], viewControllerMock.flutterView);
 
  NSTextField* textField = [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 1, 1)];
  [viewControllerMock.view addSubview:textField];
 
  subViews = [viewControllerMock.view subviews];
  EXPECT_EQ([subViews count], 2u);
 
  auto accessibilityChildren = viewControllerMock.view.accessibilityChildren;
  // The accessibilityChildren should only contains the FlutterView.
  EXPECT_EQ([accessibilityChildren count], 1u);
  EXPECT_EQ(accessibilityChildren[0], viewControllerMock.flutterView);
}

◆ TEST_F() [562/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		ReparentsPluginWhenAccessibilityDisabled
	)

Definition at line 209 of file FlutterViewControllerTest.mm.

                                                                            {
  FlutterEngine* engine = CreateTestEngine();
  FlutterViewController* viewController = [[FlutterViewController alloc] initWithEngine:engine
                                                                                nibName:nil
                                                                                 bundle:nil];
  [viewController loadView];
  // Creates a NSWindow so that sub view can be first responder.
  NSWindow* window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 800, 600)
                                                 styleMask:NSBorderlessWindowMask
                                                   backing:NSBackingStoreBuffered
                                                     defer:NO];
  window.contentView = viewController.view;
  NSView* dummyView = [[NSView alloc] initWithFrame:CGRectZero];
  [viewController.view addSubview:dummyView];
  // Attaches FlutterTextInputPlugin to the view;
  [dummyView addSubview:viewController.textInputPlugin];
  // Makes sure the textInputPlugin can be the first responder.
  EXPECT_TRUE([window makeFirstResponder:viewController.textInputPlugin]);
  EXPECT_EQ([window firstResponder], viewController.textInputPlugin);
  EXPECT_FALSE(viewController.textInputPlugin.superview == viewController.view);
  [viewController onAccessibilityStatusChanged:NO];
  // FlutterView becomes child of view controller
  EXPECT_TRUE(viewController.textInputPlugin.superview == viewController.view);
}

◆ TEST_F() [563/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		testLookupKeyAssets
	)

Definition at line 319 of file FlutterViewControllerTest.mm.

                                                       {
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testLookupKeyAssets]);
}

◆ TEST_F() [564/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		testLookupKeyAssetsWithPackage
	)

Definition at line 323 of file FlutterViewControllerTest.mm.

                                                                  {
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testLookupKeyAssetsWithPackage]);
}

◆ TEST_F() [565/925]

flutter::testing::TEST_F	(	FlutterViewControllerTest	,
		testViewControllerIsReleased
	)

Definition at line 327 of file FlutterViewControllerTest.mm.

                                                                {
  ASSERT_TRUE([[FlutterViewControllerTestObjC alloc] testViewControllerIsReleased]);
}

◆ TEST_F() [566/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AccessibilityAnnouncement
	)

Definition at line 657 of file flutter_windows_engine_unittests.cc.

                                                            {
  auto& context = GetContext();
  WindowsConfigBuilder builder{context};
  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
 
  bool done = false;
  auto native_entry =
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
  context.AddNativeFunction("Signal", native_entry);
 
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  ui::AXPlatformNodeDelegateBase parent_delegate;
  AlertPlatformNodeDelegate delegate{parent_delegate};
 
  auto window_binding_handler =
      std::make_unique<NiceMock<MockWindowBindingHandler>>();
  EXPECT_CALL(*window_binding_handler, GetAlertDelegate)
      .WillOnce(Return(&delegate));
 
  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
  MockFlutterWindowsView view{windows_engine,
                              std::move(window_binding_handler)};
  EngineModifier modifier{windows_engine};
  modifier.SetImplicitView(&view);
 
  windows_engine->UpdateSemanticsEnabled(true);
 
  EXPECT_CALL(view, NotifyWinEventWrapper).Times(1);
 
  // Rely on timeout mechanism in CI.
  while (!done) {
    windows_engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [567/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AccessibilityAnnouncementHeadless
	)

Definition at line 695 of file flutter_windows_engine_unittests.cc.

                                                                    {
  auto& context = GetContext();
  WindowsConfigBuilder builder{context};
  builder.SetDartEntrypoint("sendAccessibilityAnnouncement");
 
  bool done = false;
  auto native_entry =
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
  context.AddNativeFunction("Signal", native_entry);
 
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
  windows_engine->UpdateSemanticsEnabled(true);
 
  // Rely on timeout mechanism in CI.
  while (!done) {
    windows_engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [568/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AccessibilityTooltip
	)

Definition at line 719 of file flutter_windows_engine_unittests.cc.

                                                       {
  fml::testing::LogCapture log_capture;
 
  auto& context = GetContext();
  WindowsConfigBuilder builder{context};
  builder.SetDartEntrypoint("sendAccessibilityTooltipEvent");
 
  bool done = false;
  auto native_entry =
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { done = true; });
  context.AddNativeFunction("Signal", native_entry);
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine);
  windows_engine->UpdateSemanticsEnabled(true);
 
  // Rely on timeout mechanism in CI.
  while (!done) {
    windows_engine->task_runner()->ProcessTasks();
  }
 
  // Verify no error was logged.
  // Regression test for:
  // https://github.com/flutter/flutter/issues/144274
  EXPECT_EQ(log_capture.str().find("tooltip"), std::string::npos);
}

◆ TEST_F() [569/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AddPluginRegistrarDestructionCallback
	)

Definition at line 510 of file flutter_windows_engine_unittests.cc.

                                                                        {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  MockEmbedderApiForKeyboard(modifier,
                             std::make_shared<MockKeyResponseController>());
 
  engine->Run();
 
  // Verify that destruction handlers don't overwrite each other.
  int result1 = 0;
  int result2 = 0;
  engine->AddPluginRegistrarDestructionCallback(
      [](FlutterDesktopPluginRegistrarRef ref) {
        auto result = reinterpret_cast<int*>(ref);
        *result = 1;
      },
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result1));
  engine->AddPluginRegistrarDestructionCallback(
      [](FlutterDesktopPluginRegistrarRef ref) {
        auto result = reinterpret_cast<int*>(ref);
        *result = 2;
      },
      reinterpret_cast<FlutterDesktopPluginRegistrarRef>(&result2));
 
  engine->Stop();
  EXPECT_EQ(result1, 1);
  EXPECT_EQ(result2, 2);
}

◆ TEST_F() [570/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AddViewFailureDoesNotHang
	)

Definition at line 1268 of file flutter_windows_engine_unittests.cc.

                                                            {
  FlutterWindowsEngineBuilder builder{GetContext()};
  auto engine = builder.Build();
 
  EngineModifier modifier{engine.get()};
 
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  modifier.embedder_api().AddView = MOCK_ENGINE_PROC(
      AddView,
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         const FlutterAddViewInfo* info) { return kInternalInconsistency; });
 
  ASSERT_TRUE(engine->Run());
 
  // Create the first view. This is the implicit view and isn't added to the
  // engine.
  auto implicit_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
 
  std::unique_ptr<FlutterWindowsView> implicit_view =
      engine->CreateView(std::move(implicit_window));
 
  EXPECT_TRUE(implicit_view);
 
  // Create a second view. The embedder attempts to add it to the engine.
  auto second_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
 
  EXPECT_DEBUG_DEATH(engine->CreateView(std::move(second_window)),
                     "FlutterEngineAddView returned an unexpected result");
}

◆ TEST_F() [571/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ApplicationLifecycleExternalWindow
	)

Definition at line 992 of file flutter_windows_engine_unittests.cc.

                                                                     {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
  modifier.SetLifecycleManager(std::move(handler));
  engine->lifecycle_manager()->BeginProcessingExit();
 
  engine->lifecycle_manager()->ExternalWindowMessage(0, WM_CLOSE, 0, 0);
}

◆ TEST_F() [572/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		AppStartsInResumedState
	)

Definition at line 1011 of file flutter_windows_engine_unittests.cc.

                                                          {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed))
      .Times(1);
  modifier.SetLifecycleManager(std::move(handler));
  engine->Run();
}

◆ TEST_F() [573/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ChannelListenedTo
	)

Definition at line 1217 of file flutter_windows_engine_unittests.cc.

                                                    {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("enableLifecycleToFrom");
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
 
  bool lifecycle_began = false;
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState).Times(1);
  handler->begin_processing_callback = [&]() { lifecycle_began = true; };
  modifier.SetLifecycleManager(std::move(handler));
 
  engine->Run();
 
  while (!lifecycle_began) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [574/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ConfiguresFrameVsync
	)

Definition at line 167 of file flutter_windows_engine_unittests.cc.

                                                       {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
  bool on_vsync_called = false;
 
  modifier.embedder_api().GetCurrentTime =
      MOCK_ENGINE_PROC(GetCurrentTime, ([]() -> uint64_t { return 1; }));
  modifier.embedder_api().OnVsync = MOCK_ENGINE_PROC(
      OnVsync,
      ([&on_vsync_called, engine_instance = engine.get()](
           FLUTTER_API_SYMBOL(FlutterEngine) engine, intptr_t baton,
           uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos) {
        EXPECT_EQ(baton, 1);
        EXPECT_EQ(frame_start_time_nanos, 16600000);
        EXPECT_EQ(frame_target_time_nanos, 33200000);
        on_vsync_called = true;
        return kSuccess;
      }));
  modifier.SetStartTime(0);
  modifier.SetFrameInterval(16600000);
 
  engine->OnVsync(1);
 
  EXPECT_TRUE(on_vsync_called);
}

◆ TEST_F() [575/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		DispatchSemanticsAction
	)

Definition at line 464 of file flutter_windows_engine_unittests.cc.

                                                          {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  bool called = false;
  std::string message = "Hello";
  modifier.embedder_api().DispatchSemanticsAction = MOCK_ENGINE_PROC(
      DispatchSemanticsAction,
      ([&called, &message](auto engine, auto target, auto action, auto data,
                           auto data_length) {
        called = true;
        EXPECT_EQ(target, 42);
        EXPECT_EQ(action, kFlutterSemanticsActionDismiss);
        EXPECT_EQ(memcmp(data, message.c_str(), message.size()), 0);
        EXPECT_EQ(data_length, message.size());
        return kSuccess;
      }));
 
  auto data = fml::MallocMapping::Copy(message.c_str(), message.size());
  engine->DispatchSemanticsAction(42, kFlutterSemanticsActionDismiss,
                                  std::move(data));
  EXPECT_TRUE(called);
}

◆ TEST_F() [576/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		EnableApplicationLifecycle
	)

Definition at line 972 of file flutter_windows_engine_unittests.cc.

                                                             {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(false));
  modifier.SetLifecycleManager(std::move(handler));
  engine->lifecycle_manager()->BeginProcessingExit();
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
}

◆ TEST_F() [577/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		EnableLifecycleState
	)

Definition at line 1116 of file flutter_windows_engine_unittests.cc.

                                                       {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("enableLifecycleTest");
  bool finished = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState)
      .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
        handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
      });
  modifier.SetLifecycleManager(std::move(handler));
 
  auto binary_messenger =
      std::make_unique<BinaryMessengerImpl>(engine->messenger());
  // Mark the test only as completed on receiving an inactive state message.
  binary_messenger->SetMessageHandler(
      "flutter/unittest", [&finished](const uint8_t* message,
                                      size_t message_size, BinaryReply reply) {
        std::string contents(message, message + message_size);
        EXPECT_NE(contents.find("AppLifecycleState.inactive"),
                  std::string::npos);
        finished = true;
        char response[] = "";
        reply(reinterpret_cast<uint8_t*>(response), 0);
      });
 
  engine->Run();
 
  // Test that setting the state before enabling lifecycle does nothing.
  HWND hwnd = reinterpret_cast<HWND>(1);
  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
  EXPECT_FALSE(finished);
 
  // Test that we can set the state afterwards.
 
  engine->lifecycle_manager()->BeginProcessingLifecycle();
  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
 
  while (!finished) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [578/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ExternalWindowMessage
	)

Definition at line 1058 of file flutter_windows_engine_unittests.cc.

                                                        {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  // Sets lifecycle state to resumed.
  engine->Run();
 
  // Ensure HWND(1) is in the set of visible windows before hiding it.
  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
                                       TRUE, NULL);
  engine->ProcessExternalWindowMessage(reinterpret_cast<HWND>(1), WM_SHOWWINDOW,
                                       FALSE, NULL);
 
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kHidden);
}

◆ TEST_F() [579/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		GetExecutableName
	)

Definition at line 573 of file flutter_windows_engine_unittests.cc.

                                                    {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EXPECT_EQ(engine->GetExecutableName(), "flutter_windows_unittests.exe");
}

◆ TEST_F() [580/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		InnerWindowHidden
	)

Definition at line 1082 of file flutter_windows_engine_unittests.cc.

                                                    {
  FlutterWindowsEngineBuilder builder{GetContext()};
  HWND outer = reinterpret_cast<HWND>(1);
  HWND inner = reinterpret_cast<HWND>(2);
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
  ON_CALL(view, GetWindowHandle).WillByDefault([=]() { return inner; });
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  // Sets lifecycle state to resumed.
  engine->Run();
 
  // Show both top-level and Flutter window.
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
      outer, WM_SHOWWINDOW, TRUE, NULL);
  view.OnWindowStateEvent(inner, WindowStateEvent::kShow);
  view.OnWindowStateEvent(inner, WindowStateEvent::kFocus);
 
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kResumed);
 
  // Hide Flutter window, but not top level window.
  view.OnWindowStateEvent(inner, WindowStateEvent::kHide);
 
  // The top-level window is still visible, so we ought not enter hidden state.
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kInactive);
}

◆ TEST_F() [581/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		LifecycleManagerDisabledByDefault
	)

Definition at line 953 of file flutter_windows_engine_unittests.cc.

                                                                    {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(0);
  modifier.SetLifecycleManager(std::move(handler));
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
}

◆ TEST_F() [582/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		LifecycleStateToFrom
	)

Definition at line 1168 of file flutter_windows_engine_unittests.cc.

                                                       {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("enableLifecycleToFrom");
  bool enabled_lifecycle = false;
  bool dart_responded = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState)
      .WillRepeatedly([handler_ptr = handler.get()](AppLifecycleState state) {
        handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
      });
  handler->begin_processing_callback = [&]() { enabled_lifecycle = true; };
  modifier.SetLifecycleManager(std::move(handler));
 
  auto binary_messenger =
      std::make_unique<BinaryMessengerImpl>(engine->messenger());
  binary_messenger->SetMessageHandler(
      "flutter/unittest",
      [&](const uint8_t* message, size_t message_size, BinaryReply reply) {
        std::string contents(message, message + message_size);
        EXPECT_NE(contents.find("AppLifecycleState."), std::string::npos);
        dart_responded = true;
        char response[] = "";
        reply(reinterpret_cast<uint8_t*>(response), 0);
      });
 
  engine->Run();
 
  while (!enabled_lifecycle) {
    engine->task_runner()->ProcessTasks();
  }
 
  HWND hwnd = reinterpret_cast<HWND>(1);
  view.OnWindowStateEvent(hwnd, WindowStateEvent::kShow);
  view.OnWindowStateEvent(hwnd, WindowStateEvent::kHide);
 
  while (!dart_responded) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [583/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		LifecycleStateTransition
	)

Definition at line 1029 of file flutter_windows_engine_unittests.cc.

                                                           {
  FlutterWindowsEngineBuilder builder{GetContext()};
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  engine->Run();
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
      (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kResumed);
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
      (HWND)1, WM_SIZE, SIZE_MINIMIZED, 0);
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kHidden);
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
      (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
  EXPECT_EQ(engine->lifecycle_manager()->GetLifecycleState(),
            AppLifecycleState::kInactive);
}

◆ TEST_F() [584/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		PlatformMessageRespondOnDifferentThread
	)

Definition at line 354 of file flutter_windows_engine_unittests.cc.

                                                                          {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("hiPlatformChannels");
 
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
 
  EngineModifier modifier(engine.get());
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
 
  auto binary_messenger =
      std::make_unique<BinaryMessengerImpl>(engine->messenger());
 
  engine->Run();
  bool did_call_callback = false;
  bool did_call_reply = false;
  bool did_call_dart_reply = false;
  std::string channel = "hi";
  std::unique_ptr<std::thread> reply_thread;
  binary_messenger->SetMessageHandler(
      channel,
      [&did_call_callback, &did_call_dart_reply, &reply_thread](
          const uint8_t* message, size_t message_size, BinaryReply reply) {
        if (message_size == 5) {
          EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
          reply_thread.reset(new std::thread([reply = std::move(reply)]() {
            char response[] = {'b', 'y', 'e'};
            reply(reinterpret_cast<uint8_t*>(response), 3);
          }));
          did_call_callback = true;
        } else {
          EXPECT_EQ(message_size, 3);
          EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
          did_call_dart_reply = true;
        }
      });
  char payload[] = {'h', 'e', 'l', 'l', 'o'};
  binary_messenger->Send(
      channel, reinterpret_cast<uint8_t*>(payload), 5,
      [&did_call_reply](const uint8_t* reply, size_t reply_size) {
        EXPECT_EQ(reply_size, 5);
        EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
        did_call_reply = true;
      });
  // Rely on timeout mechanism in CI.
  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
    engine->task_runner()->ProcessTasks();
  }
  ASSERT_TRUE(reply_thread);
  reply_thread->join();
}

◆ TEST_F() [585/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		PlatformMessageRoundTrip
	)

Definition at line 309 of file flutter_windows_engine_unittests.cc.

                                                           {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("hiPlatformChannels");
 
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
 
  auto binary_messenger =
      std::make_unique<BinaryMessengerImpl>(engine->messenger());
 
  engine->Run();
  bool did_call_callback = false;
  bool did_call_reply = false;
  bool did_call_dart_reply = false;
  std::string channel = "hi";
  binary_messenger->SetMessageHandler(
      channel,
      [&did_call_callback, &did_call_dart_reply](
          const uint8_t* message, size_t message_size, BinaryReply reply) {
        if (message_size == 5) {
          EXPECT_EQ(message[0], static_cast<uint8_t>('h'));
          char response[] = {'b', 'y', 'e'};
          reply(reinterpret_cast<uint8_t*>(response), 3);
          did_call_callback = true;
        } else {
          EXPECT_EQ(message_size, 3);
          EXPECT_EQ(message[0], static_cast<uint8_t>('b'));
          did_call_dart_reply = true;
        }
      });
  char payload[] = {'h', 'e', 'l', 'l', 'o'};
  binary_messenger->Send(
      channel, reinterpret_cast<uint8_t*>(payload), 5,
      [&did_call_reply](const uint8_t* reply, size_t reply_size) {
        EXPECT_EQ(reply_size, 5);
        EXPECT_EQ(reply[0], static_cast<uint8_t>('h'));
        did_call_reply = true;
      });
  // Rely on timeout mechanism in CI.
  while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [586/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		PostRasterThreadTask
	)

Definition at line 622 of file flutter_windows_engine_unittests.cc.

                                                       {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
      PostRenderThreadTask, ([](auto engine, auto callback, auto context) {
        callback(context);
        return kSuccess;
      }));
 
  bool called = false;
  engine->PostRasterThreadTask([&called]() { called = true; });
 
  EXPECT_TRUE(called);
}

◆ TEST_F() [587/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ReceivePlatformViewMessage
	)

Definition at line 1243 of file flutter_windows_engine_unittests.cc.

                                                             {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("sendCreatePlatformViewMethod");
  auto engine = builder.Build();
 
  EngineModifier modifier{engine.get()};
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
 
  bool received_call = false;
 
  auto manager = std::make_unique<MockPlatformViewManager>(engine.get());
  EXPECT_CALL(*manager, AddPlatformView)
      .WillOnce([&](PlatformViewId id, std::string_view type_name) {
        received_call = true;
        return true;
      });
  modifier.SetPlatformViewPlugin(std::move(manager));
 
  engine->Run();
 
  while (!received_call) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [588/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		RemoveViewFailureDoesNotHang
	)

Definition at line 1298 of file flutter_windows_engine_unittests.cc.

                                                               {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("sendCreatePlatformViewMethod");
  auto engine = builder.Build();
 
  EngineModifier modifier{engine.get()};
 
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  modifier.embedder_api().RemoveView = MOCK_ENGINE_PROC(
      RemoveView,
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         const FlutterRemoveViewInfo* info) { return kInternalInconsistency; });
 
  ASSERT_TRUE(engine->Run());
  EXPECT_DEBUG_DEATH(engine->RemoveView(123),
                     "FlutterEngineRemoveView returned an unexpected result");
}

◆ TEST_F() [589/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		RunDoesExpectedInitialization
	)

Definition at line 51 of file flutter_windows_engine_unittests.cc.

                                                                {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.AddDartEntrypointArgument("arg1");
  builder.AddDartEntrypointArgument("arg2");
 
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  // The engine should be run with expected configuration values.
  bool run_called = false;
  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
      Run, ([&run_called, engine_instance = engine.get()](
                size_t version, const FlutterRendererConfig* config,
                const FlutterProjectArgs* args, void* user_data,
                FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        run_called = true;
        *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
 
        EXPECT_EQ(version, FLUTTER_ENGINE_VERSION);
        EXPECT_NE(config, nullptr);
        // We have an EGL manager, so this should be using OpenGL.
        EXPECT_EQ(config->type, kOpenGL);
        EXPECT_EQ(user_data, engine_instance);
        // Spot-check arguments.
        EXPECT_NE(args->assets_path, nullptr);
        EXPECT_NE(args->icu_data_path, nullptr);
        EXPECT_EQ(args->dart_entrypoint_argc, 2U);
        EXPECT_EQ(strcmp(args->dart_entrypoint_argv[0], "arg1"), 0);
        EXPECT_EQ(strcmp(args->dart_entrypoint_argv[1], "arg2"), 0);
        EXPECT_NE(args->platform_message_callback, nullptr);
        EXPECT_NE(args->custom_task_runners, nullptr);
        EXPECT_NE(args->custom_task_runners->thread_priority_setter, nullptr);
        EXPECT_EQ(args->custom_dart_entrypoint, nullptr);
        EXPECT_NE(args->vsync_callback, nullptr);
        EXPECT_EQ(args->update_semantics_callback, nullptr);
        EXPECT_NE(args->update_semantics_callback2, nullptr);
        EXPECT_EQ(args->update_semantics_node_callback, nullptr);
        EXPECT_EQ(args->update_semantics_custom_action_callback, nullptr);
 
        args->custom_task_runners->thread_priority_setter(
            FlutterThreadPriority::kRaster);
        EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
                  THREAD_PRIORITY_ABOVE_NORMAL);
        return kSuccess;
      }));
  // Accessibility updates must do nothing when the embedder engine is mocked
  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
      UpdateAccessibilityFeatures,
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         FlutterAccessibilityFeature flags) { return kSuccess; });
 
  // It should send locale info.
  bool update_locales_called = false;
  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales,
      ([&update_locales_called](auto engine, const FlutterLocale** locales,
                                size_t locales_count) {
        update_locales_called = true;
 
        EXPECT_GT(locales_count, 0);
        EXPECT_NE(locales, nullptr);
 
        return kSuccess;
      }));
 
  // And it should send initial settings info.
  bool settings_message_sent = false;
  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&settings_message_sent](auto engine, auto message) {
        if (std::string(message->channel) == std::string("flutter/settings")) {
          settings_message_sent = true;
        }
 
        return kSuccess;
      }));
 
  // And it should send display info.
  bool notify_display_update_called = false;
  modifier.SetFrameInterval(16600000);  // 60 fps.
  modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
      NotifyDisplayUpdate,
      ([&notify_display_update_called, engine_instance = engine.get()](
           FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
           const FlutterEngineDisplaysUpdateType update_type,
           const FlutterEngineDisplay* embedder_displays,
           size_t display_count) {
        EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
        EXPECT_EQ(display_count, 1);
 
        FlutterEngineDisplay display = embedder_displays[0];
 
        EXPECT_EQ(display.display_id, 0);
        EXPECT_EQ(display.single_display, true);
        EXPECT_EQ(std::floor(display.refresh_rate), 60.0);
 
        notify_display_update_called = true;
        return kSuccess;
      }));
 
  // Set the EGL manager to !nullptr to test ANGLE rendering.
  modifier.SetEGLManager(std::make_unique<egl::MockManager>());
 
  engine->Run();
 
  EXPECT_TRUE(run_called);
  EXPECT_TRUE(update_locales_called);
  EXPECT_TRUE(settings_message_sent);
  EXPECT_TRUE(notify_display_update_called);
 
  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
  // engine pointer that the overridden Run returned.
  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
  modifier.ReleaseEGLManager();
}

◆ TEST_F() [590/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		RunHeadless
	)

Definition at line 39 of file flutter_windows_engine_unittests.cc.

                                              {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
 
  EngineModifier modifier(engine.get());
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
 
  ASSERT_TRUE(engine->Run());
  ASSERT_EQ(engine->view(kImplicitViewId), nullptr);
  ASSERT_EQ(engine->view(123), nullptr);
}

◆ TEST_F() [591/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		RunWithoutANGLEOnImpellerFailsToStart
	)

Definition at line 247 of file flutter_windows_engine_unittests.cc.

                                                                        {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetSwitches({"--enable-impeller=true"});
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  modifier.embedder_api().NotifyDisplayUpdate =
      MOCK_ENGINE_PROC(NotifyDisplayUpdate,
                       ([engine_instance = engine.get()](
                            FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
                            const FlutterEngineDisplaysUpdateType update_type,
                            const FlutterEngineDisplay* embedder_displays,
                            size_t display_count) { return kSuccess; }));
 
  // Accessibility updates must do nothing when the embedder engine is mocked
  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
      UpdateAccessibilityFeatures,
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         FlutterAccessibilityFeature flags) { return kSuccess; });
 
  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
  // initialized engine instance.
  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([](auto engine, const FlutterLocale** locales,
                         size_t locales_count) { return kSuccess; }));
  modifier.embedder_api().SendPlatformMessage =
      MOCK_ENGINE_PROC(SendPlatformMessage,
                       ([](auto engine, auto message) { return kSuccess; }));
 
  // Set the EGL manager to nullptr to test software fallback path.
  modifier.SetEGLManager(nullptr);
 
  EXPECT_FALSE(engine->Run());
}

◆ TEST_F() [592/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		RunWithoutANGLEUsesSoftware
	)

Definition at line 194 of file flutter_windows_engine_unittests.cc.

                                                              {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  modifier.embedder_api().NotifyDisplayUpdate =
      MOCK_ENGINE_PROC(NotifyDisplayUpdate,
                       ([engine_instance = engine.get()](
                            FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
                            const FlutterEngineDisplaysUpdateType update_type,
                            const FlutterEngineDisplay* embedder_displays,
                            size_t display_count) { return kSuccess; }));
 
  // The engine should be run with expected configuration values.
  bool run_called = false;
  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
      Run, ([&run_called, engine_instance = engine.get()](
                size_t version, const FlutterRendererConfig* config,
                const FlutterProjectArgs* args, void* user_data,
                FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        run_called = true;
        *engine_out = reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(1);
        // We don't have an EGL Manager, so we should be using software.
        EXPECT_EQ(config->type, kSoftware);
        return kSuccess;
      }));
  // Accessibility updates must do nothing when the embedder engine is mocked
  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
      UpdateAccessibilityFeatures,
      [](FLUTTER_API_SYMBOL(FlutterEngine) engine,
         FlutterAccessibilityFeature flags) { return kSuccess; });
 
  // Stub out UpdateLocales and SendPlatformMessage as we don't have a fully
  // initialized engine instance.
  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([](auto engine, const FlutterLocale** locales,
                         size_t locales_count) { return kSuccess; }));
  modifier.embedder_api().SendPlatformMessage =
      MOCK_ENGINE_PROC(SendPlatformMessage,
                       ([](auto engine, auto message) { return kSuccess; }));
 
  // Set the EGL manager to nullptr to test software fallback path.
  modifier.SetEGLManager(nullptr);
 
  engine->Run();
 
  EXPECT_TRUE(run_called);
 
  // Ensure that deallocation doesn't call the actual Shutdown with the bogus
  // engine pointer that the overridden Run returned.
  modifier.embedder_api().Shutdown = [](auto engine) { return kSuccess; };
}

◆ TEST_F() [593/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		ScheduleFrame
	)

Definition at line 541 of file flutter_windows_engine_unittests.cc.

                                                {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  bool called = false;
  modifier.embedder_api().ScheduleFrame =
      MOCK_ENGINE_PROC(ScheduleFrame, ([&called](auto engine) {
                         called = true;
                         return kSuccess;
                       }));
 
  engine->ScheduleFrame();
  EXPECT_TRUE(called);
}

◆ TEST_F() [594/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		SendPlatformMessageWithoutResponse
	)

Definition at line 282 of file flutter_windows_engine_unittests.cc.

                                                                     {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  const char* channel = "test";
  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
 
  // Without a response, SendPlatformMessage should be a simple pass-through.
  bool called = false;
  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage, ([&called, test_message](auto engine, auto message) {
        called = true;
        EXPECT_STREQ(message->channel, "test");
        EXPECT_EQ(message->message_size, test_message.size());
        EXPECT_EQ(memcmp(message->message, test_message.data(),
                         message->message_size),
                  0);
        EXPECT_EQ(message->response_handle, nullptr);
        return kSuccess;
      }));
 
  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
                              nullptr, nullptr);
  EXPECT_TRUE(called);
}

◆ TEST_F() [595/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		SendPlatformMessageWithResponse
	)

Definition at line 405 of file flutter_windows_engine_unittests.cc.

                                                                  {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  const char* channel = "test";
  const std::vector<uint8_t> test_message = {1, 2, 3, 4};
  auto* dummy_response_handle =
      reinterpret_cast<FlutterPlatformMessageResponseHandle*>(5);
  const FlutterDesktopBinaryReply reply_handler = [](auto... args) {};
  void* reply_user_data = reinterpret_cast<void*>(6);
 
  // When a response is requested, a handle should be created, passed as part
  // of the message, and then released.
  bool create_response_handle_called = false;
  modifier.embedder_api().PlatformMessageCreateResponseHandle =
      MOCK_ENGINE_PROC(
          PlatformMessageCreateResponseHandle,
          ([&create_response_handle_called, &reply_handler, reply_user_data,
            dummy_response_handle](auto engine, auto reply, auto user_data,
                                   auto response_handle) {
            create_response_handle_called = true;
            EXPECT_EQ(reply, reply_handler);
            EXPECT_EQ(user_data, reply_user_data);
            EXPECT_NE(response_handle, nullptr);
            *response_handle = dummy_response_handle;
            return kSuccess;
          }));
  bool release_response_handle_called = false;
  modifier.embedder_api().PlatformMessageReleaseResponseHandle =
      MOCK_ENGINE_PROC(
          PlatformMessageReleaseResponseHandle,
          ([&release_response_handle_called, dummy_response_handle](
               auto engine, auto response_handle) {
            release_response_handle_called = true;
            EXPECT_EQ(response_handle, dummy_response_handle);
            return kSuccess;
          }));
  bool send_message_called = false;
  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage, ([&send_message_called, test_message,
                             dummy_response_handle](auto engine, auto message) {
        send_message_called = true;
        EXPECT_STREQ(message->channel, "test");
        EXPECT_EQ(message->message_size, test_message.size());
        EXPECT_EQ(memcmp(message->message, test_message.data(),
                         message->message_size),
                  0);
        EXPECT_EQ(message->response_handle, dummy_response_handle);
        return kSuccess;
      }));
 
  engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
                              reply_handler, reply_user_data);
  EXPECT_TRUE(create_response_handle_called);
  EXPECT_TRUE(release_response_handle_called);
  EXPECT_TRUE(send_message_called);
}

◆ TEST_F() [596/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		SetNextFrameCallback
	)

Definition at line 557 of file flutter_windows_engine_unittests.cc.

                                                       {
  FlutterWindowsEngineBuilder builder{GetContext()};
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  bool called = false;
  modifier.embedder_api().SetNextFrameCallback = MOCK_ENGINE_PROC(
      SetNextFrameCallback, ([&called](auto engine, auto callback, auto data) {
        called = true;
        return kSuccess;
      }));
 
  engine->SetNextFrameCallback([]() {});
  EXPECT_TRUE(called);
}

◆ TEST_F() [597/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		SetsThreadPriority
	)

Definition at line 489 of file flutter_windows_engine_unittests.cc.

                                                     {
  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kBackground);
  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
            THREAD_PRIORITY_BELOW_NORMAL);
 
  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kDisplay);
  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
            THREAD_PRIORITY_ABOVE_NORMAL);
 
  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kRaster);
  EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
            THREAD_PRIORITY_ABOVE_NORMAL);
 
  // FlutterThreadPriority::kNormal does not change thread priority, reset to 0
  // here.
  SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
 
  WindowsPlatformThreadPrioritySetter(FlutterThreadPriority::kNormal);
  EXPECT_EQ(GetThreadPriority(GetCurrentThread()), THREAD_PRIORITY_NORMAL);
}

◆ TEST_F() [598/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		TestExit
	)

Definition at line 774 of file flutter_windows_engine_unittests.cc.

                                           {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("exitTestExit");
  bool finished = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
  EXPECT_CALL(*handler, Quit)
      .WillOnce([&finished](std::optional<HWND> hwnd,
                            std::optional<WPARAM> wparam,
                            std::optional<LPARAM> lparam,
                            UINT exit_code) { finished = exit_code == 0; });
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
  modifier.SetLifecycleManager(std::move(handler));
 
  engine->lifecycle_manager()->BeginProcessingExit();
 
  engine->Run();
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
 
  // The test will only succeed when this while loop exits. Otherwise it will
  // timeout.
  while (!finished) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [599/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		TestExitCancel
	)

Definition at line 811 of file flutter_windows_engine_unittests.cc.

                                                 {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("exitTestCancel");
  bool did_call = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(true));
  EXPECT_CALL(*handler, Quit).Times(0);
  modifier.SetLifecycleManager(std::move(handler));
  engine->lifecycle_manager()->BeginProcessingExit();
 
  auto binary_messenger =
      std::make_unique<BinaryMessengerImpl>(engine->messenger());
  binary_messenger->SetMessageHandler(
      "flutter/platform", [&did_call](const uint8_t* message,
                                      size_t message_size, BinaryReply reply) {
        std::string contents(message, message + message_size);
        EXPECT_NE(contents.find("\"method\":\"System.exitApplication\""),
                  std::string::npos);
        EXPECT_NE(contents.find("\"type\":\"required\""), std::string::npos);
        EXPECT_NE(contents.find("\"exitCode\":0"), std::string::npos);
        did_call = true;
        char response[] = "";
        reply(reinterpret_cast<uint8_t*>(response), 0);
      });
 
  engine->Run();
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
 
  while (!did_call) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [600/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		TestExitCloseMultiWindow
	)

Definition at line 919 of file flutter_windows_engine_unittests.cc.

                                                           {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("exitTestExit");
  bool finished = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce([&finished]() {
    finished = true;
    return false;
  });
  // Quit should not be called when there is more than one window.
  EXPECT_CALL(*handler, Quit).Times(0);
  modifier.SetLifecycleManager(std::move(handler));
  engine->lifecycle_manager()->BeginProcessingExit();
 
  engine->Run();
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
 
  while (!finished) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [601/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		TestExitSecondCloseMessage
	)

Definition at line 859 of file flutter_windows_engine_unittests.cc.

                                                             {
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetDartEntrypoint("exitTestExit");
  bool second_close = false;
 
  auto engine = builder.Build();
  auto window_binding_handler =
      std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
  MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
 
  EngineModifier modifier(engine.get());
  modifier.SetImplicitView(&view);
  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
  auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
  EXPECT_CALL(*handler, SetLifecycleState(AppLifecycleState::kResumed));
  EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(true));
  EXPECT_CALL(*handler, Quit)
      .WillOnce([handler_ptr = handler.get()](
                    std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
                    std::optional<LPARAM> lparam, UINT exit_code) {
        handler_ptr->WindowsLifecycleManager::Quit(hwnd, wparam, lparam,
                                                   exit_code);
      });
  EXPECT_CALL(*handler, DispatchMessage)
      .WillRepeatedly(
          [&engine](HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
            engine->window_proc_delegate_manager()->OnTopLevelWindowProc(
                hwnd, msg, wparam, lparam);
          });
  modifier.SetLifecycleManager(std::move(handler));
  engine->lifecycle_manager()->BeginProcessingExit();
 
  engine->Run();
 
  // This delegate will be registered after the lifecycle manager, so it will be
  // called only when a message is not consumed by the lifecycle manager. This
  // should be called on the second, synthesized WM_CLOSE message that the
  // lifecycle manager posts.
  engine->window_proc_delegate_manager()->RegisterTopLevelWindowProcDelegate(
      [](HWND hwnd, UINT message, WPARAM wpar, LPARAM lpar, void* user_data,
         LRESULT* result) {
        switch (message) {
          case WM_CLOSE: {
            bool* called = reinterpret_cast<bool*>(user_data);
            *called = true;
            return true;
          }
        }
        return false;
      },
      reinterpret_cast<void*>(&second_close));
 
  engine->window_proc_delegate_manager()->OnTopLevelWindowProc(0, WM_CLOSE, 0,
                                                               0);
 
  while (!second_close) {
    engine->task_runner()->ProcessTasks();
  }
}

◆ TEST_F() [602/925]

flutter::testing::TEST_F	(	FlutterWindowsEngineTest	,
		UpdateHighContrastFeature
	)

Definition at line 581 of file flutter_windows_engine_unittests.cc.

                                                            {
  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
  EXPECT_CALL(*windows_proc_table, GetHighContrastEnabled)
      .WillOnce(Return(true))
      .WillOnce(Return(false));
 
  FlutterWindowsEngineBuilder builder{GetContext()};
  builder.SetWindowsProcTable(windows_proc_table);
  std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
  EngineModifier modifier(engine.get());
 
  std::optional<FlutterAccessibilityFeature> engine_flags;
  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
      UpdateAccessibilityFeatures, ([&engine_flags](auto engine, auto flags) {
        engine_flags = flags;
        return kSuccess;
      }));
  modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      [](auto engine, const auto message) { return kSuccess; });
 
  // 1: High contrast is enabled.
  engine->UpdateHighContrastMode();
 
  EXPECT_TRUE(engine->high_contrast_enabled());
  EXPECT_TRUE(engine_flags.has_value());
  EXPECT_TRUE(
      engine_flags.value() &
      FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
 
  // 2: High contrast is disabled.
  engine_flags.reset();
  engine->UpdateHighContrastMode();
 
  EXPECT_FALSE(engine->high_contrast_enabled());
  EXPECT_TRUE(engine_flags.has_value());
  EXPECT_FALSE(
      engine_flags.value() &
      FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
}

◆ TEST_F() [603/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		AccessibilityNodeWithoutView
	)

Definition at line 310 of file flutter_window_unittests.cc.

                                                        {
  MockFlutterWindow win32window;
 
  EXPECT_EQ(win32window.GetNativeViewAccessible(), nullptr);
}

◆ TEST_F() [604/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		AlertNode
	)

Definition at line 318 of file flutter_window_unittests.cc.

                                     {
  std::unique_ptr<FlutterWindowsEngine> engine =
      FlutterWindowsEngineBuilder{GetContext()}.Build();
  auto win32window = std::make_unique<MockFlutterWindow>();
  EXPECT_CALL(*win32window.get(), GetAxFragmentRootDelegate())
      .WillRepeatedly(Return(nullptr));
  EXPECT_CALL(*win32window.get(), OnWindowStateEvent).Times(AnyNumber());
  EXPECT_CALL(*win32window.get(), GetWindowHandle).Times(AnyNumber());
  MockFlutterWindowsView view{engine.get(), std::move(win32window)};
  std::wstring message = L"Test alert";
  EXPECT_CALL(view, NotifyWinEventWrapper(_, ax::mojom::Event::kAlert))
      .Times(1);
  view.AnnounceAlert(message);
 
  IAccessible* alert = view.AlertNode();
  VARIANT self{.vt = VT_I4, .lVal = CHILDID_SELF};
  BSTR strptr;
  alert->get_accName(self, &strptr);
  EXPECT_EQ(message, strptr);
 
  alert->get_accDescription(self, &strptr);
  EXPECT_EQ(message, strptr);
 
  alert->get_accValue(self, &strptr);
  EXPECT_EQ(message, strptr);
 
  VARIANT role;
  alert->get_accRole(self, &role);
  EXPECT_EQ(role.vt, VT_I4);
  EXPECT_EQ(role.lVal, ROLE_SYSTEM_ALERT);
}

◆ TEST_F() [605/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		CachedLifecycleMessage
	)

Definition at line 382 of file flutter_window_unittests.cc.

                                                  {
  MockFlutterWindow win32window;
  EXPECT_CALL(win32window, GetWindowHandle)
      .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
  EXPECT_CALL(win32window, OnWindowStateEvent)
      .WillRepeatedly([&](WindowStateEvent event) {
        win32window.FlutterWindow::OnWindowStateEvent(event);
      });
  EXPECT_CALL(win32window, OnResize).Times(1);
 
  // Restore
  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
 
  // Focus
  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
 
  MockWindowBindingHandlerDelegate delegate;
  bool focused = false;
  bool restored = false;
  EXPECT_CALL(delegate, OnWindowStateEvent)
      .WillRepeatedly([&](HWND hwnd, WindowStateEvent event) {
        if (event == WindowStateEvent::kFocus) {
          focused = true;
        } else if (event == WindowStateEvent::kShow) {
          restored = true;
        }
      });
 
  win32window.SetView(&delegate);
  EXPECT_TRUE(focused);
  EXPECT_TRUE(restored);
}

◆ TEST_F() [606/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		CreateDestroy
	)

Definition at line 118 of file flutter_window_unittests.cc.

                                         {
  FlutterWindow window(800, 600);
  ASSERT_TRUE(TRUE);
}

◆ TEST_F() [607/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		LifecycleFocusMessages
	)

Definition at line 350 of file flutter_window_unittests.cc.

                                                  {
  MockFlutterWindow win32window;
  EXPECT_CALL(win32window, GetWindowHandle)
      .WillRepeatedly(Return(reinterpret_cast<HWND>(1)));
  MockWindowBindingHandlerDelegate delegate;
 
  WindowStateEvent last_event;
  EXPECT_CALL(delegate, OnWindowStateEvent)
      .WillRepeatedly([&last_event](HWND hwnd, WindowStateEvent event) {
        last_event = event;
      });
  EXPECT_CALL(win32window, OnWindowStateEvent)
      .WillRepeatedly([&](WindowStateEvent event) {
        win32window.FlutterWindow::OnWindowStateEvent(event);
      });
  EXPECT_CALL(win32window, OnResize).Times(AnyNumber());
 
  win32window.SetView(&delegate);
 
  win32window.InjectWindowMessage(WM_SIZE, 0, 0);
  EXPECT_EQ(last_event, WindowStateEvent::kHide);
 
  win32window.InjectWindowMessage(WM_SIZE, 0, MAKEWORD(1, 1));
  EXPECT_EQ(last_event, WindowStateEvent::kShow);
 
  win32window.InjectWindowMessage(WM_SETFOCUS, 0, 0);
  EXPECT_EQ(last_event, WindowStateEvent::kFocus);
 
  win32window.InjectWindowMessage(WM_KILLFOCUS, 0, 0);
  EXPECT_EQ(last_event, WindowStateEvent::kUnfocus);
}

◆ TEST_F() [608/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnBitmapSurfaceUpdated
	)

Definition at line 123 of file flutter_window_unittests.cc.

                                                  {
  FlutterWindow win32window(100, 100);
  int old_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
 
  constexpr size_t row_bytes = 100 * 4;
  constexpr size_t height = 100;
  std::array<char, row_bytes * height> allocation;
  win32window.OnBitmapSurfaceUpdated(allocation.data(), row_bytes, height);
 
  int new_handle_count = GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS);
  // Check GDI resources leak
  EXPECT_EQ(old_handle_count, new_handle_count);
}

◆ TEST_F() [609/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnCursorRectUpdatedHighDPI
	)

Definition at line 153 of file flutter_window_unittests.cc.

                                                      {
  MockFlutterWindow win32window;
  EXPECT_CALL(win32window, GetDpiScale()).WillOnce(Return(1.5));
 
  Rect expected_cursor_rect(Point(15, 30), Size(45, 60));
  EXPECT_CALL(win32window, UpdateCursorRect(expected_cursor_rect)).Times(1);
 
  Rect cursor_rect(Point(10, 20), Size(30, 40));
  win32window.OnCursorRectUpdated(cursor_rect);
}

◆ TEST_F() [610/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnCursorRectUpdatedRegularDPI
	)

Definition at line 140 of file flutter_window_unittests.cc.

                                                         {
  MockFlutterWindow win32window;
  EXPECT_CALL(win32window, GetDpiScale()).WillOnce(Return(1.0));
 
  Rect cursor_rect(Point(10, 20), Size(30, 40));
  EXPECT_CALL(win32window, UpdateCursorRect(cursor_rect)).Times(1);
 
  win32window.OnCursorRectUpdated(cursor_rect);
}

◆ TEST_F() [611/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnPointerStarSendsDeviceType
	)

Definition at line 164 of file flutter_window_unittests.cc.

                                                        {
  FlutterWindow win32window(100, 100);
  MockWindowBindingHandlerDelegate delegate;
  EXPECT_CALL(delegate, OnWindowStateEvent).Times(AnyNumber());
  win32window.SetView(&delegate);
 
  // Move
  EXPECT_CALL(delegate,
              OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                            kDefaultPointerDeviceId, 0))
      .Times(1);
  EXPECT_CALL(delegate,
              OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                            kDefaultPointerDeviceId, 0))
      .Times(1);
  EXPECT_CALL(delegate,
              OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                            kDefaultPointerDeviceId, 0))
      .Times(1);
 
  // Down
  EXPECT_CALL(
      delegate,
      OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                    kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
      .Times(1);
  EXPECT_CALL(
      delegate,
      OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                    kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
      .Times(1);
  EXPECT_CALL(
      delegate,
      OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                    kDefaultPointerDeviceId, kFlutterPointerButtonMousePrimary))
      .Times(1);
 
  // Up
  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                                    kDefaultPointerDeviceId,
                                    kFlutterPointerButtonMousePrimary))
      .Times(1);
  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                                    kDefaultPointerDeviceId,
                                    kFlutterPointerButtonMousePrimary))
      .Times(1);
  EXPECT_CALL(delegate, OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                                    kDefaultPointerDeviceId,
                                    kFlutterPointerButtonMousePrimary))
      .Times(1);
 
  // Leave
  EXPECT_CALL(delegate,
              OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                             kDefaultPointerDeviceId))
      .Times(1);
  EXPECT_CALL(delegate,
              OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                             kDefaultPointerDeviceId))
      .Times(1);
  EXPECT_CALL(delegate,
              OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                             kDefaultPointerDeviceId))
      .Times(1);
 
  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                            kDefaultPointerDeviceId, 0);
  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                            kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                          kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindMouse,
                             kDefaultPointerDeviceId);
 
  // Touch
  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                            kDefaultPointerDeviceId, 0);
  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                            kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                          kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindTouch,
                             kDefaultPointerDeviceId);
 
  // Pen
  win32window.OnPointerMove(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                            kDefaultPointerDeviceId, 0);
  win32window.OnPointerDown(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                            kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerUp(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                          kDefaultPointerDeviceId, WM_LBUTTONDOWN);
  win32window.OnPointerLeave(10.0, 10.0, kFlutterPointerDeviceKindStylus,
                             kDefaultPointerDeviceId);
 
  // Destruction of win32window sends a HIDE update. In situ, the window is
  // owned by the delegate, and so is destructed first. Not so here.
  win32window.SetView(nullptr);
}

◆ TEST_F() [612/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnScrollCallsGetScrollOffsetMultiplier
	)

Definition at line 265 of file flutter_window_unittests.cc.

                                                                  {
  MockFlutterWindow win32window;
  MockWindowBindingHandlerDelegate delegate;
  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
  win32window.SetView(&delegate);
 
  EXPECT_CALL(win32window, GetWindowHandle).WillOnce([&win32window]() {
    return win32window.FlutterWindow::GetWindowHandle();
  });
  EXPECT_CALL(win32window, GetScrollOffsetMultiplier).WillOnce(Return(120.0f));
 
  EXPECT_CALL(delegate,
              OnScroll(_, _, 0, 0, 120.0f, kFlutterPointerDeviceKindMouse,
                       kDefaultPointerDeviceId))
      .Times(1);
 
  win32window.OnScroll(0.0f, 0.0f, kFlutterPointerDeviceKindMouse,
                       kDefaultPointerDeviceId);
}

◆ TEST_F() [613/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnThemeChange
	)

Definition at line 296 of file flutter_window_unittests.cc.

                                         {
  MockFlutterWindow win32window;
  MockWindowBindingHandlerDelegate delegate;
  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
  win32window.SetView(&delegate);
 
  EXPECT_CALL(delegate, OnHighContrastChanged).Times(1);
 
  win32window.InjectWindowMessage(WM_THEMECHANGED, 0, 0);
}

◆ TEST_F() [614/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		OnWindowRepaint
	)

Definition at line 285 of file flutter_window_unittests.cc.

                                           {
  MockFlutterWindow win32window;
  MockWindowBindingHandlerDelegate delegate;
  EXPECT_CALL(win32window, OnWindowStateEvent).Times(AnyNumber());
  win32window.SetView(&delegate);
 
  EXPECT_CALL(delegate, OnWindowRepaint()).Times(1);
 
  win32window.InjectWindowMessage(WM_PAINT, 0, 0);
}

◆ TEST_F() [615/925]

flutter::testing::TEST_F	(	FlutterWindowTest	,
		UpdateCursor
	)

Definition at line 415 of file flutter_window_unittests.cc.

                                        {
  FlutterWindow win32window(100, 100);
  win32window.UpdateFlutterCursor("text");
  HCURSOR cursor = ::GetCursor();
  EXPECT_EQ(cursor, ::LoadCursor(nullptr, IDC_IBEAM));
}

◆ TEST_F() [616/925]

flutter::testing::TEST_F	(	FuchsiaShellTest	,
		LocaltimesVaryOnTimezoneChanges
	)

Definition at line 166 of file shell_fuchsia_unittests.cc.

                                                          {
#if defined(OS_FUCHSIA)
  GTEST_SKIP()
      << "This test fails after the CF V2 migration. https://fxbug.dev/110019 ";
#else
 
  // See fixtures/shell_test.dart, the callback NotifyLocalTime is declared
  // there.
  fml::AutoResetWaitableEvent latch;
  std::string dart_isolate_time_str;
  AddNativeCallback("NotifyLocalTime", CREATE_NATIVE_ENTRY([&](auto args) {
                      dart_isolate_time_str =
                          tonic::DartConverter<std::string>::FromDart(
                              Dart_GetNativeArgument(args, 0));
                      latch.Signal();
                    }));
 
  // As long as this is set, the isolate will keep rerunning its only task.
  bool continue_fixture = true;
  fml::AutoResetWaitableEvent fixture_latch;
  AddNativeCallback("WaitFixture", CREATE_NATIVE_ENTRY([&](auto args) {
                      // Wait for the test fixture to advance.
                      fixture_latch.Wait();
                      tonic::DartConverter<bool>::SetReturnValue(
                          args, continue_fixture);
                    }));
 
  auto settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("timezonesChange");
 
  std::unique_ptr<Shell> shell = CreateShell(settings);
  ASSERT_NE(shell.get(), nullptr);
  ASSERT_TRUE(ValidateShell(shell.get()));
  RunEngine(shell.get(), std::move(configuration));
  latch.Wait();  // After this point, the fixture is at waitFixture().
 
  // Start with the local timezone, ensure that the isolate and the test
  // fixture are the same.
  SetTimezone(GetLocalTimezone());
  AssertTimezone(GetLocalTimezone(), GetSettings());
  std::string expected = GetLocalTime();
  std::string actual = "undefined";
  RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
    actual = dart_isolate_time_str;
    FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
    return expected == actual;
  });
  ASSERT_EQ(expected, actual)
      << "The Dart isolate was expected to show the same time as the test "
      << "fixture eventually, but that didn't happen after multiple retries.";
 
  // Set a new timezone, which is hopefully different from the local one.
  SetTimezone("America/New_York");
  AssertTimezone("America/New_York", GetSettings());
  RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
    actual = dart_isolate_time_str;
    FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
    return expected != actual;
  });
  ASSERT_NE(expected, actual)
      << "The Dart isolate was expected to show a time different from the test "
      << "fixture eventually, but that didn't happen after multiple retries.";
 
  // Set a new isolate timezone, and check that the reported time is eventually
  // different from what it used to be prior to the change.
  SetTimezone("Europe/Amsterdam");
  AssertTimezone("Europe/Amsterdam", GetSettings());
  RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
    actual = dart_isolate_time_str;
    FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
    return expected != actual;
  });
  ASSERT_NE(expected, actual)
      << "The Dart isolate was expected to show a time different from the "
      << "prior timezone eventually, but that didn't happen after multiple "
      << "retries.";
 
  // Let's try to bring the timezone back to the old one.
  expected = actual;
  SetTimezone("America/New_York");
  AssertTimezone("America/New_York", GetSettings());
  RunCoroutineWithRetry(10, &fixture_latch, &latch, [&]() {
    actual = dart_isolate_time_str;
    FML_LOG(INFO) << "reference: " << expected << ", actual: " << actual;
    return expected != actual;
  });
  ASSERT_NE(expected, actual)
      << "The Dart isolate was expected to show a time different from the "
      << "prior timezone eventually, but that didn't happen after multiple "
      << "retries.";
 
  // Tell the isolate to exit its loop.
  ASSERT_FALSE(fixture_latch.IsSignaledForTest());
  continue_fixture = false;
  fixture_latch.Signal();
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [617/925]

flutter::testing::TEST_F	(	HooksTest	,
		HooksUnitTests
	)

Definition at line 26 of file hooks_unittests.cc.

                                  {
  auto settings = CreateSettingsForFixture();
 
  TaskRunners task_runners(GetCurrentTestName(),       // label
                           GetCurrentTaskRunner(),     // platform
                           CreateNewThread("raster"),  // raster
                           CreateNewThread("ui"),      // ui
                           CreateNewThread("io")       // io
  );
 
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell->IsSetup());
 
  auto call_hook = [](Dart_NativeArguments args) {
    Dart_Handle hook_name = Dart_GetNativeArgument(args, 0);
    CHECK_DART_ERROR(hook_name);
 
    Dart_Handle ui_library = Dart_LookupLibrary(tonic::ToDart("dart:ui"));
    CHECK_DART_ERROR(ui_library);
 
    Dart_Handle hook = Dart_GetField(ui_library, hook_name);
    CHECK_DART_ERROR(hook);
 
    Dart_Handle arg_count_handle = Dart_GetNativeArgument(args, 1);
    CHECK_DART_ERROR(arg_count_handle);
 
    int64_t arg_count;
    Dart_IntegerToInt64(arg_count_handle, &arg_count);
 
    std::vector<Dart_Handle> hook_args;
    for (int i = 0; i < static_cast<int>(arg_count); i++) {
      hook_args.push_back(Dart_GetNativeArgument(args, 2 + i));
      CHECK_DART_ERROR(hook_args.back());
    }
 
    Dart_Handle hook_result =
        Dart_InvokeClosure(hook, hook_args.size(), hook_args.data());
    CHECK_DART_ERROR(hook_result);
  };
 
  auto finished = [&message_latch](Dart_NativeArguments args) {
    message_latch->Signal();
  };
  AddNativeCallback("CallHook", CREATE_NATIVE_ENTRY(call_hook));
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finished));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("hooksTests");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [618/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		CanCreateImageDecoder
	)

Definition at line 177 of file image_decoder_unittests.cc.

                                                       {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto thread_task_runner = CreateNewThread();
  TaskRunners runners(GetCurrentTestName(),  // label
                      thread_task_runner,    // platform
                      thread_task_runner,    // raster
                      thread_task_runner,    // ui
                      thread_task_runner     // io
 
  );
 
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    TestIOManager manager(runners.GetIOTaskRunner());
    Settings settings;
    auto decoder = ImageDecoder::Make(settings, runners, loop->GetTaskRunner(),
                                      manager.GetWeakIOManager(),
                                      std::make_shared<fml::SyncSwitch>());
    ASSERT_NE(decoder, nullptr);
  });
}

◆ TEST_F() [619/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		CanDecodeWithoutAGPUContext
	)

Definition at line 547 of file image_decoder_unittests.cc.

                                                             {
  auto loop = fml::ConcurrentMessageLoop::Create();
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  fml::AutoResetWaitableEvent latch;
 
  std::unique_ptr<IOManager> io_manager;
 
  auto release_io_manager = [&]() {
    io_manager.reset();
    latch.Signal();
  };
 
  auto decode_image = [&]() {
    Settings settings;
    std::unique_ptr<ImageDecoder> image_decoder = ImageDecoder::Make(
        settings, runners, loop->GetTaskRunner(),
        io_manager->GetWeakIOManager(), std::make_shared<fml::SyncSwitch>());
 
    auto data = flutter::testing::OpenFixtureAsSkData("DashInNooglerHat.jpg");
 
    ASSERT_TRUE(data);
    ASSERT_GE(data->size(), 0u);
 
    ImageGeneratorRegistry registry;
    std::shared_ptr<ImageGenerator> generator =
        registry.CreateCompatibleGenerator(data);
    ASSERT_TRUE(generator);
 
    auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
        std::move(data), std::move(generator));
 
    ImageDecoder::ImageResult callback = [&](const sk_sp<DlImage>& image,
                                             const std::string& decode_error) {
      ASSERT_TRUE(runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
      ASSERT_TRUE(image && image->skia_image());
      runners.GetIOTaskRunner()->PostTask(release_io_manager);
    };
    image_decoder->Decode(descriptor, descriptor->width(), descriptor->height(),
                          callback);
  };
 
  auto set_up_io_manager_and_decode = [&]() {
    io_manager =
        std::make_unique<TestIOManager>(runners.GetIOTaskRunner(), false);
    runners.GetUITaskRunner()->PostTask(decode_image);
  };
 
  runners.GetIOTaskRunner()->PostTask(set_up_io_manager_and_decode);
 
  latch.Wait();
}

◆ TEST_F() [620/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		CanDecodeWithResizes
	)

Definition at line 605 of file image_decoder_unittests.cc.

                                                      {
  const auto image_dimensions =
      SkImages::DeferredFromEncodedData(
          flutter::testing::OpenFixtureAsSkData("DashInNooglerHat.jpg"))
          ->dimensions();
 
  ASSERT_FALSE(image_dimensions.isEmpty());
 
  ASSERT_NE(image_dimensions.width(), image_dimensions.height());
 
  auto loop = fml::ConcurrentMessageLoop::Create();
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  fml::AutoResetWaitableEvent latch;
  std::unique_ptr<IOManager> io_manager;
  std::unique_ptr<ImageDecoder> image_decoder;
 
  // Setup the IO manager.
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
  });
 
  // Setup the image decoder.
  PostTaskSync(runners.GetUITaskRunner(), [&]() {
    Settings settings;
    image_decoder = ImageDecoder::Make(settings, runners, loop->GetTaskRunner(),
                                       io_manager->GetWeakIOManager(),
                                       std::make_shared<fml::SyncSwitch>());
  });
 
  // Setup a generic decoding utility that gives us the final decoded size.
  auto decoded_size = [&](uint32_t target_width,
                          uint32_t target_height) -> SkISize {
    SkISize final_size = SkISize::MakeEmpty();
    runners.GetUITaskRunner()->PostTask([&]() {
      auto data = flutter::testing::OpenFixtureAsSkData("DashInNooglerHat.jpg");
 
      ASSERT_TRUE(data);
      ASSERT_GE(data->size(), 0u);
 
      ImageGeneratorRegistry registry;
      std::shared_ptr<ImageGenerator> generator =
          registry.CreateCompatibleGenerator(data);
      ASSERT_TRUE(generator);
 
      auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
          std::move(data), std::move(generator));
 
      ImageDecoder::ImageResult callback =
          [&](const sk_sp<DlImage>& image, const std::string& decode_error) {
            ASSERT_TRUE(runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
            ASSERT_TRUE(image && image->skia_image());
            final_size = image->skia_image()->dimensions();
            latch.Signal();
          };
      image_decoder->Decode(descriptor, target_width, target_height, callback);
    });
    latch.Wait();
    return final_size;
  };
 
  ASSERT_EQ(SkISize::Make(3024, 4032), image_dimensions);
  ASSERT_EQ(decoded_size(3024, 4032), image_dimensions);
  ASSERT_EQ(decoded_size(100, 100), SkISize::Make(100, 100));
 
  // Destroy the IO manager
  PostTaskSync(runners.GetIOTaskRunner(), [&]() { io_manager.reset(); });
 
  // Destroy the image decoder
  PostTaskSync(runners.GetUITaskRunner(), [&]() { image_decoder.reset(); });
}

◆ TEST_F() [621/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ExifDataIsRespectedOnDecode
	)

Definition at line 485 of file image_decoder_unittests.cc.

                                                             {
  auto loop = fml::ConcurrentMessageLoop::Create();
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  fml::AutoResetWaitableEvent latch;
 
  std::unique_ptr<IOManager> io_manager;
 
  auto release_io_manager = [&]() {
    io_manager.reset();
    latch.Signal();
  };
 
  SkISize decoded_size = SkISize::MakeEmpty();
  auto decode_image = [&]() {
    Settings settings;
    std::unique_ptr<ImageDecoder> image_decoder = ImageDecoder::Make(
        settings, runners, loop->GetTaskRunner(),
        io_manager->GetWeakIOManager(), std::make_shared<fml::SyncSwitch>());
 
    auto data = flutter::testing::OpenFixtureAsSkData("Horizontal.jpg");
 
    ASSERT_TRUE(data);
    ASSERT_GE(data->size(), 0u);
 
    ImageGeneratorRegistry registry;
    std::shared_ptr<ImageGenerator> generator =
        registry.CreateCompatibleGenerator(data);
    ASSERT_TRUE(generator);
 
    auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
        std::move(data), std::move(generator));
 
    ImageDecoder::ImageResult callback = [&](const sk_sp<DlImage>& image,
                                             const std::string& decode_error) {
      ASSERT_TRUE(runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
      ASSERT_TRUE(image && image->skia_image());
      decoded_size = image->skia_image()->dimensions();
      runners.GetIOTaskRunner()->PostTask(release_io_manager);
    };
    image_decoder->Decode(descriptor, descriptor->width(), descriptor->height(),
                          callback);
  };
 
  auto set_up_io_manager_and_decode = [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
    runners.GetUITaskRunner()->PostTask(decode_image);
  };
 
  runners.GetIOTaskRunner()->PostTask(set_up_io_manager_and_decode);
 
  latch.Wait();
 
  ASSERT_EQ(decoded_size.width(), 600);
  ASSERT_EQ(decoded_size.height(), 200);
}

◆ TEST_F() [622/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ImpellerNonWideGamut
	)

Definition at line 458 of file image_decoder_unittests.cc.

                                                      {
  auto data = flutter::testing::OpenFixtureAsSkData("Horizontal.jpg");
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(600, 200), image->dimensions());
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(600, 200), {600, 200},
          /*supports_wide_gamut=*/true, allocator);
 
  ASSERT_TRUE(result.has_value());
  ASSERT_EQ(result->image_info.colorType(), kRGBA_8888_SkColorType);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST_F() [623/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ImpellerNullColorspace
	)

Definition at line 351 of file image_decoder_unittests.cc.

                                                        {
  auto info = SkImageInfo::Make(10, 10, SkColorType::kRGBA_8888_SkColorType,
                                SkAlphaType::kPremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 10 * 4);
  auto data = SkData::MakeWithoutCopy(bitmap.getPixels(), 10 * 10 * 4);
  auto image = SkImages::RasterFromBitmap(bitmap);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(10, 10), image->dimensions());
  ASSERT_EQ(nullptr, image->colorSpace());
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
      std::move(data), image->imageInfo(), 10 * 4);
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> decompressed =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/true, allocator);
  ASSERT_TRUE(decompressed.has_value());
  ASSERT_EQ(decompressed->image_info.colorType(), kRGBA_8888_SkColorType);
  ASSERT_EQ(decompressed->image_info.colorSpace(), nullptr);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST_F() [624/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ImpellerPixelConversion32F
	)

Definition at line 378 of file image_decoder_unittests.cc.

                                                            {
  auto info = SkImageInfo::Make(10, 10, SkColorType::kRGBA_F32_SkColorType,
                                SkAlphaType::kUnpremul_SkAlphaType);
  SkBitmap bitmap;
  bitmap.allocPixels(info, 10 * 16);
  auto data = SkData::MakeWithoutCopy(bitmap.getPixels(), 10 * 10 * 16);
  auto image = SkImages::RasterFromBitmap(bitmap);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(10, 10), image->dimensions());
  ASSERT_EQ(nullptr, image->colorSpace());
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
      std::move(data), image->imageInfo(), 10 * 16);
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> decompressed =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/true, allocator);
 
  ASSERT_TRUE(decompressed.has_value());
  ASSERT_EQ(decompressed->image_info.colorType(), kRGBA_F16_SkColorType);
  ASSERT_EQ(decompressed->image_info.colorSpace(), nullptr);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST_F() [625/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ImpellerUploadToSharedNoGpu
	)

Definition at line 322 of file image_decoder_unittests.cc.

                                                             {
#if !IMPELLER_SUPPORTS_RENDERING
  GTEST_SKIP() << "Impeller only test.";
#endif  // IMPELLER_SUPPORTS_RENDERING
 
  auto no_gpu_access_context =
      std::make_shared<impeller::TestImpellerContext>();
  auto gpu_disabled_switch = std::make_shared<fml::SyncSwitch>(true);
 
  auto info = SkImageInfo::Make(10, 10, SkColorType::kRGBA_8888_SkColorType,
                                SkAlphaType::kPremul_SkAlphaType);
  auto bitmap = std::make_shared<SkBitmap>();
  bitmap->allocPixels(info, 10 * 4);
  impeller::DeviceBufferDescriptor desc;
  desc.size = bitmap->computeByteSize();
  auto buffer = std::make_shared<impeller::TestImpellerDeviceBuffer>(desc);
 
  auto result = ImageDecoderImpeller::UploadTextureToPrivate(
      no_gpu_access_context, buffer, info, bitmap, gpu_disabled_switch);
  ASSERT_EQ(no_gpu_access_context->command_buffer_count_, 0ul);
  ASSERT_EQ(result.second, "");
 
  result = ImageDecoderImpeller::UploadTextureToStorage(
      no_gpu_access_context, bitmap, gpu_disabled_switch,
      impeller::StorageMode::kHostVisible, true);
  ASSERT_EQ(no_gpu_access_context->command_buffer_count_, 0ul);
  ASSERT_EQ(result.second, "");
}

◆ TEST_F() [626/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ImpellerWideGamutDisplayP3Opaque
	)

Definition at line 406 of file image_decoder_unittests.cc.

                                                                  {
  auto data = flutter::testing::OpenFixtureAsSkData("DisplayP3Logo.jpg");
  auto image = SkImages::DeferredFromEncodedData(data);
  ASSERT_TRUE(image != nullptr);
  ASSERT_EQ(SkISize::Make(100, 100), image->dimensions());
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> generator =
      registry.CreateCompatibleGenerator(data);
  ASSERT_TRUE(generator);
 
  auto descriptor = fml::MakeRefCounted<ImageDescriptor>(std::move(data),
                                                         std::move(generator));
 
#if IMPELLER_SUPPORTS_RENDERING
  std::shared_ptr<impeller::Allocator> allocator =
      std::make_shared<impeller::TestImpellerAllocator>();
  std::optional<DecompressResult> wide_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/true, allocator);
 
  ASSERT_TRUE(wide_result.has_value());
  ASSERT_EQ(wide_result->image_info.colorType(), kBGR_101010x_XR_SkColorType);
  ASSERT_TRUE(wide_result->image_info.colorSpace()->isSRGB());
 
  const SkPixmap& wide_pixmap = wide_result->sk_bitmap->pixmap();
  const uint32_t* pixel_ptr = static_cast<const uint32_t*>(wide_pixmap.addr());
  bool found_deep_red = false;
  for (int i = 0; i < wide_pixmap.width() * wide_pixmap.height(); ++i) {
    uint32_t pixel = *pixel_ptr++;
    float blue = DecodeBGR10((pixel >> 0) & 0x3ff);
    float green = DecodeBGR10((pixel >> 10) & 0x3ff);
    float red = DecodeBGR10((pixel >> 20) & 0x3ff);
    if (fabsf(red - 1.0931f) < 0.01f && fabsf(green - -0.2268f) < 0.01f &&
        fabsf(blue - -0.1501f) < 0.01f) {
      found_deep_red = true;
      break;
    }
  }
  ASSERT_TRUE(found_deep_red);
 
  std::optional<DecompressResult> narrow_result =
      ImageDecoderImpeller::DecompressTexture(
          descriptor.get(), SkISize::Make(100, 100), {100, 100},
          /*supports_wide_gamut=*/false, allocator);
 
  ASSERT_TRUE(narrow_result.has_value());
  ASSERT_EQ(narrow_result->image_info.colorType(), kRGBA_8888_SkColorType);
#endif  // IMPELLER_SUPPORTS_RENDERING
}

◆ TEST_F() [627/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		InvalidImageResultsError
	)

Definition at line 229 of file image_decoder_unittests.cc.

                                                          {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto thread_task_runner = CreateNewThread();
  TaskRunners runners(GetCurrentTestName(),  // label
                      thread_task_runner,    // platform
                      thread_task_runner,    // raster
                      thread_task_runner,    // ui
                      thread_task_runner     // io
  );
 
  fml::AutoResetWaitableEvent latch;
  thread_task_runner->PostTask([&]() {
    TestIOManager manager(runners.GetIOTaskRunner());
    Settings settings;
    auto decoder = ImageDecoder::Make(settings, runners, loop->GetTaskRunner(),
                                      manager.GetWeakIOManager(),
                                      std::make_shared<fml::SyncSwitch>());
 
    auto data = flutter::testing::OpenFixtureAsSkData("ThisDoesNotExist.jpg");
    ASSERT_FALSE(data);
 
    fml::RefPtr<ImageDescriptor> image_descriptor =
        fml::MakeRefCounted<ImageDescriptor>(
            std::move(data), std::make_unique<UnknownImageGenerator>());
 
    ImageDecoder::ImageResult callback = [&](const sk_sp<DlImage>& image,
                                             const std::string& decode_error) {
      ASSERT_TRUE(runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
      ASSERT_FALSE(image);
      latch.Signal();
    };
    decoder->Decode(image_descriptor, 0, 0, callback);
  });
  latch.Wait();
}

◆ TEST_F() [628/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		MultiFrameCodecCanBeCollectedBeforeIOTasksFinish
	)

Definition at line 801 of file image_decoder_unittests.cc.

                                                         {
  // This test verifies that the MultiFrameCodec safely shares state between
  // tasks on the IO and UI runners, and does not allow unsafe memory access if
  // the UI object is collected while the IO thread still has pending decode
  // work. This could happen in a real application if the engine is collected
  // while a multi-frame image is decoding. To exercise this, the test:
  //   - Starts a Dart VM
  //   - Latches the IO task runner
  //   - Create a MultiFrameCodec for an animated gif pointed to a callback
  //     in the Dart fixture
  //   - Calls getNextFrame on the UI task runner
  //   - Collects the MultiFrameCodec object before unlatching the IO task
  //     runner.
  //   - Unlatches the IO task runner
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto vm_data = vm_ref.GetVMData();
 
  auto gif_mapping = flutter::testing::OpenFixtureAsSkData("hello_loop_2.gif");
 
  ASSERT_TRUE(gif_mapping);
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> gif_generator =
      registry.CreateCompatibleGenerator(gif_mapping);
  ASSERT_TRUE(gif_generator);
 
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  fml::AutoResetWaitableEvent io_latch;
  std::unique_ptr<TestIOManager> io_manager;
 
  // Setup the IO manager.
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
  });
 
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, runners, "main", {},
                                      GetDefaultKernelFilePath(),
                                      io_manager->GetWeakIOManager());
 
  // Latch the IO task runner.
  runners.GetIOTaskRunner()->PostTask([&]() { io_latch.Wait(); });
 
  PostTaskSync(runners.GetUITaskRunner(), [&]() {
    fml::AutoResetWaitableEvent isolate_latch;
    fml::RefPtr<MultiFrameCodec> codec;
    EXPECT_TRUE(isolate->RunInIsolateScope([&]() -> bool {
      Dart_Handle library = Dart_RootLibrary();
      if (Dart_IsError(library)) {
        isolate_latch.Signal();
        return false;
      }
      Dart_Handle closure =
          Dart_GetField(library, Dart_NewStringFromCString("frameCallback"));
      if (Dart_IsError(closure) || !Dart_IsClosure(closure)) {
        isolate_latch.Signal();
        return false;
      }
 
      codec = fml::MakeRefCounted<MultiFrameCodec>(std::move(gif_generator));
      codec->getNextFrame(closure);
      codec = nullptr;
      isolate_latch.Signal();
      return true;
    }));
    isolate_latch.Wait();
 
    EXPECT_FALSE(codec);
 
    io_latch.Signal();
  });
 
  // Destroy the IO manager
  PostTaskSync(runners.GetIOTaskRunner(), [&]() { io_manager.reset(); });
}

◆ TEST_F() [629/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		MultiFrameCodecDidAccessGpuDisabledSyncSwitch
	)

Definition at line 884 of file image_decoder_unittests.cc.

                                                                               {
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto vm_data = vm_ref.GetVMData();
 
  auto gif_mapping = flutter::testing::OpenFixtureAsSkData("hello_loop_2.gif");
 
  ASSERT_TRUE(gif_mapping);
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> gif_generator =
      registry.CreateCompatibleGenerator(gif_mapping);
  ASSERT_TRUE(gif_generator);
 
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  std::unique_ptr<TestIOManager> io_manager;
  fml::RefPtr<MultiFrameCodec> codec;
  fml::AutoResetWaitableEvent latch;
 
  auto validate_frame_callback = [&latch](Dart_NativeArguments args) {
    EXPECT_FALSE(Dart_IsNull(Dart_GetNativeArgument(args, 0)));
    latch.Signal();
  };
 
  AddNativeCallback("ValidateFrameCallback",
                    CREATE_NATIVE_ENTRY(validate_frame_callback));
  // Setup the IO manager.
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
  });
 
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, runners, "main", {},
                                      GetDefaultKernelFilePath(),
                                      io_manager->GetWeakIOManager());
 
  PostTaskSync(runners.GetUITaskRunner(), [&]() {
    fml::AutoResetWaitableEvent isolate_latch;
 
    EXPECT_TRUE(isolate->RunInIsolateScope([&]() -> bool {
      Dart_Handle library = Dart_RootLibrary();
      if (Dart_IsError(library)) {
        isolate_latch.Signal();
        return false;
      }
      Dart_Handle closure =
          Dart_GetField(library, Dart_NewStringFromCString("frameCallback"));
      if (Dart_IsError(closure) || !Dart_IsClosure(closure)) {
        isolate_latch.Signal();
        return false;
      }
 
      EXPECT_FALSE(io_manager->did_access_is_gpu_disabled_sync_switch_);
      codec = fml::MakeRefCounted<MultiFrameCodec>(std::move(gif_generator));
      codec->getNextFrame(closure);
      isolate_latch.Signal();
      return true;
    }));
    isolate_latch.Wait();
  });
 
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    EXPECT_TRUE(io_manager->did_access_is_gpu_disabled_sync_switch_);
  });
 
  latch.Wait();
 
  // Destroy the Isolate
  isolate = nullptr;
 
  // Destroy the MultiFrameCodec
  PostTaskSync(runners.GetUITaskRunner(), [&]() { codec = nullptr; });
 
  // Destroy the IO manager
  PostTaskSync(runners.GetIOTaskRunner(), [&]() { io_manager.reset(); });
}

◆ TEST_F() [630/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		MultiFrameCodecProducesATextureEvenIfGPUIsDisabledOnImpeller
	)

Definition at line 966 of file image_decoder_unittests.cc.

                                                                     {
  auto settings = CreateSettingsForFixture();
  settings.enable_impeller = true;
  auto vm_ref = DartVMRef::Create(settings);
  auto vm_data = vm_ref.GetVMData();
 
  auto gif_mapping = flutter::testing::OpenFixtureAsSkData("hello_loop_2.gif");
 
  ASSERT_TRUE(gif_mapping);
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> gif_generator =
      registry.CreateCompatibleGenerator(gif_mapping);
  ASSERT_TRUE(gif_generator);
 
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  std::unique_ptr<TestIOManager> io_manager;
  fml::RefPtr<MultiFrameCodec> codec;
  fml::AutoResetWaitableEvent latch;
 
  auto validate_frame_callback = [&latch](Dart_NativeArguments args) {
    EXPECT_FALSE(Dart_IsNull(Dart_GetNativeArgument(args, 0)));
    latch.Signal();
  };
 
  AddNativeCallback("ValidateFrameCallback",
                    CREATE_NATIVE_ENTRY(validate_frame_callback));
 
  // Setup the IO manager.
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
    // Mark GPU disabled.
    io_manager->SetGpuDisabled(true);
  });
 
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, runners, "main", {},
                                      GetDefaultKernelFilePath(),
                                      io_manager->GetWeakIOManager());
 
  PostTaskSync(runners.GetUITaskRunner(), [&]() {
    fml::AutoResetWaitableEvent isolate_latch;
 
    EXPECT_TRUE(isolate->RunInIsolateScope([&]() -> bool {
      Dart_Handle library = Dart_RootLibrary();
      if (Dart_IsError(library)) {
        isolate_latch.Signal();
        return false;
      }
      Dart_Handle closure =
          Dart_GetField(library, Dart_NewStringFromCString("frameCallback"));
      if (Dart_IsError(closure) || !Dart_IsClosure(closure)) {
        isolate_latch.Signal();
        return false;
      }
 
      EXPECT_FALSE(io_manager->did_access_is_gpu_disabled_sync_switch_);
      codec = fml::MakeRefCounted<MultiFrameCodec>(std::move(gif_generator));
      codec->getNextFrame(closure);
      isolate_latch.Signal();
      return true;
    }));
    isolate_latch.Wait();
  });
 
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    EXPECT_TRUE(io_manager->did_access_is_gpu_disabled_sync_switch_);
  });
 
  latch.Wait();
 
  // Destroy the Isolate
  isolate = nullptr;
 
  // Destroy the MultiFrameCodec
  PostTaskSync(runners.GetUITaskRunner(), [&]() { codec = nullptr; });
 
  // Destroy the IO manager
  PostTaskSync(runners.GetIOTaskRunner(), [&]() { io_manager.reset(); });
}

◆ TEST_F() [631/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		NullCheckBuffer
	)

Definition at line 1053 of file image_decoder_unittests.cc.

                                                 {
  auto context = std::make_shared<impeller::TestImpellerContext>();
  auto allocator = ImpellerAllocator(context->GetResourceAllocator());
 
  EXPECT_FALSE(allocator.allocPixelRef(nullptr));
}

◆ TEST_F() [632/925]

flutter::testing::TEST_F	(	ImageDecoderFixtureTest	,
		ValidImageResultsInSuccess
	)

Definition at line 265 of file image_decoder_unittests.cc.

                                                            {
  auto loop = fml::ConcurrentMessageLoop::Create();
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  fml::AutoResetWaitableEvent latch;
 
  std::unique_ptr<TestIOManager> io_manager;
 
  auto release_io_manager = [&]() {
    io_manager.reset();
    latch.Signal();
  };
  auto decode_image = [&]() {
    Settings settings;
    std::unique_ptr<ImageDecoder> image_decoder = ImageDecoder::Make(
        settings, runners, loop->GetTaskRunner(),
        io_manager->GetWeakIOManager(), std::make_shared<fml::SyncSwitch>());
 
    auto data = flutter::testing::OpenFixtureAsSkData("DashInNooglerHat.jpg");
 
    ASSERT_TRUE(data);
    ASSERT_GE(data->size(), 0u);
 
    ImageGeneratorRegistry registry;
    std::shared_ptr<ImageGenerator> generator =
        registry.CreateCompatibleGenerator(data);
    ASSERT_TRUE(generator);
 
    auto descriptor = fml::MakeRefCounted<ImageDescriptor>(
        std::move(data), std::move(generator));
 
    ImageDecoder::ImageResult callback = [&](const sk_sp<DlImage>& image,
                                             const std::string& decode_error) {
      ASSERT_TRUE(runners.GetUITaskRunner()->RunsTasksOnCurrentThread());
      ASSERT_TRUE(image && image->skia_image());
      EXPECT_TRUE(io_manager->did_access_is_gpu_disabled_sync_switch_);
      runners.GetIOTaskRunner()->PostTask(release_io_manager);
    };
    EXPECT_FALSE(io_manager->did_access_is_gpu_disabled_sync_switch_);
    image_decoder->Decode(descriptor, descriptor->width(), descriptor->height(),
                          callback);
  };
 
  auto set_up_io_manager_and_decode = [&]() {
    io_manager = std::make_unique<TestIOManager>(runners.GetIOTaskRunner());
    runners.GetUITaskRunner()->PostTask(decode_image);
  };
 
  runners.GetIOTaskRunner()->PostTask(set_up_io_manager_and_decode);
  latch.Wait();
}

◆ TEST_F() [633/925]

flutter::testing::TEST_F	(	ImageDisposeTest	,
		ImageReleasedAfterFrameAndDisposePictureAndLayer
	)

Definition at line 40 of file image_dispose_unittests.cc.

                                                                           {
  auto native_capture_image_and_picture = [&](Dart_NativeArguments args) {
    auto image_handle = Dart_GetNativeArgument(args, 0);
    auto native_image_handle =
        Dart_GetField(image_handle, Dart_NewStringFromCString("_image"));
    ASSERT_FALSE(Dart_IsError(native_image_handle))
        << Dart_GetError(native_image_handle);
    ASSERT_FALSE(Dart_IsNull(native_image_handle));
    CanvasImage* image = GetNativePeer<CanvasImage>(native_image_handle);
    Picture* picture = GetNativePeer<Picture>(Dart_GetNativeArgument(args, 1));
    ASSERT_FALSE(image->image()->unique());
    ASSERT_FALSE(picture->display_list()->unique());
    current_display_list_ = picture->display_list();
    current_image_ = image->image();
  };
 
  auto native_finish = [&](Dart_NativeArguments args) {
    message_latch_.Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  fml::CountDownLatch frame_latch{2};
  settings.frame_rasterized_callback = [&frame_latch](const FrameTiming& t) {
    frame_latch.CountDown();
  };
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           task_runner,             // raster
                           task_runner,             // ui
                           task_runner              // io
  );
 
  AddNativeCallback("CaptureImageAndPicture",
                    CREATE_NATIVE_ENTRY(native_capture_image_and_picture));
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(native_finish));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
 
  SetViewportMetrics(shell.get(), 800, 600);
 
  shell->GetPlatformView()->NotifyCreated();
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("pumpImage");
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
  message_latch_.Wait();
 
  ASSERT_TRUE(current_display_list_);
  ASSERT_TRUE(current_image_);
 
  // Wait for 2 frames to be rasterized. The 2nd frame releases resources of the
  // 1st frame.
  frame_latch.Wait();
 
  // Force a drain the SkiaUnrefQueue. The engine does this normally as frames
  // pump, but we force it here to make the test more deterministic.
  message_latch_.Reset();
  task_runner->PostTask([&, io_manager = shell->GetIOManager()]() {
    io_manager->GetSkiaUnrefQueue()->Drain();
    message_latch_.Signal();
  });
  message_latch_.Wait();
 
  if (current_display_list_) {
    EXPECT_TRUE(current_display_list_->unique());
    current_display_list_.reset();
  }
 
  EXPECT_TRUE(current_image_->unique());
  current_image_.reset();
 
  shell->GetPlatformView()->NotifyDestroyed();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [634/925]

flutter::testing::TEST_F	(	ImageFilterLayerDiffTest	,
		ImageFilterLayer
	)

Definition at line 625 of file image_filter_layer_unittests.cc.

                                                   {
  auto dl_blur_filter =
      std::make_shared<DlBlurImageFilter>(10, 10, DlTileMode::kClamp);
  {
    // tests later assume 30px paint area, fail early if that's not the case
    SkIRect input_bounds;
    dl_blur_filter->get_input_device_bounds(SkIRect::MakeWH(10, 10),
                                            SkMatrix::I(), input_bounds);
    EXPECT_EQ(input_bounds, SkIRect::MakeLTRB(-30, -30, 40, 40));
  }
 
  MockLayerTree l1;
  auto filter_layer = std::make_shared<ImageFilterLayer>(dl_blur_filter);
  auto path = SkPath().addRect(SkRect::MakeLTRB(100, 100, 110, 110));
  filter_layer->Add(std::make_shared<MockLayer>(path));
  l1.root()->Add(filter_layer);
 
  auto damage = DiffLayerTree(l1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(70, 70, 140, 140));
 
  MockLayerTree l2;
  auto scale = std::make_shared<TransformLayer>(SkMatrix::Scale(2.0, 2.0));
  scale->Add(filter_layer);
  l2.root()->Add(scale);
 
  damage = DiffLayerTree(l2, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(140, 140, 280, 280));
 
  MockLayerTree l3;
  l3.root()->Add(scale);
 
  // path outside of ImageFilterLayer
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(130, 130, 140, 140));
  l3.root()->Add(std::make_shared<MockLayer>(path1));
  damage = DiffLayerTree(l3, l2);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(130, 130, 140, 140));
 
  // path intersecting ImageFilterLayer, shouldn't trigger entire
  // ImageFilterLayer repaint
  MockLayerTree l4;
  l4.root()->Add(scale);
  auto path2 = SkPath().addRect(SkRect::MakeLTRB(130, 130, 141, 141));
  l4.root()->Add(std::make_shared<MockLayer>(path2));
  damage = DiffLayerTree(l4, l3);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(130, 130, 141, 141));
}

◆ TEST_F() [635/925]

flutter::testing::TEST_F	(	ImageFilterLayerDiffTest	,
		ImageFilterLayerInflatestChildSize
	)

Definition at line 672 of file image_filter_layer_unittests.cc.

                                                                     {
  auto dl_blur_filter =
      std::make_shared<DlBlurImageFilter>(10, 10, DlTileMode::kClamp);
 
  {
    // tests later assume 30px paint area, fail early if that's not the case
    SkIRect input_bounds;
    dl_blur_filter->get_input_device_bounds(SkIRect::MakeWH(10, 10),
                                            SkMatrix::I(), input_bounds);
    EXPECT_EQ(input_bounds, SkIRect::MakeLTRB(-30, -30, 40, 40));
  }
 
  MockLayerTree l1;
 
  // Use nested filter layers to check if both contribute to child bounds
  auto filter_layer_1_1 = std::make_shared<ImageFilterLayer>(dl_blur_filter);
  auto filter_layer_1_2 = std::make_shared<ImageFilterLayer>(dl_blur_filter);
  filter_layer_1_1->Add(filter_layer_1_2);
  auto path = SkPath().addRect(SkRect::MakeLTRB(100, 100, 110, 110));
  filter_layer_1_2->Add(
      std::make_shared<MockLayer>(path, DlPaint(DlColor::kYellow())));
  l1.root()->Add(filter_layer_1_1);
 
  // second layer tree with identical filter layers but different child layer
  MockLayerTree l2;
  auto filter_layer2_1 = std::make_shared<ImageFilterLayer>(dl_blur_filter);
  filter_layer2_1->AssignOldLayer(filter_layer_1_1.get());
  auto filter_layer2_2 = std::make_shared<ImageFilterLayer>(dl_blur_filter);
  filter_layer2_2->AssignOldLayer(filter_layer_1_2.get());
  filter_layer2_1->Add(filter_layer2_2);
  filter_layer2_2->Add(
      std::make_shared<MockLayer>(path, DlPaint(DlColor::kRed())));
  l2.root()->Add(filter_layer2_1);
 
  DiffLayerTree(l1, MockLayerTree());
  auto damage = DiffLayerTree(l2, l1);
 
  // ensure that filter properly inflated child size
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(40, 40, 170, 170));
}

◆ TEST_F() [636/925]

flutter::testing::TEST_F	(	ImageFilterLayerTest	,
		CacheImageFilterLayerSelf
	)

Definition at line 470 of file image_filter_layer_unittests.cc.

                                                        {
  auto dl_image_filter = std::make_shared<DlMatrixImageFilter>(
      SkMatrix(), DlImageSampling::kMipmapLinear);
 
  auto initial_transform = SkMatrix::Translate(50.0, 25.5);
  auto other_transform = SkMatrix::Scale(1.0, 2.0);
  auto child_rect = SkRect::MakeWH(5.0f, 5.0f);
  const SkPath child_path = SkPath().addRect(child_rect);
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  auto offset = SkPoint::Make(53.8, 24.4);
  auto layer = std::make_shared<ImageFilterLayer>(dl_image_filter, offset);
  layer->Add(mock_layer);
 
  SkMatrix cache_ctm = initial_transform;
  DisplayListBuilder cache_canvas;
  cache_canvas.Transform(cache_ctm);
  DisplayListBuilder other_canvas;
  other_canvas.Transform(other_transform);
  DlPaint paint;
 
  SkMatrix snapped_matrix = SkMatrix::MakeAll(  //
      1, 0, SkScalarRoundToScalar(offset.fX),   //
      0, 1, SkScalarRoundToScalar(offset.fY),   //
      0, 0, 1);
 
  use_mock_raster_cache();
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  const auto* cacheable_image_filter_item = layer->raster_cache_item();
  // frame 1.
  layer->Preroll(preroll_context());
 
  layer->Paint(display_list_paint_context());
  {
    DisplayListBuilder expected_builder;
    /* (ImageFilter)layer::Paint */ {
      expected_builder.Save();
      {
        expected_builder.Translate(offset.fX, offset.fY);
        // Snap to pixel translation due to use of raster cache
        expected_builder.TransformReset();
        expected_builder.Transform(snapped_matrix);
        DlPaint save_paint = DlPaint().setImageFilter(dl_image_filter);
        expected_builder.SaveLayer(&child_rect, &save_paint);
        {
          /* mock_layer::Paint */ {
            expected_builder.DrawPath(child_path, DlPaint());
          }
        }
        expected_builder.Restore();
      }
      expected_builder.Restore();
    }
    EXPECT_TRUE(
        DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
  }
 
  // frame 2.
  layer->Preroll(preroll_context());
  layer->Paint(display_list_paint_context());
  // frame 3.
  layer->Preroll(preroll_context());
  layer->Paint(display_list_paint_context());
 
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  // frame1,2 cache the ImageFilter's children layer, frame3 cache the
  // ImageFilterLayer
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)2);
 
  // ImageFilterLayer default cache itself.
  EXPECT_EQ(cacheable_image_filter_item->cache_state(),
            RasterCacheItem::CacheState::kCurrent);
  EXPECT_EQ(cacheable_image_filter_item->GetId(),
            RasterCacheKeyID(layer->unique_id(), RasterCacheKeyType::kLayer));
  EXPECT_TRUE(raster_cache()->Draw(cacheable_image_filter_item->GetId().value(),
                                   cache_canvas, &paint));
  EXPECT_FALSE(raster_cache()->Draw(
      cacheable_image_filter_item->GetId().value(), other_canvas, &paint));
 
  layer->Preroll(preroll_context());
 
  reset_display_list();
  layer->Paint(display_list_paint_context());
  {
    DisplayListBuilder expected_builder;
    /* (ImageFilter)layer::Paint */ {
      expected_builder.Save();
      {
        EXPECT_TRUE(
            raster_cache()->Draw(cacheable_image_filter_item->GetId().value(),
                                 expected_builder, nullptr));
      }
      expected_builder.Restore();
    }
    EXPECT_TRUE(
        DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
  }
}

◆ TEST_F() [637/925]

flutter::testing::TEST_F	(	ImageFilterLayerTest	,
		EmptyFilterWithOffset
	)

Definition at line 713 of file image_filter_layer_unittests.cc.

                                                    {
  const SkRect child_bounds = SkRect::MakeLTRB(10.0f, 11.0f, 19.0f, 20.0f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  const SkPoint offset = SkPoint::Make(5.0f, 6.0f);
  auto layer = std::make_shared<ImageFilterLayer>(nullptr, offset);
  layer->Add(mock_layer);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), child_bounds.makeOffset(offset));
}

◆ TEST_F() [638/925]

flutter::testing::TEST_F	(	ImageFilterLayerTest	,
		SimpleFilterBounds
	)

Definition at line 171 of file image_filter_layer_unittests.cc.

                                                 {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  const SkMatrix filter_transform = SkMatrix::Scale(2.0, 2.0);
 
  auto dl_image_filter = std::make_shared<DlMatrixImageFilter>(
      filter_transform, DlImageSampling::kMipmapLinear);
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ImageFilterLayer>(dl_image_filter);
  layer->Add(mock_layer);
 
  const SkRect filter_bounds = SkRect::MakeLTRB(10.0f, 12.0f, 42.0f, 44.0f);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), filter_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), initial_transform);
 
  DisplayListBuilder expected_builder;
  /* ImageFilterLayer::Paint() */ {
    DlPaint dl_paint;
    dl_paint.setImageFilter(dl_image_filter.get());
    expected_builder.SaveLayer(&child_bounds, &dl_paint);
    {
      /* MockLayer::Paint() */ {
        expected_builder.DrawPath(child_path, DlPaint(DlColor::kYellow()));
      }
    }
  }
  expected_builder.Restore();
  auto expected_display_list = expected_builder.Build();
 
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_display_list));
}

◆ TEST_F() [639/925]

flutter::testing::TEST_F	(	ImageFilterLayerTest	,
		SimpleFilterWithOffset
	)

Definition at line 119 of file image_filter_layer_unittests.cc.

                                                     {
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect initial_cull_rect = SkRect::MakeLTRB(0, 0, 100, 100);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  const SkPoint layer_offset = SkPoint::Make(5.5, 6.5);
  auto dl_image_filter = std::make_shared<DlMatrixImageFilter>(
      SkMatrix(), DlImageSampling::kMipmapLinear);
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer =
      std::make_shared<ImageFilterLayer>(dl_image_filter, layer_offset);
  layer->Add(mock_layer);
 
  SkMatrix child_matrix = initial_transform;
  child_matrix.preTranslate(layer_offset.fX, layer_offset.fY);
  const SkRect child_rounded_bounds =
      SkRect::MakeLTRB(10.5f, 12.5f, 26.5f, 28.5f);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_cull_rect,
                                                      initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), child_rounded_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), child_matrix);
  EXPECT_EQ(preroll_context()->state_stack.device_cull_rect(),
            initial_cull_rect);
 
  DisplayListBuilder expected_builder;
  /* ImageFilterLayer::Paint() */ {
    expected_builder.Save();
    {
      expected_builder.Translate(layer_offset.fX, layer_offset.fY);
      DlPaint dl_paint;
      dl_paint.setImageFilter(dl_image_filter.get());
      expected_builder.SaveLayer(&child_bounds, &dl_paint);
      {
        /* MockLayer::Paint() */ {
          expected_builder.DrawPath(child_path, DlPaint(DlColor::kYellow()));
        }
      }
      expected_builder.Restore();
    }
    expected_builder.Restore();
  }
  auto expected_display_list = expected_builder.Build();
 
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_display_list));
}

◆ TEST_F() [640/925]

flutter::testing::TEST_F	(	IsolateStartupFailureTest	,
		HandlesIsolateInitializationFailureCorrectly
	)

Definition at line 348 of file dart_isolate_unittests.cc.

                                                     {
  AddNativeCallback("MakeNextIsolateSpawnFail",
                    CREATE_NATIVE_ENTRY(([](Dart_NativeArguments args) {
                      Dart_SetRootLibrary(Dart_Null());
                    })));
  AddNativeCallback("NotifyNative",
                    CREATE_NATIVE_ENTRY(
                        ([this](Dart_NativeArguments args) { NotifyDone(); })));
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto thread = CreateNewThread();
  TaskRunners task_runners(GetCurrentTestName(),  //
                           thread,                //
                           thread,                //
                           thread,                //
                           thread                 //
  );
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, task_runners,
                                      "testIsolateStartupFailure", {},
                                      GetDefaultKernelFilePath());
  ASSERT_TRUE(isolate);
  ASSERT_EQ(isolate->get()->GetPhase(), DartIsolate::Phase::Running);
  WaitForDone();
}

◆ TEST_F() [641/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		AltGrModifiedKey
	)

Definition at line 1240 of file keyboard_unittests.cc.

                                       {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // German Keyboard layout
 
  // Press AltGr, which Win32 precedes with a ContrlLeft down.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, true},
      WmKeyDownInfo{VK_LCONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      KeyStateChange{VK_RMENU, true, true},
      WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Press Q
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'@', kScanCodeKeyQ, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyQ, kLogicalKeyQ, "@", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"@");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release Q
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyQ, kScanCodeKeyQ, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyQ, kLogicalKeyQ, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release AltGr. Win32 doesn't dispatch ControlLeft up. Instead Flutter will
  // forge one. The AltGr is a system key, therefore will be handled by Win32's
  // default WndProc.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true},
      ExpectForgedMessage{
          WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
              kWmResultZero)},
      KeyStateChange{VK_RMENU, false, true},
      WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
          kWmResultDefault)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  // The sys key up must not be redispatched. The forged ControlLeft up will.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [642/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		AltGrTwice
	)

Definition at line 1327 of file keyboard_unittests.cc.

                                 {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // 1. AltGr down.
 
  // The key down event causes a ControlLeft down and a AltRight (extended
  // AltLeft) down.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, true},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      KeyStateChange{VK_RMENU, true, true},
      WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // 2. AltGr up.
 
  // The key up event only causes a AltRight (extended AltLeft) up.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true},
      ExpectForgedMessage{
          WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
              kWmResultZero)},
      KeyStateChange{VK_RMENU, false, true},
      WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
          kWmResultDefault)});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  // The sys key up must not be redispatched. The forged ControlLeft up will.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // 3. AltGr down (or: ControlLeft down then AltRight down.)
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, false},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      KeyStateChange{VK_RMENU, true, true},
      WmKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // 4. AltGr up.
 
  // The key up event only causes a AltRight (extended AltLeft) up.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, false},
      ExpectForgedMessage{
          WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
              kWmResultZero)},
      KeyStateChange{VK_RMENU, false, false},
      WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
          kWmResultDefault)});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  // The sys key up must not be redispatched. The forged ControlLeft up will.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // 5. For key sequence 2: a real ControlLeft up.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
          kWmResultZero)});
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [643/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		AltLeftUnhandled
	)

Definition at line 837 of file keyboard_unittests.cc.

                                       {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press AltLeft. AltLeft is a SysKeyDown event.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LMENU, true, false},
      WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kNotExtended, kWasUp}.Build(
          kWmResultDefault)});  // Always pass to the default WndProc.
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
  tester.clear_key_calls();
  // Don't redispatch sys messages.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // Release AltLeft. AltLeft is a SysKeyUp event.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LMENU, false, true},
      WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kNotExtended}.Build(
          kWmResultDefault)});  // Always pass to the default WndProc.
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalAltLeft, kLogicalAltLeft, "", kNotSynthesized);
  tester.clear_key_calls();
  // Don't redispatch sys messages.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [644/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		AltRightUnhandled
	)

Definition at line 870 of file keyboard_unittests.cc.

                                        {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press AltRight. AltRight is a SysKeyDown event.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RMENU, true, false},
      WmSysKeyDownInfo{VK_MENU, kScanCodeAlt, kExtended, kWasUp}.Build(
          kWmResultDefault)});  // Always pass to the default WndProc.
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  // Don't redispatch sys messages.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // Release AltRight. AltRight is a SysKeyUp event.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RMENU, false, true},
      WmSysKeyUpInfo{VK_MENU, kScanCodeAlt, kExtended}.Build(
          kWmResultDefault)});  // Always pass to the default WndProc.
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalAltRight, kLogicalAltRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  // Don't redispatch sys messages.
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [645/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ArrowLeftHandled
	)

Definition at line 631 of file keyboard_unittests.cc.

                                       {
  KeyboardTester tester{GetContext()};
  tester.Responding(true);
 
  // US Keyboard layout
 
  // Press ArrowLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalArrowLeft, kLogicalArrowLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // Release ArrowLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalArrowLeft, kLogicalArrowLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [646/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ArrowLeftUnhandled
	)

Definition at line 662 of file keyboard_unittests.cc.

                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ArrowLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_LEFT, kScanCodeArrowLeft, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalArrowLeft, kLogicalArrowLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ArrowLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{VK_LEFT, kScanCodeArrowLeft, kExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalArrowLeft, kLogicalArrowLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [647/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		CtrlLeftDigit1
	)

Definition at line 1150 of file keyboard_unittests.cc.

                                     {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ControlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, true},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
          .Build(kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ControlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true},
      WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [648/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		CtrlLeftKeyA
	)

Definition at line 1092 of file keyboard_unittests.cc.

                                   {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ControlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, true},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0x01, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ControlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true},
      WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [649/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		CtrlLeftUnhandled
	)

Definition at line 771 of file keyboard_unittests.cc.

                                        {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press CtrlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, false},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release CtrlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true},
      WmKeyUpInfo{VK_SHIFT, kScanCodeControl, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [650/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		CtrlRightUnhandled
	)

Definition at line 804 of file keyboard_unittests.cc.

                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press CtrlRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RCONTROL, true, false},
      WmKeyDownInfo{VK_CONTROL, kScanCodeControl, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlRight, kLogicalControlRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release CtrlRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RCONTROL, false, true},
      WmKeyUpInfo{VK_CONTROL, kScanCodeControl, kExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlRight, kLogicalControlRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [651/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		DeadKeyThatCombines
	)

Definition at line 1430 of file keyboard_unittests.cc.

                                          {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  tester.SetLayout(LayoutFrench);
 
  // Press ^¨ (US: Left bracket)
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBracketLeft, kLogicalBracketRight, "^",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release ^¨
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalBracketLeft, kLogicalBracketRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press E
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release E
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [652/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		DeadKeyThatDoesNotCombine
	)

Definition at line 1574 of file keyboard_unittests.cc.

                                                {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  tester.SetLayout(LayoutFrench);
 
  // Press ^¨ (US: Left bracket)
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{0xDD, kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmDeadCharInfo{'^', kScanCodeBracketLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBracketLeft, kLogicalBracketRight, "^",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release ^¨
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{0xDD, kScanCodeBracketLeft, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalBracketLeft, kLogicalBracketRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
          .Build(kWmResultZero),
      WmCharInfo{'^', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalDigit1, kLogicalDigit1, "^", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"^");
  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"&");
  tester.clear_key_calls();
  // TODO(dkwingsmt): This count should probably be 3. Currently the '^'
  // message is redispatched due to being part of the KeyDown session, which is
  // not handled by the framework, while the '&' message is not redispatched
  // for being a standalone message. We should resolve this inconsistency.
  // https://github.com/flutter/flutter/issues/98306
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [653/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		DeadKeyTwiceThenLetter
	)

Definition at line 1643 of file keyboard_unittests.cc.

                                             {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US INTL layout.
 
  // Press `
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmDeadCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBackquote, kLogicalBackquote, "`",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release `
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalBackquote, kLogicalBackquote, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press ` again.
  // The response should be slow.
  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
  tester.LateResponding(
      [&recorded_callbacks](
          const FlutterKeyEvent* event,
          MockKeyResponseController::ResponseCallback callback) {
        recorded_callbacks.push_back(callback);
      });
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{0xC0, kScanCodeBackquote, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp, kBeingReleased,
                 kNoContext, 1, /*bit25*/ true}
          .Build(kWmResultZero),
      WmCharInfo{'`', kScanCodeBackquote, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(recorded_callbacks.size(), 1);
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBackquote, kLogicalBackquote, "`",
                       kNotSynthesized);
  tester.clear_key_calls();
  // Key down event responded with false.
  recorded_callbacks.front()(false);
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"`");
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"`");
  tester.clear_key_calls();
  // TODO(dkwingsmt): This count should probably be 3. See the comment above
  // that is marked with the same issue.
  // https://github.com/flutter/flutter/issues/98306
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  tester.Responding(false);
 
  // Release `
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{0xC0, kScanCodeBackquote, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalBackquote, kLogicalBackquote, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [654/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		DeadKeyWithoutDeadMaskThatCombines
	)

Definition at line 1493 of file keyboard_unittests.cc.

                                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // Press ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, true, true},
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press 6^
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{'6', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmDeadCharInfo{'^', kScanCodeDigit6, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalDigit6, kLogicalDigit6, "6", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release 6^
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{'6', kScanCodeDigit6, kNotExtended}.Build(kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalDigit6, kLogicalDigit6, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, false, true},
      WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press E
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0xEA, kScanCodeKeyE, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyE, kLogicalKeyE, "ê", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"ê");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release E
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyE, kScanCodeKeyE, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyE, kLogicalKeyE, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [655/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		Digit1OnFrenchLayout
	)

Definition at line 1207 of file keyboard_unittests.cc.

                                           {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  tester.SetLayout(LayoutFrench);
 
  // Press 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended, kWasUp}
          .Build(kWmResultZero),
      WmCharInfo{'&', kScanCodeDigit1, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalDigit1, kLogicalDigit1, "&", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"&");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release 1
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualDigit1, kScanCodeDigit1, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalDigit1, kLogicalDigit1, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [656/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		DoubleCapsLock
	)

Definition at line 2466 of file keyboard_unittests.cc.

                                     {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_CAPITAL, 0, kNotExtended}.Build(),
      WmKeyUpInfo{VK_CAPITAL, 0, kNotExtended}.Build()});
 
  tester.clear_key_calls();
}

◆ TEST_F() [657/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ImeExtendedEventsAreIgnored
	)

Definition at line 1992 of file keyboard_unittests.cc.

                                                  {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout.
 
  // There should be preceding key events to make the keyboard into IME mode.
  // Omit them in this test since they are not relavent.
 
  // Press CtrlRight in IME mode.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RCONTROL, true, false},
      WmKeyDownInfo{VK_PROCESSKEY, kScanCodeControl, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [658/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		LowerCaseAHandled
	)

Definition at line 568 of file keyboard_unittests.cc.

                                        {
  KeyboardTester tester{GetContext()};
  tester.Responding(true);
 
  // US Keyboard layout
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [659/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		LowerCaseAUnhandled
	)

Definition at line 599 of file keyboard_unittests.cc.

                                          {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [660/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		MetaLeftUnhandled
	)

Definition at line 905 of file keyboard_unittests.cc.

                                        {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press MetaLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LWIN, true, false},
      WmKeyDownInfo{VK_LWIN, kScanCodeMetaLeft, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalMetaLeft, kLogicalMetaLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release MetaLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LWIN, false, true},
      WmKeyUpInfo{VK_LWIN, kScanCodeMetaLeft, kExtended}.Build(kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalMetaLeft, kLogicalMetaLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [661/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		MetaRightUnhandled
	)

Definition at line 937 of file keyboard_unittests.cc.

                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press MetaRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RWIN, true, false},
      WmKeyDownInfo{VK_RWIN, kScanCodeMetaRight, kExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalMetaRight, kLogicalMetaRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release MetaRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RWIN, false, true},
      WmKeyUpInfo{VK_RWIN, kScanCodeMetaRight, kExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalMetaRight, kLogicalMetaRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [662/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		MultibyteCharacter
	)

Definition at line 1727 of file keyboard_unittests.cc.

                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // Gothic Keyboard layout. (We need a layout that yields non-BMP characters
  // without IME, which is actually very rare.)
 
  // Press key W of a US keyboard, which should yield character '𐍅'.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0xd800, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0xdf45, kScanCodeKeyW, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  const char* st = tester.key_calls[0].key_event.character;
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyW, kLogicalKeyW, "𐍅", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"𐍅");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
 
  // Release W
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyW, kScanCodeKeyW, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyW, kLogicalKeyW, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [663/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		RepeatA
	)

Definition at line 971 of file keyboard_unittests.cc.

                              {
  KeyboardTester tester{GetContext()};
  tester.Responding(true);
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  // Hold A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeRepeat,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [664/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		RestartClearsKeyboardState
	)

Definition at line 1000 of file keyboard_unittests.cc.

                                                 {
  KeyboardTester tester{GetContext()};
  tester.Responding(true);
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  // Reset the keyboard's state.
  tester.ResetKeyboard();
 
  // Hold A. Notice the message declares the key is already down, however, the
  // the keyboard does not send a repeat event as its state was reset.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [665/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ShiftLeftKeyA
	)

Definition at line 1032 of file keyboard_unittests.cc.

                                    {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, true, true},
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'A', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "A", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"A");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, false, true},
      WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [666/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ShiftLeftUnhandled
	)

Definition at line 693 of file keyboard_unittests.cc.

                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, true, false},
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Hold ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasDown}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeRepeat,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, false, true},
      WmKeyUpInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [667/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		ShiftRightUnhandled
	)

Definition at line 738 of file keyboard_unittests.cc.

                                          {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press ShiftRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RSHIFT, true, false},
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftRight, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftRight, kLogicalShiftRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release ShiftRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RSHIFT, false, true},
      WmKeyUpInfo{VK_SHIFT, kScanCodeShiftRight, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftRight, kLogicalShiftRight, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [668/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		SlowFrameworkResponse
	)

Definition at line 2059 of file keyboard_unittests.cc.

                                            {
  KeyboardTester tester{GetContext()};
 
  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
 
  // Store callbacks to manually call them.
  tester.LateResponding(
      [&recorded_callbacks](
          const FlutterKeyEvent* event,
          MockKeyResponseController::ResponseCallback callback) {
        recorded_callbacks.push_back(callback);
      });
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  // Hold A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasDown}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_EQ(recorded_callbacks.size(), 1);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // The first response.
  recorded_callbacks.front()(false);
 
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_EQ(recorded_callbacks.size(), 2);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeRepeat,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // The second response.
  recorded_callbacks.back()(false);
 
  EXPECT_EQ(tester.key_calls.size(), 4);
  EXPECT_CALL_IS_TEXT(tester.key_calls[3], u"a");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
}

◆ TEST_F() [669/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		SlowFrameworkResponseForIdenticalEvents
	)

Definition at line 2122 of file keyboard_unittests.cc.

                                                              {
  KeyboardTester tester{GetContext()};
  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
 
  // Store callbacks to manually call them.
  tester.LateResponding(
      [&recorded_callbacks](
          const FlutterKeyEvent* event,
          MockKeyResponseController::ResponseCallback callback) {
        recorded_callbacks.push_back(callback);
      });
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 0);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // The first down event responded with false.
  EXPECT_EQ(recorded_callbacks.size(), 1);
  recorded_callbacks.front()(false);
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"a");
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Press A again
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  // Nothing more was dispatched because the first up event hasn't been
  // responded yet.
  EXPECT_EQ(recorded_callbacks.size(), 2);
  EXPECT_EQ(tester.key_calls.size(), 0);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  // The first up event responded with false, which was redispatched, and caused
  // the down event to be dispatched.
  recorded_callbacks.back()(false);
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(recorded_callbacks.size(), 3);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Release A again
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 0);
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [670/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		SynthesizeModifiers
	)

Definition at line 1764 of file keyboard_unittests.cc.

                                          {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // Two dummy events used to trigger synthesization.
  Win32Message event1 =
      WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
          kWmResultZero);
  Win32Message event2 =
      WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
          kWmResultZero);
 
  // ShiftLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // ShiftRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RSHIFT, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftRight, kLogicalShiftRight, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RSHIFT, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalShiftRight, kLogicalShiftRight, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // ControlLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LCONTROL, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlLeft, kLogicalControlLeft, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // ControlRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RCONTROL, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalControlRight, kLogicalControlRight, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RCONTROL, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalControlRight, kLogicalControlRight, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // AltLeft
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LMENU, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LMENU, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalAltLeft, kLogicalAltLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // AltRight
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RMENU, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RMENU, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalAltRight, kLogicalAltRight, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // MetaLeft
  tester.InjectKeyboardChanges(
      std::vector<KeyboardChange>{KeyStateChange{VK_LWIN, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LWIN, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalMetaLeft, kLogicalMetaLeft, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // MetaRight
  tester.InjectKeyboardChanges(
      std::vector<KeyboardChange>{KeyStateChange{VK_RWIN, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_RWIN, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalMetaRight, kLogicalMetaRight, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // CapsLock, phase 0 -> 2 -> 0.
  // (For phases, see |SynchronizeCriticalToggledStates|.)
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_CAPITAL, false, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_CAPITAL, false, false}, event2});
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalCapsLock, kLogicalCapsLock, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // ScrollLock, phase 0 -> 1 -> 3
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_SCROLL, true, true}, event1});
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalScrollLock, kLogicalScrollLock, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_SCROLL, true, false}, event2});
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalScrollLock, kLogicalScrollLock, "",
                       kSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalScrollLock, kLogicalScrollLock, "",
                       kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // NumLock, phase 0 -> 3 -> 2
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_NUMLOCK, true, false}, event1});
  // TODO(dkwingsmt): Synthesizing from phase 0 to 3 should yield a full key
  // tap and a key down. Fix the algorithm so that the following result becomes
  // 4 keycalls with an extra pair of key down and up.
  // https://github.com/flutter/flutter/issues/98533
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_NUMLOCK, false, true}, event2});
  EXPECT_EQ(tester.key_calls.size(), 4);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown,
                       kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeUp,
                       kPhysicalNumLock, kLogicalNumLock, "", kSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
}

◆ TEST_F() [671/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		TextInputSubmit
	)

Definition at line 2198 of file keyboard_unittests.cc.

                                      {
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  tester.InjectPlatformMessage(
      "flutter/textinput", "TextInput.setClient",
      R"|([108, {"inputAction": "TextInputAction.none"}])|");
 
  // Press Enter
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_RETURN, kScanCodeEnter, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'\n', kScanCodeEnter, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
  EXPECT_CALL_IS_TEXT_METHOD_CALL(
      tester.key_calls[1],
      "{"
      R"|("method":"TextInputClient.performAction",)|"
      R"|("args":[108,"TextInputAction.none"])|"
      "}");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release Enter
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{VK_RETURN, kScanCodeEnter, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalEnter, kLogicalEnter, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Make sure OnText is not obstructed after pressing Enter.
  //
  // Regression test for https://github.com/flutter/flutter/issues/97706.
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
  tester.clear_key_calls();
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
}

◆ TEST_F() [672/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		UpOnlyImeEventsAreCorrectlyHandled
	)

Definition at line 2020 of file keyboard_unittests.cc.

                                                         {
  KeyboardTester tester{GetContext()};
  tester.Responding(true);
 
  // US Keyboard layout.
 
  // Press CtrlRight in IME mode.
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      KeyStateChange{VK_LSHIFT, true, false},
      WmKeyDownInfo{VK_SHIFT, kScanCodeShiftLeft, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmKeyDownInfo{VK_PROCESSKEY, kScanCodeDigit2, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      KeyStateChange{VK_LSHIFT, false, true},
      WmKeyUpInfo{VK_PROCESSKEY, kScanCodeShiftLeft, kNotExtended}.Build(
          kWmResultZero),
      WmKeyUpInfo{'2', kScanCodeDigit2, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 4);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[2], kFlutterKeyEventTypeUp,
                       kPhysicalShiftLeft, kLogicalShiftLeft, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[3], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  tester.clear_key_calls();
}

◆ TEST_F() [673/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		VietnameseTelexAddDiacriticWithFastResponse
	)

Definition at line 2266 of file keyboard_unittests.cc.

                                                                  {
  // In this test, the user presses the folloing keys:
  //
  //   Key         Current text
  //  ===========================
  //   A           a
  //   F           à
  //
  // And the Backspace event is responded immediately.
 
  KeyboardTester tester{GetContext()};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  // Press F, which is translated to:
  //
  // Backspace down, char & up, then VK_PACKET('à').
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
          kWmResultZero),
      WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
      WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
      WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
 
  EXPECT_EQ(tester.key_calls.size(), 3);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBackspace, kLogicalBackspace, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_EVENT(tester.key_calls[1], kFlutterKeyEventTypeUp,
                       kPhysicalBackspace, kLogicalBackspace, "",
                       kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[2], u"à");
  tester.clear_key_calls();
  // TODO(dkwingsmt): This count should probably be 4. Currently the CHAR 0x8
  // message is redispatched due to being part of the KeyDown session, which is
  // not handled by the framework, while the 'à' message is not redispatched
  // for being a standalone message. We should resolve this inconsistency.
  // https://github.com/flutter/flutter/issues/98306
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 3);
 
  // Release F
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
                  /* overwrite_prev_state_0 */ true}
          .Build(kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ TEST_F() [674/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		VietnameseTelexAddDiacriticWithSlowFalseResponse
	)

Definition at line 2456 of file keyboard_unittests.cc.

                                                                       {
  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), false);
}

◆ TEST_F() [675/925]

flutter::testing::TEST_F	(	KeyboardTest	,
		VietnameseTelexAddDiacriticWithSlowTrueResponse
	)

Definition at line 2460 of file keyboard_unittests.cc.

                                                                      {
  VietnameseTelexAddDiacriticWithSlowResponse(GetContext(), true);
}

◆ TEST_F() [676/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		Multiple
	)

Definition at line 96 of file layer_tree_unittests.cc.

                                {
  const SkPath child_path1 = SkPath().addRect(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path2 = SkPath().addRect(8.0f, 2.0f, 16.5f, 14.5f);
  const DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  const DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  mock_layer1->set_fake_has_platform_view(true);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  SkRect expected_total_bounds = child_path1.getBounds();
  expected_total_bounds.join(child_path2.getBounds());
  auto layer_tree = BuildLayerTree(layer);
  layer_tree->Preroll(frame());
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
  EXPECT_FALSE(mock_layer1->is_empty());
  EXPECT_FALSE(mock_layer2->is_empty());
  EXPECT_FALSE(layer->is_empty());
  EXPECT_EQ(mock_layer1->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer2->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(),
            kGiantRect);  // Siblings are independent
 
  layer_tree->Paint(frame());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector({MockCanvas::DrawCall{
                       0, MockCanvas::DrawPathData{child_path1, child_paint1}},
                   MockCanvas::DrawCall{0, MockCanvas::DrawPathData{
                                               child_path2, child_paint2}}}));
}

◆ TEST_F() [677/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		MultipleWithEmpty
	)

Definition at line 133 of file layer_tree_unittests.cc.

                                         {
  const SkPath child_path1 = SkPath().addRect(5.0f, 6.0f, 20.5f, 21.5f);
  const DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  const DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(SkPath(), child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  auto layer_tree = BuildLayerTree(layer);
  layer_tree->Preroll(frame());
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), SkPath().getBounds());
  EXPECT_EQ(layer->paint_bounds(), child_path1.getBounds());
  EXPECT_FALSE(mock_layer1->is_empty());
  EXPECT_TRUE(mock_layer2->is_empty());
  EXPECT_FALSE(layer->is_empty());
  EXPECT_EQ(mock_layer1->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer2->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
  layer_tree->Paint(frame());
  EXPECT_EQ(mock_canvas().draw_calls(),
            std::vector({MockCanvas::DrawCall{
                0, MockCanvas::DrawPathData{child_path1, child_paint1}}}));
}

◆ TEST_F() [678/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		NeedsSystemComposite
	)

Definition at line 162 of file layer_tree_unittests.cc.

                                            {
  const SkPath child_path1 = SkPath().addRect(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path2 = SkPath().addRect(8.0f, 2.0f, 16.5f, 14.5f);
  const DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  const DlPaint child_paint2 = DlPaint(DlColor::kGreen());
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path2, child_paint2);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer1);
  layer->Add(mock_layer2);
 
  SkRect expected_total_bounds = child_path1.getBounds();
  expected_total_bounds.join(child_path2.getBounds());
  auto layer_tree = BuildLayerTree(layer);
  layer_tree->Preroll(frame());
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path1.getBounds());
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path2.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_total_bounds);
  EXPECT_FALSE(mock_layer1->is_empty());
  EXPECT_FALSE(mock_layer2->is_empty());
  EXPECT_FALSE(layer->is_empty());
  EXPECT_EQ(mock_layer1->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer2->parent_matrix(), root_transform());
  EXPECT_EQ(mock_layer1->parent_cull_rect(), kGiantRect);
  EXPECT_EQ(mock_layer2->parent_cull_rect(), kGiantRect);
 
  layer_tree->Paint(frame());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector({MockCanvas::DrawCall{
                       0, MockCanvas::DrawPathData{child_path1, child_paint1}},
                   MockCanvas::DrawCall{0, MockCanvas::DrawPathData{
                                               child_path2, child_paint2}}}));
}

◆ TEST_F() [679/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		PaintBeforePrerollDies
	)

Definition at line 56 of file layer_tree_unittests.cc.

                                              {
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  SkPath child_path;
  child_path.addRect(child_bounds);
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer);
 
  auto layer_tree = BuildLayerTree(layer);
  EXPECT_EQ(mock_layer->paint_bounds(), kEmptyRect);
  EXPECT_EQ(layer->paint_bounds(), kEmptyRect);
  EXPECT_TRUE(mock_layer->is_empty());
  EXPECT_TRUE(layer->is_empty());
 
  layer_tree->Paint(frame());
  EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
}

◆ TEST_F() [680/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		PaintContextInitialization
	)

Definition at line 237 of file layer_tree_unittests.cc.

                                                  {
  LayerStateStack state_stack;
  FixedRefreshRateStopwatch mock_raster_time;
  FixedRefreshRateStopwatch mock_ui_time;
  std::shared_ptr<TextureRegistry> mock_registry;
 
  auto expect_defaults = [&state_stack, &mock_raster_time, &mock_ui_time,
                          &mock_registry](const PaintContext& context) {
    EXPECT_EQ(&context.state_stack, &state_stack);
    EXPECT_EQ(context.canvas, nullptr);
    EXPECT_EQ(context.gr_context, nullptr);
    EXPECT_EQ(context.view_embedder, nullptr);
    EXPECT_EQ(&context.raster_time, &mock_raster_time);
    EXPECT_EQ(&context.ui_time, &mock_ui_time);
    EXPECT_EQ(context.texture_registry.get(), mock_registry.get());
    EXPECT_EQ(context.raster_cache, nullptr);
 
    EXPECT_EQ(context.enable_leaf_layer_tracing, false);
    EXPECT_EQ(context.layer_snapshot_store, nullptr);
  };
 
  // These 4 initializers are required because they are handled by reference
  PaintContext context{
      .state_stack = state_stack,
      .raster_time = mock_raster_time,
      .ui_time = mock_ui_time,
      .texture_registry = mock_registry,
  };
  expect_defaults(context);
}

◆ TEST_F() [681/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		PaintingEmptyLayerDies
	)

Definition at line 46 of file layer_tree_unittests.cc.

                                              {
  auto layer = std::make_shared<ContainerLayer>();
  auto layer_tree = BuildLayerTree(layer);
  layer_tree->Preroll(frame());
  EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
  EXPECT_TRUE(layer->is_empty());
 
  layer_tree->Paint(frame());
}

◆ TEST_F() [682/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		PrerollContextInitialization
	)

Definition at line 197 of file layer_tree_unittests.cc.

                                                    {
  LayerStateStack state_stack;
  state_stack.set_preroll_delegate(kGiantRect, SkMatrix::I());
  FixedRefreshRateStopwatch mock_raster_time;
  FixedRefreshRateStopwatch mock_ui_time;
  std::shared_ptr<TextureRegistry> mock_registry;
 
  auto expect_defaults = [&state_stack, &mock_raster_time, &mock_ui_time,
                          &mock_registry](const PrerollContext& context) {
    EXPECT_EQ(context.raster_cache, nullptr);
    EXPECT_EQ(context.gr_context, nullptr);
    EXPECT_EQ(context.view_embedder, nullptr);
    EXPECT_EQ(&context.state_stack, &state_stack);
    EXPECT_EQ(context.dst_color_space, nullptr);
    EXPECT_EQ(context.state_stack.device_cull_rect(), kGiantRect);
    EXPECT_EQ(context.state_stack.transform_3x3(), SkMatrix::I());
    EXPECT_EQ(context.state_stack.transform_4x4(), SkM44());
    EXPECT_EQ(context.surface_needs_readback, false);
 
    EXPECT_EQ(&context.raster_time, &mock_raster_time);
    EXPECT_EQ(&context.ui_time, &mock_ui_time);
    EXPECT_EQ(context.texture_registry.get(), mock_registry.get());
 
    EXPECT_EQ(context.has_platform_view, false);
    EXPECT_EQ(context.has_texture_layer, false);
 
    EXPECT_EQ(context.renderable_state_flags, 0);
    EXPECT_EQ(context.raster_cached_entries, nullptr);
  };
 
  // These 4 initializers are required because they are handled by reference
  PrerollContext context{
      .state_stack = state_stack,
      .raster_time = mock_raster_time,
      .ui_time = mock_ui_time,
      .texture_registry = mock_registry,
  };
  expect_defaults(context);
}

◆ TEST_F() [683/925]

flutter::testing::TEST_F	(	LayerTreeTest	,
		Simple
	)

Definition at line 74 of file layer_tree_unittests.cc.

                              {
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kCyan());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ContainerLayer>();
  layer->Add(mock_layer);
 
  auto layer_tree = BuildLayerTree(layer);
  layer_tree->Preroll(frame());
  EXPECT_EQ(mock_layer->paint_bounds(), child_bounds);
  EXPECT_EQ(layer->paint_bounds(), mock_layer->paint_bounds());
  EXPECT_FALSE(mock_layer->is_empty());
  EXPECT_FALSE(layer->is_empty());
  EXPECT_EQ(mock_layer->parent_matrix(), root_transform());
 
  layer_tree->Paint(frame());
  EXPECT_EQ(mock_canvas().draw_calls(),
            std::vector({MockCanvas::DrawCall{
                0, MockCanvas::DrawPathData{child_path, child_paint}}}));
}

◆ TEST_F() [684/925]

flutter::testing::TEST_F	(	MockCanvasTest	,
		DrawCalls
	)

Definition at line 21 of file mock_canvas_unittests.cc.

                                  {
  const SkRect rect = SkRect::MakeWH(5.0f, 5.0f);
  const DlPaint paint = DlPaint(DlColor::kGreen());
  const auto expected_draw_calls = std::vector{
      MockCanvas::DrawCall{0, MockCanvas::DrawRectData{rect, paint}}};
 
  mock_canvas().DrawRect(rect, paint);
  EXPECT_EQ(mock_canvas().draw_calls(), expected_draw_calls);
}

◆ TEST_F() [685/925]

flutter::testing::TEST_F	(	MockCanvasTest	,
		DrawRRectDies
	)

Definition at line 16 of file mock_canvas_unittests.cc.

                                      {
  EXPECT_DEATH_IF_SUPPORTED(mock_canvas().DrawRRect(SkRRect(), DlPaint()), "");
}

◆ TEST_F() [686/925]

flutter::testing::TEST_F	(	MockLayerTest	,
		FakePlatformView
	)

Definition at line 67 of file mock_layer_unittests.cc.

                                        {
  auto layer = std::make_shared<MockLayer>(SkPath(), DlPaint());
  layer->set_fake_has_platform_view(true);
  EXPECT_EQ(preroll_context()->has_platform_view, false);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(preroll_context()->has_platform_view, true);
}

◆ TEST_F() [687/925]

flutter::testing::TEST_F	(	MockLayerTest	,
		FlagGetSet
	)

Definition at line 99 of file mock_layer_unittests.cc.

                                  {
  auto mock_layer = std::make_shared<MockLayer>(SkPath());
 
  EXPECT_EQ(mock_layer->parent_has_platform_view(), false);
  mock_layer->set_parent_has_platform_view(true);
  EXPECT_EQ(mock_layer->parent_has_platform_view(), true);
 
  EXPECT_EQ(mock_layer->parent_has_texture_layer(), false);
  mock_layer->set_parent_has_texture_layer(true);
  EXPECT_EQ(mock_layer->parent_has_texture_layer(), true);
 
  EXPECT_EQ(mock_layer->fake_has_platform_view(), false);
  mock_layer->set_fake_has_platform_view(true);
  EXPECT_EQ(mock_layer->fake_has_platform_view(), true);
 
  EXPECT_EQ(mock_layer->fake_reads_surface(), false);
  mock_layer->set_fake_reads_surface(true);
  EXPECT_EQ(mock_layer->fake_reads_surface(), true);
 
  EXPECT_EQ(mock_layer->fake_opacity_compatible(), false);
  mock_layer->set_fake_opacity_compatible(true);
  EXPECT_EQ(mock_layer->fake_opacity_compatible(), true);
 
  EXPECT_EQ(mock_layer->fake_has_texture_layer(), false);
  mock_layer->set_fake_has_texture_layer(true);
  EXPECT_EQ(mock_layer->fake_has_texture_layer(), true);
}

◆ TEST_F() [688/925]

flutter::testing::TEST_F	(	MockLayerTest	,
		SaveLayerOnLeafNodesCanvas
	)

Definition at line 76 of file mock_layer_unittests.cc.

                                                  {
  auto layer = std::make_shared<MockLayer>(SkPath(), DlPaint());
  layer->set_fake_has_platform_view(true);
  EXPECT_EQ(preroll_context()->has_platform_view, false);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(preroll_context()->has_platform_view, true);
}

◆ TEST_F() [689/925]

flutter::testing::TEST_F	(	MockLayerTest	,
		SimpleParams
	)

Definition at line 36 of file mock_layer_unittests.cc.

                                    {
  const SkPath path = SkPath().addRect(5.0f, 6.0f, 20.5f, 21.5f);
  const DlPaint paint = DlPaint(DlColor::kBlue());
  const SkMatrix start_matrix = SkMatrix::Translate(1.0f, 2.0f);
  const SkMatrix scale_matrix = SkMatrix::Scale(0.5f, 0.5f);
  const SkMatrix combined_matrix = SkMatrix::Concat(start_matrix, scale_matrix);
  const SkRect local_cull_rect = SkRect::MakeWH(5.0f, 5.0f);
  const SkRect device_cull_rect = combined_matrix.mapRect(local_cull_rect);
  const bool parent_has_platform_view = true;
  auto layer = std::make_shared<MockLayer>(path, paint);
 
  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,
                                                      start_matrix);
  auto mutator = preroll_context()->state_stack.save();
  mutator.transform(scale_matrix);
  preroll_context()->has_platform_view = parent_has_platform_view;
  layer->Preroll(preroll_context());
  EXPECT_EQ(preroll_context()->has_platform_view, false);
  EXPECT_EQ(layer->paint_bounds(), path.getBounds());
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(layer->parent_mutators(), std::vector{Mutator(scale_matrix)});
  EXPECT_EQ(layer->parent_matrix(), combined_matrix);
  EXPECT_EQ(layer->parent_cull_rect(), local_cull_rect);
  EXPECT_EQ(layer->parent_has_platform_view(), parent_has_platform_view);
 
  layer->Paint(paint_context());
  EXPECT_EQ(mock_canvas().draw_calls(),
            std::vector({MockCanvas::DrawCall{
                0, MockCanvas::DrawPathData{path, paint}}}));
}

◆ TEST_F() [690/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		CullRectIsTransformed
	)

Definition at line 472 of file opacity_layer_unittests.cc.

                                                {
  auto clip_rect_layer = std::make_shared<ClipRectLayer>(
      SkRect::MakeLTRB(0, 0, 10, 10), Clip::kHardEdge);
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto mock_layer = std::make_shared<MockLayer>(SkPath());
  clip_rect_layer->Add(opacity_layer);
  opacity_layer->Add(mock_layer);
  clip_rect_layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->parent_cull_rect().fLeft, -20);
  EXPECT_EQ(mock_layer->parent_cull_rect().fTop, -20);
}

◆ TEST_F() [691/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		FullyOpaque
	)

Definition at line 205 of file opacity_layer_unittests.cc.

                                      {
  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  const SkPoint layer_offset = SkPoint::Make(0.5f, 1.5f);
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
  const SkMatrix layer_transform =
      SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
  const DlPaint child_paint = DlPaint(DlColor::kGreen());
  const SkRect expected_layer_bounds =
      layer_transform.mapRect(child_path.getBounds());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<OpacityLayer>(SK_AlphaOPAQUE, layer_offset);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_layer_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_path.getBounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer_transform));
  EXPECT_EQ(mock_layer->parent_mutators(),
            std::vector({Mutator(layer_transform)}));
 
  DisplayListBuilder expected_builder;
  /* (Opacity)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Translate(layer_offset.fX, layer_offset.fY);
      // Opaque alpha needs no SaveLayer, just recurse into painting mock_layer
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, child_paint);
      }
    }
    expected_builder.Restore();
  }
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [692/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		FullyOpaqueWithFractionalValues
	)

Definition at line 678 of file opacity_layer_unittests.cc.

                                                          {
  use_mock_raster_cache();  // Ensure pixel-snapped alignment.
 
  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  const SkPoint layer_offset = SkPoint::Make(0.5f, 1.5f);
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
  const DlPaint child_paint = DlPaint(DlColor::kGreen());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<OpacityLayer>(SK_AlphaOPAQUE, layer_offset);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
 
  auto expected_builder = DisplayListBuilder();
  /* (Opacity)layer::Paint */ {
    expected_builder.Save();
    expected_builder.Translate(layer_offset.fX, layer_offset.fY);
    // Opaque alpha needs no SaveLayer, just recurse into painting mock_layer
    // but since we use the mock raster cache we pixel snap the transform
    expected_builder.TransformReset();
    expected_builder.Transform2DAffine(
        1, 0, SkScalarRoundToScalar(layer_offset.fX),  //
        0, 1, SkScalarRoundToScalar(layer_offset.fY));
    /* mock_layer::Paint */ {
      expected_builder.DrawPath(child_path, child_paint);
    }
    expected_builder.Restore();
  }
  sk_sp<DisplayList> expected_display_list = expected_builder.Build();
 
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_display_list));
}

◆ TEST_F() [693/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		FullyTransparent
	)

Definition at line 246 of file opacity_layer_unittests.cc.

                                           {
  const SkRect child_bounds = SkRect::MakeWH(5.0f, 5.0f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const SkPoint layer_offset = SkPoint::Make(0.5f, 1.5f);
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
  const SkMatrix layer_transform =
      SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
  const DlPaint child_paint = DlPaint(DlColor::kGreen());
  const SkRect expected_layer_bounds =
      layer_transform.mapRect(child_path.getBounds());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer =
      std::make_shared<OpacityLayer>(SK_AlphaTRANSPARENT, layer_offset);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_layer_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_path.getBounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer_transform));
  EXPECT_EQ(
      mock_layer->parent_mutators(),
      std::vector({Mutator(layer_transform), Mutator(SK_AlphaTRANSPARENT)}));
 
  DisplayListBuilder expected_builder;
  /* (Opacity)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Translate(layer_offset.fX, layer_offset.fY);
      /* (Opacity)layer::PaintChildren */ {
        DlPaint save_paint(DlPaint().setOpacity(layer->opacity()));
        expected_builder.SaveLayer(&child_bounds, &save_paint);
        /* mock_layer::Paint */ {
          expected_builder.DrawPath(child_path, child_paint);
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [694/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		FullyTransparentDoesNotCullPlatformView
	)

Definition at line 713 of file opacity_layer_unittests.cc.

                                                                  {
  const SkPoint opacity_offset = SkPoint::Make(0.5f, 1.5f);
  const SkPoint view_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize view_size = SkSize::Make(8.0f, 8.0f);
  const int64_t view_id = 42;
  auto platform_view =
      std::make_shared<PlatformViewLayer>(view_offset, view_size, view_id);
 
  auto opacity =
      std::make_shared<OpacityLayer>(SK_AlphaTRANSPARENT, opacity_offset);
  opacity->Add(platform_view);
 
  auto embedder = MockViewEmbedder();
  DisplayListBuilder fake_overlay_builder;
  embedder.AddCanvas(&fake_overlay_builder);
  preroll_context()->view_embedder = &embedder;
  paint_context().view_embedder = &embedder;
 
  opacity->Preroll(preroll_context());
  EXPECT_EQ(embedder.prerolled_views(), std::vector<int64_t>({view_id}));
 
  opacity->Paint(paint_context());
  EXPECT_EQ(embedder.painted_views(), std::vector<int64_t>({view_id}));
}

◆ TEST_F() [695/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		HalfTransparent
	)

Definition at line 294 of file opacity_layer_unittests.cc.

                                          {
  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  const SkPoint layer_offset = SkPoint::Make(0.5f, 1.5f);
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 0.5f);
  const SkMatrix layer_transform =
      SkMatrix::Translate(layer_offset.fX, layer_offset.fY);
  const DlPaint child_paint = DlPaint(DlColor::kGreen());
  const SkRect expected_layer_bounds =
      layer_transform.mapRect(child_path.getBounds());
  const SkAlpha alpha_half = 255 / 2;
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<OpacityLayer>(alpha_half, layer_offset);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), expected_layer_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_path.getBounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer_transform));
  EXPECT_EQ(mock_layer->parent_mutators(),
            std::vector({Mutator(layer_transform), Mutator(alpha_half)}));
 
  SkRect opacity_bounds;
  expected_layer_bounds.makeOffset(-layer_offset.fX, -layer_offset.fY)
      .roundOut(&opacity_bounds);
  DlPaint save_paint = DlPaint().setAlpha(alpha_half);
  DlPaint child_dl_paint = DlPaint(DlColor::kGreen());
 
  auto expected_builder = DisplayListBuilder();
  /* (Opacity)layer::Paint */ {
    expected_builder.Save();
    expected_builder.Translate(layer_offset.fX, layer_offset.fY);
    /* (Opacity)layer::PaintChildren */ {
      expected_builder.SaveLayer(&opacity_bounds, &save_paint);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, child_dl_paint);
      }
      expected_builder.Restore();
    }
    expected_builder.Restore();
  }
  sk_sp<DisplayList> expected_display_list = expected_builder.Build();
 
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_display_list));
}

◆ TEST_F() [696/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceCompatibleChild
	)

Definition at line 485 of file opacity_layer_unittests.cc.

                                                            {
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto mock_layer = MockLayer::MakeOpacityCompatible(SkPath());
  opacity_layer->Add(mock_layer);
 
  PrerollContext* context = preroll_context();
  opacity_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [697/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceIncompatibleChild
	)

Definition at line 498 of file opacity_layer_unittests.cc.

                                                              {
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto mock_layer = MockLayer::Make(SkPath());
  opacity_layer->Add(mock_layer);
 
  PrerollContext* context = preroll_context();
  opacity_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_FALSE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [698/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceNestedWithCompatibleChild
	)

Definition at line 557 of file opacity_layer_unittests.cc.

                                                                      {
  SkPoint offset1 = SkPoint::Make(10, 20);
  SkPoint offset2 = SkPoint::Make(20, 10);
  SkPath mock_path = SkPath::Rect({10, 10, 20, 20});
  auto opacity_layer_1 = std::make_shared<OpacityLayer>(128, offset1);
  auto opacity_layer_2 = std::make_shared<OpacityLayer>(64, offset2);
  auto mock_layer = MockLayer::MakeOpacityCompatible(mock_path);
  opacity_layer_2->Add(mock_layer);
  opacity_layer_1->Add(opacity_layer_2);
 
  PrerollContext* context = preroll_context();
  opacity_layer_1->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer_1->children_can_accept_opacity());
  EXPECT_TRUE(opacity_layer_2->children_can_accept_opacity());
 
  DlPaint savelayer_paint;
  SkScalar inherited_opacity = 128 * 1.0 / SK_AlphaOPAQUE;
  inherited_opacity *= 64 * 1.0 / SK_AlphaOPAQUE;
  savelayer_paint.setOpacity(inherited_opacity);
 
  DisplayListBuilder expected_builder;
  /* opacity_layer_1::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Translate(offset1.fX, offset1.fY);
      /* opacity_layer_2::Paint */ {
        expected_builder.Save();
        {
          expected_builder.Translate(offset2.fX, offset2.fY);
          /* mock_layer::Paint */ {
            expected_builder.DrawPath(mock_path,
                                      DlPaint().setOpacity(inherited_opacity));
          }
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
 
  opacity_layer_1->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(expected_builder.Build(), display_list()));
}

◆ TEST_F() [699/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceNestedWithIncompatibleChild
	)

Definition at line 603 of file opacity_layer_unittests.cc.

                                                                        {
  SkPoint offset1 = SkPoint::Make(10, 20);
  SkPoint offset2 = SkPoint::Make(20, 10);
  SkPath mock_path = SkPath::Rect({10, 10, 20, 20});
  auto opacity_layer_1 = std::make_shared<OpacityLayer>(128, offset1);
  auto opacity_layer_2 = std::make_shared<OpacityLayer>(64, offset2);
  auto mock_layer = MockLayer::Make(mock_path);
  opacity_layer_2->Add(mock_layer);
  opacity_layer_1->Add(opacity_layer_2);
 
  PrerollContext* context = preroll_context();
  opacity_layer_1->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer_1->children_can_accept_opacity());
  EXPECT_FALSE(opacity_layer_2->children_can_accept_opacity());
 
  DlPaint savelayer_paint;
  SkScalar inherited_opacity = 128 * 1.0 / SK_AlphaOPAQUE;
  inherited_opacity *= 64 * 1.0 / SK_AlphaOPAQUE;
  savelayer_paint.setOpacity(inherited_opacity);
 
  DisplayListBuilder expected_builder;
  /* opacity_layer_1::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Translate(offset1.fX, offset1.fY);
      /* opacity_layer_2::Paint */ {
        expected_builder.Save();
        {
          expected_builder.Translate(offset2.fX, offset2.fY);
          expected_builder.SaveLayer(&mock_layer->paint_bounds(),
                                     &savelayer_paint);
          /* mock_layer::Paint */ {
            expected_builder.DrawPath(mock_path, DlPaint());
          }
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
 
  opacity_layer_1->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(expected_builder.Build(), display_list()));
}

◆ TEST_F() [700/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceThroughContainer
	)

Definition at line 511 of file opacity_layer_unittests.cc.

                                                             {
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto container_layer = std::make_shared<ContainerLayer>();
  auto mock_layer = MockLayer::MakeOpacityCompatible(SkPath());
  container_layer->Add(mock_layer);
  opacity_layer->Add(container_layer);
 
  PrerollContext* context = preroll_context();
  opacity_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [701/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceThroughImageFilter
	)

Definition at line 541 of file opacity_layer_unittests.cc.

                                                               {
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto filter_layer = std::make_shared<ImageFilterLayer>(
      std::make_shared<DlBlurImageFilter>(5.0, 5.0, DlTileMode::kClamp));
  auto mock_layer = MockLayer::MakeOpacityCompatible(SkPath());
  filter_layer->Add(mock_layer);
  opacity_layer->Add(filter_layer);
 
  PrerollContext* context = preroll_context();
  opacity_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [702/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		OpacityInheritanceThroughTransform
	)

Definition at line 526 of file opacity_layer_unittests.cc.

                                                             {
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto transformLayer = std::make_shared<TransformLayer>(SkMatrix::Scale(2, 2));
  auto mock_layer = MockLayer::MakeOpacityCompatible(SkPath());
  transformLayer->Add(mock_layer);
  opacity_layer->Add(transformLayer);
 
  PrerollContext* context = preroll_context();
  opacity_layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
}

◆ TEST_F() [703/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		ShouldNotCacheChildren
	)

Definition at line 173 of file opacity_layer_unittests.cc.

                                                 {
  DlPaint paint;
  auto opacity_layer =
      std::make_shared<OpacityLayer>(128, SkPoint::Make(20, 20));
  auto mock_layer = MockLayer::MakeOpacityCompatible(SkPath());
  opacity_layer->Add(mock_layer);
 
  PrerollContext* context = preroll_context();
 
  use_mock_raster_cache();
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
 
  const auto* cacheable_opacity_item = opacity_layer->raster_cache_item();
 
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(cacheable_opacity_item->cache_state(),
            RasterCacheItem::CacheState::kNone);
  EXPECT_FALSE(cacheable_opacity_item->GetId().has_value());
 
  opacity_layer->Preroll(preroll_context());
 
  EXPECT_EQ(context->renderable_state_flags,
            LayerStateStack::kCallerCanApplyOpacity);
  EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
  LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
  EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
  EXPECT_EQ(cacheable_opacity_item->cache_state(),
            RasterCacheItem::CacheState::kNone);
  EXPECT_FALSE(cacheable_opacity_item->Draw(paint_context(), &paint));
}

◆ TEST_F() [704/925]

flutter::testing::TEST_F	(	OpacityLayerTest	,
		TranslateChildren
	)

Definition at line 60 of file opacity_layer_unittests.cc.

                                            {
  SkPath child_path1;
  child_path1.addRect(10.0f, 10.0f, 20.0f, 20.f);
  DlPaint child_paint1 = DlPaint(DlColor::kMidGrey());
  auto layer = std::make_shared<OpacityLayer>(0.5, SkPoint::Make(10, 10));
  auto mock_layer1 = std::make_shared<MockLayer>(child_path1, child_paint1);
  layer->Add(mock_layer1);
 
  auto initial_transform = SkMatrix::Scale(2.0, 2.0);
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
 
  SkRect layer_bounds = mock_layer1->paint_bounds();
  mock_layer1->parent_matrix().mapRect(&layer_bounds);
 
  EXPECT_EQ(layer_bounds, SkRect::MakeXYWH(40, 40, 20, 20));
}

◆ TEST_F() [705/925]

flutter::testing::TEST_F	(	PainterTest	,
		DrawDashedLineSkia
	)

Definition at line 198 of file paragraph_unittests.cc.

                                        {
  PretendImpellerIsEnabled(false);
 
  auto recorder = DlOpRecorder();
  draw(makeDecoratedStyle(txt::TextDecorationStyle::kDashed))
      ->Dispatch(recorder);
 
  // Skia draws a dashed underline as a filled rectangle with a path effect.
  EXPECT_EQ(recorder.lineCount(), 0);
  EXPECT_EQ(recorder.dashedLineCount(), 1);
}

◆ TEST_F() [706/925]

flutter::testing::TEST_F	(	PainterTest	,
		DrawsSolidLineSkia
	)

Definition at line 186 of file paragraph_unittests.cc.

                                        {
  PretendImpellerIsEnabled(false);
 
  auto recorder = DlOpRecorder();
  draw(makeDecoratedStyle(txt::TextDecorationStyle::kSolid))
      ->Dispatch(recorder);
 
  // Skia may draw a solid underline as a filled rectangle:
  // https://skia.googlesource.com/skia/+/refs/heads/main/modules/skparagraph/src/Decorations.cpp#91
  EXPECT_EQ(recorder.rectCount(), 1);
}

◆ TEST_F() [707/925]

flutter::testing::TEST_F	(	PerformanceOverlayLayerTest	,
		InvalidOptions
	)

Definition at line 146 of file performance_overlay_layer_unittests.cc.

                                                    {
  const SkRect layer_bounds = SkRect::MakeLTRB(0.0f, 0.0f, 64.0f, 64.0f);
  const uint64_t overlay_opts = 0;
  auto layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
 
  // TODO(): Note calling code has to call set_paint_bounds right now.  Make
  // this a constructor parameter and move the set_paint_bounds into Preroll
  layer->set_paint_bounds(layer_bounds);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), layer_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
 
  // Nothing is drawn if options are invalid (0).
  layer->Paint(paint_context());
  EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
}

◆ TEST_F() [708/925]

flutter::testing::TEST_F	(	PerformanceOverlayLayerTest	,
		MarkAsDirtyWhenResized
	)

Definition at line 197 of file performance_overlay_layer_unittests.cc.

                                                            {
  // Regression test for https://github.com/flutter/flutter/issues/54188
 
  // Create a PerformanceOverlayLayer.
  const uint64_t overlay_opts = kVisualizeRasterizerStatistics;
  auto layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
  layer->set_paint_bounds(SkRect::MakeLTRB(0.0f, 0.0f, 48.0f, 48.0f));
  layer->Preroll(preroll_context());
  layer->Paint(paint_context());
  auto data = mock_canvas().draw_calls().front().data;
  auto image_data = std::get<MockCanvas::DrawImageDataNoPaint>(data);
  auto first_draw_width = image_data.image->width();
 
  // Create a second PerformanceOverlayLayer with different bounds.
  layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
  layer->set_paint_bounds(SkRect::MakeLTRB(0.0f, 0.0f, 64.0f, 64.0f));
  layer->Preroll(preroll_context());
  layer->Paint(paint_context());
  data = mock_canvas().draw_calls().back().data;
  image_data = std::get<MockCanvas::DrawImageDataNoPaint>(data);
  auto refreshed_draw_width = image_data.image->width();
 
  EXPECT_NE(first_draw_width, refreshed_draw_width);
}

◆ TEST_F() [709/925]

flutter::testing::TEST_F	(	PerformanceOverlayLayerTest	,
		SimpleRasterizerStatistics
	)

Definition at line 164 of file performance_overlay_layer_unittests.cc.

                                                                {
  const SkRect layer_bounds = SkRect::MakeLTRB(0.0f, 0.0f, 64.0f, 64.0f);
  const uint64_t overlay_opts = kDisplayRasterizerStatistics;
  auto layer = std::make_shared<PerformanceOverlayLayer>(overlay_opts);
 
  // TODO(): Note calling code has to call set_paint_bounds right now.  Make
  // this a constructor parameter and move the set_paint_bounds into Preroll
  layer->set_paint_bounds(layer_bounds);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), layer_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
 
  layer->Paint(paint_context());
  auto overlay_text = PerformanceOverlayLayer::MakeStatisticsText(
      paint_context().raster_time, "Raster", "");
  auto overlay_text_data = overlay_text->serialize(SkSerialProcs{});
  // Historically SK_ColorGRAY (== 0xFF888888) was used here
  DlPaint text_paint(DlColor(0xFF888888));
  SkPoint text_position = SkPoint::Make(16.0f, 22.0f);
 
  // TODO(https://github.com/flutter/flutter/issues/82202): Remove once the
  // performance overlay can use Fuchsia's font manager instead of the empty
  // default.
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Expectation requires a valid default font manager";
#endif  // OS_FUCHSIA
  EXPECT_EQ(mock_canvas().draw_calls(),
            std::vector({MockCanvas::DrawCall{
                0, MockCanvas::DrawTextData{overlay_text_data, text_paint,
                                            text_position}}}));
}

◆ TEST_F() [710/925]

flutter::testing::TEST_F	(	PersistentCacheTest	,
		CanLoadSkSLsFromAsset
	)

Definition at line 43 of file persistent_cache_unittests.cc.

                                                   {
  // Avoid polluting unit tests output by hiding INFO level logging.
  fml::LogSettings warning_only = {fml::kLogWarning};
  fml::ScopedSetLogSettings scoped_set_log_settings(warning_only);
 
  // The SkSL key is Base32 encoded. "IE" is the encoding of "A" and "II" is the
  // encoding of "B".
  //
  // The SkSL data is Base64 encoded. "eA==" is the encoding of "x" and "eQ=="
  // is the encoding of "y".
  const std::string kTestJson =
      "{\n"
      "  \"data\": {\n"
      "    \"IE\": \"eA==\",\n"
      "    \"II\": \"eQ==\"\n"
      "  }\n"
      "}\n";
 
  // Temp dir for the asset.
  fml::ScopedTemporaryDirectory asset_dir;
 
  auto data = std::make_unique<fml::DataMapping>(
      std::vector<uint8_t>{kTestJson.begin(), kTestJson.end()});
  fml::WriteAtomically(asset_dir.fd(), PersistentCache::kAssetFileName, *data);
 
  // 1st, test that RunConfiguration::InferFromSettings sets the asset manager.
  ResetAssetManager();
  auto settings = CreateSettingsForFixture();
  settings.assets_path = asset_dir.path();
  RunConfiguration::InferFromSettings(settings);
  CheckTwoSkSLsAreLoaded();
 
  // 2nd, test that the RunConfiguration constructor sets the asset manager.
  // (Android is directly calling that constructor without InferFromSettings.)
  ResetAssetManager();
  auto asset_manager = std::make_shared<AssetManager>();
  RunConfiguration config(nullptr, asset_manager);
  asset_manager->PushBack(std::make_unique<DirectoryAssetBundle>(
      fml::OpenDirectory(asset_dir.path().c_str(), false,
                         fml::FilePermission::kRead),
      false));
  CheckTwoSkSLsAreLoaded();
 
  // 3rd, test the content of the SkSLs in the asset.
  {
    auto shaders = PersistentCache::GetCacheForProcess()->LoadSkSLs();
    ASSERT_EQ(shaders.size(), 2u);
 
    // Make sure that the 2 shaders are sorted by their keys. Their keys should
    // be "A" and "B" (decoded from "II" and "IE").
    if (shaders[0].key->bytes()[0] == 'B') {
      std::swap(shaders[0], shaders[1]);
    }
 
    CheckTextSkData(shaders[0].key, "A");
    CheckTextSkData(shaders[1].key, "B");
    CheckTextSkData(shaders[0].value, "x");
    CheckTextSkData(shaders[1].value, "y");
  }
 
  // Cleanup.
  fml::UnlinkFile(asset_dir.fd(), PersistentCache::kAssetFileName);
}

◆ TEST_F() [711/925]

flutter::testing::TEST_F	(	PersistentCacheTest	,
		CanPurgePersistentCache
	)

Definition at line 137 of file persistent_cache_unittests.cc.

                                                     {
  fml::ScopedTemporaryDirectory base_dir;
  ASSERT_TRUE(base_dir.fd().is_valid());
  auto cache_dir = fml::CreateDirectory(
      base_dir.fd(),
      {"flutter_engine", GetFlutterEngineVersion(), "skia", GetSkiaVersion()},
      fml::FilePermission::kReadWrite);
  PersistentCache::SetCacheDirectoryPath(base_dir.path());
  PersistentCache::ResetCacheForProcess();
 
  // Generate a dummy persistent cache.
  fml::DataMapping test_data(std::string("test"));
  ASSERT_TRUE(fml::WriteAtomically(cache_dir, "test", test_data));
  auto file = fml::OpenFileReadOnly(cache_dir, "test");
  ASSERT_TRUE(file.is_valid());
 
  // Run engine with purge_persistent_cache to remove the dummy cache.
  auto settings = CreateSettingsForFixture();
  settings.purge_persistent_cache = true;
  auto config = RunConfiguration::InferFromSettings(settings);
  std::unique_ptr<Shell> shell = CreateShell(settings);
  RunEngine(shell.get(), std::move(config));
 
  // Verify that the dummy is purged.
  file = fml::OpenFileReadOnly(cache_dir, "test");
  ASSERT_FALSE(file.is_valid());
 
  // Cleanup
  fml::RemoveFilesInDirectory(base_dir.fd());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [712/925]

flutter::testing::TEST_F	(	PersistentCacheTest	,
		CanRemoveOldPersistentCache
	)

Definition at line 107 of file persistent_cache_unittests.cc.

                                                         {
  fml::ScopedTemporaryDirectory base_dir;
  ASSERT_TRUE(base_dir.fd().is_valid());
 
  fml::CreateDirectory(base_dir.fd(),
                       {"flutter_engine", GetFlutterEngineVersion(), "skia"},
                       fml::FilePermission::kReadWrite);
 
  constexpr char kOldEngineVersion[] = "old";
  auto old_created = fml::CreateDirectory(
      base_dir.fd(), {"flutter_engine", kOldEngineVersion, "skia"},
      fml::FilePermission::kReadWrite);
  ASSERT_TRUE(old_created.is_valid());
 
  PersistentCache::SetCacheDirectoryPath(base_dir.path());
  PersistentCache::ResetCacheForProcess();
 
  auto engine_dir = fml::OpenDirectoryReadOnly(base_dir.fd(), "flutter_engine");
  auto current_dir =
      fml::OpenDirectoryReadOnly(engine_dir, GetFlutterEngineVersion());
  auto old_dir = fml::OpenDirectoryReadOnly(engine_dir, kOldEngineVersion);
 
  ASSERT_TRUE(engine_dir.is_valid());
  ASSERT_TRUE(current_dir.is_valid());
  ASSERT_FALSE(old_dir.is_valid());
 
  // Cleanup
  fml::RemoveFilesInDirectory(base_dir.fd());
}

◆ TEST_F() [713/925]

flutter::testing::TEST_F	(	PersistentCacheTest	,
		PurgeAllowsFutureSkSLCache
	)

Definition at line 169 of file persistent_cache_unittests.cc.

                                                        {
  sk_sp<SkData> shader_key = SkData::MakeWithCString("key");
  sk_sp<SkData> shader_value = SkData::MakeWithCString("value");
  std::string shader_filename = PersistentCache::SkKeyToFilePath(*shader_key);
 
  fml::ScopedTemporaryDirectory base_dir;
  ASSERT_TRUE(base_dir.fd().is_valid());
  PersistentCache::SetCacheDirectoryPath(base_dir.path());
  PersistentCache::ResetCacheForProcess();
 
  // Run engine with purge_persistent_cache and cache_sksl.
  auto settings = CreateSettingsForFixture();
  settings.purge_persistent_cache = true;
  settings.cache_sksl = true;
  auto config = RunConfiguration::InferFromSettings(settings);
  std::unique_ptr<Shell> shell = CreateShell(settings);
  RunEngine(shell.get(), std::move(config));
  auto persistent_cache = PersistentCache::GetCacheForProcess();
  ASSERT_EQ(persistent_cache->LoadSkSLs().size(), 0u);
 
  // Store the cache and verify it's valid.
  StorePersistentCache(persistent_cache, *shader_key, *shader_value);
  std::promise<bool> io_flushed;
  shell->GetTaskRunners().GetIOTaskRunner()->PostTask(
      [&io_flushed]() { io_flushed.set_value(true); });
  io_flushed.get_future().get();  // Wait for the IO thread to flush the file.
  ASSERT_GT(persistent_cache->LoadSkSLs().size(), 0u);
 
  // Cleanup
  fml::RemoveFilesInDirectory(base_dir.fd());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [714/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		GetWindowReturnsNullForNonexistentId
	)

Definition at line 109 of file platform_configuration_unittests.cc.

                                                                        {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto nativeValidateConfiguration =
      [message_latch](Dart_NativeArguments args) {
        PlatformConfiguration* configuration =
            UIDartState::Current()->platform_configuration();
 
        ASSERT_EQ(configuration->GetMetrics(1), nullptr);
        ASSERT_EQ(configuration->GetMetrics(2), nullptr);
 
        message_latch->Signal();
      };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidateConfiguration",
                    CREATE_NATIVE_ENTRY(nativeValidateConfiguration));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("validateConfiguration");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [715/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		Initialization
	)

Definition at line 24 of file platform_configuration_unittests.cc.

                                                  {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto nativeValidateConfiguration =
      [message_latch](Dart_NativeArguments args) {
        PlatformConfiguration* configuration =
            UIDartState::Current()->platform_configuration();
        ASSERT_NE(configuration->GetMetrics(0), nullptr);
        ASSERT_EQ(configuration->GetMetrics(0)->device_pixel_ratio, 1.0);
        ASSERT_EQ(configuration->GetMetrics(0)->physical_width, 0.0);
        ASSERT_EQ(configuration->GetMetrics(0)->physical_height, 0.0);
 
        message_latch->Signal();
      };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidateConfiguration",
                    CREATE_NATIVE_ENTRY(nativeValidateConfiguration));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("validateConfiguration");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [716/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		OnErrorDoesNotHandleError
	)

Definition at line 194 of file platform_configuration_unittests.cc.

                                                             {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  std::string ex;
  std::string st;
  size_t throw_count = 0;
 
  auto finish = [message_latch](Dart_NativeArguments args) {
    message_latch->Signal();
  };
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finish));
 
  Settings settings = CreateSettingsForFixture();
  settings.unhandled_exception_callback =
      [&ex, &st, &throw_count](const std::string& exception,
                               const std::string& stack_trace) -> bool {
    throw_count += 1;
    ex = exception;
    st = stack_trace;
    return true;
  };
 
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("customOnErrorFalse");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  // Flush the UI task runner to make sure errors that were triggered had a turn
  // to propagate.
  task_runners.GetUITaskRunner()->PostTask(
      [&message_latch]() { message_latch->Signal(); });
  message_latch->Wait();
 
  ASSERT_EQ(throw_count, 1ul);
  ASSERT_EQ(ex, "Exception: false") << ex;
  ASSERT_EQ(st.rfind("#0      customOnErrorFalse", 0), 0ul) << st;
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [717/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		OnErrorHandlesError
	)

Definition at line 148 of file platform_configuration_unittests.cc.

                                                       {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  bool did_throw = false;
 
  auto finish = [message_latch](Dart_NativeArguments args) {
    message_latch->Signal();
  };
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finish));
 
  Settings settings = CreateSettingsForFixture();
  settings.unhandled_exception_callback =
      [&did_throw](const std::string& exception,
                   const std::string& stack_trace) -> bool {
    did_throw = true;
    return false;
  };
 
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("customOnErrorTrue");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  // Flush the UI task runner to make sure errors that were triggered had a turn
  // to propagate.
  task_runners.GetUITaskRunner()->PostTask(
      [&message_latch]() { message_latch->Signal(); });
  message_latch->Wait();
 
  ASSERT_FALSE(did_throw);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [718/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		OnErrorThrows
	)

Definition at line 246 of file platform_configuration_unittests.cc.

                                                 {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  std::vector<std::string> errors;
  size_t throw_count = 0;
 
  auto finish = [message_latch](Dart_NativeArguments args) {
    message_latch->Signal();
  };
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finish));
 
  Settings settings = CreateSettingsForFixture();
  settings.unhandled_exception_callback =
      [&errors, &throw_count](const std::string& exception,
                              const std::string& stack_trace) -> bool {
    throw_count += 1;
    errors.push_back(exception);
    errors.push_back(stack_trace);
    return true;
  };
 
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("customOnErrorThrow");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  // Flush the UI task runner to make sure errors that were triggered had a turn
  // to propagate.
  task_runners.GetUITaskRunner()->PostTask(
      [&message_latch]() { message_latch->Signal(); });
  message_latch->Wait();
 
  ASSERT_EQ(throw_count, 2ul);
  ASSERT_EQ(errors.size(), 4ul);
  ASSERT_EQ(errors[0], "Exception: throw2") << errors[0];
  ASSERT_EQ(errors[1].rfind("#0      customOnErrorThrow"), 0ul) << errors[1];
  ASSERT_EQ(errors[2], "Exception: throw1") << errors[2];
  ASSERT_EQ(errors[3].rfind("#0      customOnErrorThrow"), 0ul) << errors[3];
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [719/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		SetDartPerformanceMode
	)

Definition at line 301 of file platform_configuration_unittests.cc.

                                                          {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  auto finish = [message_latch](Dart_NativeArguments args) {
    // call needs to happen on the UI thread.
    Dart_PerformanceMode prev =
        Dart_SetPerformanceMode(Dart_PerformanceMode_Default);
    ASSERT_EQ(Dart_PerformanceMode_Latency, prev);
    message_latch->Signal();
  };
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finish));
 
  Settings settings = CreateSettingsForFixture();
 
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("setLatencyPerformanceMode");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [720/925]

flutter::testing::TEST_F	(	PlatformConfigurationTest	,
		WindowMetricsUpdate
	)

Definition at line 64 of file platform_configuration_unittests.cc.

                                                       {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto nativeValidateConfiguration =
      [message_latch](Dart_NativeArguments args) {
        PlatformConfiguration* configuration =
            UIDartState::Current()->platform_configuration();
 
        ASSERT_NE(configuration->GetMetrics(0), nullptr);
        bool has_view = configuration->UpdateViewMetrics(
            0, ViewportMetrics{2.0, 10.0, 20.0, 22, 0});
        ASSERT_TRUE(has_view);
        ASSERT_EQ(configuration->GetMetrics(0)->device_pixel_ratio, 2.0);
        ASSERT_EQ(configuration->GetMetrics(0)->physical_width, 10.0);
        ASSERT_EQ(configuration->GetMetrics(0)->physical_height, 20.0);
        ASSERT_EQ(configuration->GetMetrics(0)->physical_touch_slop, 22);
 
        message_latch->Signal();
      };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidateConfiguration",
                    CREATE_NATIVE_ENTRY(nativeValidateConfiguration));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto run_configuration = RunConfiguration::InferFromSettings(settings);
  run_configuration.SetEntrypoint("validateConfiguration");
 
  shell->RunEngine(std::move(run_configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [721/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStrings
	)

Definition at line 267 of file platform_handler_unittests.cc.

                                                 {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
 
  EXPECT_EQ(result, "[{\"value\":true}]");
}

◆ TEST_F() [722/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStringsIgnoresPermissionErrors
	)

Definition at line 336 of file platform_handler_unittests.cc.

                                                                        {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kAccessDeniedErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
 
  EXPECT_EQ(result, "[{\"value\":false}]");
}

◆ TEST_F() [723/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStringsRejectsUnknownContentType
	)

Definition at line 309 of file platform_handler_unittests.cc.

                                                                          {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result = SimulatePlatformMessage(
      &messenger, kClipboardHasStringsFakeContentTypeMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
}

◆ TEST_F() [724/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStringsReportsErrors
	)

Definition at line 356 of file platform_handler_unittests.cc.

                                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kArbitraryErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
}

◆ TEST_F() [725/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStringsRequiresView
	)

Definition at line 321 of file platform_handler_unittests.cc.

                                                             {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
 
  EXPECT_EQ(result,
            "[\"Clipboard error\",\"Clipboard is not available in Windows "
            "headless mode\",null]");
}

◆ TEST_F() [726/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardHasStringsReturnsFalse
	)

Definition at line 288 of file platform_handler_unittests.cc.

                                                             {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(false));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardHasStringsMessage);
 
  EXPECT_EQ(result, "[{\"value\":false}]");
}

◆ TEST_F() [727/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetData
	)

Definition at line 376 of file platform_handler_unittests.cc.

                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), SetString)
        .Times(1)
        .WillOnce([](std::wstring string) {
          EXPECT_EQ(string, L"hello");
          return kErrorSuccess;
        });
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
 
  EXPECT_EQ(result, "[null]");
}

◆ TEST_F() [728/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetDataReportsOpenFailure
	)

Definition at line 441 of file platform_handler_unittests.cc.

                                                                {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kArbitraryErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
}

◆ TEST_F() [729/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetDataReportsSetDataFailure
	)

Definition at line 461 of file platform_handler_unittests.cc.

                                                                   {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), SetString)
        .Times(1)
        .WillOnce(Return(kArbitraryErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to set clipboard data\",1]");
}

◆ TEST_F() [730/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetDataRequiresView
	)

Definition at line 427 of file platform_handler_unittests.cc.

                                                          {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataMessage);
 
  EXPECT_EQ(result,
            "[\"Clipboard error\",\"Clipboard is not available in Windows "
            "headless mode\",null]");
}

◆ TEST_F() [731/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetDataTextMustBeString
	)

Definition at line 403 of file platform_handler_unittests.cc.

                                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataNullTextMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
}

◆ TEST_F() [732/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		ClipboardSetDataUnknownType
	)

Definition at line 415 of file platform_handler_unittests.cc.

                                                         {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardSetDataUnknownTypeMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
}

◆ TEST_F() [733/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		GetClipboardData
	)

Definition at line 172 of file platform_handler_unittests.cc.

                                              {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
    EXPECT_CALL(*clipboard.get(), GetString)
        .Times(1)
        .WillOnce(Return(std::wstring(L"Hello world")));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
 
  EXPECT_EQ(result, "[{\"text\":\"Hello world\"}]");
}

◆ TEST_F() [734/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		GetClipboardDataRejectsUnknownContentType
	)

Definition at line 196 of file platform_handler_unittests.cc.

                                                                       {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  // Requesting an unknown content type is an error.
  std::string result = SimulatePlatformMessage(
      &messenger, kClipboardGetDataFakeContentTypeMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unknown clipboard format\",null]");
}

◆ TEST_F() [735/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		GetClipboardDataReportsGetDataFailure
	)

Definition at line 243 of file platform_handler_unittests.cc.

                                                                   {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kErrorSuccess));
    EXPECT_CALL(*clipboard.get(), HasString).Times(1).WillOnce(Return(true));
    EXPECT_CALL(*clipboard.get(), GetString)
        .Times(1)
        .WillOnce(Return(kArbitraryErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to get clipboard data\",1]");
}

◆ TEST_F() [736/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		GetClipboardDataReportsOpenFailure
	)

Definition at line 223 of file platform_handler_unittests.cc.

                                                                {
  UseEngineWithView();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine(), []() {
    auto clipboard = std::make_unique<MockScopedClipboard>();
 
    EXPECT_CALL(*clipboard.get(), Open)
        .Times(1)
        .WillOnce(Return(kArbitraryErrorCode));
 
    return clipboard;
  });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
 
  EXPECT_EQ(result, "[\"Clipboard error\",\"Unable to open clipboard\",1]");
}

◆ TEST_F() [737/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		GetClipboardDataRequiresView
	)

Definition at line 209 of file platform_handler_unittests.cc.

                                                          {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  PlatformHandler platform_handler(&messenger, engine());
 
  std::string result =
      SimulatePlatformMessage(&messenger, kClipboardGetDataMessage);
 
  EXPECT_EQ(result,
            "[\"Clipboard error\",\"Clipboard is not available in "
            "Windows headless mode\",null]");
}

◆ TEST_F() [738/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		PlaySystemSound
	)

Definition at line 484 of file platform_handler_unittests.cc.

                                             {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger;
  MockPlatformHandler platform_handler(&messenger, engine());
 
  EXPECT_CALL(platform_handler, SystemSoundPlay("SystemSoundType.alert", _))
      .WillOnce([](const std::string& sound,
                   std::unique_ptr<MethodResult<rapidjson::Document>> result) {
        result->Success();
      });
 
  std::string result =
      SimulatePlatformMessage(&messenger, kSystemSoundTypeAlertMessage);
 
  EXPECT_EQ(result, "[null]");
}

◆ TEST_F() [739/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		SystemExitApplicationCancelableCancel
	)

Definition at line 524 of file platform_handler_unittests.cc.

                                                                   {
  UseHeadlessEngine();
  bool called_cancel = false;
 
  TestBinaryMessenger messenger(
      [&called_cancel](const std::string& channel, const uint8_t* message,
                       size_t size, BinaryReply reply) {
        reply(reinterpret_cast<const uint8_t*>(kExitResponseCancelMessage),
              sizeof(kExitResponseCancelMessage));
        called_cancel = true;
      });
  MockPlatformHandler platform_handler(&messenger, engine());
 
  EXPECT_CALL(platform_handler, QuitApplication).Times(0);
 
  std::string result = SimulatePlatformMessage(
      &messenger, kSystemExitApplicationCancelableMessage);
  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
  EXPECT_TRUE(called_cancel);
}

◆ TEST_F() [740/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		SystemExitApplicationCancelableExit
	)

Definition at line 545 of file platform_handler_unittests.cc.

                                                                 {
  UseHeadlessEngine();
  bool called_cancel = false;
  UINT exit_code = 0;
 
  TestBinaryMessenger messenger(
      [&called_cancel](const std::string& channel, const uint8_t* message,
                       size_t size, BinaryReply reply) {
        reply(reinterpret_cast<const uint8_t*>(kExitResponseExitMessage),
              sizeof(kExitResponseExitMessage));
        called_cancel = true;
      });
  MockPlatformHandler platform_handler(&messenger, engine());
 
  ON_CALL(platform_handler, QuitApplication)
      .WillByDefault([&exit_code](std::optional<HWND> hwnd,
                                  std::optional<WPARAM> wparam,
                                  std::optional<LPARAM> lparam,
                                  UINT ec) { exit_code = ec; });
  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
 
  std::string result = SimulatePlatformMessage(
      &messenger, kSystemExitApplicationCancelableMessage);
  EXPECT_EQ(result, "[{\"response\":\"cancel\"}]");
  EXPECT_TRUE(called_cancel);
  EXPECT_EQ(exit_code, 2);
}

◆ TEST_F() [741/925]

flutter::testing::TEST_F	(	PlatformHandlerTest	,
		SystemExitApplicationRequired
	)

Definition at line 502 of file platform_handler_unittests.cc.

                                                           {
  UseHeadlessEngine();
  UINT exit_code = 0;
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t size,
                                   BinaryReply reply) {});
  MockPlatformHandler platform_handler(&messenger, engine());
 
  ON_CALL(platform_handler, QuitApplication)
      .WillByDefault([&exit_code](std::optional<HWND> hwnd,
                                  std::optional<WPARAM> wparam,
                                  std::optional<LPARAM> lparam,
                                  UINT ec) { exit_code = ec; });
  EXPECT_CALL(platform_handler, QuitApplication).Times(1);
 
  std::string result = SimulatePlatformMessage(
      &messenger, kSystemExitApplicationRequiredMessage);
  EXPECT_EQ(result, "[{\"response\":\"exit\"}]");
  EXPECT_EQ(exit_code, 1);
}

◆ TEST_F() [742/925]

flutter::testing::TEST_F	(	PlatformIsolateManagerTest	,
		EarlyShutdown
	)

Definition at line 162 of file platform_isolate_manager_unittests.cc.

                                                  {
  TestWithRootIsolate([this]() {
    PlatformIsolateManager mgr;
    EXPECT_FALSE(mgr.HasShutdown());
 
    Dart_Isolate isolateA = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateA);
    EXPECT_FALSE(IsolateIsShutdown(isolateA));
    EXPECT_TRUE(IsolateWasRegistered(isolateA));
    EXPECT_TRUE(mgr.IsRegisteredForTestingOnly(isolateA));
 
    Dart_Isolate isolateB = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateB);
    EXPECT_FALSE(IsolateIsShutdown(isolateB));
    EXPECT_TRUE(IsolateWasRegistered(isolateB));
    EXPECT_TRUE(mgr.IsRegisteredForTestingOnly(isolateB));
 
    Dart_EnterIsolate(isolateA);
    Dart_ShutdownIsolate();
    EXPECT_TRUE(IsolateIsShutdown(isolateA));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateA));
 
    Dart_EnterIsolate(isolateB);
    Dart_ShutdownIsolate();
    EXPECT_TRUE(IsolateIsShutdown(isolateB));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateB));
 
    mgr.ShutdownPlatformIsolates();
    EXPECT_TRUE(mgr.HasShutdown());
 
    EXPECT_TRUE(IsolateIsShutdown(isolateA));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateA));
    EXPECT_TRUE(IsolateIsShutdown(isolateB));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateB));
  });
}

◆ TEST_F() [743/925]

flutter::testing::TEST_F	(	PlatformIsolateManagerTest	,
		MultithreadedCreation
	)

Definition at line 229 of file platform_isolate_manager_unittests.cc.

                                                          {
  // Try to generate race conditions by creating Isolates on multiple threads,
  // while shutting down the manager.
  TestWithRootIsolate([this]() {
    PlatformIsolateManager mgr;
    EXPECT_FALSE(mgr.HasShutdown());
 
    std::atomic<bool> test_finished = false;
    std::vector<std::thread> threads;
    threads.reserve(10);
    for (int i = 0; i < 10; ++i) {
      threads.push_back(std::thread([this, &mgr, &test_finished]() {
        for (int j = 0; j < 100; ++j) {
          Dart_Isolate isolate = CreateAndRegisterIsolate(&mgr);
          ASSERT_TRUE(isolate);
 
          if (!IsolateWasRegistered(isolate)) {
            Dart_EnterIsolate(isolate);
            Dart_ShutdownIsolate();
          }
        }
        while (!test_finished.load()) {
          // Wait for the test to finish, to avoid prematurely destroying thread
          // local isolate_data_map_.
        }
      }));
    }
 
    mgr.ShutdownPlatformIsolates();
    EXPECT_TRUE(mgr.HasShutdown());
 
    test_finished = true;
    for (auto& thread : threads) {
      thread.join();
    }
  });
}

◆ TEST_F() [744/925]

flutter::testing::TEST_F	(	PlatformIsolateManagerTest	,
		OrdinaryFlow
	)

Definition at line 133 of file platform_isolate_manager_unittests.cc.

                                                 {
  TestWithRootIsolate([this]() {
    PlatformIsolateManager mgr;
    EXPECT_FALSE(mgr.HasShutdown());
    EXPECT_FALSE(mgr.HasShutdownMaybeFalseNegative());
 
    Dart_Isolate isolateA = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateA);
    EXPECT_FALSE(IsolateIsShutdown(isolateA));
    EXPECT_TRUE(IsolateWasRegistered(isolateA));
    EXPECT_TRUE(mgr.IsRegisteredForTestingOnly(isolateA));
 
    Dart_Isolate isolateB = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateB);
    EXPECT_FALSE(IsolateIsShutdown(isolateB));
    EXPECT_TRUE(IsolateWasRegistered(isolateB));
    EXPECT_TRUE(mgr.IsRegisteredForTestingOnly(isolateB));
 
    mgr.ShutdownPlatformIsolates();
    EXPECT_TRUE(mgr.HasShutdown());
    EXPECT_TRUE(mgr.HasShutdownMaybeFalseNegative());
 
    EXPECT_TRUE(IsolateIsShutdown(isolateA));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateA));
    EXPECT_TRUE(IsolateIsShutdown(isolateB));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateB));
  });
}

◆ TEST_F() [745/925]

flutter::testing::TEST_F	(	PlatformIsolateManagerTest	,
		RegistrationAfterShutdown
	)

Definition at line 199 of file platform_isolate_manager_unittests.cc.

                                                              {
  TestWithRootIsolate([this]() {
    PlatformIsolateManager mgr;
    EXPECT_FALSE(mgr.HasShutdown());
 
    Dart_Isolate isolateA = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateA);
    EXPECT_FALSE(IsolateIsShutdown(isolateA));
    EXPECT_TRUE(IsolateWasRegistered(isolateA));
    EXPECT_TRUE(mgr.IsRegisteredForTestingOnly(isolateA));
 
    mgr.ShutdownPlatformIsolates();
    EXPECT_TRUE(mgr.HasShutdown());
 
    EXPECT_TRUE(IsolateIsShutdown(isolateA));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateA));
 
    Dart_Isolate isolateB = CreateAndRegisterIsolate(&mgr);
    ASSERT_TRUE(isolateB);
    EXPECT_FALSE(IsolateIsShutdown(isolateB));
    EXPECT_FALSE(IsolateWasRegistered(isolateB));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateB));
 
    Dart_EnterIsolate(isolateB);
    Dart_ShutdownIsolate();
    EXPECT_TRUE(IsolateIsShutdown(isolateB));
    EXPECT_FALSE(mgr.IsRegisteredForTestingOnly(isolateB));
  });
}

◆ TEST_F() [746/925]

flutter::testing::TEST_F	(	PlatformViewLayerTest	,
		ClippedPlatformViewPrerollsAndPaintsNothing
	)

Definition at line 42 of file platform_view_layer_unittests.cc.

                                                                           {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize layer_size = SkSize::Make(8.0f, 8.0f);
  const SkRect child_clip = SkRect::MakeLTRB(20.0f, 20.0f, 40.0f, 40.0f);
  const SkRect parent_clip = SkRect::MakeLTRB(50.0f, 50.0f, 80.0f, 80.0f);
  const int64_t view_id = 0;
  auto layer =
      std::make_shared<PlatformViewLayer>(layer_offset, layer_size, view_id);
  auto child_clip_layer =
      std::make_shared<ClipRectLayer>(child_clip, Clip::kHardEdge);
  auto parent_clip_layer =
      std::make_shared<ClipRectLayer>(parent_clip, Clip::kHardEdge);
  parent_clip_layer->Add(child_clip_layer);
  child_clip_layer->Add(layer);
 
  auto embedder = MockViewEmbedder();
  preroll_context()->view_embedder = &embedder;
 
  parent_clip_layer->Preroll(preroll_context());
  EXPECT_TRUE(preroll_context()->has_platform_view);
  EXPECT_EQ(layer->paint_bounds(),
            SkRect::MakeSize(layer_size)
                .makeOffset(layer_offset.fX, layer_offset.fY));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_TRUE(child_clip_layer->needs_painting(paint_context()));
  EXPECT_TRUE(parent_clip_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->subtree_has_platform_view());
  EXPECT_TRUE(child_clip_layer->subtree_has_platform_view());
  EXPECT_TRUE(parent_clip_layer->subtree_has_platform_view());
 
  parent_clip_layer->Paint(paint_context());
  EXPECT_EQ(paint_context().canvas, &mock_canvas());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector(
          {MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
           MockCanvas::DrawCall{
               1, MockCanvas::ClipRectData{parent_clip, ClipOp::kIntersect,
                                           MockCanvas::kHardClipEdgeStyle}},
           MockCanvas::DrawCall{1, MockCanvas::SaveData{2}},
           MockCanvas::DrawCall{
               2, MockCanvas::ClipRectData{child_clip, ClipOp::kIntersect,
                                           MockCanvas::kHardClipEdgeStyle}},
           MockCanvas::DrawCall{2, MockCanvas::RestoreData{1}},
           MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
}

◆ TEST_F() [747/925]

flutter::testing::TEST_F	(	PlatformViewLayerTest	,
		NullViewEmbedderDoesntPrerollCompositeOrPaint
	)

Definition at line 22 of file platform_view_layer_unittests.cc.

                                                                             {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize layer_size = SkSize::Make(8.0f, 8.0f);
  const int64_t view_id = 0;
  auto layer =
      std::make_shared<PlatformViewLayer>(layer_offset, layer_size, view_id);
 
  layer->Preroll(preroll_context());
  EXPECT_FALSE(preroll_context()->has_platform_view);
  EXPECT_EQ(layer->paint_bounds(),
            SkRect::MakeSize(layer_size)
                .makeOffset(layer_offset.fX, layer_offset.fY));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_FALSE(layer->subtree_has_platform_view());
 
  layer->Paint(paint_context());
  EXPECT_EQ(paint_context().canvas, &mock_canvas());
  EXPECT_EQ(mock_canvas().draw_calls(), std::vector<MockCanvas::DrawCall>());
}

◆ TEST_F() [748/925]

flutter::testing::TEST_F	(	PlatformViewLayerTest	,
		StateTransfer
	)

Definition at line 101 of file platform_view_layer_unittests.cc.

                                             {
  const SkMatrix transform1 = SkMatrix::Translate(5, 5);
  const SkMatrix transform2 = SkMatrix::Translate(15, 15);
  const SkMatrix combined_transform = SkMatrix::Translate(20, 20);
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize layer_size = SkSize::Make(8.0f, 8.0f);
  const int64_t view_id = 0;
  const SkPath path1 = SkPath().addOval({10, 10, 20, 20});
  const SkPath path2 = SkPath().addOval({15, 15, 30, 30});
 
  // transform_layer1
  //   |- child1
  //   |- platform_layer
  //   |- transform_layer2
  //        |- child2
  auto transform_layer1 = std::make_shared<TransformLayer>(transform1);
  auto transform_layer2 = std::make_shared<TransformLayer>(transform2);
  auto platform_layer =
      std::make_shared<PlatformViewLayer>(layer_offset, layer_size, view_id);
  auto child1 = std::make_shared<MockLayer>(path1);
  child1->set_expected_paint_matrix(transform1);
  auto child2 = std::make_shared<MockLayer>(path2);
  child2->set_expected_paint_matrix(combined_transform);
  transform_layer1->Add(child1);
  transform_layer1->Add(platform_layer);
  transform_layer1->Add(transform_layer2);
  transform_layer2->Add(child2);
 
  auto embedder = MockViewEmbedder();
  DisplayListBuilder builder({0, 0, 500, 500});
  embedder.AddCanvas(&builder);
 
  PrerollContext* preroll_ctx = preroll_context();
  preroll_ctx->view_embedder = &embedder;
  transform_layer1->Preroll(preroll_ctx);
 
  PaintContext& paint_ctx = paint_context();
  paint_ctx.view_embedder = &embedder;
  transform_layer1->Paint(paint_ctx);
}

◆ TEST_F() [749/925]

flutter::testing::TEST_F	(	RasterCacheTest	,
		RasterCacheKeyIDLayerChildrenIds
	)

Definition at line 750 of file raster_cache_unittests.cc.

                                                          {
  auto layer = std::make_shared<ContainerLayer>();
 
  const SkPath child_path = SkPath().addRect(SkRect::MakeWH(5.0f, 5.0f));
  auto mock_layer = std::make_shared<MockLayer>(child_path);
  layer->Add(mock_layer);
 
  auto display_list = GetSampleDisplayList();
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      SkPoint::Make(0.0f, 0.0f), display_list, false, false);
  layer->Add(display_list_layer);
 
  auto ids = RasterCacheKeyID::LayerChildrenIds(layer.get()).value();
  std::vector<RasterCacheKeyID> expected_ids;
  expected_ids.emplace_back(
      RasterCacheKeyID(mock_layer->unique_id(), RasterCacheKeyType::kLayer));
  expected_ids.emplace_back(RasterCacheKeyID(display_list->unique_id(),
                                             RasterCacheKeyType::kDisplayList));
  ASSERT_EQ(expected_ids[0], mock_layer->caching_key_id());
  ASSERT_EQ(expected_ids[1], display_list_layer->caching_key_id());
  ASSERT_EQ(ids, expected_ids);
}

◆ TEST_F() [750/925]

flutter::testing::TEST_F	(	SemanticsUpdateBuilderTest	,
		CanHandleAttributedStrings
	)

Definition at line 15 of file semantics_update_builder_unittests.cc.

                                                               {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto nativeSemanticsUpdate = [message_latch](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    SemanticsUpdate* update = reinterpret_cast<SemanticsUpdate*>(peer);
    SemanticsNodeUpdates nodes = update->takeNodes();
    ASSERT_EQ(nodes.size(), (size_t)1);
    auto node = nodes.find(0)->second;
    // Should match the updateNode in ui_test.dart.
    ASSERT_EQ(node.label, "label");
    ASSERT_EQ(node.labelAttributes.size(), (size_t)1);
    ASSERT_EQ(node.labelAttributes[0]->start, 1);
    ASSERT_EQ(node.labelAttributes[0]->end, 2);
    ASSERT_EQ(node.labelAttributes[0]->type, StringAttributeType::kSpellOut);
 
    ASSERT_EQ(node.value, "value");
    ASSERT_EQ(node.valueAttributes.size(), (size_t)1);
    ASSERT_EQ(node.valueAttributes[0]->start, 2);
    ASSERT_EQ(node.valueAttributes[0]->end, 3);
    ASSERT_EQ(node.valueAttributes[0]->type, StringAttributeType::kSpellOut);
 
    ASSERT_EQ(node.hint, "hint");
    ASSERT_EQ(node.hintAttributes.size(), (size_t)1);
    ASSERT_EQ(node.hintAttributes[0]->start, 0);
    ASSERT_EQ(node.hintAttributes[0]->end, 1);
    ASSERT_EQ(node.hintAttributes[0]->type, StringAttributeType::kLocale);
    auto local_attribute =
        std::static_pointer_cast<LocaleStringAttribute>(node.hintAttributes[0]);
    ASSERT_EQ(local_attribute->locale, "en-MX");
 
    ASSERT_EQ(node.increasedValue, "increasedValue");
    ASSERT_EQ(node.increasedValueAttributes.size(), (size_t)1);
    ASSERT_EQ(node.increasedValueAttributes[0]->start, 4);
    ASSERT_EQ(node.increasedValueAttributes[0]->end, 5);
    ASSERT_EQ(node.increasedValueAttributes[0]->type,
              StringAttributeType::kSpellOut);
 
    ASSERT_EQ(node.decreasedValue, "decreasedValue");
    ASSERT_EQ(node.decreasedValueAttributes.size(), (size_t)1);
    ASSERT_EQ(node.decreasedValueAttributes[0]->start, 5);
    ASSERT_EQ(node.decreasedValueAttributes[0]->end, 6);
    ASSERT_EQ(node.decreasedValueAttributes[0]->type,
              StringAttributeType::kSpellOut);
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("SemanticsUpdate",
                    CREATE_NATIVE_ENTRY(nativeSemanticsUpdate));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("sendSemanticsUpdate");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [751/925]

flutter::testing::TEST_F	(	ShaderMaskLayerTest	,
		SimpleFilterWithRasterCacheLayerNotCached
	)

Definition at line 420 of file shader_mask_layer_unittests.cc.

                                                                       {
  use_mock_raster_cache();  // Ensure non-fractional alignment.
 
  const SkMatrix initial_transform = SkMatrix::Translate(0.5f, 1.0f);
  const SkRect child_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkRect layer_bounds = SkRect::MakeLTRB(2.0f, 4.0f, 6.5f, 6.5f);
  const SkPath child_path = SkPath().addRect(child_bounds);
  const DlPaint child_paint = DlPaint(DlColor::kYellow());
  auto dl_filter = MakeFilter(DlColor::kBlue());
  auto mock_layer = std::make_shared<MockLayer>(child_path, child_paint);
  auto layer = std::make_shared<ShaderMaskLayer>(dl_filter, layer_bounds,
                                                 DlBlendMode::kSrc);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(initial_transform);
  layer->Preroll(preroll_context());
 
  DlPaint filter_paint;
  filter_paint.setBlendMode(DlBlendMode::kSrc);
  filter_paint.setColorSource(dl_filter);
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (ShaderMask)layer::Paint */ {
    expected_builder.Save();
    {
      // The layer will notice that the CTM is already an integer matrix
      // and will not perform an Integral CTM operation.
      // expected_builder.TransformReset();
      // expected_builder.Transform(SkMatrix());
      expected_builder.SaveLayer(&child_bounds);
      {
        /* mock_layer::Paint */ {
          expected_builder.DrawPath(child_path, child_paint);
        }
        expected_builder.Translate(layer_bounds.fLeft, layer_bounds.fTop);
        expected_builder.DrawRect(
            SkRect::MakeWH(layer_bounds.width(), layer_bounds.height()),
            filter_paint);
      }
      expected_builder.Restore();
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [752/925]

flutter::testing::TEST_F	(	ShellIOManagerTest	,
		ItDoesNotCrashThatSkiaUnrefQueueDrainAfterIOManagerReset
	)

Definition at line 22 of file shell_io_manager_unittests.cc.

                                                                 {
  auto settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(settings);
  auto vm_data = vm_ref.GetVMData();
  auto gif_mapping = flutter::testing::OpenFixtureAsSkData("hello_loop_2.gif");
  ASSERT_TRUE(gif_mapping);
 
  ImageGeneratorRegistry registry;
  std::shared_ptr<ImageGenerator> gif_generator =
      registry.CreateCompatibleGenerator(gif_mapping);
  ASSERT_TRUE(gif_generator);
 
  TaskRunners runners(GetCurrentTestName(),         // label
                      CreateNewThread("platform"),  // platform
                      CreateNewThread("raster"),    // raster
                      CreateNewThread("ui"),        // ui
                      CreateNewThread("io")         // io
  );
 
  std::unique_ptr<TestGLSurface> gl_surface;
  std::unique_ptr<ShellIOManager> io_manager;
  fml::RefPtr<MultiFrameCodec> codec;
 
  // Setup the IO manager.
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    gl_surface = std::make_unique<TestGLSurface>(SkISize::Make(1, 1));
    io_manager = std::make_unique<ShellIOManager>(
        gl_surface->CreateGrContext(), std::make_shared<fml::SyncSwitch>(),
        runners.GetIOTaskRunner(), nullptr,
        fml::TimeDelta::FromMilliseconds(0));
  });
 
  auto isolate = RunDartCodeInIsolate(vm_ref, settings, runners, "emptyMain",
                                      {}, GetDefaultKernelFilePath(),
                                      io_manager->GetWeakIOManager());
 
  PostTaskSync(runners.GetUITaskRunner(), [&]() {
    fml::AutoResetWaitableEvent isolate_latch;
 
    EXPECT_TRUE(isolate->RunInIsolateScope([&]() -> bool {
      Dart_Handle library = Dart_RootLibrary();
      if (Dart_IsError(library)) {
        isolate_latch.Signal();
        return false;
      }
      Dart_Handle closure =
          Dart_GetField(library, Dart_NewStringFromCString("frameCallback"));
      if (Dart_IsError(closure) || !Dart_IsClosure(closure)) {
        isolate_latch.Signal();
        return false;
      }
 
      codec = fml::MakeRefCounted<MultiFrameCodec>(std::move(gif_generator));
      codec->getNextFrame(closure);
      isolate_latch.Signal();
      return true;
    }));
    isolate_latch.Wait();
  });
 
  // Destroy the IO manager
  PostTaskSync(runners.GetIOTaskRunner(), [&]() {
    // 'SkiaUnrefQueue.Drain' will be called after 'io_manager.reset()' in this
    // test, If the resource context has been destroyed at that time, it will
    // crash.
    //
    // 'Drain()' currently checks whether the weak pointer is still valid or not
    // before trying to call anything on it.
    //
    // However, calling 'unref' on the 'SkImage_Lazy' ends up freeing a
    // 'GrBackendTexture'. That object seems to assume that something else is
    // keeping the context alive. This seems like it might be a bad assumption
    // on Skia's part, but in Skia's defense we're doing something pretty weird
    // here by keeping GPU resident objects alive without keeping the
    // 'GrDirectContext' alive ourselves.
    //
    // See https://github.com/flutter/flutter/issues/87895
    io_manager.reset();
    gl_surface.reset();
  });
}

◆ TEST_F() [753/925]

flutter::testing::TEST_F	(	ShellTest	,
		AllowedDartVMFlag
	)

Definition at line 661 of file shell_unittests.cc.

                                     {
  std::vector<const char*> flags = {
      "--enable-isolate-groups",
      "--no-enable-isolate-groups",
  };
#if !FLUTTER_RELEASE
  flags.push_back("--max_profile_depth 1");
  flags.push_back("--random_seed 42");
  flags.push_back("--max_subtype_cache_entries=22");
  if (!DartVM::IsRunningPrecompiledCode()) {
    flags.push_back("--enable_mirrors");
  }
#endif
 
  TestDartVmFlags(flags);
}

◆ TEST_F() [754/925]

flutter::testing::TEST_F	(	ShellTest	,
		AnimatorDoesNotNotifyDelegateIfPipelineIsNotEmpty
	)

Definition at line 209 of file animator_unittests.cc.

                                                                     {
  FakeAnimatorDelegate delegate;
  TaskRunners task_runners = {
      "test",
      CreateNewThread(),  // platform
      CreateNewThread(),  // raster
      CreateNewThread(),  // ui
      CreateNewThread()   // io
  };
 
  auto clock = std::make_shared<ShellTestVsyncClock>();
  std::shared_ptr<Animator> animator;
 
  auto flush_vsync_task = [&] {
    fml::AutoResetWaitableEvent ui_latch;
    task_runners.GetUITaskRunner()->PostTask([&] { ui_latch.Signal(); });
    do {
      clock->SimulateVSync();
    } while (ui_latch.WaitWithTimeout(fml::TimeDelta::FromMilliseconds(1)));
  };
 
  // Create the animator on the UI task runner.
  PostTaskSync(task_runners.GetUITaskRunner(), [&] {
    auto vsync_waiter = static_cast<std::unique_ptr<VsyncWaiter>>(
        std::make_unique<ShellTestVsyncWaiter>(task_runners, clock));
    animator = std::make_unique<Animator>(delegate, task_runners,
                                          std::move(vsync_waiter));
  });
 
  fml::AutoResetWaitableEvent begin_frame_latch;
  // It must always be called when the method 'Animator::Render' is called,
  // regardless of whether the pipeline is empty or not.
  EXPECT_CALL(delegate, OnAnimatorUpdateLatestFrameTargetTime).Times(2);
  // It will only be called once even though we call the method
  // 'Animator::Render' twice. because it will only be called when the pipeline
  // is empty.
  EXPECT_CALL(delegate, OnAnimatorDraw).Times(1);
 
  for (int i = 0; i < 2; i++) {
    task_runners.GetUITaskRunner()->PostTask([&] {
      EXPECT_CALL(delegate, OnAnimatorBeginFrame).WillOnce([&] {
        auto layer_tree =
            std::make_unique<LayerTree>(nullptr, SkISize::Make(600, 800));
        animator->Render(kImplicitViewId, std::move(layer_tree), 1.0);
        begin_frame_latch.Signal();
      });
      animator->RequestFrame();
      task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
    });
    begin_frame_latch.Wait();
  }
 
  PostTaskSync(task_runners.GetUITaskRunner(), [&] { animator.reset(); });
}

◆ TEST_F() [755/925]

flutter::testing::TEST_F	(	ShellTest	,
		AnimatorDoesNotNotifyIdleBeforeRender
	)

Definition at line 119 of file animator_unittests.cc.

                                                         {
  FakeAnimatorDelegate delegate;
  TaskRunners task_runners = {
      "test",
      CreateNewThread(),  // platform
      CreateNewThread(),  // raster
      CreateNewThread(),  // ui
      CreateNewThread()   // io
  };
 
  auto clock = std::make_shared<ShellTestVsyncClock>();
  fml::AutoResetWaitableEvent latch;
  std::shared_ptr<Animator> animator;
 
  auto flush_vsync_task = [&] {
    fml::AutoResetWaitableEvent ui_latch;
    task_runners.GetUITaskRunner()->PostTask([&] { ui_latch.Signal(); });
    do {
      clock->SimulateVSync();
    } while (ui_latch.WaitWithTimeout(fml::TimeDelta::FromMilliseconds(1)));
    latch.Signal();
  };
 
  // Create the animator on the UI task runner.
  task_runners.GetUITaskRunner()->PostTask([&] {
    auto vsync_waiter = static_cast<std::unique_ptr<VsyncWaiter>>(
        std::make_unique<ShellTestVsyncWaiter>(task_runners, clock));
    animator = std::make_unique<Animator>(delegate, task_runners,
                                          std::move(vsync_waiter));
    latch.Signal();
  });
  latch.Wait();
 
  // Validate it has not notified idle and start it. This will request a frame.
  task_runners.GetUITaskRunner()->PostTask([&] {
    ASSERT_FALSE(delegate.notify_idle_called_);
    // Immediately request a frame saying it can reuse the last layer tree to
    // avoid more calls to BeginFrame by the animator.
    animator->RequestFrame(false);
    task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
  });
  latch.Wait();
  ASSERT_FALSE(delegate.notify_idle_called_);
 
  fml::AutoResetWaitableEvent render_latch;
  // Validate it has not notified idle and try to render.
  task_runners.GetUITaskRunner()->PostDelayedTask(
      [&] {
        ASSERT_FALSE(delegate.notify_idle_called_);
        EXPECT_CALL(delegate, OnAnimatorBeginFrame).WillOnce([&] {
          auto layer_tree =
              std::make_unique<LayerTree>(nullptr, SkISize::Make(600, 800));
          animator->Render(kImplicitViewId, std::move(layer_tree), 1.0);
          render_latch.Signal();
        });
        // Request a frame that builds a layer tree and renders a frame.
        // When the frame is rendered, render_latch will be signaled.
        animator->RequestFrame(true);
        task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
      },
      // See kNotifyIdleTaskWaitTime in animator.cc.
      fml::TimeDelta::FromMilliseconds(60));
  latch.Wait();
  render_latch.Wait();
 
  // A frame has been rendered, and the next frame request will notify idle.
  // But at the moment there isn't another frame request, therefore it still
  // hasn't notified idle.
  task_runners.GetUITaskRunner()->PostTask([&] {
    ASSERT_FALSE(delegate.notify_idle_called_);
    // False to avoid getting cals to BeginFrame that will request more frames
    // before we are ready.
    animator->RequestFrame(false);
    task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
  });
  latch.Wait();
 
  // Now it should notify idle. Make sure it is destroyed on the UI thread.
  ASSERT_TRUE(delegate.notify_idle_called_);
 
  task_runners.GetPlatformTaskRunner()->PostTask(flush_vsync_task);
  latch.Wait();
 
  task_runners.GetUITaskRunner()->PostTask([&] {
    animator.reset();
    latch.Signal();
  });
  latch.Wait();
}

◆ TEST_F() [756/925]

flutter::testing::TEST_F	(	ShellTest	,
		AssetManagerMulti
	)

Definition at line 3099 of file shell_unittests.cc.

                                     {
  fml::ScopedTemporaryDirectory asset_dir;
  fml::UniqueFD asset_dir_fd = fml::OpenDirectory(
      asset_dir.path().c_str(), false, fml::FilePermission::kRead);
 
  std::vector<std::string> filenames = {
      "good0",
      "bad0",
      "good1",
      "bad1",
  };
 
  for (const auto& filename : filenames) {
    bool success = fml::WriteAtomically(asset_dir_fd, filename.c_str(),
                                        fml::DataMapping(filename));
    ASSERT_TRUE(success);
  }
 
  AssetManager asset_manager;
  asset_manager.PushBack(
      std::make_unique<DirectoryAssetBundle>(std::move(asset_dir_fd), false));
 
  auto mappings = asset_manager.GetAsMappings("(.*)", std::nullopt);
  EXPECT_EQ(mappings.size(), 4u);
 
  std::vector<std::string> expected_results = {
      "good0",
      "good1",
  };
 
  mappings = asset_manager.GetAsMappings("(.*)good(.*)", std::nullopt);
  ASSERT_EQ(mappings.size(), expected_results.size());
 
  for (auto& mapping : mappings) {
    std::string result(reinterpret_cast<const char*>(mapping->GetMapping()),
                       mapping->GetSize());
    EXPECT_NE(
        std::find(expected_results.begin(), expected_results.end(), result),
        expected_results.end());
  }
}

◆ TEST_F() [757/925]

flutter::testing::TEST_F	(	ShellTest	,
		AssetManagerSingle
	)

Definition at line 3074 of file shell_unittests.cc.

                                      {
  fml::ScopedTemporaryDirectory asset_dir;
  fml::UniqueFD asset_dir_fd = fml::OpenDirectory(
      asset_dir.path().c_str(), false, fml::FilePermission::kRead);
 
  std::string filename = "test_name";
  std::string content = "test_content";
 
  bool success = fml::WriteAtomically(asset_dir_fd, filename.c_str(),
                                      fml::DataMapping(content));
  ASSERT_TRUE(success);
 
  AssetManager asset_manager;
  asset_manager.PushBack(
      std::make_unique<DirectoryAssetBundle>(std::move(asset_dir_fd), false));
 
  auto mapping = asset_manager.GetAsMapping(filename);
  ASSERT_TRUE(mapping != nullptr);
 
  std::string result(reinterpret_cast<const char*>(mapping->GetMapping()),
                     mapping->GetSize());
 
  ASSERT_TRUE(result == content);
}

◆ TEST_F() [758/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCorrectlyPipePointerPacket
	)

Definition at line 315 of file input_events_unittests.cc.

                                                 {
  // Sets up shell with test fixture.
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .simulate_vsync = true,
      }),
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onPointerDataPacketMain");
  // Sets up native handler.
  fml::AutoResetWaitableEvent reportLatch;
  std::vector<int64_t> result_sequence;
  auto nativeOnPointerDataPacket = [&reportLatch, &result_sequence](
                                       Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    result_sequence = tonic::DartConverter<std::vector<int64_t>>::FromArguments(
        args, 0, exception);
    reportLatch.Signal();
  };
  // Starts engine.
  AddNativeCallback("NativeOnPointerDataPacket",
                    CREATE_NATIVE_ENTRY(nativeOnPointerDataPacket));
  ASSERT_TRUE(configuration.IsValid());
  RunEngine(shell.get(), std::move(configuration));
  // Starts test.
  auto packet = std::make_unique<PointerDataPacket>(6);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0.0, 0.0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kHover, 3.0, 0.0);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 3.0, 0.0);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kMove, 3.0, 4.0);
  packet->SetPointerData(3, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 3.0, 4.0);
  packet->SetPointerData(4, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 3.0, 4.0);
  packet->SetPointerData(5, data);
  ShellTest::DispatchPointerData(shell.get(), std::move(packet));
  ShellTest::VSyncFlush(shell.get());
 
  reportLatch.Wait();
  size_t expect_length = 6;
  ASSERT_EQ(result_sequence.size(), expect_length);
  ASSERT_EQ(PointerData::Change(result_sequence[0]), PointerData::Change::kAdd);
  ASSERT_EQ(PointerData::Change(result_sequence[1]),
            PointerData::Change::kHover);
  ASSERT_EQ(PointerData::Change(result_sequence[2]),
            PointerData::Change::kDown);
  ASSERT_EQ(PointerData::Change(result_sequence[3]),
            PointerData::Change::kMove);
  ASSERT_EQ(PointerData::Change(result_sequence[4]), PointerData::Change::kUp);
  ASSERT_EQ(PointerData::Change(result_sequence[5]),
            PointerData::Change::kRemove);
 
  // Cleans up shell.
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [759/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCorrectlySynthesizePointerPacket
	)

Definition at line 380 of file input_events_unittests.cc.

                                                       {
  // Sets up shell with test fixture.
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .simulate_vsync = true,
      }),
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onPointerDataPacketMain");
  // Sets up native handler.
  fml::AutoResetWaitableEvent reportLatch;
  std::vector<int64_t> result_sequence;
  auto nativeOnPointerDataPacket = [&reportLatch, &result_sequence](
                                       Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    result_sequence = tonic::DartConverter<std::vector<int64_t>>::FromArguments(
        args, 0, exception);
    reportLatch.Signal();
  };
  // Starts engine.
  AddNativeCallback("NativeOnPointerDataPacket",
                    CREATE_NATIVE_ENTRY(nativeOnPointerDataPacket));
  ASSERT_TRUE(configuration.IsValid());
  RunEngine(shell.get(), std::move(configuration));
  // Starts test.
  auto packet = std::make_unique<PointerDataPacket>(4);
  PointerData data;
  CreateSimulatedPointerData(data, PointerData::Change::kAdd, 0.0, 0.0);
  packet->SetPointerData(0, data);
  CreateSimulatedPointerData(data, PointerData::Change::kDown, 3.0, 0.0);
  packet->SetPointerData(1, data);
  CreateSimulatedPointerData(data, PointerData::Change::kUp, 3.0, 4.0);
  packet->SetPointerData(2, data);
  CreateSimulatedPointerData(data, PointerData::Change::kRemove, 3.0, 4.0);
  packet->SetPointerData(3, data);
  ShellTest::DispatchPointerData(shell.get(), std::move(packet));
  ShellTest::VSyncFlush(shell.get());
 
  reportLatch.Wait();
  size_t expect_length = 6;
  ASSERT_EQ(result_sequence.size(), expect_length);
  ASSERT_EQ(PointerData::Change(result_sequence[0]), PointerData::Change::kAdd);
  // The pointer data packet converter should synthesize a hover event.
  ASSERT_EQ(PointerData::Change(result_sequence[1]),
            PointerData::Change::kHover);
  ASSERT_EQ(PointerData::Change(result_sequence[2]),
            PointerData::Change::kDown);
  // The pointer data packet converter should synthesize a move event.
  ASSERT_EQ(PointerData::Change(result_sequence[3]),
            PointerData::Change::kMove);
  ASSERT_EQ(PointerData::Change(result_sequence[4]), PointerData::Change::kUp);
  ASSERT_EQ(PointerData::Change(result_sequence[5]),
            PointerData::Change::kRemove);
 
  // Cleans up shell.
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [760/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCreateImagefromDecompressedBytes
	)

Definition at line 1931 of file shell_unittests.cc.

                                                       {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
 
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("canCreateImageFromDecompressedData");
 
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("NotifyWidthHeight",
                    CREATE_NATIVE_ENTRY([&latch](auto args) {
                      auto width = tonic::DartConverter<int>::FromDart(
                          Dart_GetNativeArgument(args, 0));
                      auto height = tonic::DartConverter<int>::FromDart(
                          Dart_GetNativeArgument(args, 1));
                      ASSERT_EQ(width, 10);
                      ASSERT_EQ(height, 10);
                      latch.Signal();
                    }));
 
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [761/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCreateShellsWithGLBackend
	)

Definition at line 3728 of file shell_unittests.cc.

                                                {
#if !SHELL_ENABLE_GL
  // GL emulation does not exist on Fuchsia.
  GTEST_SKIP();
#else
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .rendering_backend = ShellTestPlatformView::BackendType::kGLBackend,
      }),
  });
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  PlatformViewNotifyCreated(shell.get());
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // !SHELL_ENABLE_GL
}

◆ TEST_F() [762/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCreateShellsWithMetalBackend
	)

Definition at line 3776 of file shell_unittests.cc.

                                                   {
#if !SHELL_ENABLE_METAL
  GTEST_SKIP();
#else
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .rendering_backend =
              ShellTestPlatformView::BackendType::kMetalBackend,
      }),
  });
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  PlatformViewNotifyCreated(shell.get());
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // !SHELL_ENABLE_METAL
}

◆ TEST_F() [763/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanCreateShellsWithVulkanBackend
	)

Definition at line 3752 of file shell_unittests.cc.

                                                    {
#if !SHELL_ENABLE_VULKAN
  GTEST_SKIP();
#else
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .rendering_backend =
              ShellTestPlatformView::BackendType::kVulkanBackend,
      }),
  });
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  PlatformViewNotifyCreated(shell.get());
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // !SHELL_ENABLE_VULKAN
}

◆ TEST_F() [764/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanRegisterImageDecoders
	)

Definition at line 2316 of file shell_unittests.cc.

                                            {
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("NotifyWidthHeight", CREATE_NATIVE_ENTRY([&](auto args) {
                      auto width = tonic::DartConverter<int>::FromDart(
                          Dart_GetNativeArgument(args, 0));
                      auto height = tonic::DartConverter<int>::FromDart(
                          Dart_GetNativeArgument(args, 1));
                      ASSERT_EQ(width, 1);
                      ASSERT_EQ(height, 1);
                      latch.Signal();
                    }));
 
  auto settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("canRegisterImageDecoders");
  std::unique_ptr<Shell> shell = CreateShell(settings);
  ASSERT_NE(shell.get(), nullptr);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
        shell->RegisterImageDecoder(
            [](const sk_sp<SkData>& buffer) {
              return std::make_unique<SinglePixelImageGenerator>();
            },
            100);
      });
 
  RunEngine(shell.get(), std::move(configuration));
  latch.Wait();
  DestroyShell(std::move(shell));
}

◆ TEST_F() [765/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanRemoveViewBeforeLaunchingIsolate
	)

Definition at line 4739 of file shell_unittests.cc.

                                                       {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    auto platform_view = shell->GetPlatformView();
 
    // A view can be added and removed all before the isolate launches.
    // The pending add view operation is cancelled, the view is never
    // added to the Dart isolate.
    shell->GetPlatformView()->AddView(123, ViewportMetrics{1, 30, 1, 0, 0},
                                      [](bool added) { ASSERT_FALSE(added); });
    shell->GetPlatformView()->RemoveView(
        123, [](bool removed) { ASSERT_FALSE(removed); });
  });
 
  bool first_report = true;
  std::map<int64_t, int64_t> view_widths;
  fml::AutoResetWaitableEvent report_latch;
  AddNativeCallback("NativeReportViewWidthsCallback",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      EXPECT_TRUE(first_report);
                      first_report = false;
                      ParseViewWidthsCallback(args, &view_widths);
                      report_latch.Signal();
                    }));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewWidths");
  RunEngine(shell.get(), std::move(configuration));
 
  report_latch.Wait();
  EXPECT_EQ(view_widths.size(), 1u);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [766/925]

flutter::testing::TEST_F	(	ShellTest	,
		CanScheduleFrameFromPlatform
	)

Definition at line 2076 of file shell_unittests.cc.

                                                {
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners = GetTaskRunnersForFixture();
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback(
      "NotifyNative",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
  fml::AutoResetWaitableEvent check_latch;
  AddNativeCallback("NativeOnBeginFrame",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      check_latch.Signal();
                    }));
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell->IsSetup());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onBeginFrameWithNotifyNativeMain");
  RunEngine(shell.get(), std::move(configuration));
 
  // Wait for the application to attach the listener.
  latch.Wait();
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [&shell]() { shell->GetPlatformView()->ScheduleFrame(); });
  check_latch.Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [767/925]

flutter::testing::TEST_F	(	ShellTest	,
		ConvertPaintToDlPaint
	)

Definition at line 14 of file paint_unittests.cc.

                                         {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  DlPaint dl_paint;
 
  auto nativeToDlPaint = [message_latch, &dl_paint](Dart_NativeArguments args) {
    Dart_Handle dart_paint = Dart_GetNativeArgument(args, 0);
    Dart_Handle paint_objects =
        Dart_GetField(dart_paint, tonic::ToDart("_objects"));
    Dart_Handle paint_data = Dart_GetField(dart_paint, tonic::ToDart("_data"));
    Paint ui_paint(paint_objects, paint_data);
    ui_paint.toDlPaint(dl_paint);
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ConvertPaintToDlPaint",
                    CREATE_NATIVE_ENTRY(nativeToDlPaint));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("convertPaintToDlPaint");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
 
  ASSERT_EQ(dl_paint.getBlendMode(), DlBlendMode::kModulate);
  ASSERT_EQ(static_cast<uint32_t>(dl_paint.getColor().argb()), 0x11223344u);
  ASSERT_EQ(*dl_paint.getColorFilter(),
            DlBlendColorFilter(DlColor(0x55667788), DlBlendMode::kXor));
  ASSERT_EQ(*dl_paint.getMaskFilter(),
            DlBlurMaskFilter(DlBlurStyle::kInner, 0.75));
  ASSERT_EQ(dl_paint.getDrawStyle(), DlDrawStyle::kStroke);
}

◆ TEST_F() [768/925]

flutter::testing::TEST_F	(	ShellTest	,
		CreateCompatibleReturnsBuiltinImageGeneratorForValidImage
	)

Definition at line 34 of file image_generator_registry_unittests.cc.

                                                                             {
  auto data = LoadValidImageFixture();
 
  // Fetch the generator and query for basic info
  ImageGeneratorRegistry registry;
  auto result = registry.CreateCompatibleGenerator(data);
  auto info = result->GetInfo();
  ASSERT_EQ(info.width(), 3024);
  ASSERT_EQ(info.height(), 4032);
}

◆ TEST_F() [769/925]

flutter::testing::TEST_F	(	ShellTest	,
		CreateCompatibleReturnsNullptrForInvalidImage
	)

Definition at line 45 of file image_generator_registry_unittests.cc.

                                                                 {
  ImageGeneratorRegistry registry;
  auto result = registry.CreateCompatibleGenerator(SkData::MakeEmpty());
  ASSERT_EQ(result, nullptr);
}

◆ TEST_F() [770/925]

flutter::testing::TEST_F	(	ShellTest	,
		DefaultGeneratorsTakePrecedentOverNegativePriority
	)

Definition at line 100 of file image_generator_registry_unittests.cc.

                                                                      {
  ImageGeneratorRegistry registry;
 
  registry.AddFactory(
      [](const sk_sp<SkData>& buffer) {
        return std::make_unique<FakeImageGenerator>(1337);
      },
      -1);
 
  // Fetch the generator and query for basic info.
  auto result = registry.CreateCompatibleGenerator(LoadValidImageFixture());
  // If the real width of the image pops out, then the default generator was
  // returned rather than the fake one.
  ASSERT_EQ(result->GetInfo().width(), 3024);
}

◆ TEST_F() [771/925]

flutter::testing::TEST_F	(	ShellTest	,
		DefaultGeneratorsTakePrecedentOverZeroPriority
	)

Definition at line 116 of file image_generator_registry_unittests.cc.

                                                                  {
  ImageGeneratorRegistry registry;
 
  registry.AddFactory(
      [](const sk_sp<SkData>& buffer) {
        return std::make_unique<FakeImageGenerator>(1337);
      },
      0);
 
  // Fetch the generator and query for basic info.
  auto result = registry.CreateCompatibleGenerator(LoadValidImageFixture());
  // If the real width of the image pops out, then the default generator was
  // returned rather than the fake one.
  ASSERT_EQ(result->GetInfo().width(), 3024);
}

◆ TEST_F() [772/925]

flutter::testing::TEST_F	(	ShellTest	,
		DelayAtMostOneEventForFasterThanVSyncInputEvents
	)

Definition at line 220 of file input_events_unittests.cc.

                                                                    {
  // We don't use `constexpr int frame_time` here because MSVC doesn't handle
  // it well with lambda capture.
  UnitlessTime frame_time = 10;
  UnitlessTime base_latency = 0.2 * frame_time;
  Generator double_sampling = [frame_time, base_latency](int i) {
    return static_cast<UnitlessTime>(i * 0.5 * frame_time + base_latency);
  };
  constexpr int n = 40;
  std::vector<int> events_consumed_at_frame;
  TestSimulatedInputEvents(this, n, base_latency, double_sampling, frame_time,
                           events_consumed_at_frame);
 
  // Draw one extra frame due to delaying a pending packet for the next frame.
  int frame_drawn = events_consumed_at_frame.size();
  ASSERT_EQ(frame_drawn, n / 2 + 1);
 
  for (int i = 0; i < n / 2; i += 1) {
    ASSERT_GE(events_consumed_at_frame[i], 2 * i - 1);
  }
}

◆ TEST_F() [773/925]

flutter::testing::TEST_F	(	ShellTest	,
		DeterministicRenderingDisablesPathVolatility
	)

Definition at line 131 of file path_unittests.cc.

                                                                {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto native_validate_path = [message_latch](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    EXPECT_FALSE(Dart_IsError(result));
    CanvasPath* path = reinterpret_cast<CanvasPath*>(peer);
    EXPECT_TRUE(path);
    EXPECT_FALSE(path->path().isVolatile());
    std::shared_ptr<VolatilePathTracker> tracker =
        UIDartState::Current()->GetVolatilePathTracker();
    EXPECT_TRUE(tracker);
    EXPECT_FALSE(tracker->enabled());
 
    for (int i = 0; i < VolatilePathTracker::kFramesOfVolatility; i++) {
      tracker->OnFrame();
      EXPECT_FALSE(path->path().isVolatile());
    }
    EXPECT_FALSE(path->path().isVolatile());
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  settings.skia_deterministic_rendering_on_cpu = true;
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidatePath", CREATE_NATIVE_ENTRY(native_validate_path));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("createPath");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [774/925]

flutter::testing::TEST_F	(	ShellTest	,
		DiesIfSoftwareRenderingAndImpellerAreEnabledDeathTest
	)

Definition at line 4415 of file shell_unittests.cc.

                                                                         {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "Fuchsia";
#else
  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
  Settings settings = CreateSettingsForFixture();
  settings.enable_impeller = true;
  settings.enable_software_rendering = true;
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  auto task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  EXPECT_DEATH_IF_SUPPORTED(
      CreateShell(settings, task_runners),
      "Software rendering is incompatible with Impeller.");
#endif  // OS_FUCHSIA
}

◆ TEST_F() [775/925]

flutter::testing::TEST_F	(	ShellTest	,
		DISABLED_DiscardLayerTreeOnResize
	)

Definition at line 2725 of file shell_unittests.cc.

                                                     {
  auto settings = CreateSettingsForFixture();
 
  SkISize wrong_size = SkISize::Make(400, 100);
  SkISize expected_size = SkISize::Make(400, 200);
 
  fml::AutoResetWaitableEvent end_frame_latch;
  auto end_frame_callback =
      [&](bool should_merge_thread,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        end_frame_latch.Signal();
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      std::move(end_frame_callback), PostPrerollResult::kSuccess, false);
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [&shell, &expected_size]() {
        shell->GetPlatformView()->SetViewportMetrics(
            kImplicitViewId,
            {1.0, static_cast<double>(expected_size.width()),
             static_cast<double>(expected_size.height()), 22, 0});
      });
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  PumpOneFrame(shell.get(), ViewContent::DummyView(
                                static_cast<double>(wrong_size.width()),
                                static_cast<double>(wrong_size.height())));
  end_frame_latch.Wait();
  // Wrong size, no frames are submitted.
  ASSERT_EQ(0, external_view_embedder->GetSubmittedFrameCount());
 
  PumpOneFrame(shell.get(), ViewContent::DummyView(
                                static_cast<double>(expected_size.width()),
                                static_cast<double>(expected_size.height())));
  end_frame_latch.Wait();
  // Expected size, 1 frame submitted.
  ASSERT_EQ(1, external_view_embedder->GetSubmittedFrameCount());
  ASSERT_EQ(expected_size, external_view_embedder->GetLastSubmittedFrameSize());
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [776/925]

flutter::testing::TEST_F	(	ShellTest	,
		DISABLED_DiscardResubmittedLayerTreeOnResize
	)

Definition at line 2786 of file shell_unittests.cc.

                                                                {
  auto settings = CreateSettingsForFixture();
 
  SkISize origin_size = SkISize::Make(400, 100);
  SkISize new_size = SkISize::Make(400, 200);
 
  fml::AutoResetWaitableEvent end_frame_latch;
 
  fml::AutoResetWaitableEvent resize_latch;
 
  std::shared_ptr<ShellTestExternalViewEmbedder> external_view_embedder;
  fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger_ref;
  auto end_frame_callback =
      [&](bool should_merge_thread,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        if (!raster_thread_merger_ref) {
          raster_thread_merger_ref = raster_thread_merger;
        }
        if (should_merge_thread) {
          raster_thread_merger->MergeWithLease(10);
          external_view_embedder->UpdatePostPrerollResult(
              PostPrerollResult::kSuccess);
        }
        end_frame_latch.Signal();
 
        if (should_merge_thread) {
          resize_latch.Wait();
        }
      };
 
  external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      std::move(end_frame_callback), PostPrerollResult::kResubmitFrame, true);
 
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [&shell, &origin_size]() {
        shell->GetPlatformView()->SetViewportMetrics(
            kImplicitViewId,
            {1.0, static_cast<double>(origin_size.width()),
             static_cast<double>(origin_size.height()), 22, 0});
      });
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  PumpOneFrame(shell.get(), ViewContent::DummyView(
                                static_cast<double>(origin_size.width()),
                                static_cast<double>(origin_size.height())));
 
  end_frame_latch.Wait();
  ASSERT_EQ(0, external_view_embedder->GetSubmittedFrameCount());
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [&shell, &new_size, &resize_latch]() {
        shell->GetPlatformView()->SetViewportMetrics(
            kImplicitViewId, {1.0, static_cast<double>(new_size.width()),
                              static_cast<double>(new_size.height()), 22, 0});
        resize_latch.Signal();
      });
 
  end_frame_latch.Wait();
 
  // The frame resubmitted with origin size should be discarded after the
  // viewport metrics changed.
  ASSERT_EQ(0, external_view_embedder->GetSubmittedFrameCount());
 
  // Threads will be merged at the end of this frame.
  PumpOneFrame(shell.get(),
               ViewContent::DummyView(static_cast<double>(new_size.width()),
                                      static_cast<double>(new_size.height())));
 
  end_frame_latch.Wait();
  ASSERT_TRUE(raster_thread_merger_ref->IsMerged());
  ASSERT_EQ(1, external_view_embedder->GetSubmittedFrameCount());
  ASSERT_EQ(new_size, external_view_embedder->GetLastSubmittedFrameSize());
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [777/925]

flutter::testing::TEST_F	(	ShellTest	,
		DISABLED_SkipAndSubmitFrame
	)

Definition at line 1450 of file shell_unittests.cc.

                                               {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  std::shared_ptr<ShellTestExternalViewEmbedder> external_view_embedder;
 
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        if (should_resubmit_frame && !raster_thread_merger->IsMerged()) {
          raster_thread_merger->MergeWithLease(10);
          external_view_embedder->UpdatePostPrerollResult(
              PostPrerollResult::kSuccess);
        }
        end_frame_latch.Signal();
      };
  external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSkipAndRetryFrame, true);
 
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
 
  ASSERT_EQ(0, external_view_embedder->GetSubmittedFrameCount());
 
  PumpOneFrame(shell.get());
 
  // `EndFrame` changed the post preroll result to `kSuccess`.
  end_frame_latch.Wait();
 
  // Let the resubmitted frame to run and `GetSubmittedFrameCount` should be
  // called.
  end_frame_latch.Wait();
  // 2 frames are submitted because `kSkipAndRetryFrame`, but only the 2nd frame
  // should be submitted with `external_view_embedder`, hence the below check.
  ASSERT_EQ(1, external_view_embedder->GetSubmittedFrameCount());
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [778/925]

flutter::testing::TEST_F	(	ShellTest	,
		DisallowedDartVMFlag
	)

Definition at line 642 of file shell_unittests.cc.

                                        {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "This test flakes on Fuchsia. https://fxbug.dev/110006 ";
#else
 
  // Run this test in a thread-safe manner, otherwise gtest will complain.
  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
  const std::vector<fml::CommandLine::Option> options = {
      fml::CommandLine::Option("dart-flags", "--verify_after_gc")};
  fml::CommandLine command_line("", options, std::vector<std::string>());
 
  // Upon encountering a disallowed Dart flag the process terminates.
  const char* expected =
      "Encountered disallowed Dart VM flag: --verify_after_gc";
  ASSERT_DEATH(flutter::SettingsFromCommandLine(command_line), expected);
#endif  // OS_FUCHSIA
}

◆ TEST_F() [779/925]

flutter::testing::TEST_F	(	ShellTest	,
		EncodeImageAccessesSyncSwitch
	)

Definition at line 130 of file image_encoding_unittests.cc.

                                                 {
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  auto native_encode_image = [&](Dart_NativeArguments args) {
    auto image_handle = Dart_GetNativeArgument(args, 0);
    image_handle =
        Dart_GetField(image_handle, Dart_NewStringFromCString("_image"));
    ASSERT_FALSE(Dart_IsError(image_handle)) << Dart_GetError(image_handle);
    ASSERT_FALSE(Dart_IsNull(image_handle));
    auto format_handle = Dart_GetNativeArgument(args, 1);
 
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        image_handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    CanvasImage* canvas_image = reinterpret_cast<CanvasImage*>(peer);
 
    int64_t format = -1;
    result = Dart_IntegerToInt64(format_handle, &format);
    ASSERT_FALSE(Dart_IsError(result));
 
    auto io_manager = UIDartState::Current()->GetIOManager();
    fml::AutoResetWaitableEvent latch;
 
    task_runners.GetIOTaskRunner()->PostTask([&]() {
      auto is_gpu_disabled_sync_switch =
          std::make_shared<const MockSyncSwitch>();
      EXPECT_CALL(*is_gpu_disabled_sync_switch, Execute)
          .WillOnce([](const MockSyncSwitch::Handlers& handlers) {
            handlers.true_handler();
          });
      ConvertToRasterUsingResourceContext(canvas_image->image()->skia_image(),
                                          io_manager->GetResourceContext(),
                                          is_gpu_disabled_sync_switch);
      latch.Signal();
    });
 
    latch.Wait();
 
    message_latch.Signal();
  };
 
  AddNativeCallback("EncodeImage", CREATE_NATIVE_ENTRY(native_encode_image));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("encodeImageProducesExternalUint8List");
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch.Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [780/925]

flutter::testing::TEST_F	(	ShellTest	,
		EncodeImageGivesExternalTypedData
	)

Definition at line 71 of file image_encoding_unittests.cc.

                                                     {
  auto native_encode_image = [&](Dart_NativeArguments args) {
    auto image_handle = Dart_GetNativeArgument(args, 0);
    image_handle =
        Dart_GetField(image_handle, Dart_NewStringFromCString("_image"));
    ASSERT_FALSE(Dart_IsError(image_handle)) << Dart_GetError(image_handle);
    ASSERT_FALSE(Dart_IsNull(image_handle));
    auto format_handle = Dart_GetNativeArgument(args, 1);
    auto callback_handle = Dart_GetNativeArgument(args, 2);
 
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        image_handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    CanvasImage* canvas_image = reinterpret_cast<CanvasImage*>(peer);
 
    int64_t format = -1;
    result = Dart_IntegerToInt64(format_handle, &format);
    ASSERT_FALSE(Dart_IsError(result));
 
    result = EncodeImage(canvas_image, format, callback_handle);
    ASSERT_TRUE(Dart_IsNull(result));
  };
 
  auto nativeValidateExternal = [&](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
 
    auto typed_data_type = Dart_GetTypeOfExternalTypedData(handle);
    EXPECT_EQ(typed_data_type, Dart_TypedData_kUint8);
 
    message_latch.Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("EncodeImage", CREATE_NATIVE_ENTRY(native_encode_image));
  AddNativeCallback("ValidateExternal",
                    CREATE_NATIVE_ENTRY(nativeValidateExternal));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("encodeImageProducesExternalUint8List");
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch.Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [781/925]

flutter::testing::TEST_F	(	ShellTest	,
		EngineLayerDisposeReleasesReference
	)

Definition at line 99 of file scene_builder_unittests.cc.

                                                       {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  std::shared_ptr<ContainerLayer> root_layer;
 
  auto capture_root_layer = [&root_layer](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    SceneBuilder* scene_builder = reinterpret_cast<SceneBuilder*>(peer);
    ASSERT_TRUE(scene_builder);
    root_layer = scene_builder->layer_stack()[0];
    ASSERT_TRUE(root_layer);
  };
 
  auto validate_layer_tree_counts = [&root_layer](Dart_NativeArguments args) {
    // One for the EngineLayer, one for our pointer in the test.
    EXPECT_EQ(root_layer->layers().front().use_count(), 2);
  };
 
  auto validate_engine_layer_dispose =
      [message_latch, &root_layer](Dart_NativeArguments args) {
        // Just one for our pointer now.
        EXPECT_EQ(root_layer->layers().front().use_count(), 1);
        root_layer.reset();
        message_latch->Signal();
      };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("CaptureRootLayer",
                    CREATE_NATIVE_ENTRY(capture_root_layer));
  AddNativeCallback("ValidateLayerTreeCounts",
                    CREATE_NATIVE_ENTRY(validate_layer_tree_counts));
  AddNativeCallback("ValidateEngineLayerDispose",
                    CREATE_NATIVE_ENTRY(validate_engine_layer_dispose));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("validateEngineLayerDispose");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [782/925]

flutter::testing::TEST_F	(	ShellTest	,
		EngineRootIsolateLaunchesDontTakeVMDataSettings
	)

Definition at line 3051 of file shell_unittests.cc.

                                                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  // Make sure the shell launch does not kick off the creation of the VM
  // instance by already creating one upfront.
  auto vm_settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(vm_settings);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
 
  auto settings = vm_settings;
  fml::AutoResetWaitableEvent isolate_create_latch;
  settings.root_isolate_create_callback = [&](const auto& isolate) {
    isolate_create_latch.Signal();
  };
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  RunEngine(shell.get(), std::move(configuration));
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  isolate_create_latch.Wait();
}

◆ TEST_F() [783/925]

flutter::testing::TEST_F	(	ShellTest	,
		ExternalEmbedderEndFrameIsCalledWhenPostPrerollResultIsResubmit
	)

Definition at line 994 of file shell_unittests.cc.

                                                                        {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  bool end_frame_called = false;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        ASSERT_TRUE(raster_thread_merger.get() != nullptr);
        ASSERT_TRUE(should_resubmit_frame);
        end_frame_called = true;
        end_frame_latch.Signal();
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kResubmitFrame, true);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
 
  ASSERT_TRUE(end_frame_called);
 
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [784/925]

flutter::testing::TEST_F	(	ShellTest	,
		ExternalEmbedderNoThreadMerger
	)

Definition at line 865 of file shell_unittests.cc.

                                                  {
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  bool end_frame_called = false;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        ASSERT_TRUE(raster_thread_merger.get() == nullptr);
        ASSERT_FALSE(should_resubmit_frame);
        end_frame_called = true;
        end_frame_latch.Signal();
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kResubmitFrame, false);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
  ASSERT_TRUE(end_frame_called);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [785/925]

flutter::testing::TEST_F	(	ShellTest	,
		FixturesAreFunctional
	)

Definition at line 536 of file shell_unittests.cc.

                                         {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("fixturesAreFunctionalMain");
 
  fml::AutoResetWaitableEvent main_latch;
  AddNativeCallback(
      "SayHiFromFixturesAreFunctionalMain",
      CREATE_NATIVE_ENTRY([&main_latch](auto args) { main_latch.Signal(); }));
 
  RunEngine(shell.get(), std::move(configuration));
  main_latch.Wait();
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [786/925]

flutter::testing::TEST_F	(	ShellTest	,
		FrameRasterizedCallbackIsCalled
	)

Definition at line 803 of file shell_unittests.cc.

                                                   {
  auto settings = CreateSettingsForFixture();
 
  FrameTiming timing;
  fml::AutoResetWaitableEvent timingLatch;
  settings.frame_rasterized_callback = [&timing,
                                        &timingLatch](const FrameTiming& t) {
    timing = t;
    timingLatch.Signal();
  };
 
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Wait to make |start| bigger than zero
  using namespace std::chrono_literals;
  std::this_thread::sleep_for(1ms);
 
  // We MUST put |start| after |CreateShell()| because the clock source will be
  // reset through |TimePoint::SetClockSource()| in
  // |DartVMInitializer::Initialize()| within |CreateShell()|.
  fml::TimePoint start = fml::TimePoint::Now();
 
  for (auto phase : FrameTiming::kPhases) {
    timing.Set(phase, fml::TimePoint());
    // Check that the time points are initially smaller than start, so
    // CheckFrameTimings will fail if they're not properly set later.
    ASSERT_TRUE(timing.Get(phase) < start);
  }
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onBeginFrameMain");
 
  int64_t frame_target_time;
  auto nativeOnBeginFrame = [&frame_target_time](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    frame_target_time =
        tonic::DartConverter<int64_t>::FromArguments(args, 0, exception);
  };
  AddNativeCallback("NativeOnBeginFrame",
                    CREATE_NATIVE_ENTRY(nativeOnBeginFrame));
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  // Check that timing is properly set. This implies that
  // settings.frame_rasterized_callback is called.
  timingLatch.Wait();
  fml::TimePoint finish = fml::TimePoint::Now();
  std::vector<FrameTiming> timings = {timing};
  CheckFrameTimings(timings, start, finish);
 
  // Check that onBeginFrame, which is the frame_target_time, is after
  // FrameTiming's build start
  int64_t build_start =
      timing.Get(FrameTiming::kBuildStart).ToEpochDelta().ToMicroseconds();
  ASSERT_GT(frame_target_time, build_start);
  DestroyShell(std::move(shell));
}

◆ TEST_F() [787/925]

flutter::testing::TEST_F	(	ShellTest	,
		GetUsedThisFrameShouldBeSetBeforeEndFrame
	)

Definition at line 1404 of file shell_unittests.cc.

                                                             {
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  std::shared_ptr<ShellTestExternalViewEmbedder> external_view_embedder;
  bool used_this_frame = true;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        // We expect `used_this_frame` to be false.
        used_this_frame = external_view_embedder->GetUsedThisFrame();
        end_frame_latch.Signal();
      };
  external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
  ASSERT_FALSE(used_this_frame);
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [788/925]

flutter::testing::TEST_F	(	ShellTest	,
		HandlesActualIphoneXsInputEvents
	)

Definition at line 242 of file input_events_unittests.cc.

                                                    {
  // Actual delivery times measured on iPhone Xs, in the unit of frame_time
  // (16.67ms for 60Hz).
  static constexpr double iphone_xs_times[] = {0.15,
                                               1.0773046874999999,
                                               2.1738720703124996,
                                               3.0579052734374996,
                                               4.0890087890624995,
                                               5.0952685546875,
                                               6.1251708984375,
                                               7.1253076171875,
                                               8.125927734374999,
                                               9.37248046875,
                                               10.133950195312499,
                                               11.161201171875,
                                               12.226992187499999,
                                               13.1443798828125,
                                               14.440327148437499,
                                               15.091684570312498,
                                               16.138681640625,
                                               17.126469726562497,
                                               18.1592431640625,
                                               19.371372070312496,
                                               20.033774414062496,
                                               21.021782226562497,
                                               22.070053710937497,
                                               23.325541992187496,
                                               24.119648437499997,
                                               25.084262695312496,
                                               26.077866210937497,
                                               27.036547851562496,
                                               28.035073242187497,
                                               29.081411132812498,
                                               30.066064453124998,
                                               31.089360351562497,
                                               32.086142578125,
                                               33.4618798828125,
                                               34.14697265624999,
                                               35.0513525390625,
                                               36.136025390624994,
                                               37.1618408203125,
                                               38.144472656249995,
                                               39.201123046875,
                                               40.4339501953125,
                                               41.1552099609375,
                                               42.102128906249995,
                                               43.0426318359375,
                                               44.070131835937495,
                                               45.08862304687499,
                                               46.091469726562494};
  constexpr int n = sizeof(iphone_xs_times) / sizeof(iphone_xs_times[0]);
  // We don't use `constexpr int frame_time` here because MSVC doesn't handle
  // it well with lambda capture.
  UnitlessTime frame_time = 10000;
  double base_latency_f = 0.0;
  for (int i = 0; i < 10; i++) {
    base_latency_f += 0.1;
    // Everything is converted to int to avoid floating point error in
    // TestSimulatedInputEvents.
    UnitlessTime base_latency =
        static_cast<UnitlessTime>(base_latency_f * frame_time);
    Generator iphone_xs_generator = [frame_time, base_latency](int i) {
      return base_latency +
             static_cast<UnitlessTime>(iphone_xs_times[i] * frame_time);
    };
    std::vector<int> events_consumed_at_frame;
    TestSimulatedInputEvents(this, n, base_latency, iphone_xs_generator,
                             frame_time, events_consumed_at_frame);
    int frame_drawn = events_consumed_at_frame.size();
    ASSERT_GE(frame_drawn, n - 1);
  }
}

◆ TEST_F() [789/925]

flutter::testing::TEST_F	(	ShellTest	,
		IgnoresBadAddViewsBeforeLaunchingIsolate
	)

Definition at line 4790 of file shell_unittests.cc.

                                                            {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    auto platform_view = shell->GetPlatformView();
 
    // Add the same view twice. The second time should fail.
    shell->GetPlatformView()->AddView(123, ViewportMetrics{1, 100, 1, 0, 0},
                                      [](bool added) { ASSERT_TRUE(added); });
 
    shell->GetPlatformView()->AddView(123, ViewportMetrics{1, 200, 1, 0, 0},
                                      [](bool added) { ASSERT_FALSE(added); });
 
    // Add another view. Previous failures should not affect this.
    shell->GetPlatformView()->AddView(456, ViewportMetrics{1, 300, 1, 0, 0},
                                      [](bool added) { ASSERT_TRUE(added); });
  });
 
  bool first_report = true;
  std::map<int64_t, int64_t> view_widths;
  fml::AutoResetWaitableEvent report_latch;
  AddNativeCallback("NativeReportViewWidthsCallback",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      EXPECT_TRUE(first_report);
                      first_report = false;
                      ParseViewWidthsCallback(args, &view_widths);
                      report_latch.Signal();
                    }));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewWidths");
  RunEngine(shell.get(), std::move(configuration));
 
  report_latch.Wait();
  EXPECT_EQ(view_widths.size(), 3u);
  EXPECT_EQ(view_widths[0], 0);
  EXPECT_EQ(view_widths[123], 100);
  EXPECT_EQ(view_widths[456], 300);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [790/925]

flutter::testing::TEST_F	(	ShellTest	,
		IgnoresInvalidMetrics
	)

Definition at line 2879 of file shell_unittests.cc.

                                         {
  fml::AutoResetWaitableEvent latch;
  double last_device_pixel_ratio;
  double last_width;
  double last_height;
  auto native_report_device_pixel_ratio = [&](Dart_NativeArguments args) {
    auto dpr_handle = Dart_GetNativeArgument(args, 0);
    ASSERT_TRUE(Dart_IsDouble(dpr_handle));
    Dart_DoubleValue(dpr_handle, &last_device_pixel_ratio);
    ASSERT_FALSE(last_device_pixel_ratio == 0.0);
 
    auto width_handle = Dart_GetNativeArgument(args, 1);
    ASSERT_TRUE(Dart_IsDouble(width_handle));
    Dart_DoubleValue(width_handle, &last_width);
    ASSERT_FALSE(last_width == 0.0);
 
    auto height_handle = Dart_GetNativeArgument(args, 2);
    ASSERT_TRUE(Dart_IsDouble(height_handle));
    Dart_DoubleValue(height_handle, &last_height);
    ASSERT_FALSE(last_height == 0.0);
 
    latch.Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
 
  AddNativeCallback("ReportMetrics",
                    CREATE_NATIVE_ENTRY(native_report_device_pixel_ratio));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("reportMetrics");
 
  RunEngine(shell.get(), std::move(configuration));
 
  task_runner->PostTask([&]() {
    // This one is invalid for having 0 pixel ratio.
    shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                 {0.0, 400, 200, 22, 0});
    task_runner->PostTask([&]() {
      // This one is invalid for having 0 width.
      shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                   {0.8, 0.0, 200, 22, 0});
      task_runner->PostTask([&]() {
        // This one is invalid for having 0 height.
        shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                     {0.8, 400, 0.0, 22, 0});
        task_runner->PostTask([&]() {
          // This one makes it through.
          shell->GetPlatformView()->SetViewportMetrics(
              kImplicitViewId, {0.8, 400, 200.0, 22, 0});
        });
      });
    });
  });
  latch.Wait();
  ASSERT_EQ(last_device_pixel_ratio, 0.8);
  ASSERT_EQ(last_width, 400.0);
  ASSERT_EQ(last_height, 200.0);
  latch.Reset();
 
  task_runner->PostTask([&]() {
    shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                 {1.2, 600, 300, 22, 0});
  });
  latch.Wait();
  ASSERT_EQ(last_device_pixel_ratio, 1.2);
  ASSERT_EQ(last_width, 600.0);
  ASSERT_EQ(last_height, 300.0);
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [791/925]

flutter::testing::TEST_F	(	ShellTest	,
		IgnoresMetricsUpdateToInvalidView
	)

Definition at line 2956 of file shell_unittests.cc.

                                                     {
  fml::AutoResetWaitableEvent latch;
  double last_device_pixel_ratio;
  // This callback will be called whenever any view's metrics change.
  auto native_report_device_pixel_ratio = [&](Dart_NativeArguments args) {
    // The correct call will have a DPR of 3.
    auto dpr_handle = Dart_GetNativeArgument(args, 0);
    ASSERT_TRUE(Dart_IsDouble(dpr_handle));
    Dart_DoubleValue(dpr_handle, &last_device_pixel_ratio);
    ASSERT_TRUE(last_device_pixel_ratio > 2.5);
 
    latch.Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
 
  AddNativeCallback("ReportMetrics",
                    CREATE_NATIVE_ENTRY(native_report_device_pixel_ratio));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("reportMetrics");
 
  RunEngine(shell.get(), std::move(configuration));
 
  task_runner->PostTask([&]() {
    // This one is invalid for having an nonexistent view ID.
    // Also, it has a DPR of 2.0 for detection.
    shell->GetPlatformView()->SetViewportMetrics(2, {2.0, 400, 200, 22, 0});
    task_runner->PostTask([&]() {
      // This one is valid with DPR 3.0.
      shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                   {3.0, 400, 200, 22, 0});
    });
  });
  latch.Wait();
  ASSERT_EQ(last_device_pixel_ratio, 3.0);
  latch.Reset();
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [792/925]

flutter::testing::TEST_F	(	ShellTest	,
		ImageGeneratorRegistryNotNullAfterParentShellDestroyed
	)

Definition at line 3510 of file shell_unittests.cc.

                                                                          {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  std::unique_ptr<Shell> spawn;
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell, &settings,
                                                             &spawn] {
    auto second_configuration = RunConfiguration::InferFromSettings(settings);
    ASSERT_TRUE(second_configuration.IsValid());
    second_configuration.SetEntrypoint("emptyMain");
    const std::string initial_route("/foo");
    MockPlatformViewDelegate platform_view_delegate;
    auto child = shell->Spawn(
        std::move(second_configuration), initial_route,
        [&platform_view_delegate](Shell& shell) {
          auto result = std::make_unique<MockPlatformView>(
              platform_view_delegate, shell.GetTaskRunners());
          ON_CALL(*result, CreateRenderingSurface())
              .WillByDefault(::testing::Invoke(
                  [] { return std::make_unique<MockSurface>(); }));
          return result;
        },
        [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
    spawn = std::move(child);
  });
 
  PostSync(spawn->GetTaskRunners().GetUITaskRunner(), [&spawn] {
    std::shared_ptr<const DartIsolate> isolate =
        spawn->GetEngine()->GetRuntimeController()->GetRootIsolate().lock();
    ASSERT_TRUE(isolate);
    ASSERT_TRUE(isolate->GetImageGeneratorRegistry());
  });
 
  // Destroy the parent shell.
  DestroyShell(std::move(shell));
 
  PostSync(spawn->GetTaskRunners().GetUITaskRunner(), [&spawn] {
    std::shared_ptr<const DartIsolate> isolate =
        spawn->GetEngine()->GetRuntimeController()->GetRootIsolate().lock();
    ASSERT_TRUE(isolate);
    ASSERT_TRUE(isolate->GetImageGeneratorRegistry());
  });
  // Destroy the child shell.
  DestroyShell(std::move(spawn));
}

◆ TEST_F() [793/925]

flutter::testing::TEST_F	(	ShellTest	,
		ImageGeneratorsWithSamePriorityCascadeChronologically
	)

Definition at line 132 of file image_generator_registry_unittests.cc.

                                                                         {
  ImageGeneratorRegistry registry;
 
  // Add 2 factories with the same high priority.
  registry.AddFactory(
      [](const sk_sp<SkData>& buffer) {
        return std::make_unique<FakeImageGenerator>(1337);
      },
      5);
  registry.AddFactory(
      [](const sk_sp<SkData>& buffer) {
        return std::make_unique<FakeImageGenerator>(7777);
      },
      5);
 
  // Feed empty data so that Skia's image generators will reject it, but ours
  // won't.
  auto result = registry.CreateCompatibleGenerator(SkData::MakeEmpty());
  ASSERT_EQ(result->GetInfo().width(), 1337);
}

◆ TEST_F() [794/925]

flutter::testing::TEST_F	(	ShellTest	,
		ImmutableBufferLoadsAssetOnBackgroundThread
	)

Definition at line 4043 of file shell_unittests.cc.

                                                               {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  fml::CountDownLatch latch(1);
  AddNativeCallback("NotifyNative",
                    CREATE_NATIVE_ENTRY([&](auto args) { latch.CountDown(); }));
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testThatAssetLoadingHappensOnWorkerThread");
  auto asset_manager = configuration.GetAssetManager();
  auto test_resolver = std::make_unique<ThreadCheckingAssetResolver>(
      shell->GetDartVM()->GetConcurrentMessageLoop());
  auto leaked_resolver = test_resolver.get();
  asset_manager->PushBack(std::move(test_resolver));
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  latch.Wait();
 
  EXPECT_EQ(leaked_resolver->mapping_requests[0], "DoesNotExist");
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [795/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithDifferentThreads
	)

Definition at line 407 of file shell_unittests.cc.

                                                  {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  std::string name_prefix = "io.flutter.test." + GetCurrentTestName() + ".";
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      name_prefix, ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
                       ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  ASSERT_EQ(thread_host.name_prefix, name_prefix);
 
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(ValidateShell(shell.get()));
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [796/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithDisabledGpu
	)

Definition at line 491 of file shell_unittests.cc.

                                             {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  auto task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell({
      .settings = settings,
      .task_runners = task_runners,
      .is_gpu_disabled = true,
  });
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  bool is_disabled = false;
  shell->GetIsGpuDisabledSyncSwitch()->Execute(
      fml::SyncSwitch::Handlers().SetIfTrue([&] { is_disabled = true; }));
  ASSERT_TRUE(is_disabled);
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [797/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithGPUAndPlatformThreadsTheSame
	)

Definition at line 516 of file shell_unittests.cc.

                                                              {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners(
      "test",
      thread_host.platform_thread->GetTaskRunner(),  // platform
      thread_host.platform_thread->GetTaskRunner(),  // raster
      thread_host.ui_thread->GetTaskRunner(),        // ui
      thread_host.io_thread->GetTaskRunner()         // io
  );
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [798/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithInvalidThreads
	)

Definition at line 398 of file shell_unittests.cc.

                                                {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test", nullptr, nullptr, nullptr, nullptr);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_FALSE(shell);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [799/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithMultipleThreadButCallingThreadAsPlatformThread
	)

Definition at line 456 of file shell_unittests.cc.

                                                                     {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  TaskRunners task_runners("test",
                           fml::MessageLoop::GetCurrent().GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  auto shell = Shell::Create(
      flutter::PlatformData(), task_runners, settings,
      [](Shell& shell) {
        // This is unused in the platform view as we are not using the simulated
        // vsync mechanism. We should have better DI in the tests.
        const auto vsync_clock = std::make_shared<ShellTestVsyncClock>();
        return ShellTestPlatformView::Create(
            shell, shell.GetTaskRunners(), vsync_clock,
            [task_runners = shell.GetTaskRunners()]() {
              return static_cast<std::unique_ptr<VsyncWaiter>>(
                  std::make_unique<VsyncWaiterFallback>(task_runners));
            },
            ShellTestPlatformView::BackendType::kDefaultBackend, nullptr,
            shell.GetIsGpuDisabledSyncSwitch());
      },
      [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
  ASSERT_TRUE(ValidateShell(shell.get()));
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [800/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithSingleThread
	)

Definition at line 427 of file shell_unittests.cc.

                                              {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  auto task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [801/925]

flutter::testing::TEST_F	(	ShellTest	,
		InitializeWithSingleThreadWhichIsTheCallingThread
	)

Definition at line 442 of file shell_unittests.cc.

                                                                     {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(ValidateShell(shell.get()));
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [802/925]

flutter::testing::TEST_F	(	ShellTest	,
		IOManagerInSpawnedShellIsNotNullAfterParentShellDestroyed
	)

Definition at line 3447 of file shell_unittests.cc.

                                                                             {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  PostSync(shell->GetTaskRunners().GetUITaskRunner(), [&shell] {
    // We must get engine on UI thread.
    auto runtime_controller = shell->GetEngine()->GetRuntimeController();
    PostSync(shell->GetTaskRunners().GetIOTaskRunner(),
             [&shell, &runtime_controller] {
               // We must get io_manager on IO thread.
               auto io_manager = runtime_controller->GetIOManager();
               // Check io_manager existence.
               ASSERT_NE(io_manager.get(), nullptr);
               ASSERT_NE(io_manager->GetSkiaUnrefQueue().get(), nullptr);
               // Get io_manager directly from shell and check its existence.
               ASSERT_NE(shell->GetIOManager().get(), nullptr);
             });
  });
 
  std::unique_ptr<Shell> spawn;
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell, &settings,
                                                             &spawn] {
    auto second_configuration = RunConfiguration::InferFromSettings(settings);
    ASSERT_TRUE(second_configuration.IsValid());
    second_configuration.SetEntrypoint("emptyMain");
    const std::string initial_route("/foo");
    MockPlatformViewDelegate platform_view_delegate;
    auto child = shell->Spawn(
        std::move(second_configuration), initial_route,
        [&platform_view_delegate](Shell& shell) {
          auto result = std::make_unique<MockPlatformView>(
              platform_view_delegate, shell.GetTaskRunners());
          ON_CALL(*result, CreateRenderingSurface())
              .WillByDefault(::testing::Invoke(
                  [] { return std::make_unique<MockSurface>(); }));
          return result;
        },
        [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
    spawn = std::move(child);
  });
  // Destroy the parent shell.
  DestroyShell(std::move(shell));
 
  PostSync(spawn->GetTaskRunners().GetUITaskRunner(), [&spawn] {
    // We must get engine on UI thread.
    auto runtime_controller = spawn->GetEngine()->GetRuntimeController();
    PostSync(spawn->GetTaskRunners().GetIOTaskRunner(),
             [&spawn, &runtime_controller] {
               // We must get io_manager on IO thread.
               auto io_manager = runtime_controller->GetIOManager();
               // Check io_manager existence here.
               ASSERT_NE(io_manager.get(), nullptr);
               ASSERT_NE(io_manager->GetSkiaUnrefQueue().get(), nullptr);
               // Get io_manager directly from shell and check its existence.
               ASSERT_NE(spawn->GetIOManager().get(), nullptr);
             });
  });
  // Destroy the child shell.
  DestroyShell(std::move(spawn));
}

◆ TEST_F() [803/925]

flutter::testing::TEST_F	(	ShellTest	,
		IOManagerIsSharedBetweenParentAndSpawnedShell
	)

Definition at line 3409 of file shell_unittests.cc.

                                                                 {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [this,
                                                             &spawner = shell,
                                                             &settings] {
    auto second_configuration = RunConfiguration::InferFromSettings(settings);
    ASSERT_TRUE(second_configuration.IsValid());
    second_configuration.SetEntrypoint("emptyMain");
    const std::string initial_route("/foo");
    MockPlatformViewDelegate platform_view_delegate;
    auto spawn = spawner->Spawn(
        std::move(second_configuration), initial_route,
        [&platform_view_delegate](Shell& shell) {
          auto result = std::make_unique<MockPlatformView>(
              platform_view_delegate, shell.GetTaskRunners());
          ON_CALL(*result, CreateRenderingSurface())
              .WillByDefault(::testing::Invoke(
                  [] { return std::make_unique<MockSurface>(); }));
          return result;
        },
        [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
    ASSERT_TRUE(ValidateShell(spawn.get()));
 
    PostSync(spawner->GetTaskRunners().GetIOTaskRunner(), [&spawner, &spawn] {
      ASSERT_NE(spawner->GetIOManager().get(), nullptr);
      ASSERT_EQ(spawner->GetIOManager().get(), spawn->GetIOManager().get());
    });
 
    // Destroy the child shell.
    DestroyShell(std::move(spawn));
  });
  // Destroy the parent shell.
  DestroyShell(std::move(shell));
}

◆ TEST_F() [804/925]

flutter::testing::TEST_F	(	ShellTest	,
		IsolateCanAccessPersistentIsolateData
	)

Definition at line 2038 of file shell_unittests.cc.

                                                         {
  const std::string message = "dummy isolate launch data.";
 
  Settings settings = CreateSettingsForFixture();
  settings.persistent_isolate_data =
      std::make_shared<fml::DataMapping>(message);
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  fml::AutoResetWaitableEvent message_latch;
  AddNativeCallback("NotifyMessage",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      const auto message_from_dart =
                          tonic::DartConverter<std::string>::FromDart(
                              Dart_GetNativeArgument(args, 0));
                      ASSERT_EQ(message, message_from_dart);
                      message_latch.Signal();
                    }));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("canAccessIsolateLaunchData");
 
  fml::AutoResetWaitableEvent event;
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch.Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [805/925]

flutter::testing::TEST_F	(	ShellTest	,
		LastEntrypoint
	)

Definition at line 582 of file shell_unittests.cc.

                                  {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  std::string entry_point = "fixturesAreFunctionalMain";
  configuration.SetEntrypoint(entry_point);
 
  fml::AutoResetWaitableEvent main_latch;
  std::string last_entry_point;
  AddNativeCallback(
      "SayHiFromFixturesAreFunctionalMain", CREATE_NATIVE_ENTRY([&](auto args) {
        last_entry_point = shell->GetEngine()->GetLastEntrypoint();
        main_latch.Signal();
      }));
 
  RunEngine(shell.get(), std::move(configuration));
  main_latch.Wait();
  EXPECT_EQ(entry_point, last_entry_point);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [806/925]

flutter::testing::TEST_F	(	ShellTest	,
		LastEntrypointArgs
	)

Definition at line 609 of file shell_unittests.cc.

                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  std::string entry_point = "fixturesAreFunctionalMain";
  std::vector<std::string> entry_point_args = {"arg1"};
  configuration.SetEntrypoint(entry_point);
  configuration.SetEntrypointArgs(entry_point_args);
 
  fml::AutoResetWaitableEvent main_latch;
  std::vector<std::string> last_entry_point_args;
  AddNativeCallback(
      "SayHiFromFixturesAreFunctionalMain", CREATE_NATIVE_ENTRY([&](auto args) {
        last_entry_point_args = shell->GetEngine()->GetLastEntrypointArgs();
        main_latch.Signal();
      }));
 
  RunEngine(shell.get(), std::move(configuration));
  main_latch.Wait();
#if (FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG)
  EXPECT_EQ(last_entry_point_args, entry_point_args);
#else
  ASSERT_TRUE(last_entry_point_args.empty());
#endif
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [807/925]

flutter::testing::TEST_F	(	ShellTest	,
		LocaltimesMatch
	)

Definition at line 2237 of file shell_unittests.cc.

                                   {
  fml::AutoResetWaitableEvent latch;
  std::string dart_isolate_time_str;
 
  // See fixtures/shell_test.dart, the callback NotifyLocalTime is declared
  // there.
  AddNativeCallback("NotifyLocalTime", CREATE_NATIVE_ENTRY([&](auto args) {
                      dart_isolate_time_str =
                          tonic::DartConverter<std::string>::FromDart(
                              Dart_GetNativeArgument(args, 0));
                      latch.Signal();
                    }));
 
  auto settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("localtimesMatch");
  std::unique_ptr<Shell> shell = CreateShell(settings);
  ASSERT_NE(shell.get(), nullptr);
  RunEngine(shell.get(), std::move(configuration));
  latch.Wait();
 
  char timestr[200];
  const time_t timestamp = time(nullptr);
  const struct tm* local_time = localtime(&timestamp);
  ASSERT_NE(local_time, nullptr)
      << "Could not get local time: errno=" << errno << ": " << strerror(errno);
  // Example: "2020-02-26 14" for 2pm on February 26, 2020.
  const size_t format_size =
      strftime(timestr, sizeof(timestr), "%Y-%m-%d %H", local_time);
  ASSERT_NE(format_size, 0UL)
      << "strftime failed: host time: " << std::string(timestr)
      << " dart isolate time: " << dart_isolate_time_str;
 
  const std::string host_local_time_str = timestr;
 
  ASSERT_EQ(dart_isolate_time_str, host_local_time_str)
      << "Local times in the dart isolate and the local time seen by the test "
      << "differ by more than 1 hour, but are expected to be about equal";
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [808/925]

flutter::testing::TEST_F	(	ShellTest	,
		MissAtMostOneFrameForIrregularInputEvents
	)

Definition at line 196 of file input_events_unittests.cc.

                                                             {
  // We don't use `constexpr int frame_time` here because MSVC doesn't handle
  // it well with lambda capture.
  UnitlessTime frame_time = 10;
  UnitlessTime base_latency = 0.5 * frame_time;
  Generator extreme = [frame_time, base_latency](int i) {
    return static_cast<UnitlessTime>(
        i * frame_time + base_latency +
        (i % 2 == 0 ? 0.1 * frame_time : 0.9 * frame_time));
  };
  constexpr int n = 40;
  std::vector<int> events_consumed_at_frame;
  TestSimulatedInputEvents(this, n, base_latency, extreme, frame_time,
                           events_consumed_at_frame);
  int frame_drawn = events_consumed_at_frame.size();
  ASSERT_GE(frame_drawn, n - 1);
 
  // Make sure that it also works after an engine restart.
  TestSimulatedInputEvents(this, n, base_latency, extreme, frame_time,
                           events_consumed_at_frame, true /* restart_engine */);
  int frame_drawn_after_restart = events_consumed_at_frame.size();
  ASSERT_GE(frame_drawn_after_restart, n - 1);
}

◆ TEST_F() [809/925]

flutter::testing::TEST_F	(	ShellTest	,
		MultipleFluttersSetResourceCacheBytes
	)

Definition at line 1680 of file shell_unittests.cc.

                                                         {
  TaskRunners task_runners = GetTaskRunnersForFixture();
  auto settings = CreateSettingsForFixture();
  settings.resource_cache_max_bytes_threshold = 4000000U;
  GrMockOptions main_context_options;
  sk_sp<GrDirectContext> main_context =
      GrDirectContext::MakeMock(&main_context_options);
  Shell::CreateCallback<PlatformView> platform_view_create_callback =
      [task_runners, main_context](flutter::Shell& shell) {
        auto result = std::make_unique<TestPlatformView>(shell, task_runners);
        ON_CALL(*result, CreateRenderingSurface())
            .WillByDefault(::testing::Invoke([main_context] {
              auto surface = std::make_unique<MockSurface>();
              ON_CALL(*surface, GetContext())
                  .WillByDefault(Return(main_context.get()));
              ON_CALL(*surface, IsValid()).WillByDefault(Return(true));
              ON_CALL(*surface, MakeRenderContextCurrent())
                  .WillByDefault(::testing::Invoke([] {
                    return std::make_unique<GLContextDefaultResult>(true);
                  }));
              return surface;
            }));
        return result;
      };
 
  auto shell = CreateShell({
      .settings = settings,
      .task_runners = task_runners,
      .platform_view_create_callback = platform_view_create_callback,
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
    shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                 {1.0, 100, 100, 22, 0});
  });
 
  // first cache bytes
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(480000U));
 
  auto shell_spawn_callback = [&]() {
    std::unique_ptr<Shell> spawn;
    PostSync(
        shell->GetTaskRunners().GetPlatformTaskRunner(),
        [this, &spawn, &spawner = shell, platform_view_create_callback]() {
          auto configuration =
              RunConfiguration::InferFromSettings(CreateSettingsForFixture());
          configuration.SetEntrypoint("emptyMain");
          spawn = spawner->Spawn(
              std::move(configuration), "", platform_view_create_callback,
              [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
          ASSERT_NE(nullptr, spawn.get());
          ASSERT_TRUE(ValidateShell(spawn.get()));
        });
    return spawn;
  };
 
  std::unique_ptr<Shell> second_shell = shell_spawn_callback();
  PlatformViewNotifyCreated(second_shell.get());
  PostSync(second_shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&second_shell]() {
             second_shell->GetPlatformView()->SetViewportMetrics(
                 kImplicitViewId, {1.0, 100, 100, 22, 0});
           });
  // first cache bytes + second cache bytes
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(960000U));
 
  PostSync(second_shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&second_shell]() {
             second_shell->GetPlatformView()->SetViewportMetrics(
                 kImplicitViewId, {1.0, 100, 300, 22, 0});
           });
  // first cache bytes + second cache bytes
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(1920000U));
 
  std::unique_ptr<Shell> third_shell = shell_spawn_callback();
  PlatformViewNotifyCreated(third_shell.get());
  PostSync(third_shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&third_shell]() {
             third_shell->GetPlatformView()->SetViewportMetrics(
                 kImplicitViewId, {1.0, 400, 100, 22, 0});
           });
  // first cache bytes + second cache bytes + third cache bytes
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(3840000U));
 
  PostSync(third_shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&third_shell]() {
             third_shell->GetPlatformView()->SetViewportMetrics(
                 kImplicitViewId, {1.0, 800, 100, 22, 0});
           });
  // max bytes threshold
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(4000000U));
  DestroyShell(std::move(third_shell), task_runners);
  // max bytes threshold
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(4000000U));
 
  PostSync(second_shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&second_shell]() {
             second_shell->GetPlatformView()->SetViewportMetrics(
                 kImplicitViewId, {1.0, 100, 100, 22, 0});
           });
  // first cache bytes + second cache bytes
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(960000U));
 
  DestroyShell(std::move(second_shell), task_runners);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [810/925]

flutter::testing::TEST_F	(	ShellTest	,
		NeedsReportTimingsIsSetWithCallback
	)

Definition at line 706 of file shell_unittests.cc.

                                                       {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("dummyReportTimingsMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  ASSERT_TRUE(GetNeedsReportTimings(shell.get()));
  DestroyShell(std::move(shell));
}

◆ TEST_F() [811/925]

flutter::testing::TEST_F	(	ShellTest	,
		NoNeedToReportTimingsByDefault
	)

Definition at line 678 of file shell_unittests.cc.

                                                  {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  ASSERT_FALSE(GetNeedsReportTimings(shell.get()));
 
  // This assertion may or may not be the direct result of needs_report_timings_
  // being false. The count could be 0 simply because we just cleared
  // unreported timings by reporting them. Hence this can't replace the
  // ASSERT_FALSE(GetNeedsReportTimings(shell.get())) check. We added
  // this assertion for an additional confidence that we're not pushing
  // back to unreported timings unnecessarily.
  //
  // Conversely, do not assert UnreportedTimingsCount(shell.get()) to be
  // positive in any tests. Otherwise those tests will be flaky as the clearing
  // of unreported timings is unpredictive.
  ASSERT_EQ(UnreportedTimingsCount(shell.get()), 0);
  DestroyShell(std::move(shell));
}

◆ TEST_F() [812/925]

flutter::testing::TEST_F	(	ShellTest	,
		NotifyDestroyed
	)

Definition at line 4332 of file shell_unittests.cc.

                                   {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::kUi |
                             ThreadHost::kIo | ThreadHost::kRaster);
  auto platform_task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  fml::CountDownLatch latch(1);
  AddNativeCallback("NotifyDestroyed", CREATE_NATIVE_ENTRY([&](auto args) {
                      auto runtime_controller = const_cast<RuntimeController*>(
                          shell->GetEngine()->GetRuntimeController());
                      bool success = runtime_controller->NotifyDestroyed();
                      EXPECT_TRUE(success);
                      latch.CountDown();
                    }));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("callNotifyDestroyed");
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [813/925]

flutter::testing::TEST_F	(	ShellTest	,
		NotifyIdleNotCalledInLatencyMode
	)

Definition at line 4289 of file shell_unittests.cc.

                                                    {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::kUi |
                             ThreadHost::kIo | ThreadHost::kRaster);
  auto platform_task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  // we start off in balanced mode, where we expect idle notifications to
  // succeed. After the first `NotifyNativeBool` we expect to be in latency
  // mode, where we expect idle notifications to fail.
  fml::CountDownLatch latch(2);
  AddNativeCallback(
      "NotifyNativeBool", CREATE_NATIVE_ENTRY([&](auto args) {
        Dart_Handle exception = nullptr;
        bool is_in_latency_mode =
            tonic::DartConverter<bool>::FromArguments(args, 0, exception);
        auto runtime_controller = const_cast<RuntimeController*>(
            shell->GetEngine()->GetRuntimeController());
        bool success =
            runtime_controller->NotifyIdle(fml::TimeDelta::FromMicroseconds(
                Dart_TimelineGetMicros() + 100000));
        EXPECT_EQ(success, !is_in_latency_mode);
        latch.CountDown();
      }));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("performanceModeImpactsNotifyIdle");
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [814/925]

flutter::testing::TEST_F	(	ShellTest	,
		NotifyIdleRejectsPastAndNearFuture
	)

Definition at line 4244 of file shell_unittests.cc.

                                                      {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::kUi |
                             ThreadHost::kIo | ThreadHost::kRaster);
  auto platform_task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  fml::AutoResetWaitableEvent latch;
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
 
  fml::TaskRunner::RunNowOrPostTask(
      task_runners.GetUITaskRunner(), [&latch, &shell]() {
        auto runtime_controller = const_cast<RuntimeController*>(
            shell->GetEngine()->GetRuntimeController());
 
        auto now = fml::TimeDelta::FromMicroseconds(Dart_TimelineGetMicros());
 
        EXPECT_FALSE(runtime_controller->NotifyIdle(
            now - fml::TimeDelta::FromMilliseconds(10)));
        EXPECT_FALSE(runtime_controller->NotifyIdle(now));
        EXPECT_FALSE(runtime_controller->NotifyIdle(
            now + fml::TimeDelta::FromNanoseconds(100)));
 
        EXPECT_TRUE(runtime_controller->NotifyIdle(
            now + fml::TimeDelta::FromMilliseconds(100)));
        latch.Signal();
      });
 
  latch.Wait();
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [815/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewCreatedWhenUIThreadIsBusy
	)

Definition at line 3874 of file shell_unittests.cc.

                                                           {
  // This test will deadlock if the threading logic in
  // Shell::OnCreatePlatformView is wrong.
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
 
  fml::AutoResetWaitableEvent latch;
  fml::TaskRunner::RunNowOrPostTask(shell->GetTaskRunners().GetUITaskRunner(),
                                    [&latch]() { latch.Wait(); });
 
  ShellTest::PlatformViewNotifyCreated(shell.get());
  latch.Signal();
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [816/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyAfterMergingThreads
	)

Definition at line 1102 of file shell_unittests.cc.

                                                            {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  const int ThreadMergingLease = 10;
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  std::shared_ptr<ShellTestExternalViewEmbedder> external_view_embedder;
 
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        if (should_resubmit_frame && !raster_thread_merger->IsMerged()) {
          raster_thread_merger->MergeWithLease(ThreadMergingLease);
 
          ASSERT_TRUE(raster_thread_merger->IsMerged());
          external_view_embedder->UpdatePostPrerollResult(
              PostPrerollResult::kSuccess);
        }
        end_frame_latch.Signal();
      };
  external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
  // Set resubmit once to trigger thread merging.
  external_view_embedder->UpdatePostPrerollResult(
      PostPrerollResult::kResubmitFrame);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  // Pump one frame to trigger thread merging.
  end_frame_latch.Wait();
  // Pump another frame to ensure threads are merged and a regular layer tree is
  // submitted.
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  // Threads are merged here. PlatformViewNotifyDestroy should be executed
  // successfully.
  ASSERT_TRUE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
  ValidateDestroyPlatformView(shell.get());
 
  // Ensure threads are unmerged after platform view destroy
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [817/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyDisablesThreadMerger
	)

Definition at line 1044 of file shell_unittests.cc.

                                                             {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
  fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          fml::RefPtr<fml::RasterThreadMerger> thread_merger) {
        raster_thread_merger = std::move(thread_merger);
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
 
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
 
  auto result = shell->WaitForFirstFrame(fml::TimeDelta::Max());
  // Wait for the rasterizer to process the frame. WaitForFirstFrame only waits
  // for the Animator, but end_frame_callback is called by the Rasterizer.
  PostSync(shell->GetTaskRunners().GetRasterTaskRunner(), [] {});
  ASSERT_TRUE(result.ok()) << "Result: " << static_cast<int>(result.code())
                           << ": " << result.message();
 
  ASSERT_TRUE(raster_thread_merger->IsEnabled());
 
  ValidateDestroyPlatformView(shell.get());
  ASSERT_TRUE(raster_thread_merger->IsEnabled());
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
  ASSERT_TRUE(raster_thread_merger->IsEnabled());
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [818/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyWhenThreadsAreMerging
	)

Definition at line 1176 of file shell_unittests.cc.

                                                              {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  const int kThreadMergingLease = 10;
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        if (should_resubmit_frame && !raster_thread_merger->IsMerged()) {
          raster_thread_merger->MergeWithLease(kThreadMergingLease);
        }
        end_frame_latch.Signal();
      };
  // Start with a regular layer tree with `PostPrerollResult::kSuccess` so we
  // can later check if the rasterizer is tore down using
  // |ValidateDestroyPlatformView|
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
 
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  // Pump one frame and threads aren't merged
  end_frame_latch.Wait();
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
 
  // Pump a frame with `PostPrerollResult::kResubmitFrame` to start merging
  // threads
  external_view_embedder->UpdatePostPrerollResult(
      PostPrerollResult::kResubmitFrame);
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
 
  // Now destroy the platform view immediately.
  // Two things can happen here:
  // 1. Threads haven't merged. 2. Threads has already merged.
  // |Shell:OnPlatformViewDestroy| should be able to handle both cases.
  ValidateDestroyPlatformView(shell.get());
 
  // Ensure threads are unmerged after platform view destroy
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [819/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyWithoutRasterThreadMerger
	)

Definition at line 1308 of file shell_unittests.cc.

                                                                  {
  auto settings = CreateSettingsForFixture();
 
  auto shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
 
  // Threads should not be merged.
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
  ValidateDestroyPlatformView(shell.get());
 
  // Ensure threads are unmerged after platform view destroy
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [820/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyWithStaticThreadMerging
	)

Definition at line 1346 of file shell_unittests.cc.

                                                                {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        end_frame_latch.Signal();
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform | ThreadHost::Type::kIo |
                             ThreadHost::Type::kUi);
  TaskRunners task_runners(
      "test",
      thread_host.platform_thread->GetTaskRunner(),  // platform
      thread_host.platform_thread->GetTaskRunner(),  // raster
      thread_host.ui_thread->GetTaskRunner(),        // ui
      thread_host.io_thread->GetTaskRunner()         // io
  );
  auto shell = CreateShell({
      .settings = settings,
      .task_runners = task_runners,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
 
  ValidateDestroyPlatformView(shell.get());
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell), task_runners);
#endif  // OS_FUCHSIA
}

◆ TEST_F() [821/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnPlatformViewDestroyWithThreadMergerWhileThreadsAreUnmerged
	)

Definition at line 1251 of file shell_unittests.cc.

                                                                     {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent end_frame_latch;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        end_frame_latch.Signal();
      };
  auto external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kSuccess, true);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
 
  // Threads should not be merged.
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
  ValidateDestroyPlatformView(shell.get());
 
  // Ensure threads are unmerged after platform view destroy
  ASSERT_FALSE(fml::TaskRunnerChecker::RunsOnTheSameThread(
      shell->GetTaskRunners().GetRasterTaskRunner()->GetTaskQueueId(),
      shell->GetTaskRunners().GetPlatformTaskRunner()->GetTaskQueueId()));
 
  // Validate the platform view can be recreated and destroyed again
  ValidateShell(shell.get());
 
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [822/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnServiceProtocolEstimateRasterCacheMemoryWorks
	)

Definition at line 2463 of file shell_unittests.cc.

                                                                   {
  Settings settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // 1. Construct a picture and a picture layer to be raster cached.
  sk_sp<DisplayList> display_list = MakeSizedDisplayList(10, 10);
  auto display_list_layer = std::make_shared<DisplayListLayer>(
      SkPoint::Make(0, 0), MakeSizedDisplayList(100, 100), false, false);
  display_list_layer->set_paint_bounds(SkRect::MakeWH(100, 100));
 
  // 2. Rasterize the picture and the picture layer in the raster cache.
  std::promise<bool> rasterized;
 
  shell->GetTaskRunners().GetRasterTaskRunner()->PostTask(
      [&shell, &rasterized, &display_list, &display_list_layer] {
        std::vector<RasterCacheItem*> raster_cache_items;
        auto* compositor_context = shell->GetRasterizer()->compositor_context();
        auto& raster_cache = compositor_context->raster_cache();
 
        LayerStateStack state_stack;
        FixedRefreshRateStopwatch raster_time;
        FixedRefreshRateStopwatch ui_time;
        PaintContext paint_context = {
            // clang-format off
            .state_stack                   = state_stack,
            .canvas                        = nullptr,
            .gr_context                    = nullptr,
            .dst_color_space               = nullptr,
            .view_embedder                 = nullptr,
            .raster_time                   = raster_time,
            .ui_time                       = ui_time,
            .texture_registry              = nullptr,
            .raster_cache                  = &raster_cache,
            // clang-format on
        };
 
        PrerollContext preroll_context = {
            // clang-format off
            .raster_cache                  = &raster_cache,
            .gr_context                    = nullptr,
            .view_embedder                 = nullptr,
            .state_stack                   = state_stack,
            .dst_color_space               = nullptr,
            .surface_needs_readback        = false,
            .raster_time                   = raster_time,
            .ui_time                       = ui_time,
            .texture_registry              = nullptr,
            .has_platform_view             = false,
            .has_texture_layer             = false,
            .raster_cached_entries         = &raster_cache_items,
            // clang-format on
        };
 
        // 2.1. Rasterize the picture. Call Draw multiple times to pass the
        // access threshold (default to 3) so a cache can be generated.
        MockCanvas dummy_canvas;
        DlPaint paint;
        bool picture_cache_generated;
        DisplayListRasterCacheItem display_list_raster_cache_item(
            display_list, SkPoint(), true, false);
        for (int i = 0; i < 4; i += 1) {
          SkMatrix matrix = SkMatrix::I();
          state_stack.set_preroll_delegate(matrix);
          display_list_raster_cache_item.PrerollSetup(&preroll_context, matrix);
          display_list_raster_cache_item.PrerollFinalize(&preroll_context,
                                                         matrix);
          picture_cache_generated =
              display_list_raster_cache_item.need_caching();
          state_stack.set_delegate(&dummy_canvas);
          display_list_raster_cache_item.TryToPrepareRasterCache(paint_context);
          display_list_raster_cache_item.Draw(paint_context, &dummy_canvas,
                                              &paint);
        }
        ASSERT_TRUE(picture_cache_generated);
 
        // 2.2. Rasterize the picture layer.
        LayerRasterCacheItem layer_raster_cache_item(display_list_layer.get());
        state_stack.set_preroll_delegate(SkMatrix::I());
        layer_raster_cache_item.PrerollSetup(&preroll_context, SkMatrix::I());
        layer_raster_cache_item.PrerollFinalize(&preroll_context,
                                                SkMatrix::I());
        state_stack.set_delegate(&dummy_canvas);
        layer_raster_cache_item.TryToPrepareRasterCache(paint_context);
        layer_raster_cache_item.Draw(paint_context, &dummy_canvas, &paint);
        rasterized.set_value(true);
      });
  rasterized.get_future().wait();
 
  // 3. Call the service protocol and check its output.
  ServiceProtocol::Handler::ServiceProtocolMap empty_params;
  rapidjson::Document document;
  OnServiceProtocol(
      shell.get(), ServiceProtocolEnum::kEstimateRasterCacheMemory,
      shell->GetTaskRunners().GetRasterTaskRunner(), empty_params, &document);
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
  std::string expected_json =
      "{\"type\":\"EstimateRasterCacheMemory\",\"layerBytes\":40024,\"picture"
      "Bytes\":424}";
  std::string actual_json = buffer.GetString();
  ASSERT_EQ(actual_json, expected_json);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [823/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnServiceProtocolGetSkSLsWorks
	)

Definition at line 2348 of file shell_unittests.cc.

                                                  {
  fml::ScopedTemporaryDirectory base_dir;
  ASSERT_TRUE(base_dir.fd().is_valid());
  PersistentCache::SetCacheDirectoryPath(base_dir.path());
  PersistentCache::ResetCacheForProcess();
 
  // Create 2 dummy SkSL cache file IE (base32 encoding of A), II (base32
  // encoding of B) with content x and y.
  std::vector<std::string> components = {
      "flutter_engine", GetFlutterEngineVersion(), "skia", GetSkiaVersion(),
      PersistentCache::kSkSLSubdirName};
  auto sksl_dir = fml::CreateDirectory(base_dir.fd(), components,
                                       fml::FilePermission::kReadWrite);
  const std::string x_key_str = "A";
  const std::string x_value_str = "x";
  sk_sp<SkData> x_key =
      SkData::MakeWithCopy(x_key_str.data(), x_key_str.size());
  sk_sp<SkData> x_value =
      SkData::MakeWithCopy(x_value_str.data(), x_value_str.size());
  auto x_data = PersistentCache::BuildCacheObject(*x_key, *x_value);
 
  const std::string y_key_str = "B";
  const std::string y_value_str = "y";
  sk_sp<SkData> y_key =
      SkData::MakeWithCopy(y_key_str.data(), y_key_str.size());
  sk_sp<SkData> y_value =
      SkData::MakeWithCopy(y_value_str.data(), y_value_str.size());
  auto y_data = PersistentCache::BuildCacheObject(*y_key, *y_value);
 
  ASSERT_TRUE(fml::WriteAtomically(sksl_dir, "x_cache", *x_data));
  ASSERT_TRUE(fml::WriteAtomically(sksl_dir, "y_cache", *y_data));
 
  Settings settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
  ServiceProtocol::Handler::ServiceProtocolMap empty_params;
  rapidjson::Document document;
  OnServiceProtocol(shell.get(), ServiceProtocolEnum::kGetSkSLs,
                    shell->GetTaskRunners().GetIOTaskRunner(), empty_params,
                    &document);
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
  DestroyShell(std::move(shell));
 
  const std::string expected_json1 =
      "{\"type\":\"GetSkSLs\",\"SkSLs\":{\"II\":\"eQ==\",\"IE\":\"eA==\"}}";
  const std::string expected_json2 =
      "{\"type\":\"GetSkSLs\",\"SkSLs\":{\"IE\":\"eA==\",\"II\":\"eQ==\"}}";
  bool json_is_expected = (expected_json1 == buffer.GetString()) ||
                          (expected_json2 == buffer.GetString());
  ASSERT_TRUE(json_is_expected) << buffer.GetString() << " is not equal to "
                                << expected_json1 << " or " << expected_json2;
}

◆ TEST_F() [824/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnServiceProtocolRenderFrameWithRasterStatsWorks
	)

Definition at line 2570 of file shell_unittests.cc.

                                                                    {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("scene_with_red_box");
 
  RunEngine(shell.get(), std::move(configuration));
  // Set a non-zero viewport metrics, otherwise the scene would be discarded.
  PostSync(shell->GetTaskRunners().GetUITaskRunner(),
           [engine = shell->GetEngine()]() {
             engine->SetViewportMetrics(kImplicitViewId,
                                        ViewportMetrics{1, 1, 1, 22, 0});
           });
  PumpOneFrame(shell.get(), ViewContent::NoViews());
 
  ServiceProtocol::Handler::ServiceProtocolMap empty_params;
  rapidjson::Document document;
  OnServiceProtocol(
      shell.get(), ServiceProtocolEnum::kRenderFrameWithRasterStats,
      shell->GetTaskRunners().GetRasterTaskRunner(), empty_params, &document);
  rapidjson::StringBuffer buffer;
  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
  document.Accept(writer);
 
  // It would be better to parse out the json and check for the validity of
  // fields. Below checks approximate what needs to be checked, this can not be
  // an exact check since duration will not exactly match.
#ifdef SHELL_ENABLE_METAL
  std::string expected_json =
      "\"snapshot\":[137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,3,32,0,"
      "0,2,88,8,6,0,0,0,154,118,130,112,0,0,0,1,115,82,71,66,0,174,206,28,233,"
      "0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,0,7,103,73,68,65,84,120,"
      "156,237,206,65,13,192,48,0,3,177,211,248,115,78,73,172,234,199,70,224,"
      "86,91,45,0,0,128,203,190,215,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"
      "0,224,47,7,195,182,3,255,101,111,186,90,0,0,0,0,73,69,78,68,174,66,96,"
      "130]";
#else
  std::string expected_json =
      "\"snapshot\":[137,80,78,71,13,10,26,10,0,"
      "0,0,13,73,72,68,82,0,0,0,1,0,0,0,1,8,6,0,0,0,31,21,196,137,0,0,0,1,115,"
      "82,71,66,0,174,206,28,233,0,0,0,4,115,66,73,84,8,8,8,8,124,8,100,136,0,"
      "0,0,13,73,68,65,84,8,153,99,248,207,192,240,31,0,5,0,1,255,171,206,54,"
      "137,0,0,0,0,73,69,78,68,174,66,96,130]";
#endif
  std::string actual_json = buffer.GetString();
 
  EXPECT_THAT(actual_json, ::testing::HasSubstr(expected_json));
  EXPECT_THAT(actual_json,
              ::testing::HasSubstr("{\"type\":\"RenderFrameWithRasterStats\""));
  EXPECT_THAT(actual_json, ::testing::HasSubstr("\"duration_micros\""));
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [825/925]

flutter::testing::TEST_F	(	ShellTest	,
		OnServiceProtocolSetAssetBundlePathWorks
	)

Definition at line 3002 of file shell_unittests.cc.

                                                            {
  Settings settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
  RunConfiguration configuration =
      RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("canAccessResourceFromAssetDir");
 
  // Verify isolate can load a known resource with the
  // default asset directory - kernel_blob.bin
  fml::AutoResetWaitableEvent latch;
 
  // Callback used to signal whether the resource was loaded successfully.
  bool can_access_resource = false;
  auto native_can_access_resource = [&can_access_resource,
                                     &latch](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    can_access_resource =
        tonic::DartConverter<bool>::FromArguments(args, 0, exception);
    latch.Signal();
  };
  AddNativeCallback("NotifyCanAccessResource",
                    CREATE_NATIVE_ENTRY(native_can_access_resource));
 
  // Callback used to delay the asset load until after the service
  // protocol method has finished.
  auto native_notify_set_asset_bundle_path =
      [&shell](Dart_NativeArguments args) {
        // Update the asset directory to a bonus path.
        ServiceProtocol::Handler::ServiceProtocolMap params;
        params["assetDirectory"] = "assetDirectory";
        rapidjson::Document document;
        OnServiceProtocol(shell.get(), ServiceProtocolEnum::kSetAssetBundlePath,
                          shell->GetTaskRunners().GetUITaskRunner(), params,
                          &document);
        rapidjson::StringBuffer buffer;
        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
        document.Accept(writer);
      };
  AddNativeCallback("NotifySetAssetBundlePath",
                    CREATE_NATIVE_ENTRY(native_notify_set_asset_bundle_path));
 
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
  ASSERT_TRUE(can_access_resource);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [826/925]

flutter::testing::TEST_F	(	ShellTest	,
		PathVolatilityGCRemovesPathFromTracker
	)

Definition at line 68 of file path_unittests.cc.

                                                          {
  static_assert(VolatilePathTracker::kFramesOfVolatility > 1);
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto native_validate_path = [message_latch](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    EXPECT_FALSE(Dart_IsError(result));
    CanvasPath* path = reinterpret_cast<CanvasPath*>(peer);
    EXPECT_TRUE(path);
    EXPECT_TRUE(path->path().isVolatile());
    std::shared_ptr<VolatilePathTracker> tracker =
        UIDartState::Current()->GetVolatilePathTracker();
    EXPECT_TRUE(tracker);
    EXPECT_EQ(GetLiveTrackedPathCount(tracker), 1ul);
    EXPECT_TRUE(path->path().isVolatile());
 
    tracker->OnFrame();
    EXPECT_EQ(GetLiveTrackedPathCount(tracker), 1ul);
    EXPECT_TRUE(path->path().isVolatile());
 
    // simulate GC
    path->Release();
    EXPECT_EQ(GetLiveTrackedPathCount(tracker), 0ul);
 
    tracker->OnFrame();
    EXPECT_EQ(GetLiveTrackedPathCount(tracker), 0ul);
 
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidatePath", CREATE_NATIVE_ENTRY(native_validate_path));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("createPath");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [827/925]

flutter::testing::TEST_F	(	ShellTest	,
		PathVolatilityOldPathsBecomeNonVolatile
	)

Definition at line 19 of file path_unittests.cc.

                                                           {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto native_validate_path = [message_latch](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    EXPECT_FALSE(Dart_IsError(result));
    CanvasPath* path = reinterpret_cast<CanvasPath*>(peer);
    EXPECT_TRUE(path);
    EXPECT_TRUE(path->path().isVolatile());
    std::shared_ptr<VolatilePathTracker> tracker =
        UIDartState::Current()->GetVolatilePathTracker();
    EXPECT_TRUE(tracker);
 
    for (int i = 0; i < VolatilePathTracker::kFramesOfVolatility; i++) {
      EXPECT_TRUE(path->path().isVolatile());
      tracker->OnFrame();
    }
    EXPECT_FALSE(path->path().isVolatile());
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidatePath", CREATE_NATIVE_ENTRY(native_validate_path));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("createPath");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [828/925]

flutter::testing::TEST_F	(	ShellTest	,
		PictureToImageSync
	)

Definition at line 4076 of file shell_unittests.cc.

                                      {
#if !SHELL_ENABLE_GL
  // This test uses the GL backend.
  GTEST_SKIP();
#else
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .rendering_backend = ShellTestPlatformView::BackendType::kGLBackend,
      }),
  });
 
  AddNativeCallback("NativeOnBeforeToImageSync",
                    CREATE_NATIVE_ENTRY([&](auto args) {
                      // nop
                    }));
 
  fml::CountDownLatch latch(2);
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&](auto args) {
                      // Teardown and set up rasterizer again.
                      PlatformViewNotifyDestroyed(shell.get());
                      PlatformViewNotifyCreated(shell.get());
                      latch.CountDown();
                    }));
 
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  PlatformViewNotifyCreated(shell.get());
  configuration.SetEntrypoint("toImageSync");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  latch.Wait();
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // !SHELL_ENABLE_GL
}

◆ TEST_F() [829/925]

flutter::testing::TEST_F	(	ShellTest	,
		PictureToImageSyncImpellerNoSurface
	)

Definition at line 4117 of file shell_unittests.cc.

                                                       {
#if !SHELL_ENABLE_METAL
  // This test uses the Metal backend.
  GTEST_SKIP();
#else
  auto settings = CreateSettingsForFixture();
  settings.enable_impeller = true;
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .rendering_backend =
              ShellTestPlatformView::BackendType::kMetalBackend,
      }),
  });
 
  AddNativeCallback("NativeOnBeforeToImageSync",
                    CREATE_NATIVE_ENTRY([&](auto args) {
                      // nop
                    }));
 
  fml::CountDownLatch latch(2);
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&](auto args) {
                      // Teardown and set up rasterizer again.
                      PlatformViewNotifyDestroyed(shell.get());
                      PlatformViewNotifyCreated(shell.get());
                      latch.CountDown();
                    }));
 
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
 
  // Important: Do not create the platform view yet!
  // This test is making sure that the rasterizer can create the texture
  // as expected without a surface.
 
  configuration.SetEntrypoint("toImageSync");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  latch.Wait();
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
#endif  // !SHELL_ENABLE_METAL
}

◆ TEST_F() [830/925]

flutter::testing::TEST_F	(	ShellTest	,
		PlatformMessageResponseDart
	)

Definition at line 17 of file platform_message_response_dart_unittests.cc.

                                               {
  bool did_pass = false;
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  auto nativeCallPlatformMessageResponseDart =
      [ui_task_runner =
           task_runners.GetUITaskRunner()](Dart_NativeArguments args) {
        auto dart_state = std::make_shared<tonic::DartState>();
        auto response = fml::MakeRefCounted<PlatformMessageResponseDart>(
            tonic::DartPersistentValue(tonic::DartState::Current(),
                                       Dart_GetNativeArgument(args, 0)),
            ui_task_runner, "foobar");
        uint8_t* data = static_cast<uint8_t*>(malloc(100));
        auto mapping = std::make_unique<fml::MallocMapping>(data, 100);
        response->Complete(std::move(mapping));
      };
 
  AddNativeCallback("CallPlatformMessageResponseDart",
                    CREATE_NATIVE_ENTRY(nativeCallPlatformMessageResponseDart));
 
  auto nativeFinishCallResponse = [message_latch,
                                   &did_pass](Dart_NativeArguments args) {
    did_pass =
        tonic::DartConverter<bool>::FromDart(Dart_GetNativeArgument(args, 0));
    message_latch->Signal();
  };
 
  AddNativeCallback("FinishCallResponse",
                    CREATE_NATIVE_ENTRY(nativeFinishCallResponse));
 
  Settings settings = CreateSettingsForFixture();
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("platformMessageResponseTest");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  ASSERT_TRUE(did_pass);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [831/925]

flutter::testing::TEST_F	(	ShellTest	,
		PlatformMessageResponseDartPort
	)

Definition at line 17 of file platform_message_response_dart_port_unittests.cc.

                                                   {
  bool did_pass = false;
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  auto nativeCallPlatformMessageResponseDartPort =
      [ui_task_runner =
           task_runners.GetUITaskRunner()](Dart_NativeArguments args) {
        auto dart_state = std::make_shared<tonic::DartState>();
        auto response = fml::MakeRefCounted<PlatformMessageResponseDartPort>(
            tonic::DartConverter<int64_t>::FromDart(
                Dart_GetNativeArgument(args, 0)),
            123, "foobar");
        uint8_t* data = static_cast<uint8_t*>(malloc(100));
        auto mapping = std::make_unique<fml::MallocMapping>(data, 100);
        response->Complete(std::move(mapping));
      };
 
  AddNativeCallback(
      "CallPlatformMessageResponseDartPort",
      CREATE_NATIVE_ENTRY(nativeCallPlatformMessageResponseDartPort));
 
  auto nativeFinishCallResponse = [message_latch,
                                   &did_pass](Dart_NativeArguments args) {
    did_pass =
        tonic::DartConverter<bool>::FromDart(Dart_GetNativeArgument(args, 0));
    message_latch->Signal();
  };
 
  AddNativeCallback("FinishCallResponse",
                    CREATE_NATIVE_ENTRY(nativeFinishCallResponse));
 
  Settings settings = CreateSettingsForFixture();
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("platformMessagePortResponseTest");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
 
  ASSERT_TRUE(did_pass);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [832/925]

flutter::testing::TEST_F	(	ShellTest	,
		PluginUtilitiesCallbackHandleErrorHandling
	)

Definition at line 4215 of file shell_unittests.cc.

                                                              {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  fml::AutoResetWaitableEvent latch;
  bool test_passed;
  AddNativeCallback("NotifyNativeBool", CREATE_NATIVE_ENTRY([&](auto args) {
                      Dart_Handle exception = nullptr;
                      test_passed = tonic::DartConverter<bool>::FromArguments(
                          args, 0, exception);
                      latch.Signal();
                    }));
 
  ASSERT_NE(shell, nullptr);
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  PlatformViewNotifyCreated(shell.get());
  configuration.SetEntrypoint("testPluginUtilitiesCallbackHandle");
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  latch.Wait();
 
  ASSERT_TRUE(test_passed);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell));
}

◆ TEST_F() [833/925]

flutter::testing::TEST_F	(	ShellTest	,
		PositivePriorityTakesPrecedentOverDefaultGenerators
	)

Definition at line 85 of file image_generator_registry_unittests.cc.

                                                                       {
  ImageGeneratorRegistry registry;
 
  const int fake_width = 1337;
  registry.AddFactory(
      [fake_width](const sk_sp<SkData>& buffer) {
        return std::make_unique<FakeImageGenerator>(fake_width);
      },
      1);
 
  // Fetch the generator and query for basic info.
  auto result = registry.CreateCompatibleGenerator(LoadValidImageFixture());
  ASSERT_EQ(result->GetInfo().width(), fake_width);
}

◆ TEST_F() [834/925]

flutter::testing::TEST_F	(	ShellTest	,
		PrefetchDefaultFontManager
	)

Definition at line 3833 of file shell_unittests.cc.

                                              {
  auto settings = CreateSettingsForFixture();
  settings.prefetched_default_font_manager = true;
  std::unique_ptr<Shell> shell;
 
  auto get_font_manager_count = [&] {
    fml::AutoResetWaitableEvent latch;
    size_t font_manager_count;
    fml::TaskRunner::RunNowOrPostTask(
        shell->GetTaskRunners().GetUITaskRunner(),
        [this, &shell, &latch, &font_manager_count]() {
          font_manager_count =
              GetFontCollection(shell.get())->GetFontManagersCount();
          latch.Signal();
        });
    latch.Wait();
    return font_manager_count;
  };
  size_t initial_font_manager_count = 0;
  settings.root_isolate_create_callback = [&](const auto& isolate) {
    ASSERT_GT(initial_font_manager_count, 0ul);
    // Should not have fetched the default font manager yet, since the root
    // isolate was only just created.
    ASSERT_EQ(get_font_manager_count(), initial_font_manager_count);
  };
 
  shell = CreateShell(settings);
 
  initial_font_manager_count = get_font_manager_count();
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  RunEngine(shell.get(), std::move(configuration));
 
  // If the prefetched_default_font_manager flag is set, then the default font
  // manager will not be added until the engine starts running.
  ASSERT_EQ(get_font_manager_count(), initial_font_manager_count + 1);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [835/925]

flutter::testing::TEST_F	(	ShellTest	,
		PrintsErrorWhenPlatformMessageSentFromWrongThread
	)

Definition at line 4366 of file shell_unittests.cc.

                                                                     {
#if FLUTTER_RUNTIME_MODE != FLUTTER_RUNTIME_MODE_DEBUG || OS_FUCHSIA
  GTEST_SKIP() << "Test is for debug mode only on non-fuchsia targets.";
#else
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host("io.flutter.test." + GetCurrentTestName() + ".",
                         ThreadHost::Type::kPlatform);
  auto task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
 
  {
    fml::testing::LogCapture log_capture;
 
    // The next call will result in a thread checker violation.
    fml::ThreadChecker::DisableNextThreadCheckFailure();
    SendPlatformMessage(shell.get(), std::make_unique<PlatformMessage>(
                                         "com.test.plugin", nullptr));
 
    EXPECT_THAT(
        log_capture.str(),
        ::testing::EndsWith(
            "The 'com.test.plugin' channel sent a message from native to "
            "Flutter on a non-platform thread. Platform channel messages "
            "must be sent on the platform thread. Failure to do so may "
            "result in data loss or crashes, and must be fixed in the "
            "plugin or application code creating that channel.\nSee "
            "https://docs.flutter.dev/platform-integration/"
            "platform-channels#channels-and-platform-threading for more "
            "information.\n"));
  }
 
  {
    fml::testing::LogCapture log_capture;
 
    // The next call will result in a thread checker violation.
    fml::ThreadChecker::DisableNextThreadCheckFailure();
    SendPlatformMessage(shell.get(), std::make_unique<PlatformMessage>(
                                         "com.test.plugin", nullptr));
 
    EXPECT_EQ(log_capture.str(), "");
  }
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
#endif
}

◆ TEST_F() [836/925]

flutter::testing::TEST_F	(	ShellTest	,
		PushBackdropFilterToVisitedPlatformViews
	)

Definition at line 907 of file shell_unittests.cc.

                                                            {
#if defined(OS_FUCHSIA)
  GTEST_SKIP() << "RasterThreadMerger flakes on Fuchsia. "
                  "https://github.com/flutter/flutter/issues/59816 ";
#else
 
  auto settings = CreateSettingsForFixture();
 
  std::shared_ptr<ShellTestExternalViewEmbedder> external_view_embedder;
 
  fml::AutoResetWaitableEvent end_frame_latch;
  bool end_frame_called = false;
  std::vector<int64_t> visited_platform_views;
  MutatorsStack stack_50;
  MutatorsStack stack_75;
  auto end_frame_callback =
      [&](bool should_resubmit_frame,
          const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger) {
        if (end_frame_called) {
          return;
        }
        ASSERT_TRUE(raster_thread_merger.get() == nullptr);
        ASSERT_FALSE(should_resubmit_frame);
        end_frame_called = true;
        visited_platform_views =
            external_view_embedder->GetVisitedPlatformViews();
        stack_50 = external_view_embedder->GetStack(50);
        stack_75 = external_view_embedder->GetStack(75);
        end_frame_latch.Signal();
      };
 
  external_view_embedder = std::make_shared<ShellTestExternalViewEmbedder>(
      end_frame_callback, PostPrerollResult::kResubmitFrame, false);
  auto shell = CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .shell_test_external_view_embedder = external_view_embedder,
      }),
  });
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto platform_view_layer = std::make_shared<PlatformViewLayer>(
        SkPoint::Make(10, 10), SkSize::Make(10, 10), 50);
    root->Add(platform_view_layer);
    auto transform_layer =
        std::make_shared<TransformLayer>(SkMatrix::Translate(1, 1));
    root->Add(transform_layer);
    auto clip_rect_layer = std::make_shared<ClipRectLayer>(
        SkRect::MakeLTRB(0, 0, 30, 30), Clip::kHardEdge);
    transform_layer->Add(clip_rect_layer);
    auto filter = std::make_shared<DlBlurImageFilter>(5, 5, DlTileMode::kClamp);
    auto backdrop_filter_layer =
        std::make_shared<BackdropFilterLayer>(filter, DlBlendMode::kSrcOver);
    clip_rect_layer->Add(backdrop_filter_layer);
    auto platform_view_layer2 = std::make_shared<PlatformViewLayer>(
        SkPoint::Make(10, 10), SkSize::Make(10, 10), 75);
    backdrop_filter_layer->Add(platform_view_layer2);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  end_frame_latch.Wait();
  ASSERT_EQ(visited_platform_views, (std::vector<int64_t>{50, 75}));
  ASSERT_TRUE(stack_75.is_empty());
  ASSERT_FALSE(stack_50.is_empty());
 
  auto filter = DlBlurImageFilter(5, 5, DlTileMode::kClamp);
  auto mutator = *stack_50.Begin();
  ASSERT_EQ(mutator->GetType(), MutatorType::kBackdropFilter);
  ASSERT_EQ(mutator->GetFilterMutation().GetFilter(), filter);
  // Make sure the filterRect is in global coordinates (contains the (1,1)
  // translation).
  ASSERT_EQ(mutator->GetFilterMutation().GetFilterRect(),
            SkRect::MakeLTRB(1, 1, 31, 31));
 
  DestroyShell(std::move(shell));
#endif  // OS_FUCHSIA
}

◆ TEST_F() [837/925]

flutter::testing::TEST_F	(	ShellTest	,
		RasterizerMakeRasterSnapshot
	)

Definition at line 2432 of file shell_unittests.cc.

                                                {
  Settings settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(ValidateShell(shell.get()));
  PlatformViewNotifyCreated(shell.get());
 
  RunEngine(shell.get(), std::move(configuration));
 
  auto latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  PumpOneFrame(shell.get());
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(), [&shell, &latch]() {
        SnapshotDelegate* delegate =
            reinterpret_cast<Rasterizer*>(shell->GetRasterizer().get());
        sk_sp<DlImage> image = delegate->MakeRasterSnapshotSync(
            MakeSizedDisplayList(50, 50), SkISize::Make(50, 50));
        EXPECT_NE(image, nullptr);
 
        latch->Signal();
      });
  latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [838/925]

flutter::testing::TEST_F	(	ShellTest	,
		RasterizerScreenshot
	)

Definition at line 2402 of file shell_unittests.cc.

                                        {
  Settings settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(ValidateShell(shell.get()));
  PlatformViewNotifyCreated(shell.get());
 
  RunEngine(shell.get(), std::move(configuration));
 
  auto latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  PumpOneFrame(shell.get());
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(), [&shell, &latch]() {
        Rasterizer::Screenshot screenshot =
            shell->GetRasterizer()->ScreenshotLastLayerTree(
                Rasterizer::ScreenshotType::CompressedImage, true);
        EXPECT_NE(screenshot.data, nullptr);
 
        latch->Signal();
      });
  latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [839/925]

flutter::testing::TEST_F	(	ShellTest	,
		ReportTimingsIsCalled
	)

Definition at line 749 of file shell_unittests.cc.

                                         {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // We MUST put |start| after |CreateShell| because the clock source will be
  // reset through |TimePoint::SetClockSource()| in
  // |DartVMInitializer::Initialize()| within |CreateShell()|.
  fml::TimePoint start = fml::TimePoint::Now();
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("reportTimingsMain");
  fml::AutoResetWaitableEvent reportLatch;
  std::vector<int64_t> timestamps;
  auto nativeTimingCallback = [&reportLatch,
                               &timestamps](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    ASSERT_EQ(timestamps.size(), 0ul);
    timestamps = tonic::DartConverter<std::vector<int64_t>>::FromArguments(
        args, 0, exception);
    reportLatch.Signal();
  };
  AddNativeCallback("NativeReportTimingsCallback",
                    CREATE_NATIVE_ENTRY(nativeTimingCallback));
  RunEngine(shell.get(), std::move(configuration));
 
  // Pump many frames so we can trigger the report quickly instead of waiting
  // for the 1 second threshold.
  for (int i = 0; i < 200; i += 1) {
    PumpOneFrame(shell.get());
  }
 
  reportLatch.Wait();
  DestroyShell(std::move(shell));
 
  fml::TimePoint finish = fml::TimePoint::Now();
  ASSERT_TRUE(!timestamps.empty());
  ASSERT_TRUE(timestamps.size() % FrameTiming::kCount == 0);
  std::vector<FrameTiming> timings(timestamps.size() / FrameTiming::kCount);
 
  for (size_t i = 0; i * FrameTiming::kCount < timestamps.size(); i += 1) {
    for (auto phase : FrameTiming::kPhases) {
      timings[i].Set(
          phase,
          fml::TimePoint::FromEpochDelta(fml::TimeDelta::FromMicroseconds(
              timestamps[i * FrameTiming::kCount + phase])));
    }
  }
  CheckFrameTimings(timings, start, finish);
}

◆ TEST_F() [840/925]

flutter::testing::TEST_F	(	ShellTest	,
		ReportTimingsIsCalledImmediatelyAfterTheFirstFrame
	)

Definition at line 1522 of file shell_unittests.cc.

                                                                      {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("reportTimingsMain");
  fml::AutoResetWaitableEvent reportLatch;
  std::vector<int64_t> timestamps;
  auto nativeTimingCallback = [&reportLatch,
                               &timestamps](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    ASSERT_EQ(timestamps.size(), 0ul);
    timestamps = tonic::DartConverter<std::vector<int64_t>>::FromArguments(
        args, 0, exception);
    reportLatch.Signal();
  };
  AddNativeCallback("NativeReportTimingsCallback",
                    CREATE_NATIVE_ENTRY(nativeTimingCallback));
  ASSERT_TRUE(configuration.IsValid());
  RunEngine(shell.get(), std::move(configuration));
 
  for (int i = 0; i < 10; i += 1) {
    PumpOneFrame(shell.get());
  }
 
  reportLatch.Wait();
  DestroyShell(std::move(shell));
 
  // Check for the immediate callback of the first frame that doesn't wait for
  // the other 9 frames to be rasterized.
  ASSERT_EQ(timestamps.size(), FrameTiming::kCount);
}

◆ TEST_F() [841/925]

flutter::testing::TEST_F	(	ShellTest	,
		RuntimeStageBackendDefaultsToSkSLWithoutImpeller
	)

Definition at line 4845 of file shell_unittests.cc.

                                                                    {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  settings.enable_impeller = false;
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&latch](auto args) {
                      auto backend =
                          UIDartState::Current()->GetRuntimeStageBackend();
                      EXPECT_EQ(backend, impeller::RuntimeStageBackend::kSkSL);
                      latch.Signal();
                    }));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("mainNotifyNative");
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [842/925]

flutter::testing::TEST_F	(	ShellTest	,
		SceneBuilderBuildAndSceneDisposeReleasesLayerStack
	)

Definition at line 22 of file scene_builder_unittests.cc.

                                                                      {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  // prevent ClearDartWrapper() from deleting the scene builder.
  SceneBuilder* retained_scene_builder;
  Scene* retained_scene;
 
  auto validate_builder_has_layers =
      [&retained_scene_builder](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
        intptr_t peer = 0;
        Dart_Handle result = Dart_GetNativeInstanceField(
            handle, tonic::DartWrappable::kPeerIndex, &peer);
        ASSERT_FALSE(Dart_IsError(result));
        retained_scene_builder = reinterpret_cast<SceneBuilder*>(peer);
        retained_scene_builder->AddRef();
        ASSERT_TRUE(retained_scene_builder);
        ASSERT_EQ(retained_scene_builder->layer_stack().size(), 2ul);
      };
 
  auto validate_builder_has_no_layers =
      [&retained_scene_builder](Dart_NativeArguments args) {
        ASSERT_EQ(retained_scene_builder->layer_stack().size(), 0ul);
        retained_scene_builder->Release();
        retained_scene_builder = nullptr;
      };
 
  auto capture_scene = [&retained_scene](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
    retained_scene = reinterpret_cast<Scene*>(peer);
    retained_scene->AddRef();
    ASSERT_TRUE(retained_scene);
  };
 
  auto validate_scene_has_no_layers =
      [message_latch, &retained_scene](Dart_NativeArguments args) {
        EXPECT_FALSE(retained_scene->takeLayerTree(100, 100));
        retained_scene->Release();
        retained_scene = nullptr;
        message_latch->Signal();
      };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidateBuilderHasLayers",
                    CREATE_NATIVE_ENTRY(validate_builder_has_layers));
  AddNativeCallback("ValidateBuilderHasNoLayers",
                    CREATE_NATIVE_ENTRY(validate_builder_has_no_layers));
 
  AddNativeCallback("CaptureScene", CREATE_NATIVE_ENTRY(capture_scene));
  AddNativeCallback("ValidateSceneHasNoLayers",
                    CREATE_NATIVE_ENTRY(validate_scene_has_no_layers));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("validateSceneBuilderAndScene");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [843/925]

flutter::testing::TEST_F	(	ShellTest	,
		Screenshot
	)

Definition at line 2174 of file shell_unittests.cc.

                              {
  auto settings = CreateSettingsForFixture();
  fml::AutoResetWaitableEvent firstFrameLatch;
  settings.frame_rasterized_callback =
      [&firstFrameLatch](const FrameTiming& t) { firstFrameLatch.Signal(); };
 
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
 
  LayerTreeBuilder builder = [&](const std::shared_ptr<ContainerLayer>& root) {
    auto display_list_layer = std::make_shared<DisplayListLayer>(
        SkPoint::Make(10, 10), MakeSizedDisplayList(80, 80), false, false);
    root->Add(display_list_layer);
  };
 
  PumpOneFrame(shell.get(), ViewContent::ImplicitView(100, 100, builder));
  firstFrameLatch.Wait();
 
  std::promise<Rasterizer::Screenshot> screenshot_promise;
  auto screenshot_future = screenshot_promise.get_future();
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(),
      [&screenshot_promise, &shell]() {
        auto rasterizer = shell->GetRasterizer();
        screenshot_promise.set_value(rasterizer->ScreenshotLastLayerTree(
            Rasterizer::ScreenshotType::CompressedImage, false));
      });
 
  auto fixtures_dir =
      fml::OpenDirectory(GetFixturesPath(), false, fml::FilePermission::kRead);
 
  auto reference_png = fml::FileMapping::CreateReadOnly(
      fixtures_dir, "shelltest_screenshot.png");
 
  // Use MakeWithoutCopy instead of MakeWithCString because we don't want to
  // encode the null sentinel
  sk_sp<SkData> reference_data = SkData::MakeWithoutCopy(
      reference_png->GetMapping(), reference_png->GetSize());
 
  sk_sp<SkData> screenshot_data = screenshot_future.get().data;
  if (!reference_data->equals(screenshot_data.get())) {
    LogSkData(reference_data, "reference");
    LogSkData(screenshot_data, "screenshot");
    ASSERT_TRUE(false);
  }
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [844/925]

flutter::testing::TEST_F	(	ShellTest	,
		SecondaryIsolateBindingsAreSetupViaShellSettings
	)

Definition at line 558 of file shell_unittests.cc.

                                                                    {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("testCanLaunchSecondaryIsolate");
 
  fml::CountDownLatch latch(2);
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&latch](auto args) {
                      latch.CountDown();
                    }));
 
  RunEngine(shell.get(), std::move(configuration));
 
  latch.Wait();
 
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [845/925]

flutter::testing::TEST_F	(	ShellTest	,
		SecondaryVsyncCallbackShouldBeCalledAfterVsyncCallback
	)

Definition at line 2105 of file shell_unittests.cc.

                                                                          {
  bool is_on_begin_frame_called = false;
  bool is_secondary_callback_called = false;
  bool test_started = false;
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners = GetTaskRunnersForFixture();
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback(
      "NotifyNative",
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); }));
  fml::CountDownLatch count_down_latch(2);
  AddNativeCallback("NativeOnBeginFrame",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      if (!test_started) {
                        return;
                      }
                      EXPECT_FALSE(is_on_begin_frame_called);
                      EXPECT_FALSE(is_secondary_callback_called);
                      is_on_begin_frame_called = true;
                      count_down_latch.CountDown();
                    }));
  std::unique_ptr<Shell> shell = CreateShell({
      .settings = settings,
      .task_runners = task_runners,
  });
  ASSERT_TRUE(shell->IsSetup());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onBeginFrameWithNotifyNativeMain");
  RunEngine(shell.get(), std::move(configuration));
 
  // Wait for the application to attach the listener.
  latch.Wait();
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetUITaskRunner(), [&]() {
        shell->GetEngine()->ScheduleSecondaryVsyncCallback(0, [&]() {
          if (!test_started) {
            return;
          }
          EXPECT_TRUE(is_on_begin_frame_called);
          EXPECT_FALSE(is_secondary_callback_called);
          is_secondary_callback_called = true;
          count_down_latch.CountDown();
        });
        shell->GetEngine()->ScheduleFrame();
        test_started = true;
      });
  count_down_latch.Wait();
  EXPECT_TRUE(is_on_begin_frame_called);
  EXPECT_TRUE(is_secondary_callback_called);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [846/925]

flutter::testing::TEST_F	(	ShellTest	,
		SetResourceCacheSize
	)

Definition at line 1801 of file shell_unittests.cc.

                                        {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  // The Vulkan and GL backends set different default values for the resource
  // cache size. The default backend (specified by the default param of
  // `CreateShell` in this test) will only resolve to Vulkan (in
  // `ShellTestPlatformView::Create`) if GL is disabled. This situation arises
  // when targeting the Fuchsia Emulator.
#if defined(SHELL_ENABLE_VULKAN) && !defined(SHELL_ENABLE_GL)
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            vulkan::kGrCacheMaxByteSize);
#elif defined(SHELL_ENABLE_METAL)
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(256 * (1 << 20)));
#else
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(24 * (1 << 20)));
#endif
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
        shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                     {1.0, 400, 200, 22, 0});
      });
  PumpOneFrame(shell.get());
 
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell), 3840000U);
 
  std::string request_json = R"json({
                                "method": "Skia.setResourceCacheMaxBytes",
                                "args": 10000
                              })json";
  auto data =
      fml::MallocMapping::Copy(request_json.c_str(), request_json.length());
  auto platform_message = std::make_unique<PlatformMessage>(
      "flutter/skia", std::move(data), nullptr);
  SendEnginePlatformMessage(shell.get(), std::move(platform_message));
  PumpOneFrame(shell.get());
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell), 10000U);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
        shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                     {1.0, 800, 400, 22, 0});
      });
  PumpOneFrame(shell.get());
 
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell), 10000U);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [847/925]

flutter::testing::TEST_F	(	ShellTest	,
		SetResourceCacheSizeEarly
	)

Definition at line 1865 of file shell_unittests.cc.

                                             {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
        shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                     {1.0, 400, 200, 22, 0});
      });
  PumpOneFrame(shell.get());
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(3840000U));
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [848/925]

flutter::testing::TEST_F	(	ShellTest	,
		SetResourceCacheSizeNotifiesDart
	)

Definition at line 1893 of file shell_unittests.cc.

                                                    {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell]() {
        shell->GetPlatformView()->SetViewportMetrics(kImplicitViewId,
                                                     {1.0, 400, 200, 22, 0});
      });
  PumpOneFrame(shell.get());
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testSkiaResourceCacheSendsResponse");
 
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(3840000U));
 
  fml::AutoResetWaitableEvent latch;
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&latch](auto args) {
                      latch.Signal();
                    }));
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
 
  latch.Wait();
 
  EXPECT_EQ(GetRasterizerResourceCacheBytesSync(*shell),
            static_cast<size_t>(10000U));
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [849/925]

flutter::testing::TEST_F	(	ShellTest	,
		ShellCanAddViewOrRemoveView
	)

Definition at line 4484 of file shell_unittests.cc.

                                               {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  bool hasImplicitView;
  std::vector<int64_t> viewIds;
  fml::AutoResetWaitableEvent reportLatch;
  auto nativeViewIdsCallback = [&reportLatch, &hasImplicitView,
                                &viewIds](Dart_NativeArguments args) {
    ParseViewIdsCallback(args, &hasImplicitView, &viewIds);
    reportLatch.Signal();
  };
  AddNativeCallback("NativeReportViewIdsCallback",
                    CREATE_NATIVE_ENTRY(nativeViewIdsCallback));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewIds");
  RunEngine(shell.get(), std::move(configuration));
 
  reportLatch.Wait();
  ASSERT_TRUE(hasImplicitView);
  ASSERT_EQ(viewIds.size(), 1u);
  ASSERT_EQ(viewIds[0], 0ll);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    shell->GetPlatformView()->AddView(2, ViewportMetrics{},
                                      [](bool added) { EXPECT_TRUE(added); });
  });
  reportLatch.Wait();
  ASSERT_TRUE(hasImplicitView);
  ASSERT_EQ(viewIds.size(), 2u);
  ASSERT_EQ(viewIds[1], 2ll);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    shell->GetPlatformView()->RemoveView(
        2, [](bool removed) { ASSERT_TRUE(removed); });
  });
  reportLatch.Wait();
  ASSERT_TRUE(hasImplicitView);
  ASSERT_EQ(viewIds.size(), 1u);
  ASSERT_EQ(viewIds[0], 0ll);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    shell->GetPlatformView()->AddView(4, ViewportMetrics{},
                                      [](bool added) { EXPECT_TRUE(added); });
  });
  reportLatch.Wait();
  ASSERT_TRUE(hasImplicitView);
  ASSERT_EQ(viewIds.size(), 2u);
  ASSERT_EQ(viewIds[1], 4ll);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [850/925]

flutter::testing::TEST_F	(	ShellTest	,
		ShellCannotAddDuplicateViewId
	)

Definition at line 4551 of file shell_unittests.cc.

                                                 {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  bool has_implicit_view;
  std::vector<int64_t> view_ids;
  fml::AutoResetWaitableEvent report_latch;
  AddNativeCallback("NativeReportViewIdsCallback",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      ParseViewIdsCallback(args, &has_implicit_view, &view_ids);
                      report_latch.Signal();
                    }));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewIds");
  RunEngine(shell.get(), std::move(configuration));
 
  report_latch.Wait();
  ASSERT_TRUE(has_implicit_view);
  ASSERT_EQ(view_ids.size(), 1u);
  ASSERT_EQ(view_ids[0], kImplicitViewId);
 
  // Add view 123.
  fml::AutoResetWaitableEvent add_latch;
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell,
                                                             &add_latch] {
    shell->GetPlatformView()->AddView(123, ViewportMetrics{}, [&](bool added) {
      EXPECT_TRUE(added);
      add_latch.Signal();
    });
  });
 
  add_latch.Wait();
 
  report_latch.Wait();
  ASSERT_EQ(view_ids.size(), 2u);
  ASSERT_EQ(view_ids[0], kImplicitViewId);
  ASSERT_EQ(view_ids[1], 123);
 
  // Attempt to add duplicate view ID 123. This should fail.
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell,
                                                             &add_latch] {
    shell->GetPlatformView()->AddView(123, ViewportMetrics{}, [&](bool added) {
      EXPECT_FALSE(added);
      add_latch.Signal();
    });
  });
 
  add_latch.Wait();
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [851/925]

flutter::testing::TEST_F	(	ShellTest	,
		ShellCannotRemoveNonexistentId
	)

Definition at line 4617 of file shell_unittests.cc.

                                                  {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  bool has_implicit_view;
  std::vector<int64_t> view_ids;
  fml::AutoResetWaitableEvent report_latch;
  AddNativeCallback("NativeReportViewIdsCallback",
                    CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
                      ParseViewIdsCallback(args, &has_implicit_view, &view_ids);
                      report_latch.Signal();
                    }));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewIds");
  RunEngine(shell.get(), std::move(configuration));
 
  report_latch.Wait();
  ASSERT_TRUE(has_implicit_view);
  ASSERT_EQ(view_ids.size(), 1u);
  ASSERT_EQ(view_ids[0], kImplicitViewId);
 
  // Remove view 123. This should fail as this view doesn't exist.
  fml::AutoResetWaitableEvent remove_latch;
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(),
           [&shell, &remove_latch] {
             shell->GetPlatformView()->RemoveView(123, [&](bool removed) {
               EXPECT_FALSE(removed);
               remove_latch.Signal();
             });
           });
 
  remove_latch.Wait();
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [852/925]

flutter::testing::TEST_F	(	ShellTest	,
		ShellFlushesPlatformStatesByMain
	)

Definition at line 4687 of file shell_unittests.cc.

                                                    {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
          ThreadHost::Type::kIo | ThreadHost::Type::kUi));
  TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
                           thread_host.raster_thread->GetTaskRunner(),
                           thread_host.ui_thread->GetTaskRunner(),
                           thread_host.io_thread->GetTaskRunner());
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  PostSync(shell->GetTaskRunners().GetPlatformTaskRunner(), [&shell] {
    auto platform_view = shell->GetPlatformView();
    // The construtor for ViewportMetrics{_, width, _, _, _} (only the 2nd
    // argument matters in this test).
    platform_view->SetViewportMetrics(0, ViewportMetrics{1, 10, 1, 0, 0});
    shell->GetPlatformView()->AddView(1, ViewportMetrics{1, 30, 1, 0, 0},
                                      [](bool added) { ASSERT_TRUE(added); });
    platform_view->SetViewportMetrics(0, ViewportMetrics{1, 20, 1, 0, 0});
  });
 
  bool first_report = true;
  std::map<int64_t, int64_t> viewWidths;
  fml::AutoResetWaitableEvent reportLatch;
  auto nativeViewWidthsCallback = [&reportLatch, &viewWidths,
                                   &first_report](Dart_NativeArguments args) {
    EXPECT_TRUE(first_report);
    first_report = false;
    ParseViewWidthsCallback(args, &viewWidths);
    reportLatch.Signal();
  };
  AddNativeCallback("NativeReportViewWidthsCallback",
                    CREATE_NATIVE_ENTRY(nativeViewWidthsCallback));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewWidths");
  RunEngine(shell.get(), std::move(configuration));
 
  reportLatch.Wait();
  EXPECT_EQ(viewWidths.size(), 2u);
  EXPECT_EQ(viewWidths[0], 20ll);
  EXPECT_EQ(viewWidths[1], 30ll);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [853/925]

flutter::testing::TEST_F	(	ShellTest	,
		ShellStartsWithImplicitView
	)

Definition at line 4449 of file shell_unittests.cc.

                                               {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(shell);
 
  bool hasImplicitView;
  std::vector<int64_t> viewIds;
  fml::AutoResetWaitableEvent reportLatch;
  auto nativeViewIdsCallback = [&reportLatch, &hasImplicitView,
                                &viewIds](Dart_NativeArguments args) {
    ParseViewIdsCallback(args, &hasImplicitView, &viewIds);
    reportLatch.Signal();
  };
  AddNativeCallback("NativeReportViewIdsCallback",
                    CREATE_NATIVE_ENTRY(nativeViewIdsCallback));
 
  PlatformViewNotifyCreated(shell.get());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("testReportViewIds");
  RunEngine(shell.get(), std::move(configuration));
  reportLatch.Wait();
 
  ASSERT_TRUE(hasImplicitView);
  ASSERT_EQ(viewIds.size(), 1u);
  ASSERT_EQ(viewIds[0], 0ll);
 
  PlatformViewNotifyDestroyed(shell.get());
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [854/925]

flutter::testing::TEST_F	(	ShellTest	,
		SingleFrameCodecAccuratelyReportsSize
	)

Definition at line 19 of file single_frame_codec_unittests.cc.

                                                         {
  auto message_latch = std::make_shared<fml::AutoResetWaitableEvent>();
 
  auto validate_codec = [](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    intptr_t peer = 0;
    Dart_Handle result = Dart_GetNativeInstanceField(
        handle, tonic::DartWrappable::kPeerIndex, &peer);
    ASSERT_FALSE(Dart_IsError(result));
  };
  auto finish = [message_latch](Dart_NativeArguments args) {
    message_latch->Signal();
  };
 
  Settings settings = CreateSettingsForFixture();
  TaskRunners task_runners("test",                  // label
                           GetCurrentTaskRunner(),  // platform
                           CreateNewThread(),       // raster
                           CreateNewThread(),       // ui
                           CreateNewThread()        // io
  );
 
  AddNativeCallback("ValidateCodec", CREATE_NATIVE_ENTRY(validate_codec));
  AddNativeCallback("Finish", CREATE_NATIVE_ENTRY(finish));
 
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(shell->IsSetup());
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("createSingleFrameCodec");
 
  shell->RunEngine(std::move(configuration), [](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  message_latch->Wait();
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [855/925]

flutter::testing::TEST_F	(	ShellTest	,
		Spawn
	)

Definition at line 3204 of file shell_unittests.cc.

                         {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("fixturesAreFunctionalMain");
 
  auto second_configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(second_configuration.IsValid());
  second_configuration.SetEntrypoint("testCanLaunchSecondaryIsolate");
 
  const std::string initial_route("/foo");
 
  fml::AutoResetWaitableEvent main_latch;
  std::string last_entry_point;
  // Fulfill native function for the first Shell's entrypoint.
  AddNativeCallback(
      "SayHiFromFixturesAreFunctionalMain", CREATE_NATIVE_ENTRY([&](auto args) {
        last_entry_point = shell->GetEngine()->GetLastEntrypoint();
        main_latch.Signal();
      }));
  // Fulfill native function for the second Shell's entrypoint.
  fml::CountDownLatch second_latch(2);
  AddNativeCallback(
      // The Dart native function names aren't very consistent but this is
      // just the native function name of the second vm entrypoint in the
      // fixture.
      "NotifyNative",
      CREATE_NATIVE_ENTRY([&](auto args) { second_latch.CountDown(); }));
 
  RunEngine(shell.get(), std::move(configuration));
  main_latch.Wait();
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  // Check first Shell ran the first entrypoint.
  ASSERT_EQ("fixturesAreFunctionalMain", last_entry_point);
 
  PostSync(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [this, &spawner = shell, &second_configuration, &second_latch,
       initial_route]() {
        MockPlatformViewDelegate platform_view_delegate;
        auto spawn = spawner->Spawn(
            std::move(second_configuration), initial_route,
            [&platform_view_delegate](Shell& shell) {
              auto result = std::make_unique<MockPlatformView>(
                  platform_view_delegate, shell.GetTaskRunners());
              ON_CALL(*result, CreateRenderingSurface())
                  .WillByDefault(::testing::Invoke(
                      [] { return std::make_unique<MockSurface>(); }));
              return result;
            },
            [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
        ASSERT_NE(nullptr, spawn.get());
        ASSERT_TRUE(ValidateShell(spawn.get()));
 
        PostSync(spawner->GetTaskRunners().GetUITaskRunner(), [&spawn, &spawner,
                                                               initial_route] {
          // Check second shell ran the second entrypoint.
          ASSERT_EQ("testCanLaunchSecondaryIsolate",
                    spawn->GetEngine()->GetLastEntrypoint());
          ASSERT_EQ(initial_route, spawn->GetEngine()->InitialRoute());
 
          ASSERT_NE(spawner->GetEngine()
                        ->GetRuntimeController()
                        ->GetRootIsolateGroup(),
                    0u);
          ASSERT_EQ(spawner->GetEngine()
                        ->GetRuntimeController()
                        ->GetRootIsolateGroup(),
                    spawn->GetEngine()
                        ->GetRuntimeController()
                        ->GetRootIsolateGroup());
          auto spawner_snapshot_delegate = spawner->GetEngine()
                                               ->GetRuntimeController()
                                               ->GetSnapshotDelegate();
          auto spawn_snapshot_delegate =
              spawn->GetEngine()->GetRuntimeController()->GetSnapshotDelegate();
          PostSync(spawner->GetTaskRunners().GetRasterTaskRunner(),
                   [spawner_snapshot_delegate, spawn_snapshot_delegate] {
                     ASSERT_NE(spawner_snapshot_delegate.get(),
                               spawn_snapshot_delegate.get());
                   });
        });
        PostSync(
            spawner->GetTaskRunners().GetIOTaskRunner(), [&spawner, &spawn] {
              ASSERT_EQ(spawner->GetIOManager()->GetResourceContext().get(),
                        spawn->GetIOManager()->GetResourceContext().get());
            });
 
        // Before destroying the shell, wait for expectations of the spawned
        // isolate to be met.
        second_latch.Wait();
 
        DestroyShell(std::move(spawn));
      });
 
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [856/925]

flutter::testing::TEST_F	(	ShellTest	,
		SpawnWithDartEntrypointArgs
	)

Definition at line 3306 of file shell_unittests.cc.

                                               {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("canReceiveArgumentsWhenEngineRun");
  const std::vector<std::string> entrypoint_args{"foo", "bar"};
  configuration.SetEntrypointArgs(entrypoint_args);
 
  auto second_configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(second_configuration.IsValid());
  second_configuration.SetEntrypoint("canReceiveArgumentsWhenEngineSpawn");
  const std::vector<std::string> second_entrypoint_args{"arg1", "arg2"};
  second_configuration.SetEntrypointArgs(second_entrypoint_args);
 
  const std::string initial_route("/foo");
 
  fml::AutoResetWaitableEvent main_latch;
  std::string last_entry_point;
  // Fulfill native function for the first Shell's entrypoint.
  AddNativeCallback("NotifyNativeWhenEngineRun",
                    CREATE_NATIVE_ENTRY(([&](Dart_NativeArguments args) {
                      ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(
                          Dart_GetNativeArgument(args, 0)));
                      last_entry_point =
                          shell->GetEngine()->GetLastEntrypoint();
                      main_latch.Signal();
                    })));
 
  fml::AutoResetWaitableEvent second_latch;
  // Fulfill native function for the second Shell's entrypoint.
  AddNativeCallback("NotifyNativeWhenEngineSpawn",
                    CREATE_NATIVE_ENTRY(([&](Dart_NativeArguments args) {
                      ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(
                          Dart_GetNativeArgument(args, 0)));
                      last_entry_point =
                          shell->GetEngine()->GetLastEntrypoint();
                      second_latch.Signal();
                    })));
 
  RunEngine(shell.get(), std::move(configuration));
  main_latch.Wait();
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  // Check first Shell ran the first entrypoint.
  ASSERT_EQ("canReceiveArgumentsWhenEngineRun", last_entry_point);
 
  PostSync(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [this, &spawner = shell, &second_configuration, &second_latch,
       initial_route]() {
        MockPlatformViewDelegate platform_view_delegate;
        auto spawn = spawner->Spawn(
            std::move(second_configuration), initial_route,
            [&platform_view_delegate](Shell& shell) {
              auto result = std::make_unique<MockPlatformView>(
                  platform_view_delegate, shell.GetTaskRunners());
              ON_CALL(*result, CreateRenderingSurface())
                  .WillByDefault(::testing::Invoke(
                      [] { return std::make_unique<MockSurface>(); }));
              return result;
            },
            [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
        ASSERT_NE(nullptr, spawn.get());
        ASSERT_TRUE(ValidateShell(spawn.get()));
 
        PostSync(spawner->GetTaskRunners().GetUITaskRunner(),
                 [&spawn, &spawner, initial_route] {
                   // Check second shell ran the second entrypoint.
                   ASSERT_EQ("canReceiveArgumentsWhenEngineSpawn",
                             spawn->GetEngine()->GetLastEntrypoint());
                   ASSERT_EQ(initial_route, spawn->GetEngine()->InitialRoute());
 
                   ASSERT_NE(spawner->GetEngine()
                                 ->GetRuntimeController()
                                 ->GetRootIsolateGroup(),
                             0u);
                   ASSERT_EQ(spawner->GetEngine()
                                 ->GetRuntimeController()
                                 ->GetRootIsolateGroup(),
                             spawn->GetEngine()
                                 ->GetRuntimeController()
                                 ->GetRootIsolateGroup());
                 });
 
        PostSync(
            spawner->GetTaskRunners().GetIOTaskRunner(), [&spawner, &spawn] {
              ASSERT_EQ(spawner->GetIOManager()->GetResourceContext().get(),
                        spawn->GetIOManager()->GetResourceContext().get());
            });
 
        // Before destroying the shell, wait for expectations of the spawned
        // isolate to be met.
        second_latch.Wait();
 
        DestroyShell(std::move(spawn));
      });
 
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [857/925]

flutter::testing::TEST_F	(	ShellTest	,
		SpawnWorksWithOnError
	)

Definition at line 3975 of file shell_unittests.cc.

                                         {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
  configuration.SetEntrypoint("onErrorA");
 
  auto second_configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(second_configuration.IsValid());
  second_configuration.SetEntrypoint("onErrorB");
 
  fml::CountDownLatch latch(2);
 
  AddNativeCallback(
      "NotifyErrorA", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto string_handle = Dart_GetNativeArgument(args, 0);
        const char* c_str;
        Dart_StringToCString(string_handle, &c_str);
        EXPECT_STREQ(c_str, "Exception: I should be coming from A");
        latch.CountDown();
      }));
 
  AddNativeCallback(
      "NotifyErrorB", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto string_handle = Dart_GetNativeArgument(args, 0);
        const char* c_str;
        Dart_StringToCString(string_handle, &c_str);
        EXPECT_STREQ(c_str, "Exception: I should be coming from B");
        latch.CountDown();
      }));
 
  RunEngine(shell.get(), std::move(configuration));
 
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
 
  PostSync(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [this, &spawner = shell, &second_configuration, &latch]() {
        ::testing::NiceMock<MockPlatformViewDelegate> platform_view_delegate;
        auto spawn = spawner->Spawn(
            std::move(second_configuration), "",
            [&platform_view_delegate](Shell& shell) {
              auto result =
                  std::make_unique<::testing::NiceMock<MockPlatformView>>(
                      platform_view_delegate, shell.GetTaskRunners());
              ON_CALL(*result, CreateRenderingSurface())
                  .WillByDefault(::testing::Invoke([] {
                    return std::make_unique<::testing::NiceMock<MockSurface>>();
                  }));
              return result;
            },
            [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
        ASSERT_NE(nullptr, spawn.get());
        ASSERT_TRUE(ValidateShell(spawn.get()));
 
        // Before destroying the shell, wait for expectations of the spawned
        // isolate to be met.
        latch.Wait();
 
        DestroyShell(std::move(spawn));
      });
 
  DestroyShell(std::move(shell));
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [858/925]

flutter::testing::TEST_F	(	ShellTest	,
		TextureFrameMarkedAvailableAndUnregister
	)

Definition at line 2001 of file shell_unittests.cc.

                                                            {
  Settings settings = CreateSettingsForFixture();
  auto configuration = RunConfiguration::InferFromSettings(settings);
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  ASSERT_TRUE(ValidateShell(shell.get()));
  PlatformViewNotifyCreated(shell.get());
 
  RunEngine(shell.get(), std::move(configuration));
 
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
 
  std::shared_ptr<MockTexture> mockTexture =
      std::make_shared<MockTexture>(0, latch);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(), [&]() {
        shell->GetPlatformView()->RegisterTexture(mockTexture);
        shell->GetPlatformView()->MarkTextureFrameAvailable(0);
      });
  latch->Wait();
 
  EXPECT_EQ(mockTexture->frames_available(), 1);
 
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetRasterTaskRunner(),
      [&]() { shell->GetPlatformView()->UnregisterTexture(0); });
  latch->Wait();
 
  EXPECT_EQ(mockTexture->unregistered(), true);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [859/925]

flutter::testing::TEST_F	(	ShellTest	,
		UIWorkAfterOnPlatformViewDestroyed
	)

Definition at line 3890 of file shell_unittests.cc.

                                                      {
  auto settings = CreateSettingsForFixture();
  auto shell = CreateShell(settings);
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("drawFrames");
 
  fml::AutoResetWaitableEvent latch;
  fml::AutoResetWaitableEvent notify_native_latch;
  AddNativeCallback("NotifyNative", CREATE_NATIVE_ENTRY([&](auto args) {
                      notify_native_latch.Signal();
                      latch.Wait();
                    }));
 
  RunEngine(shell.get(), std::move(configuration));
  // Wait to make sure we get called back from Dart and thus have latched
  // the UI thread before we create/destroy the platform view.
  notify_native_latch.Wait();
 
  ShellTest::PlatformViewNotifyCreated(shell.get());
 
  fml::AutoResetWaitableEvent destroy_latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetPlatformTaskRunner(),
      [&shell, &destroy_latch]() {
        shell->GetPlatformView()->NotifyDestroyed();
        destroy_latch.Signal();
      });
 
  destroy_latch.Wait();
 
  // Unlatch the UI thread and let it send us a scene to render.
  latch.Signal();
 
  // Flush the UI task runner to make sure we process the render/scheduleFrame
  // request.
  fml::AutoResetWaitableEvent ui_flush_latch;
  fml::TaskRunner::RunNowOrPostTask(
      shell->GetTaskRunners().GetUITaskRunner(),
      [&ui_flush_latch]() { ui_flush_latch.Signal(); });
  ui_flush_latch.Wait();
  DestroyShell(std::move(shell));
}

◆ TEST_F() [860/925]

flutter::testing::TEST_F	(	ShellTest	,
		UpdateAssetResolverByTypeAppends
	)

Definition at line 3603 of file shell_unittests.cc.

                                                    {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  auto asset_manager = configuration.GetAssetManager();
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  auto platform_view =
      std::make_unique<PlatformView>(*shell.get(), task_runners);
 
  auto updated_resolver = std::make_unique<TestAssetResolver>(
      false, AssetResolver::AssetResolverType::kApkAssetProvider);
  ASSERT_FALSE(updated_resolver->IsValidAfterAssetManagerChange());
  platform_view->UpdateAssetResolverByType(
      std::move(updated_resolver),
      AssetResolver::AssetResolverType::kApkAssetProvider);
 
  auto resolvers = asset_manager->TakeResolvers();
  ASSERT_EQ(resolvers.size(), 2ull);
  ASSERT_TRUE(resolvers[0]->IsValidAfterAssetManagerChange());
 
  ASSERT_FALSE(resolvers[1]->IsValidAfterAssetManagerChange());
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [861/925]

flutter::testing::TEST_F	(	ShellTest	,
		UpdateAssetResolverByTypeDoesNotReplaceMismatchType
	)

Definition at line 3681 of file shell_unittests.cc.

                                                                       {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  auto asset_manager = configuration.GetAssetManager();
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  auto platform_view =
      std::make_unique<PlatformView>(*shell.get(), task_runners);
 
  auto old_resolver = std::make_unique<TestAssetResolver>(
      true, AssetResolver::AssetResolverType::kAssetManager);
  ASSERT_TRUE(old_resolver->IsValid());
  asset_manager->PushBack(std::move(old_resolver));
 
  auto updated_resolver = std::make_unique<TestAssetResolver>(
      false, AssetResolver::AssetResolverType::kApkAssetProvider);
  ASSERT_FALSE(updated_resolver->IsValidAfterAssetManagerChange());
  platform_view->UpdateAssetResolverByType(
      std::move(updated_resolver),
      AssetResolver::AssetResolverType::kApkAssetProvider);
 
  auto resolvers = asset_manager->TakeResolvers();
  ASSERT_EQ(resolvers.size(), 3ull);
  ASSERT_TRUE(resolvers[0]->IsValidAfterAssetManagerChange());
 
  ASSERT_TRUE(resolvers[1]->IsValidAfterAssetManagerChange());
 
  ASSERT_FALSE(resolvers[2]->IsValidAfterAssetManagerChange());
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [862/925]

flutter::testing::TEST_F	(	ShellTest	,
		UpdateAssetResolverByTypeNull
	)

Definition at line 3643 of file shell_unittests.cc.

                                                 {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  ThreadHost thread_host(ThreadHost::ThreadHostConfig(
      "io.flutter.test." + GetCurrentTestName() + ".",
      ThreadHost::Type::kPlatform));
  auto task_runner = thread_host.platform_thread->GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  auto asset_manager = configuration.GetAssetManager();
  RunEngine(shell.get(), std::move(configuration));
 
  auto platform_view =
      std::make_unique<PlatformView>(*shell.get(), task_runners);
 
  auto old_resolver = std::make_unique<TestAssetResolver>(
      true, AssetResolver::AssetResolverType::kApkAssetProvider);
  ASSERT_TRUE(old_resolver->IsValid());
  asset_manager->PushBack(std::move(old_resolver));
 
  platform_view->UpdateAssetResolverByType(
      nullptr, AssetResolver::AssetResolverType::kApkAssetProvider);
 
  auto resolvers = asset_manager->TakeResolvers();
  ASSERT_EQ(resolvers.size(), 2ull);
  ASSERT_TRUE(resolvers[0]->IsValidAfterAssetManagerChange());
  ASSERT_TRUE(resolvers[1]->IsValidAfterAssetManagerChange());
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [863/925]

flutter::testing::TEST_F	(	ShellTest	,
		UpdateAssetResolverByTypeReplaces
	)

Definition at line 3558 of file shell_unittests.cc.

                                                     {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
 
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  auto task_runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  auto shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
  auto asset_manager = configuration.GetAssetManager();
 
  shell->RunEngine(std::move(configuration), [&](auto result) {
    ASSERT_EQ(result, Engine::RunStatus::Success);
  });
 
  auto platform_view =
      std::make_unique<PlatformView>(*shell.get(), task_runners);
 
  auto old_resolver = std::make_unique<TestAssetResolver>(
      true, AssetResolver::AssetResolverType::kApkAssetProvider);
  ASSERT_TRUE(old_resolver->IsValid());
  asset_manager->PushBack(std::move(old_resolver));
 
  auto updated_resolver = std::make_unique<TestAssetResolver>(
      false, AssetResolver::AssetResolverType::kApkAssetProvider);
  ASSERT_FALSE(updated_resolver->IsValidAfterAssetManagerChange());
  platform_view->UpdateAssetResolverByType(
      std::move(updated_resolver),
      AssetResolver::AssetResolverType::kApkAssetProvider);
 
  auto resolvers = asset_manager->TakeResolvers();
  ASSERT_EQ(resolvers.size(), 2ull);
  ASSERT_TRUE(resolvers[0]->IsValidAfterAssetManagerChange());
 
  ASSERT_FALSE(resolvers[1]->IsValidAfterAssetManagerChange());
 
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [864/925]

flutter::testing::TEST_F	(	ShellTest	,
		UserTagSetOnStartup
	)

Definition at line 3800 of file shell_unittests.cc.

                                       {
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  // Make sure the shell launch does not kick off the creation of the VM
  // instance by already creating one upfront.
  auto vm_settings = CreateSettingsForFixture();
  auto vm_ref = DartVMRef::Create(vm_settings);
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
 
  auto settings = vm_settings;
  fml::AutoResetWaitableEvent isolate_create_latch;
 
  // ensure that "AppStartUpTag" is set during isolate creation.
  settings.root_isolate_create_callback = [&](const DartIsolate& isolate) {
    Dart_Handle current_tag = Dart_GetCurrentUserTag();
    Dart_Handle startup_tag = Dart_NewUserTag("AppStartUp");
    EXPECT_TRUE(Dart_IdentityEquals(current_tag, startup_tag));
 
    isolate_create_latch.Signal();
  };
 
  auto shell = CreateShell(settings);
  ASSERT_TRUE(ValidateShell(shell.get()));
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  ASSERT_TRUE(configuration.IsValid());
 
  RunEngine(shell.get(), std::move(configuration));
  ASSERT_TRUE(DartVMRef::IsInstanceRunning());
 
  DestroyShell(std::move(shell));
  isolate_create_latch.Wait();
}

◆ TEST_F() [865/925]

flutter::testing::TEST_F	(	ShellTest	,
		UsesPlatformMessageHandler
	)

Definition at line 3933 of file shell_unittests.cc.

                                              {
  TaskRunners task_runners = GetTaskRunnersForFixture();
  auto settings = CreateSettingsForFixture();
  MockPlatformViewDelegate platform_view_delegate;
  auto platform_message_handler =
      std::make_shared<MockPlatformMessageHandler>();
  int message_id = 1;
  EXPECT_CALL(*platform_message_handler, HandlePlatformMessage(_));
  EXPECT_CALL(*platform_message_handler,
              InvokePlatformMessageEmptyResponseCallback(message_id));
  Shell::CreateCallback<PlatformView> platform_view_create_callback =
      [&platform_view_delegate, task_runners,
       platform_message_handler](flutter::Shell& shell) {
        auto result = std::make_unique<MockPlatformView>(platform_view_delegate,
                                                         task_runners);
        EXPECT_CALL(*result, GetPlatformMessageHandler())
            .WillOnce(Return(platform_message_handler));
        return result;
      };
  auto shell = CreateShell({
      .settings = settings,
      .task_runners = task_runners,
      .platform_view_create_callback = platform_view_create_callback,
  });
 
  EXPECT_EQ(platform_message_handler, shell->GetPlatformMessageHandler());
  PostSync(task_runners.GetUITaskRunner(), [&shell]() {
    size_t data_size = 4;
    fml::MallocMapping bytes =
        fml::MallocMapping(static_cast<uint8_t*>(malloc(data_size)), data_size);
    fml::RefPtr<MockPlatformMessageResponse> response =
        MockPlatformMessageResponse::Create();
    auto message = std::make_unique<PlatformMessage>(
        /*channel=*/"foo", /*data=*/std::move(bytes), /*response=*/response);
    (static_cast<Engine::Delegate*>(shell.get()))
        ->OnEngineHandlePlatformMessage(std::move(message));
  });
  shell->GetPlatformMessageHandler()
      ->InvokePlatformMessageEmptyResponseCallback(message_id);
  DestroyShell(std::move(shell));
}

◆ TEST_F() [866/925]

flutter::testing::TEST_F	(	ShellTest	,
		VSyncTargetTime
	)

Definition at line 55 of file animator_unittests.cc.

                                   {
  // Add native callbacks to listen for window.onBeginFrame
  int64_t target_time;
  fml::AutoResetWaitableEvent on_target_time_latch;
  auto nativeOnBeginFrame = [&on_target_time_latch,
                             &target_time](Dart_NativeArguments args) {
    Dart_Handle exception = nullptr;
    target_time =
        tonic::DartConverter<int64_t>::FromArguments(args, 0, exception);
    on_target_time_latch.Signal();
  };
  AddNativeCallback("NativeOnBeginFrame",
                    CREATE_NATIVE_ENTRY(nativeOnBeginFrame));
 
  // Create all te prerequisites for a shell.
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  auto settings = CreateSettingsForFixture();
 
  std::unique_ptr<Shell> shell;
 
  TaskRunners task_runners = GetTaskRunnersForFixture();
  // this is not used as we are not using simulated events.
  const auto vsync_clock = std::make_shared<ShellTestVsyncClock>();
  CreateVsyncWaiter create_vsync_waiter = [&]() {
    return static_cast<std::unique_ptr<VsyncWaiter>>(
        std::make_unique<ConstantFiringVsyncWaiter>(task_runners));
  };
 
  // create a shell with a constant firing vsync waiter.
  auto platform_task = std::async(std::launch::async, [&]() {
    fml::MessageLoop::EnsureInitializedForCurrentThread();
 
    shell = Shell::Create(
        flutter::PlatformData(), task_runners, settings,
        [vsync_clock, &create_vsync_waiter](Shell& shell) {
          return ShellTestPlatformView::Create(
              shell, shell.GetTaskRunners(), vsync_clock, create_vsync_waiter,
              ShellTestPlatformView::BackendType::kDefaultBackend, nullptr,
              shell.GetIsGpuDisabledSyncSwitch());
        },
        [](Shell& shell) { return std::make_unique<Rasterizer>(shell); });
    ASSERT_TRUE(DartVMRef::IsInstanceRunning());
 
    auto configuration = RunConfiguration::InferFromSettings(settings);
    ASSERT_TRUE(configuration.IsValid());
    configuration.SetEntrypoint("onBeginFrameMain");
 
    RunEngine(shell.get(), std::move(configuration));
  });
  platform_task.wait();
  on_target_time_latch.Wait();
  const auto vsync_waiter_target_time =
      ConstantFiringVsyncWaiter::kFrameTargetTime;
  ASSERT_EQ(vsync_waiter_target_time.ToEpochDelta().ToMicroseconds(),
            target_time);
 
  // validate that the latest target time has also been updated.
  ASSERT_EQ(GetLatestFrameTargetTime(shell.get()), vsync_waiter_target_time);
 
  // teardown.
  DestroyShell(std::move(shell), task_runners);
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
}

◆ TEST_F() [867/925]

flutter::testing::TEST_F	(	ShellTest	,
		WaitForFirstFrame
	)

Definition at line 1559 of file shell_unittests.cc.

                                     {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  fml::Status result = shell->WaitForFirstFrame(fml::TimeDelta::Max());
  ASSERT_TRUE(result.ok());
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [868/925]

flutter::testing::TEST_F	(	ShellTest	,
		WaitForFirstFrameInlined
	)

Makes sure that WaitForFirstFrame works if we rendered a frame with the single-thread setup.

Definition at line 1639 of file shell_unittests.cc.

                                            {
  Settings settings = CreateSettingsForFixture();
  auto task_runner = CreateNewThread();
  TaskRunners task_runners("test", task_runner, task_runner, task_runner,
                           task_runner);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  fml::AutoResetWaitableEvent event;
  task_runner->PostTask([&shell, &event] {
    fml::Status result = shell->WaitForFirstFrame(fml::TimeDelta::Max());
    ASSERT_FALSE(result.ok());
    ASSERT_EQ(result.code(), fml::StatusCode::kFailedPrecondition);
    event.Signal();
  });
  ASSERT_FALSE(event.WaitWithTimeout(fml::TimeDelta::Max()));
 
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [869/925]

flutter::testing::TEST_F	(	ShellTest	,
		WaitForFirstFrameMultiple
	)

Definition at line 1615 of file shell_unittests.cc.

                                             {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get());
  fml::Status result = shell->WaitForFirstFrame(fml::TimeDelta::Max());
  ASSERT_TRUE(result.ok());
  for (int i = 0; i < 100; ++i) {
    result = shell->WaitForFirstFrame(fml::TimeDelta::Zero());
    ASSERT_TRUE(result.ok());
  }
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [870/925]

flutter::testing::TEST_F	(	ShellTest	,
		WaitForFirstFrameTimeout
	)

Definition at line 1597 of file shell_unittests.cc.

                                            {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  fml::Status result = shell->WaitForFirstFrame(fml::TimeDelta::Zero());
  ASSERT_FALSE(result.ok());
  ASSERT_EQ(result.code(), fml::StatusCode::kDeadlineExceeded);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [871/925]

flutter::testing::TEST_F	(	ShellTest	,
		WaitForFirstFrameZeroSizeFrame
	)

Definition at line 1577 of file shell_unittests.cc.

                                                  {
  auto settings = CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = CreateShell(settings);
 
  // Create the surface needed by rasterizer
  PlatformViewNotifyCreated(shell.get());
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("emptyMain");
 
  RunEngine(shell.get(), std::move(configuration));
  PumpOneFrame(shell.get(), ViewContent::DummyView({1.0, 0.0, 0.0, 22, 0}));
  fml::Status result = shell->WaitForFirstFrame(fml::TimeDelta::Zero());
  EXPECT_FALSE(result.ok());
  EXPECT_EQ(result.message(), "timeout");
  EXPECT_EQ(result.code(), fml::StatusCode::kDeadlineExceeded);
 
  DestroyShell(std::move(shell));
}

◆ TEST_F() [872/925]

flutter::testing::TEST_F	(	ShellTest	,
		WillLogWarningWhenImpellerIsOptedOut
	)

Definition at line 4933 of file shell_unittests.cc.

                                                        {
#if !IMPELLER_SUPPORTS_RENDERING
  GTEST_SKIP() << "This platform doesn't support Impeller.";
#endif
  ASSERT_FALSE(DartVMRef::IsInstanceRunning());
  Settings settings = CreateSettingsForFixture();
  settings.enable_impeller = false;
  settings.warn_on_impeller_opt_out = true;
  // Log captures are thread specific. Just put the shell in single threaded
  // configuration.
  const auto& runner = fml::MessageLoop::GetCurrent().GetTaskRunner();
  TaskRunners task_runners("test", runner, runner, runner, runner);
  std::ostringstream stream;
  fml::LogMessage::CaptureNextLog(&stream);
  std::unique_ptr<Shell> shell = CreateShell(settings, task_runners);
  ASSERT_TRUE(stream.str().find(
                  "[Action Required] The application opted out of Impeller") !=
              std::string::npos);
  ASSERT_TRUE(shell);
  DestroyShell(std::move(shell), task_runners);
}

◆ TEST_F() [873/925]

flutter::testing::TEST_F	(	SkiaGpuObjectTest	,
		ObjectDestructor
	)

Definition at line 100 of file skia_gpu_object_unittests.cc.

                                            {
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
  fml::TaskQueueId dtor_task_queue_id(0);
  auto object = sk_make_sp<TestSkObject>(latch, &dtor_task_queue_id);
  {
    SkiaGPUObject<TestSkObject> sk_object(std::move(object), unref_queue());
    // Verify that the default SkiaGPUObject dtor queues and unref.
  }
 
  latch->Wait();
  ASSERT_EQ(dtor_task_queue_id, unref_task_runner()->GetTaskQueueId());
}

◆ TEST_F() [874/925]

flutter::testing::TEST_F	(	SkiaGpuObjectTest	,
		ObjectReset
	)

Definition at line 114 of file skia_gpu_object_unittests.cc.

                                       {
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
  fml::TaskQueueId dtor_task_queue_id(0);
  SkiaGPUObject<TestSkObject> sk_object(
      sk_make_sp<TestSkObject>(latch, &dtor_task_queue_id), unref_queue());
  // Verify that explicitly resetting the GPU object queues and unref.
  sk_object.reset();
  ASSERT_EQ(sk_object.skia_object(), nullptr);
  latch->Wait();
  ASSERT_EQ(dtor_task_queue_id, unref_task_runner()->GetTaskQueueId());
}

◆ TEST_F() [875/925]

flutter::testing::TEST_F	(	SkiaGpuObjectTest	,
		ObjectResetTwice
	)

Definition at line 127 of file skia_gpu_object_unittests.cc.

                                            {
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
  fml::TaskQueueId dtor_task_queue_id(0);
  SkiaGPUObject<TestSkObject> sk_object(
      sk_make_sp<TestSkObject>(latch, &dtor_task_queue_id), unref_queue());
 
  sk_object.reset();
  ASSERT_EQ(sk_object.skia_object(), nullptr);
  sk_object.reset();
  ASSERT_EQ(sk_object.skia_object(), nullptr);
 
  latch->Wait();
  ASSERT_EQ(dtor_task_queue_id, unref_task_runner()->GetTaskQueueId());
}

◆ TEST_F() [876/925]

flutter::testing::TEST_F	(	SkiaGpuObjectTest	,
		QueueSimple
	)

Definition at line 89 of file skia_gpu_object_unittests.cc.

                                       {
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
  fml::TaskQueueId dtor_task_queue_id(0);
  SkRefCnt* ref_object = new TestSkObject(latch, &dtor_task_queue_id);
 
  unref_queue()->Unref(ref_object);
  latch->Wait();
  ASSERT_EQ(dtor_task_queue_id, unref_task_runner()->GetTaskQueueId());
}

◆ TEST_F() [877/925]

flutter::testing::TEST_F	(	SkiaGpuObjectTest	,
		UnrefResourceContextInTaskRunnerThread
	)

Definition at line 143 of file skia_gpu_object_unittests.cc.

                                                                  {
  std::shared_ptr<fml::AutoResetWaitableEvent> latch =
      std::make_shared<fml::AutoResetWaitableEvent>();
  fml::RefPtr<UnrefQueue<TestResourceContext>> unref_queue;
  fml::TaskQueueId dtor_task_queue_id(0);
  unref_task_runner()->PostTask([&]() {
    auto resource_context =
        sk_make_sp<TestResourceContext>(latch, &dtor_task_queue_id);
    unref_queue = fml::MakeRefCounted<UnrefQueue<TestResourceContext>>(
        unref_task_runner(), fml::TimeDelta::FromSeconds(0),
        std::move(resource_context));
    latch->Signal();
  });
  latch->Wait();
 
  // Delete the unref queue, it will schedule a task to unref the resource
  // context in the task runner's thread.
  unref_queue = nullptr;
  latch->Wait();
  // Verify that the resource context was destroyed in the task runner's thread.
  ASSERT_EQ(dtor_task_queue_id, unref_task_runner()->GetTaskQueueId());
}

◆ TEST_F() [878/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		ClearClientRequiresView
	)

Definition at line 207 of file text_input_plugin_unittest.cc.

                                                     {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
 
  std::string reply;
  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
                                       size_t reply_size) {
    reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
  };
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
  messenger.SimulateEngineMessage(kChannelName, message->data(),
                                  message->size(), reply_handler);
 
  EXPECT_EQ(reply,
            "[\"Internal Consistency Error\",\"Text input is not available in "
            "Windows headless mode\",null]");
}

◆ TEST_F() [879/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		ClearClientResetsComposing
	)

Definition at line 188 of file text_input_plugin_unittest.cc.

                                                        {
  UseEngineWithView();
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
 
  TextInputPlugin handler(&messenger, engine());
 
  EXPECT_CALL(*view(), OnResetImeComposing());
 
  auto& codec = JsonMethodCodec::GetInstance();
  auto message = codec.EncodeMethodCall({"TextInput.clearClient", nullptr});
  messenger.SimulateEngineMessage(kChannelName, message->data(),
                                  message->size(), reply_handler);
}

◆ TEST_F() [880/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		CompositionCursorPos
	)

Definition at line 453 of file text_input_plugin_unittest.cc.

                                                  {
  UseEngineWithView();
 
  int selection_base = -1;
  TestBinaryMessenger messenger([&](const std::string& channel,
                                    const uint8_t* message, size_t size,
                                    BinaryReply reply) {
    auto method = JsonMethodCodec::GetInstance().DecodeMethodCall(
        std::vector<uint8_t>(message, message + size));
    if (method->method_name() == kUpdateEditingStateMethod) {
      const auto& args = *method->arguments();
      const auto& editing_state = args[1];
      auto base = editing_state.FindMember(kSelectionBaseKey);
      auto extent = editing_state.FindMember(kSelectionExtentKey);
      ASSERT_NE(base, editing_state.MemberEnd());
      ASSERT_TRUE(base->value.IsInt());
      ASSERT_NE(extent, editing_state.MemberEnd());
      ASSERT_TRUE(extent->value.IsInt());
      selection_base = base->value.GetInt();
      EXPECT_EQ(extent->value.GetInt(), selection_base);
    }
  });
 
  TextInputPlugin plugin(&messenger, engine());
 
  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = args->GetAllocator();
  args->PushBack(123, allocator);  // client_id
  rapidjson::Value client_config(rapidjson::kObjectType);
  args->PushBack(client_config, allocator);
  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
      MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
  EXPECT_TRUE(messenger.SimulateEngineMessage(
      kChannelName, encoded->data(), encoded->size(),
      [](const uint8_t* reply, size_t reply_size) {}));
 
  plugin.ComposeBeginHook();
  EXPECT_EQ(selection_base, 0);
  plugin.ComposeChangeHook(u"abc", 3);
  EXPECT_EQ(selection_base, 3);
 
  plugin.ComposeCommitHook();
  plugin.ComposeEndHook();
  EXPECT_EQ(selection_base, 3);
 
  plugin.ComposeBeginHook();
  plugin.ComposeChangeHook(u"1", 1);
  EXPECT_EQ(selection_base, 4);
 
  plugin.ComposeChangeHook(u"12", 2);
  EXPECT_EQ(selection_base, 5);
 
  plugin.ComposeChangeHook(u"12", 1);
  EXPECT_EQ(selection_base, 4);
 
  plugin.ComposeChangeHook(u"12", 2);
  EXPECT_EQ(selection_base, 5);
}

◆ TEST_F() [881/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		SetMarkedTextRectRequiresView
	)

Definition at line 583 of file text_input_plugin_unittest.cc.

                                                           {
  UseHeadlessEngine();
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
 
  std::string reply;
  BinaryReply reply_handler = [&reply](const uint8_t* reply_bytes,
                                       size_t reply_size) {
    reply = std::string(reinterpret_cast<const char*>(reply_bytes), reply_size);
  };
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
 
  auto arguments =
      std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
  auto& allocator = arguments->GetAllocator();
 
  arguments->AddMember("x", 0, allocator);
  arguments->AddMember("y", 0, allocator);
  arguments->AddMember("width", 0, allocator);
  arguments->AddMember("height", 0, allocator);
 
  auto message = codec.EncodeMethodCall(
      {"TextInput.setMarkedTextRect", std::move(arguments)});
  messenger.SimulateEngineMessage(kChannelName, message->data(),
                                  message->size(), reply_handler);
 
  EXPECT_EQ(reply,
            "[\"Internal Consistency Error\",\"Text input is not available in "
            "Windows headless mode\",null]");
}

◆ TEST_F() [882/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		TextEditingWorksWithDeltaModel
	)

Definition at line 395 of file text_input_plugin_unittest.cc.

                                                            {
  UseEngineWithView();
 
  auto handled_message = CreateResponse(true);
  auto unhandled_message = CreateResponse(false);
  int received_scancode = 0;
 
  TestBinaryMessenger messenger(
      [&received_scancode, &handled_message, &unhandled_message](
          const std::string& channel, const uint8_t* message,
          size_t message_size, BinaryReply reply) {});
 
  int redispatch_scancode = 0;
  TextInputPlugin handler(&messenger, engine());
 
  auto args = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = args->GetAllocator();
  args->PushBack(123, allocator);  // client_id
 
  rapidjson::Value client_config(rapidjson::kObjectType);
  client_config.AddMember(kEnableDeltaModel, true, allocator);
 
  args->PushBack(client_config, allocator);
  auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall(
      MethodCall<rapidjson::Document>(kSetClientMethod, std::move(args)));
 
  EXPECT_TRUE(messenger.SimulateEngineMessage(
      kChannelName, encoded->data(), encoded->size(),
      [](const uint8_t* reply, size_t reply_size) {}));
 
  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
  handler.ComposeBeginHook();
  std::u16string text;
  text.push_back('\n');
  handler.ComposeChangeHook(text, 1);
  handler.ComposeEndHook();
 
  handler.KeyboardHook(0x4E, 100, WM_KEYDOWN, 'n', false, false);
  handler.ComposeBeginHook();
  std::u16string textN;
  text.push_back('n');
  handler.ComposeChangeHook(textN, 1);
  handler.KeyboardHook(0x49, 100, WM_KEYDOWN, 'i', false, false);
  std::u16string textNi;
  text.push_back('n');
  text.push_back('i');
  handler.ComposeChangeHook(textNi, 2);
  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
  std::u16string textChineseCharacter;
  text.push_back(u'\u4F60');
  handler.ComposeChangeHook(textChineseCharacter, 1);
  handler.ComposeCommitHook();
  handler.ComposeEndHook();
 
  // Passes if it did not crash
}

◆ TEST_F() [883/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		TextMethodsWorksWithEmptyModel
	)

Definition at line 163 of file text_input_plugin_unittest.cc.

                                                            {
  UseEngineWithView();
 
  auto handled_message = CreateResponse(true);
  auto unhandled_message = CreateResponse(false);
  int received_scancode = 0;
 
  TestBinaryMessenger messenger(
      [&received_scancode, &handled_message, &unhandled_message](
          const std::string& channel, const uint8_t* message,
          size_t message_size, BinaryReply reply) {});
 
  int redispatch_scancode = 0;
  TextInputPlugin handler(&messenger, engine());
 
  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
  handler.ComposeBeginHook();
  std::u16string text;
  text.push_back('\n');
  handler.ComposeChangeHook(text, 1);
  handler.ComposeEndHook();
 
  // Passes if it did not crash
}

◆ TEST_F() [884/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		TransformCursorRect
	)

Definition at line 512 of file text_input_plugin_unittest.cc.

                                                 {
  UseEngineWithView();
 
  // A position of `EditableText`.
  double view_x = 100;
  double view_y = 200;
 
  // A position and size of marked text, in `EditableText` local coordinates.
  double ime_x = 3;
  double ime_y = 4;
  double ime_width = 50;
  double ime_height = 60;
 
  // Transformation matrix.
  std::array<std::array<double, 4>, 4> editabletext_transform = {
      1.0, 0.0, 0.0, view_x,  //
      0.0, 1.0, 0.0, view_y,  //
      0.0, 0.0, 0.0, 0.0,     //
      0.0, 0.0, 0.0, 1.0};
 
  TestBinaryMessenger messenger([](const std::string& channel,
                                   const uint8_t* message, size_t message_size,
                                   BinaryReply reply) {});
  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
 
  EXPECT_CALL(*view(), OnCursorRectUpdated(Rect{{view_x, view_y}, {0, 0}}));
 
  {
    auto arguments =
        std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
    auto& allocator = arguments->GetAllocator();
 
    rapidjson::Value transoform(rapidjson::kArrayType);
    for (int i = 0; i < 4 * 4; i++) {
      // Pack 2-dimensional array by column-major order.
      transoform.PushBack(editabletext_transform[i % 4][i / 4], allocator);
    }
 
    arguments->AddMember("transform", transoform, allocator);
 
    auto message = codec.EncodeMethodCall(
        {"TextInput.setEditableSizeAndTransform", std::move(arguments)});
    messenger.SimulateEngineMessage(kChannelName, message->data(),
                                    message->size(), reply_handler);
  }
 
  EXPECT_CALL(*view(),
              OnCursorRectUpdated(Rect{{view_x + ime_x, view_y + ime_y},
                                       {ime_width, ime_height}}));
 
  {
    auto arguments =
        std::make_unique<rapidjson::Document>(rapidjson::kObjectType);
    auto& allocator = arguments->GetAllocator();
 
    arguments->AddMember("x", ime_x, allocator);
    arguments->AddMember("y", ime_y, allocator);
    arguments->AddMember("width", ime_width, allocator);
    arguments->AddMember("height", ime_height, allocator);
 
    auto message = codec.EncodeMethodCall(
        {"TextInput.setMarkedTextRect", std::move(arguments)});
    messenger.SimulateEngineMessage(kChannelName, message->data(),
                                    message->size(), reply_handler);
  }
}

◆ TEST_F() [885/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		VerifyComposingSendStateUpdate
	)

Definition at line 234 of file text_input_plugin_unittest.cc.

                                                            {
  UseEngineWithView();
 
  bool sent_message = false;
  TestBinaryMessenger messenger(
      [&sent_message](const std::string& channel, const uint8_t* message,
                      size_t message_size,
                      BinaryReply reply) { sent_message = true; });
  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
 
  // Call TextInput.setClient to initialize the TextInputModel.
  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = arguments->GetAllocator();
  arguments->PushBack(kDefaultClientId, allocator);
  rapidjson::Value config(rapidjson::kObjectType);
  config.AddMember("inputAction", "done", allocator);
  config.AddMember("inputType", "text", allocator);
  config.AddMember(kEnableDeltaModel, false, allocator);
  arguments->PushBack(config, allocator);
  auto message =
      codec.EncodeMethodCall({"TextInput.setClient", std::move(arguments)});
  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
                                  message->size(), reply_handler);
 
  // ComposeBeginHook should send state update.
  sent_message = false;
  handler.ComposeBeginHook();
  EXPECT_TRUE(sent_message);
 
  // ComposeChangeHook should send state update.
  sent_message = false;
  handler.ComposeChangeHook(u"4", 1);
  EXPECT_TRUE(sent_message);
 
  // ComposeCommitHook should NOT send state update.
  //
  // Commit messages are always immediately followed by a change message or an
  // end message, both of which will send an update. Sending intermediate state
  // with a collapsed composing region will trigger the framework to assume
  // composing has ended, which is not the case until a WM_IME_ENDCOMPOSING
  // event is received in the main event loop, which will trigger a call to
  // ComposeEndHook.
  sent_message = false;
  handler.ComposeCommitHook();
  EXPECT_FALSE(sent_message);
 
  // ComposeEndHook should send state update.
  sent_message = false;
  handler.ComposeEndHook();
  EXPECT_TRUE(sent_message);
}

◆ TEST_F() [886/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		VerifyInputActionNewlineInsertNewLine
	)

Definition at line 290 of file text_input_plugin_unittest.cc.

                                                                   {
  UseEngineWithView();
 
  // Store messages as std::string for convenience.
  std::vector<std::string> messages;
 
  TestBinaryMessenger messenger(
      [&messages](const std::string& channel, const uint8_t* message,
                  size_t message_size, BinaryReply reply) {
        std::string last_message(reinterpret_cast<const char*>(message),
                                 message_size);
        messages.push_back(last_message);
      });
  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
 
  // Call TextInput.setClient to initialize the TextInputModel.
  auto set_client_arguments =
      EncodedClientConfig("TextInputType.multiline", "TextInputAction.newline");
  auto message = codec.EncodeMethodCall(
      {"TextInput.setClient", std::move(set_client_arguments)});
  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
                                  message->size(), reply_handler);
 
  // Simulate a key down event for '\n'.
  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
 
  // Two messages are expected, the first is TextInput.updateEditingState and
  // the second is TextInputClient.performAction.
  EXPECT_EQ(messages.size(), 2);
 
  // Editing state should have been updated.
  auto encoded_arguments = EncodedEditingState("\n", TextRange(1));
  auto update_state_message = codec.EncodeMethodCall(
      {kUpdateEditingStateMethod, std::move(encoded_arguments)});
 
  EXPECT_TRUE(std::equal(update_state_message->begin(),
                         update_state_message->end(),
                         messages.front().begin()));
 
  // TextInputClient.performAction should have been called.
  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = arguments->GetAllocator();
  arguments->PushBack(kDefaultClientId, allocator);
  arguments->PushBack(
      rapidjson::Value("TextInputAction.newline", allocator).Move(), allocator);
  auto invoke_action_message = codec.EncodeMethodCall(
      {"TextInputClient.performAction", std::move(arguments)});
 
  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
                         invoke_action_message->end(),
                         messages.back().begin()));
}

◆ TEST_F() [887/925]

flutter::testing::TEST_F	(	TextInputPluginTest	,
		VerifyInputActionSendDoesNotInsertNewLine
	)

Definition at line 348 of file text_input_plugin_unittest.cc.

                                                                       {
  UseEngineWithView();
 
  std::vector<std::vector<uint8_t>> messages;
 
  TestBinaryMessenger messenger(
      [&messages](const std::string& channel, const uint8_t* message,
                  size_t message_size, BinaryReply reply) {
        int length = static_cast<int>(message_size);
        std::vector<uint8_t> last_message(length);
        memcpy(&last_message[0], &message[0], length * sizeof(uint8_t));
        messages.push_back(last_message);
      });
  BinaryReply reply_handler = [](const uint8_t* reply, size_t reply_size) {};
 
  TextInputPlugin handler(&messenger, engine());
 
  auto& codec = JsonMethodCodec::GetInstance();
 
  // Call TextInput.setClient to initialize the TextInputModel.
  auto set_client_arguments =
      EncodedClientConfig("TextInputType.multiline", "TextInputAction.send");
  auto message = codec.EncodeMethodCall(
      {"TextInput.setClient", std::move(set_client_arguments)});
  messenger.SimulateEngineMessage("flutter/textinput", message->data(),
                                  message->size(), reply_handler);
 
  // Simulate a key down event for '\n'.
  handler.KeyboardHook(VK_RETURN, 100, WM_KEYDOWN, '\n', false, false);
 
  // Only a call to TextInputClient.performAction is expected.
  EXPECT_EQ(messages.size(), 1);
 
  // TextInputClient.performAction should have been called.
  auto arguments = std::make_unique<rapidjson::Document>(rapidjson::kArrayType);
  auto& allocator = arguments->GetAllocator();
  arguments->PushBack(kDefaultClientId, allocator);
  arguments->PushBack(
      rapidjson::Value("TextInputAction.send", allocator).Move(), allocator);
  auto invoke_action_message = codec.EncodeMethodCall(
      {"TextInputClient.performAction", std::move(arguments)});
 
  EXPECT_TRUE(std::equal(invoke_action_message->begin(),
                         invoke_action_message->end(),
                         messages.front().begin()));
}

◆ TEST_F() [888/925]

flutter::testing::TEST_F	(	TextureLayerDiffTest	,
		TextureInRetainedLayer
	)

Definition at line 101 of file texture_layer_unittests.cc.

                                                     {
  MockLayerTree tree1;
  auto container = std::make_shared<ContainerLayer>();
  tree1.root()->Add(container);
  auto layer = std::make_shared<TextureLayer>(SkPoint::Make(0, 0),
                                              SkSize::Make(100, 100), 0, false,
                                              DlImageSampling::kLinear);
  container->Add(layer);
 
  MockLayerTree tree2;
  tree2.root()->Add(container);  // retained layer
 
  auto damage = DiffLayerTree(tree1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 100, 100));
 
  damage = DiffLayerTree(tree2, tree1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 100, 100));
}

◆ TEST_F() [889/925]

flutter::testing::TEST_F	(	TextureLayerTest	,
		InvalidTexture
	)

Definition at line 19 of file texture_layer_unittests.cc.

                                         {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize layer_size = SkSize::Make(8.0f, 8.0f);
  auto layer = std::make_shared<TextureLayer>(
      layer_offset, layer_size, 0, false, DlImageSampling::kNearestNeighbor);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(),
            (SkRect::MakeSize(layer_size)
                 .makeOffset(layer_offset.fX, layer_offset.fY)));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
 
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(display_list()->Equals(DisplayList()));
}

◆ TEST_F() [890/925]

flutter::testing::TEST_F	(	TextureLayerTest	,
		PaintingWithLinearSampling
	)

Definition at line 72 of file texture_layer_unittests.cc.

                                                     {
  const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
  const SkSize layer_size = SkSize::Make(8.0f, 8.0f);
  const SkRect layer_bounds =
      SkRect::MakeSize(layer_size).makeOffset(layer_offset.fX, layer_offset.fY);
  const int64_t texture_id = 0;
  const auto texture_image = MockTexture::MakeTestTexture(20, 20, 5);
  auto mock_texture = std::make_shared<MockTexture>(texture_id, texture_image);
  auto layer = std::make_shared<TextureLayer>(
      layer_offset, layer_size, texture_id, false, DlImageSampling::kLinear);
 
  // Ensure the texture is located by the Layer.
  preroll_context()->texture_registry->RegisterTexture(mock_texture);
 
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), layer_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Texture)layer::Paint */ {
    expected_builder.DrawImageRect(texture_image, layer_bounds,
                                   DlImageSampling::kLinear);
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [891/925]

flutter::testing::TEST_F	(	TransformLayerLayerDiffTest	,
		Transform
	)

Definition at line 477 of file transform_layer_unittests.cc.

                                               {
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(0, 0, 50, 50));
  auto m1 = std::make_shared<MockLayer>(path1);
 
  auto transform1 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(10, 10));
  transform1->Add(m1);
 
  MockLayerTree t1;
  t1.root()->Add(transform1);
 
  auto damage = DiffLayerTree(t1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 60, 60));
 
  auto transform2 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(20, 20));
  transform2->Add(m1);
  transform2->AssignOldLayer(transform1.get());
 
  MockLayerTree t2;
  t2.root()->Add(transform2);
 
  damage = DiffLayerTree(t2, t1);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(10, 10, 70, 70));
 
  auto transform3 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(20, 20));
  transform3->Add(m1);
  transform3->AssignOldLayer(transform2.get());
 
  MockLayerTree t3;
  t3.root()->Add(transform3);
 
  damage = DiffLayerTree(t3, t2);
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeEmpty());
}

◆ TEST_F() [892/925]

flutter::testing::TEST_F	(	TransformLayerLayerDiffTest	,
		TransformNested
	)

Definition at line 514 of file transform_layer_unittests.cc.

                                                     {
  auto path1 = SkPath().addRect(SkRect::MakeLTRB(0, 0, 50, 50));
  auto m1 = CreateContainerLayer(std::make_shared<MockLayer>(path1));
  auto m2 = CreateContainerLayer(std::make_shared<MockLayer>(path1));
  auto m3 = CreateContainerLayer(std::make_shared<MockLayer>(path1));
 
  auto transform1 = std::make_shared<TransformLayer>(SkMatrix::Scale(2.0, 2.0));
 
  auto transform1_1 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(10, 10));
  transform1_1->Add(m1);
  transform1->Add(transform1_1);
 
  auto transform1_2 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(100, 100));
  transform1_2->Add(m2);
  transform1->Add(transform1_2);
 
  auto transform1_3 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(200, 200));
  transform1_3->Add(m3);
  transform1->Add(transform1_3);
 
  MockLayerTree l1;
  l1.root()->Add(transform1);
 
  auto damage = DiffLayerTree(l1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(20, 20, 500, 500));
 
  auto transform2 = std::make_shared<TransformLayer>(SkMatrix::Scale(2.0, 2.0));
 
  auto transform2_1 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(10, 10));
  transform2_1->Add(m1);
  transform2_1->AssignOldLayer(transform1_1.get());
  transform2->Add(transform2_1);
 
  // Offset 1px from transform1_2 so that they're not the same
  auto transform2_2 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(100, 101));
  transform2_2->Add(m2);
  transform2_2->AssignOldLayer(transform1_2.get());
  transform2->Add(transform2_2);
 
  auto transform2_3 =
      std::make_shared<TransformLayer>(SkMatrix::Translate(200, 200));
  transform2_3->Add(m3);
  transform2_3->AssignOldLayer(transform1_3.get());
  transform2->Add(transform2_3);
 
  MockLayerTree l2;
  l2.root()->Add(transform2);
 
  damage = DiffLayerTree(l2, l1);
 
  // transform2 has not transform1 assigned as old layer, so it should be
  // invalidated completely
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(20, 20, 500, 500));
 
  // now diff the tree properly, the only difference being transform2_2 and
  // transform_2_1
  transform2->AssignOldLayer(transform1.get());
  damage = DiffLayerTree(l2, l1);
 
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(200, 200, 300, 302));
}

◆ TEST_F() [893/925]

flutter::testing::TEST_F	(	TransformLayerTest	,
		ComplexM44
	)

Definition at line 167 of file transform_layer_unittests.cc.

                                       {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkMatrix initial_transform = SkMatrix::Translate(-2.0f, -2.0f);
  SkRect local_cull_rect = SkRect::MakeXYWH(4.0f, 4.0f, 16.0f, 16.0f);
  SkRect device_cull_rect = initial_transform.mapRect(local_cull_rect);
  SkM44 layer_transform44 = SkM44();
  layer_transform44.preTranslate(1.0f, 1.0f);
  // 20 degrees around the X axis
  layer_transform44.preConcat(SkM44::Rotate({1.0f, 0.0f, 0.0f}, M_PI / 9.0f));
  // 10 degrees around the Y axis
  layer_transform44.preConcat(SkM44::Rotate({0.0f, 1.0f, 0.0f}, M_PI / 18.0f));
  SkM44 inverse_layer_transform44;
  EXPECT_TRUE(layer_transform44.invert(&inverse_layer_transform44));
  SkMatrix layer_transform = layer_transform44.asM33();
  SkMatrix inverse_layer_transform = inverse_layer_transform44.asM33();
 
  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());
  auto layer = std::make_shared<TransformLayer>(layer_transform44);
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,
                                                      initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(),
            layer_transform.mapRect(mock_layer->paint_bounds()));
  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer_transform));
 
  // Even having switched to binary-ieee friendly numbers for the
  // initial conditions, these numbers which are based on a matrix
  // concatenation and inversion still aren't exact, so we are using
  // fuzzy float comparisons to check them.
  SkRect parent_cull_rect = mock_layer->parent_cull_rect();
  SkRect expect_parent_cull_rect =
      inverse_layer_transform.mapRect(local_cull_rect);
  EXPECT_FLOAT_EQ(parent_cull_rect.fLeft, expect_parent_cull_rect.fLeft);
  EXPECT_FLOAT_EQ(parent_cull_rect.fTop, expect_parent_cull_rect.fTop);
  EXPECT_FLOAT_EQ(parent_cull_rect.fRight, expect_parent_cull_rect.fRight);
  EXPECT_FLOAT_EQ(parent_cull_rect.fBottom, expect_parent_cull_rect.fBottom);
 
  EXPECT_EQ(mock_layer->parent_mutators(),
            std::vector({Mutator(layer_transform)}));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Transform)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Transform(layer_transform44);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, DlPaint());
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [894/925]

flutter::testing::TEST_F	(	TransformLayerTest	,
		Identity
	)

Definition at line 42 of file transform_layer_unittests.cc.

                                     {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkRect cull_rect = SkRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);
  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());
  auto layer = std::make_shared<TransformLayer>(SkMatrix());  // identity
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(cull_rect);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), mock_layer->paint_bounds());
  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(), SkMatrix());  // identity
  EXPECT_EQ(mock_layer->parent_cull_rect(), cull_rect);
  EXPECT_EQ(mock_layer->parent_mutators().stack_count(), 0u);
  EXPECT_EQ(mock_layer->parent_mutators(), MutatorsStack());
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Transform)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Transform(SkMatrix());
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, DlPaint());
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [895/925]

flutter::testing::TEST_F	(	TransformLayerTest	,
		NestedSeparated
	)

Definition at line 294 of file transform_layer_unittests.cc.

                                            {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
  SkRect local_cull_rect = SkRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);
  SkRect device_cull_rect = initial_transform.mapRect(local_cull_rect);
  SkMatrix layer1_transform = SkMatrix::Translate(2.5f, 2.5f);
  SkMatrix layer2_transform = SkMatrix::Translate(3.5f, 3.5f);
  SkMatrix inverse_layer1_transform, inverse_layer2_transform;
  EXPECT_TRUE(layer1_transform.invert(&inverse_layer1_transform));
  EXPECT_TRUE(layer2_transform.invert(&inverse_layer2_transform));
  DlPaint child_paint1(DlColor::kBlue());
  DlPaint child_paint2(DlColor::kGreen());
 
  auto mock_layer1 = std::make_shared<MockLayer>(child_path, child_paint1);
  auto mock_layer2 = std::make_shared<MockLayer>(child_path, child_paint2);
  auto layer1 = std::make_shared<TransformLayer>(layer1_transform);
  auto layer2 = std::make_shared<TransformLayer>(layer2_transform);
  layer1->Add(mock_layer1);
  layer1->Add(layer2);
  layer2->Add(mock_layer2);
 
  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,
                                                      initial_transform);
  layer1->Preroll(preroll_context());
  SkRect layer1_child_bounds = layer2->paint_bounds();
  layer1_child_bounds.join(mock_layer1->paint_bounds());
  SkRect expected_layer1_bounds = layer1_child_bounds;
  layer1_transform.mapRect(&expected_layer1_bounds);
 
  EXPECT_EQ(mock_layer2->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer2->paint_bounds(),
            layer2_transform.mapRect(mock_layer2->paint_bounds()));
  EXPECT_EQ(layer2->child_paint_bounds(), mock_layer2->paint_bounds());
  EXPECT_EQ(mock_layer1->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer1->paint_bounds(), expected_layer1_bounds);
  EXPECT_EQ(layer1->child_paint_bounds(), layer1_child_bounds);
  EXPECT_TRUE(mock_layer2->needs_painting(paint_context()));
  EXPECT_TRUE(layer2->needs_painting(paint_context()));
  EXPECT_TRUE(mock_layer1->needs_painting(paint_context()));
  EXPECT_TRUE(layer1->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer1->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer1_transform));
  EXPECT_EQ(
      mock_layer2->parent_matrix(),
      SkMatrix::Concat(SkMatrix::Concat(initial_transform, layer1_transform),
                       layer2_transform));
  EXPECT_EQ(mock_layer1->parent_cull_rect(),
            inverse_layer1_transform.mapRect(local_cull_rect));
  EXPECT_EQ(mock_layer2->parent_cull_rect(),
            inverse_layer2_transform.mapRect(
                inverse_layer1_transform.mapRect(local_cull_rect)));
  EXPECT_EQ(mock_layer1->parent_mutators(),
            std::vector({Mutator(layer1_transform)}));
  EXPECT_EQ(
      mock_layer2->parent_mutators(),
      std::vector({Mutator(layer1_transform), Mutator(layer2_transform)}));
 
  layer1->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Transform)layer1::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Transform(layer1_transform);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, child_paint1);
      }
      /* (Transform)layer1::Paint */ {
        expected_builder.Save();
        {
          expected_builder.Transform(layer2_transform);
          /* mock_layer::Paint */ {
            expected_builder.DrawPath(child_path, child_paint2);
          }
        }
        expected_builder.Restore();
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [896/925]

flutter::testing::TEST_F	(	TransformLayerTest	,
		SimpleM44
	)

Definition at line 122 of file transform_layer_unittests.cc.

                                      {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
  SkRect local_cull_rect = SkRect::MakeXYWH(2.0f, 2.0f, 14.0f, 14.0f);
  SkRect device_cull_rect = initial_transform.mapRect(local_cull_rect);
  SkMatrix layer_transform = SkMatrix::Translate(2.5f, 3.5f);
  SkMatrix inverse_layer_transform;
  EXPECT_TRUE(layer_transform.invert(&inverse_layer_transform));
 
  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());
  auto layer = std::make_shared<TransformLayer>(SkM44::Translate(2.5f, 3.5f));
  layer->Add(mock_layer);
 
  preroll_context()->state_stack.set_preroll_delegate(device_cull_rect,
                                                      initial_transform);
  layer->Preroll(preroll_context());
  EXPECT_EQ(mock_layer->paint_bounds(), child_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(),
            layer_transform.mapRect(mock_layer->paint_bounds()));
  EXPECT_EQ(layer->child_paint_bounds(), mock_layer->paint_bounds());
  EXPECT_TRUE(mock_layer->needs_painting(paint_context()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(mock_layer->parent_matrix(),
            SkMatrix::Concat(initial_transform, layer_transform));
  EXPECT_EQ(mock_layer->parent_cull_rect(),
            inverse_layer_transform.mapRect(local_cull_rect));
  EXPECT_EQ(mock_layer->parent_mutators(),
            std::vector({Mutator(layer_transform)}));
 
  layer->Paint(display_list_paint_context());
  DisplayListBuilder expected_builder;
  /* (Transform)layer::Paint */ {
    expected_builder.Save();
    {
      expected_builder.Transform(layer_transform);
      /* mock_layer::Paint */ {
        expected_builder.DrawPath(child_path, DlPaint());
      }
    }
    expected_builder.Restore();
  }
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

◆ TEST_F() [897/925]

flutter::testing::TEST_F	(	TypeConversionsTest	,
		CanConvertEmptyList
	)

Definition at line 54 of file type_conversions_unittests.cc.

                                                 {
  fml::AutoResetWaitableEvent event;
  AddNativeCallback(
      "NotifySuccess", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto bool_handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(tonic::CheckAndHandleError(bool_handle));
        ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(bool_handle));
        event.Signal();
      }));
  AddNativeCallback(
      "NotifyNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments) {
        std::vector<int64_t> items;
        auto items_handle = tonic::ToDart(items);
        ASSERT_FALSE(tonic::CheckAndHandleError(items_handle));
        tonic::DartInvokeField(::Dart_RootLibrary(), "testCanConvertEmptyList",
                               {items_handle});
      }));
  ASSERT_TRUE(RunWithEntrypoint("trampoline"));
  event.Wait();
}

◆ TEST_F() [898/925]

flutter::testing::TEST_F	(	TypeConversionsTest	,
		CanConvertListOfDoubles
	)

Definition at line 100 of file type_conversions_unittests.cc.

                                                     {
  fml::AutoResetWaitableEvent event;
  AddNativeCallback(
      "NotifySuccess", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto bool_handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(tonic::CheckAndHandleError(bool_handle));
        ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(bool_handle));
        event.Signal();
      }));
  AddNativeCallback(
      "NotifyNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments) {
        std::vector<double> items;
        items.push_back(1.0);
        items.push_back(2.0);
        items.push_back(3.0);
        items.push_back(4.0);
        auto items_handle = tonic::ToDart(items);
        ASSERT_FALSE(tonic::CheckAndHandleError(items_handle));
        tonic::DartInvokeField(::Dart_RootLibrary(),
                               "testCanConvertListOfDoubles", {items_handle});
      }));
  ASSERT_TRUE(RunWithEntrypoint("trampoline"));
  event.Wait();
}

◆ TEST_F() [899/925]

flutter::testing::TEST_F	(	TypeConversionsTest	,
		CanConvertListOfInts
	)

Definition at line 125 of file type_conversions_unittests.cc.

                                                  {
  fml::AutoResetWaitableEvent event;
  AddNativeCallback(
      "NotifySuccess", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto bool_handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(tonic::CheckAndHandleError(bool_handle));
        ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(bool_handle));
        event.Signal();
      }));
  AddNativeCallback(
      "NotifyNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments) {
        std::vector<int32_t> items;
        items.push_back(1);
        items.push_back(2);
        items.push_back(3);
        items.push_back(4);
        auto items_handle = tonic::ToDart(items);
        ASSERT_FALSE(tonic::CheckAndHandleError(items_handle));
        tonic::DartInvokeField(::Dart_RootLibrary(), "testCanConvertListOfInts",
                               {items_handle});
      }));
  ASSERT_TRUE(RunWithEntrypoint("trampoline"));
  event.Wait();
}

◆ TEST_F() [900/925]

flutter::testing::TEST_F	(	TypeConversionsTest	,
		CanConvertListOfStrings
	)

Definition at line 75 of file type_conversions_unittests.cc.

                                                     {
  fml::AutoResetWaitableEvent event;
  AddNativeCallback(
      "NotifySuccess", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto bool_handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(tonic::CheckAndHandleError(bool_handle));
        ASSERT_TRUE(tonic::DartConverter<bool>::FromDart(bool_handle));
        event.Signal();
      }));
  AddNativeCallback(
      "NotifyNative", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments) {
        std::vector<std::string> items;
        items.push_back("tinker");
        items.push_back("tailor");
        items.push_back("soldier");
        items.push_back("sailor");
        auto items_handle = tonic::ToDart(items);
        ASSERT_FALSE(tonic::CheckAndHandleError(items_handle));
        tonic::DartInvokeField(::Dart_RootLibrary(),
                               "testCanConvertListOfStrings", {items_handle});
      }));
  ASSERT_TRUE(RunWithEntrypoint("trampoline"));
  event.Wait();
}

◆ TEST_F() [901/925]

flutter::testing::TEST_F	(	TypeConversionsTest	,
		TestFixture
	)

Definition at line 50 of file type_conversions_unittests.cc.

                                         {
  ASSERT_TRUE(RunWithEntrypoint("main"));
}

◆ TEST_F() [902/925]

flutter::testing::TEST_F	(	WindowsLifecycleManagerTest	,
		StateTransitions
	)

Definition at line 15 of file windows_lifecycle_manager_unittests.cc.

                                                      {
  WindowsLifecycleManager manager(nullptr);
  HWND win1 = reinterpret_cast<HWND>(1);
  HWND win2 = reinterpret_cast<HWND>(2);
 
  // Hidden to inactive upon window shown.
  manager.SetLifecycleState(AppLifecycleState::kHidden);
  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
 
  // Showing a second window does not change state.
  manager.OnWindowStateEvent(win2, WindowStateEvent::kShow);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
 
  // Inactive to resumed upon window focus.
  manager.OnWindowStateEvent(win2, WindowStateEvent::kFocus);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
 
  // Showing a second window does not change state.
  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
 
  // Unfocusing one window does not change state while another is focused.
  manager.OnWindowStateEvent(win1, WindowStateEvent::kUnfocus);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kResumed);
 
  // Unfocusing final remaining focused window transitions to inactive.
  manager.OnWindowStateEvent(win2, WindowStateEvent::kUnfocus);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
 
  // Hiding one of two visible windows does not change state.
  manager.OnWindowStateEvent(win2, WindowStateEvent::kHide);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kInactive);
 
  // Hiding only visible window transitions to hidden.
  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
 
  // Transition directly from resumed to hidden when the window is hidden.
  manager.OnWindowStateEvent(win1, WindowStateEvent::kShow);
  manager.OnWindowStateEvent(win1, WindowStateEvent::kFocus);
  manager.OnWindowStateEvent(win1, WindowStateEvent::kHide);
  EXPECT_EQ(manager.GetLifecycleState(), AppLifecycleState::kHidden);
}

◆ TEST_F() [903/925]

flutter::testing::TEST_F	(	WindowsTest	,
		AddRemoveView
	)

Definition at line 574 of file flutter_windows_unittests.cc.

                                   {
  std::mutex mutex;
  std::string view_ids;
 
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("onMetricsChangedSignalViewIds");
 
  fml::AutoResetWaitableEvent ready_latch;
  context.AddNativeFunction(
      "Signal", CREATE_NATIVE_ENTRY(
                    [&](Dart_NativeArguments args) { ready_latch.Signal(); }));
 
  context.AddNativeFunction(
      "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(Dart_IsError(handle));
 
        std::scoped_lock lock{mutex};
        view_ids = tonic::DartConverter<std::string>::FromDart(handle);
      }));
 
  // Create the implicit view.
  ViewControllerPtr first_controller{builder.Run()};
  ASSERT_NE(first_controller, nullptr);
 
  ready_latch.Wait();
 
  // Create a second view.
  FlutterDesktopEngineRef engine =
      FlutterDesktopViewControllerGetEngine(first_controller.get());
  FlutterDesktopViewControllerProperties properties = {};
  properties.width = 100;
  properties.height = 100;
  ViewControllerPtr second_controller{
      FlutterDesktopEngineCreateViewController(engine, &properties)};
  ASSERT_NE(second_controller, nullptr);
 
  // Pump messages for the Windows platform task runner until the view is added.
  while (true) {
    PumpMessage();
    std::scoped_lock lock{mutex};
    if (view_ids == "View IDs: [0, 1]") {
      break;
    }
  }
 
  // Delete the second view and pump messages for the Windows platform task
  // runner until the view is removed.
  second_controller.reset();
  while (true) {
    PumpMessage();
    std::scoped_lock lock{mutex};
    if (view_ids == "View IDs: [0]") {
      break;
    }
  }
}

◆ TEST_F() [904/925]

flutter::testing::TEST_F	(	WindowsTest	,
		EngineCanTransitionToHeadless
	)

Definition at line 152 of file flutter_windows_unittests.cc.

                                                   {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  // Create and then destroy a view controller that does not own its engine.
  // This causes the engine to transition back to headless mode.
  {
    FlutterDesktopViewControllerProperties properties = {};
    ViewControllerPtr controller{
        FlutterDesktopEngineCreateViewController(engine.get(), &properties)};
 
    ASSERT_NE(controller, nullptr);
  }
 
  // The engine is back in headless mode now.
  ASSERT_NE(engine, nullptr);
 
  auto engine_ptr = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
  ASSERT_TRUE(engine_ptr->running());
}

◆ TEST_F() [905/925]

flutter::testing::TEST_F	(	WindowsTest	,
		GetGraphicsAdapter
	)

Definition at line 411 of file flutter_windows_unittests.cc.

                                        {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
  auto view = FlutterDesktopViewControllerGetView(controller.get());
 
  Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
  dxgi_adapter = FlutterDesktopViewGetGraphicsAdapter(view);
  ASSERT_NE(dxgi_adapter, nullptr);
  DXGI_ADAPTER_DESC desc{};
  ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
}

◆ TEST_F() [906/925]

flutter::testing::TEST_F	(	WindowsTest	,
		GetKeyboardStateHeadless
	)

Definition at line 548 of file flutter_windows_unittests.cc.

                                              {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("sendGetKeyboardState");
 
  std::atomic<bool> done = false;
  context.AddNativeFunction(
      "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(Dart_IsError(handle));
        auto value = tonic::DartConverter<std::string>::FromDart(handle);
        EXPECT_EQ(value, "Success");
        done = true;
      }));
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Pump messages for the Windows platform task runner.
  ::MSG msg;
  while (!done) {
    PumpMessage();
  }
}

◆ TEST_F() [907/925]

flutter::testing::TEST_F	(	WindowsTest	,
		GetViewId
	)

Definition at line 400 of file flutter_windows_unittests.cc.

                               {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
  FlutterDesktopViewId view_id =
      FlutterDesktopViewControllerGetViewId(controller.get());
 
  ASSERT_EQ(view_id, static_cast<FlutterDesktopViewId>(kImplicitViewId));
}

◆ TEST_F() [908/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchConflictingCustomEntrypoints
	)

Definition at line 201 of file flutter_windows_unittests.cc.

                                                        {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("customEntrypoint");
  EnginePtr engine{builder.InitializeEngine()};
  ASSERT_NE(engine, nullptr);
 
  ASSERT_FALSE(FlutterDesktopEngineRun(engine.get(), "conflictingEntrypoint"));
}

◆ TEST_F() [909/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchCustomEntrypoint
	)

Definition at line 103 of file flutter_windows_unittests.cc.

                                            {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("customEntrypoint");
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
}

◆ TEST_F() [910/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchCustomEntrypointInEngineRunInvocation
	)

Definition at line 116 of file flutter_windows_unittests.cc.

                                                                 {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.InitializeEngine()};
  ASSERT_NE(engine, nullptr);
 
  ASSERT_TRUE(FlutterDesktopEngineRun(engine.get(), "customEntrypoint"));
}

◆ TEST_F() [911/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchHeadlessEngine
	)

Definition at line 126 of file flutter_windows_unittests.cc.

                                          {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("signalViewIds");
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  std::string view_ids;
  fml::AutoResetWaitableEvent latch;
  context.AddNativeFunction(
      "SignalStringValue", CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
        auto handle = Dart_GetNativeArgument(args, 0);
        ASSERT_FALSE(Dart_IsError(handle));
        view_ids = tonic::DartConverter<std::string>::FromDart(handle);
        latch.Signal();
      }));
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Verify a headless app has the implicit view.
  latch.Wait();
  EXPECT_EQ(view_ids, "View IDs: [0]");
}

◆ TEST_F() [912/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchMain
	)

Definition at line 76 of file flutter_windows_unittests.cc.

                                {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
}

◆ TEST_F() [913/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchMainHasNoOutput
	)

Definition at line 84 of file flutter_windows_unittests.cc.

                                           {
  // Replace stdout & stderr stream buffers with our own.
  StreamCapture stdout_capture(&std::cout);
  StreamCapture stderr_capture(&std::cerr);
 
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  stdout_capture.Stop();
  stderr_capture.Stop();
 
  // Verify stdout & stderr have no output.
  EXPECT_TRUE(stdout_capture.GetOutput().empty());
  EXPECT_TRUE(stderr_capture.GetOutput().empty());
}

◆ TEST_F() [914/925]

flutter::testing::TEST_F	(	WindowsTest	,
		LaunchRefreshesAccessibility
	)

Definition at line 176 of file flutter_windows_unittests.cc.

                                                  {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.InitializeEngine()};
  EngineModifier modifier{
      reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
 
  auto called = false;
  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
      UpdateAccessibilityFeatures, ([&called](auto engine, auto flags) {
        called = true;
        return kSuccess;
      }));
 
  ViewControllerPtr controller{
      FlutterDesktopViewControllerCreate(0, 0, engine.release())};
 
  ASSERT_TRUE(called);
}

◆ TEST_F() [915/925]

flutter::testing::TEST_F	(	WindowsTest	,
		Lifecycle
	)

Definition at line 503 of file flutter_windows_unittests.cc.

                               {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.InitializeEngine()};
  auto windows_engine = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
  EngineModifier modifier{windows_engine};
 
  auto lifecycle_manager =
      std::make_unique<MockWindowsLifecycleManager>(windows_engine);
  auto lifecycle_manager_ptr = lifecycle_manager.get();
  modifier.SetLifecycleManager(std::move(lifecycle_manager));
 
  EXPECT_CALL(*lifecycle_manager_ptr,
              SetLifecycleState(AppLifecycleState::kResumed))
      .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
        lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
            state);
      });
 
  EXPECT_CALL(*lifecycle_manager_ptr,
              SetLifecycleState(AppLifecycleState::kHidden))
      .WillOnce([lifecycle_manager_ptr](AppLifecycleState state) {
        lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
            state);
      });
 
  // Create a controller. This launches the engine and sets the app lifecycle
  // to the "resumed" state.
  ViewControllerPtr controller{
      FlutterDesktopViewControllerCreate(0, 0, engine.release())};
 
  FlutterDesktopViewRef view =
      FlutterDesktopViewControllerGetView(controller.get());
  ASSERT_NE(view, nullptr);
 
  HWND hwnd = FlutterDesktopViewGetHWND(view);
  ASSERT_NE(hwnd, nullptr);
 
  // Give the window a non-zero size to show it. This does not change the app
  // lifecycle directly. However, destroying the view will now result in a
  // "hidden" app lifecycle event.
  ::MoveWindow(hwnd, /* X */ 0, /* Y */ 0, /* nWidth*/ 100, /* nHeight*/ 100,
               /* bRepaint*/ false);
}

◆ TEST_F() [916/925]

flutter::testing::TEST_F	(	WindowsTest	,
		NextFrameCallback
	)

Definition at line 309 of file flutter_windows_unittests.cc.

                                       {
  struct Captures {
    fml::AutoResetWaitableEvent frame_scheduled_latch;
    fml::AutoResetWaitableEvent frame_drawn_latch;
    std::thread::id thread_id;
    bool done = false;
  };
  Captures captures;
 
  CreateNewThread("test_platform_thread")->PostTask([&]() {
    captures.thread_id = std::this_thread::get_id();
 
    auto& context = GetContext();
    WindowsConfigBuilder builder(context);
    builder.SetDartEntrypoint("drawHelloWorld");
 
    auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
      ASSERT_FALSE(captures.frame_drawn_latch.IsSignaledForTest());
      captures.frame_scheduled_latch.Signal();
    });
    context.AddNativeFunction("NotifyFirstFrameScheduled", native_entry);
 
    ViewControllerPtr controller{builder.Run()};
    ASSERT_NE(controller, nullptr);
 
    auto engine = FlutterDesktopViewControllerGetEngine(controller.get());
 
    FlutterDesktopEngineSetNextFrameCallback(
        engine,
        [](void* user_data) {
          auto captures = static_cast<Captures*>(user_data);
 
          ASSERT_TRUE(captures->frame_scheduled_latch.IsSignaledForTest());
 
          // Callback should execute on platform thread.
          ASSERT_EQ(std::this_thread::get_id(), captures->thread_id);
 
          // Signal the test passed and end the Windows message loop.
          captures->done = true;
          captures->frame_drawn_latch.Signal();
        },
        &captures);
 
    // Pump messages for the Windows platform task runner.
    while (!captures.done) {
      PumpMessage();
    }
  });
 
  captures.frame_drawn_latch.Wait();
}

◆ TEST_F() [917/925]

flutter::testing::TEST_F	(	WindowsTest	,
		PlatformExecutable
	)

Definition at line 254 of file flutter_windows_unittests.cc.

                                        {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("readPlatformExecutable");
 
  std::string executable_name;
  fml::AutoResetWaitableEvent latch;
  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeArgument(args, 0);
    ASSERT_FALSE(Dart_IsError(handle));
    executable_name = tonic::DartConverter<std::string>::FromDart(handle);
    latch.Signal();
  });
  context.AddNativeFunction("SignalStringValue", native_entry);
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Wait until signalStringValue has been called.
  latch.Wait();
  EXPECT_EQ(executable_name, "flutter_windows_unittests.exe");
}

◆ TEST_F() [918/925]

flutter::testing::TEST_F	(	WindowsTest	,
		PluginRegistrarGetImplicitView
	)

Definition at line 426 of file flutter_windows_unittests.cc.

                                                    {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  FlutterDesktopEngineRef engine =
      FlutterDesktopViewControllerGetEngine(controller.get());
  FlutterDesktopPluginRegistrarRef registrar =
      FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
  FlutterDesktopViewRef implicit_view =
      FlutterDesktopPluginRegistrarGetView(registrar);
 
  ASSERT_NE(implicit_view, nullptr);
}

◆ TEST_F() [919/925]

flutter::testing::TEST_F	(	WindowsTest	,
		PluginRegistrarGetView
	)

Definition at line 442 of file flutter_windows_unittests.cc.

                                            {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  FlutterDesktopEngineRef engine =
      FlutterDesktopViewControllerGetEngine(controller.get());
  FlutterDesktopPluginRegistrarRef registrar =
      FlutterDesktopEngineGetPluginRegistrar(engine, "foo_bar");
 
  FlutterDesktopViewId view_id =
      FlutterDesktopViewControllerGetViewId(controller.get());
  FlutterDesktopViewRef view =
      FlutterDesktopPluginRegistrarGetViewById(registrar, view_id);
 
  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
      registrar, static_cast<FlutterDesktopViewId>(123));
 
  ASSERT_NE(view, nullptr);
  ASSERT_EQ(view_123, nullptr);
}

◆ TEST_F() [920/925]

flutter::testing::TEST_F	(	WindowsTest	,
		PluginRegistrarGetViewHeadless
	)

Definition at line 465 of file flutter_windows_unittests.cc.

                                                    {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  FlutterDesktopPluginRegistrarRef registrar =
      FlutterDesktopEngineGetPluginRegistrar(engine.get(), "foo_bar");
 
  FlutterDesktopViewRef implicit_view =
      FlutterDesktopPluginRegistrarGetView(registrar);
  FlutterDesktopViewRef view_123 = FlutterDesktopPluginRegistrarGetViewById(
      registrar, static_cast<FlutterDesktopViewId>(123));
 
  ASSERT_EQ(implicit_view, nullptr);
  ASSERT_EQ(view_123, nullptr);
}

◆ TEST_F() [921/925]

flutter::testing::TEST_F	(	WindowsTest	,
		PresentHeadless
	)

Definition at line 363 of file flutter_windows_unittests.cc.

                                     {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("renderImplicitView");
 
  EnginePtr engine{builder.RunHeadless()};
  ASSERT_NE(engine, nullptr);
 
  bool done = false;
  FlutterDesktopEngineSetNextFrameCallback(
      engine.get(),
      [](void* user_data) {
        // This executes on the platform thread.
        auto done = reinterpret_cast<std::atomic<bool>*>(user_data);
        *done = true;
      },
      &done);
 
  // This app is in headless mode, however, the engine assumes the implicit
  // view always exists. Send window metrics for the implicit view, causing
  // the engine to present to the implicit view. The embedder must not crash.
  auto engine_ptr = reinterpret_cast<FlutterWindowsEngine*>(engine.get());
  FlutterWindowMetricsEvent metrics = {};
  metrics.struct_size = sizeof(FlutterWindowMetricsEvent);
  metrics.width = 100;
  metrics.height = 100;
  metrics.pixel_ratio = 1.0;
  metrics.view_id = kImplicitViewId;
  engine_ptr->SendWindowMetricsEvent(metrics);
 
  // Pump messages for the Windows platform task runner.
  while (!done) {
    PumpMessage();
  }
}

◆ TEST_F() [922/925]

flutter::testing::TEST_F	(	WindowsTest	,
		SurfaceOptional
	)

Definition at line 485 of file flutter_windows_unittests.cc.

                                     {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  EnginePtr engine{builder.InitializeEngine()};
  EngineModifier modifier{
      reinterpret_cast<FlutterWindowsEngine*>(engine.get())};
 
  auto egl_manager = std::make_unique<HalfBrokenEGLManager>();
  ASSERT_TRUE(egl_manager->IsValid());
  modifier.SetEGLManager(std::move(egl_manager));
 
  ViewControllerPtr controller{
      FlutterDesktopViewControllerCreate(0, 0, engine.release())};
 
  ASSERT_NE(controller, nullptr);
}

◆ TEST_F() [923/925]

flutter::testing::TEST_F	(	WindowsTest	,
		VerifyNativeFunction
	)

Definition at line 212 of file flutter_windows_unittests.cc.

                                          {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("verifyNativeFunction");
 
  fml::AutoResetWaitableEvent latch;
  auto native_entry =
      CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) { latch.Signal(); });
  context.AddNativeFunction("Signal", native_entry);
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Wait until signal has been called.
  latch.Wait();
}

◆ TEST_F() [924/925]

flutter::testing::TEST_F	(	WindowsTest	,
		VerifyNativeFunctionWithParameters
	)

Definition at line 231 of file flutter_windows_unittests.cc.

                                                        {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("verifyNativeFunctionWithParameters");
 
  bool bool_value = false;
  fml::AutoResetWaitableEvent latch;
  auto native_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value);
    ASSERT_FALSE(Dart_IsError(handle));
    latch.Signal();
  });
  context.AddNativeFunction("SignalBoolValue", native_entry);
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Wait until signalBoolValue has been called.
  latch.Wait();
  EXPECT_TRUE(bool_value);
}

◆ TEST_F() [925/925]

flutter::testing::TEST_F	(	WindowsTest	,
		VerifyNativeFunctionWithReturn
	)

Definition at line 279 of file flutter_windows_unittests.cc.

                                                    {
  auto& context = GetContext();
  WindowsConfigBuilder builder(context);
  builder.SetDartEntrypoint("verifyNativeFunctionWithReturn");
 
  bool bool_value_to_return = true;
  fml::CountDownLatch latch(2);
  auto bool_return_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
    Dart_SetBooleanReturnValue(args, bool_value_to_return);
    latch.CountDown();
  });
  context.AddNativeFunction("SignalBoolReturn", bool_return_entry);
 
  bool bool_value_passed = false;
  auto bool_pass_entry = CREATE_NATIVE_ENTRY([&](Dart_NativeArguments args) {
    auto handle = Dart_GetNativeBooleanArgument(args, 0, &bool_value_passed);
    ASSERT_FALSE(Dart_IsError(handle));
    latch.CountDown();
  });
  context.AddNativeFunction("SignalBoolValue", bool_pass_entry);
 
  ViewControllerPtr controller{builder.Run()};
  ASSERT_NE(controller, nullptr);
 
  // Wait until signalBoolReturn and signalBoolValue have been called.
  latch.Wait();
  EXPECT_TRUE(bool_value_passed);
}

◆ TEST_P() [1/15]

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

Definition at line 57 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/15]

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

Definition at line 23 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/15]

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

Definition at line 38 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/15]

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

Definition at line 185 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()));
}

◆ TEST_P() [5/15]

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

Definition at line 131 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() [6/15]

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

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

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

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

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

Definition at line 86 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()));
}

◆ TEST_P() [9/15]

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

Definition at line 59 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()));
}

◆ TEST_P() [10/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		CanCreateEmbedderWithCustomRenderTaskRunnerTheSameAsPlatformTaskRunner
	)

Asserts that the render task runner can be the same as the platform task runner.

Definition at line 2116 of file embedder_gl_unittests.cc.

                                                                               {
  // A new thread needs to be created for the platform thread because the test
  // can't wait for assertions to be completed on the same thread that services
  // platform task runner tasks.
  auto platform_task_runner = CreateNewThread("platform_thread");
 
  static std::mutex engine_mutex;
  static UniqueEngine engine;
  fml::AutoResetWaitableEvent task_latch;
  bool task_executed = false;
  EmbedderTestTaskRunner common_task_runner(
      platform_task_runner, [&](FlutterTask task) {
        std::scoped_lock engine_lock(engine_mutex);
        if (engine.is_valid()) {
          ASSERT_EQ(FlutterEngineRunTask(engine.get(), &task), kSuccess);
          task_executed = true;
          task_latch.Signal();
        }
      });
 
  platform_task_runner->PostTask([&]() {
    EmbedderTestContextType backend = GetParam();
    EmbedderConfigBuilder builder(GetEmbedderContext(backend));
    builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
    builder.SetRendererConfig(backend, SkISize::Make(800, 600));
    builder.SetRenderTaskRunner(
        &common_task_runner.GetFlutterTaskRunnerDescription());
    builder.SetPlatformTaskRunner(
        &common_task_runner.GetFlutterTaskRunnerDescription());
 
    {
      std::scoped_lock lock(engine_mutex);
      engine = builder.InitializeEngine();
    }
 
    ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
 
    ASSERT_TRUE(engine.is_valid());
 
    FlutterWindowMetricsEvent event = {};
    event.struct_size = sizeof(event);
    event.width = 800;
    event.height = 600;
    event.pixel_ratio = 1.0;
    ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
              kSuccess);
  });
 
  task_latch.Wait();
 
  // Don't use the task latch because that may be called multiple time
  // (including during the shutdown process).
  fml::AutoResetWaitableEvent shutdown_latch;
 
  platform_task_runner->PostTask([&]() {
    ASSERT_TRUE(task_executed);
    ASSERT_EQ(FlutterEngineDeinitialize(engine.get()), kSuccess);
 
    {
      std::scoped_lock engine_lock(engine_mutex);
      engine.reset();
    }
    shutdown_latch.Signal();
  });
 
  shutdown_latch.Wait();
 
  {
    std::scoped_lock engine_lock(engine_mutex);
    // Engine should have been killed by this point.
    ASSERT_FALSE(engine.is_valid());
  }
}

◆ TEST_P() [11/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		CanRenderGradientWithCompositor
	)

Definition at line 1614 of file embedder_gl_unittests.cc.

                                                                  {
  EmbedderTestContextType backend = GetParam();
  auto& context = GetEmbedderContext(backend);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient");
  builder.SetRendererConfig(backend, SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(GetRenderTargetFromBackend(backend, true));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture(
      FixtureNameForBackend(backend, "gradient.png"), rendered_scene));
}

◆ TEST_P() [12/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		CanRenderGradientWithCompositorOnNonRootLayer
	)

Definition at line 1680 of file embedder_gl_unittests.cc.

                                                      {
  EmbedderTestContextType backend = GetParam();
  auto& context = GetEmbedderContext(backend);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient_on_non_root_backing_store");
  builder.SetRendererConfig(backend, SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetRenderTargetType(GetRenderTargetFromBackend(backend, true));
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        // Layer Root
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.did_update = true;
          ConfigureBackingStore(backing_store, backend, true);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 1;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(100.0, 200.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.did_update = true;
          ConfigureBackingStore(backing_store, backend, true);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
      });
 
  context.GetCompositor().SetPlatformViewRendererCallback(
      [&](const FlutterLayer& layer,
          GrDirectContext* context) -> sk_sp<SkImage> {
        auto surface = CreateRenderSurface(layer, context);
        auto canvas = surface->getCanvas();
        FML_CHECK(canvas != nullptr);
 
        switch (layer.platform_view->identifier) {
          case 1: {
            FML_CHECK(layer.size.width == 100);
            FML_CHECK(layer.size.height == 200);
            // This is occluded anyway. We just want to make sure we see this.
          } break;
          default:
            // Asked to render an unknown platform view.
            FML_CHECK(false)
                << "Test was asked to composite an unknown platform view.";
        }
 
        return surface->makeImageSnapshot();
      });
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture(
      FixtureNameForBackend(backend, "gradient.png"), rendered_scene));
}

◆ TEST_P() [13/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		CanRenderGradientWithoutCompositor
	)

Definition at line 1554 of file embedder_gl_unittests.cc.

                                                                     {
  EmbedderTestContextType backend = GetParam();
  auto& context = GetEmbedderContext(backend);
 
  EmbedderConfigBuilder builder(context);
 
  builder.SetDartEntrypoint("render_gradient");
  builder.SetRendererConfig(backend, SkISize::Make(800, 600));
 
  auto rendered_scene = context.GetNextSceneImage();
 
  auto engine = builder.LaunchEngine();
  ASSERT_TRUE(engine.is_valid());
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
 
  ASSERT_TRUE(ImageMatchesFixture(
      FixtureNameForBackend(backend, "gradient.png"), rendered_scene));
}

◆ TEST_P() [14/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurface
	)

Definition at line 2191 of file embedder_gl_unittests.cc.

                                                                  {
  EmbedderTestContextType backend = GetParam();
  auto& context = GetEmbedderContext(backend);
 
  EmbedderConfigBuilder builder(context);
  builder.SetRendererConfig(backend, SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("can_display_platform_view_with_pixel_ratio");
 
  builder.SetRenderTargetType(GetRenderTargetFromBackend(backend, false));
 
  fml::CountDownLatch latch(1);
 
  auto rendered_scene = context.GetNextSceneImage();
 
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 3u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.did_update = true;
          ConfigureBackingStore(backing_store, backend, false);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 1
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(800.0, 560.0);
          layer.offset = FlutterPointMake(0.0, 40.0);
 
          ASSERT_EQ(*layers[1], layer);
        }
 
        // Layer 2
        {
          FlutterBackingStore backing_store = *layers[2]->backing_store;
          backing_store.did_update = true;
          ConfigureBackingStore(backing_store, backend, false);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[2], layer);
        }
 
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 400 * 2.0;
  event.height = 300 * 2.0;
  event.pixel_ratio = 2.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
 
  ASSERT_TRUE(ImageMatchesFixture(
      FixtureNameForBackend(backend, "dpr_noxform.png"), rendered_scene));
}

◆ TEST_P() [15/15]

flutter::testing::TEST_P	(	EmbedderTestMultiBackend	,
		PlatformViewMutatorsAreValid
	)

Definition at line 2517 of file embedder_gl_unittests.cc.

                                                               {
  EmbedderTestContextType backend = GetParam();
  auto& context = GetEmbedderContext(backend);
 
  EmbedderConfigBuilder builder(context);
  builder.SetRendererConfig(backend, SkISize::Make(800, 600));
  builder.SetCompositor();
  builder.SetDartEntrypoint("platform_view_mutators");
 
  builder.SetRenderTargetType(GetRenderTargetFromBackend(backend, false));
 
  fml::CountDownLatch latch(1);
  context.GetCompositor().SetNextPresentCallback(
      [&](FlutterViewId view_id, const FlutterLayer** layers,
          size_t layers_count) {
        ASSERT_EQ(layers_count, 2u);
 
        // Layer 0 (Root)
        {
          FlutterBackingStore backing_store = *layers[0]->backing_store;
          backing_store.did_update = true;
          ConfigureBackingStore(backing_store, backend, false);
 
          FlutterRect paint_region_rects[] = {
              FlutterRectMakeLTRB(0, 0, 800, 600),
          };
          FlutterRegion paint_region = {
              .struct_size = sizeof(FlutterRegion),
              .rects_count = 1,
              .rects = paint_region_rects,
          };
          FlutterBackingStorePresentInfo present_info = {
              .struct_size = sizeof(FlutterBackingStorePresentInfo),
              .paint_region = &paint_region,
          };
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypeBackingStore;
          layer.backing_store = &backing_store;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
          layer.backing_store_present_info = &present_info;
 
          ASSERT_EQ(*layers[0], layer);
        }
 
        // Layer 2
        {
          FlutterPlatformView platform_view = *layers[1]->platform_view;
          platform_view.struct_size = sizeof(platform_view);
          platform_view.identifier = 42;
          platform_view.mutations_count = 3;
 
          FlutterLayer layer = {};
          layer.struct_size = sizeof(layer);
          layer.type = kFlutterLayerContentTypePlatformView;
          layer.platform_view = &platform_view;
          layer.size = FlutterSizeMake(800.0, 600.0);
          layer.offset = FlutterPointMake(0.0, 0.0);
 
          ASSERT_EQ(*layers[1], layer);
 
          // There are no ordering guarantees.
          for (size_t i = 0; i < platform_view.mutations_count; i++) {
            FlutterPlatformViewMutation mutation = *platform_view.mutations[i];
            switch (mutation.type) {
              case kFlutterPlatformViewMutationTypeClipRoundedRect:
                mutation.clip_rounded_rect =
                    FlutterRoundedRectMake(SkRRect::MakeRectXY(
                        SkRect::MakeLTRB(10.0, 10.0, 800.0 - 10.0,
                                         600.0 - 10.0),
                        14.0, 14.0));
                break;
              case kFlutterPlatformViewMutationTypeClipRect:
                mutation.type = kFlutterPlatformViewMutationTypeClipRect;
                mutation.clip_rect = FlutterRectMake(
                    SkRect::MakeXYWH(10.0, 10.0, 800.0 - 20.0, 600.0 - 20.0));
                break;
              case kFlutterPlatformViewMutationTypeOpacity:
                mutation.type = kFlutterPlatformViewMutationTypeOpacity;
                mutation.opacity = 128.0 / 255.0;
                break;
              case kFlutterPlatformViewMutationTypeTransformation:
                FML_CHECK(false)
                    << "There should be no transformation in the test.";
                break;
            }
 
            ASSERT_EQ(*platform_view.mutations[i], mutation);
          }
        }
        latch.CountDown();
      });
 
  auto engine = builder.LaunchEngine();
 
  // Send a window metrics events so frames may be scheduled.
  FlutterWindowMetricsEvent event = {};
  event.struct_size = sizeof(event);
  event.width = 800;
  event.height = 600;
  event.pixel_ratio = 1.0;
  ASSERT_EQ(FlutterEngineSendWindowMetricsEvent(engine.get(), &event),
            kSuccess);
  ASSERT_TRUE(engine.is_valid());
 
  latch.Wait();
}

◆ test_rtree()

static void flutter::testing::test_rtree	(	const sk_sp< const DlRTree > &	rtree,
		const SkRect &	query,
		std::vector< SkRect >	expected_rects,
		const std::vector< int > &	expected_indices,
		const std::string &	file,
		int	line
	)

static

Definition at line 2258 of file display_list_unittests.cc.

                                 {
  std::vector<int> indices;
  auto label = "from " + file + ":" + std::to_string(line);
  rtree->search(query, &indices);
  EXPECT_EQ(indices, expected_indices) << label;
  EXPECT_EQ(indices.size(), expected_indices.size()) << label;
  std::list<SkRect> rects = rtree->searchAndConsolidateRects(query, false);
  // ASSERT_EQ(rects.size(), expected_indices.size());
  auto iterator = rects.cbegin();
  for (int i : expected_indices) {
    ASSERT_TRUE(iterator != rects.cend()) << label;
    EXPECT_EQ(*iterator++, expected_rects[i]) << label;
  }
}

◆ TestBounds() [1/2]

static void flutter::testing::TestBounds	(	const DlImageFilter &	filter,
		const SkRect &	sourceBounds,
		const SkPoint	expectedLocalOutputQuad[4]
	)

static

Definition at line 116 of file dl_image_filter_unittests.cc.

                                                                 {
  SkRect local_filter_bounds;
  ASSERT_EQ(filter.map_local_bounds(sourceBounds, local_filter_bounds),
            &local_filter_bounds);
  ASSERT_TRUE(containsInclusive(local_filter_bounds, expectedLocalOutputQuad));
 
  for (int scale = 1; scale <= 4; scale++) {
    for (int skew = 0; skew < 8; skew++) {
      for (int degrees = 0; degrees <= 360; degrees += 15) {
        SkMatrix matrix;
        matrix.setScale(scale, scale);
        matrix.postSkew(skew / 8.0, skew / 8.0);
        matrix.postRotate(degrees);
        ASSERT_TRUE(matrix.invert(nullptr));
        TestBoundsWithMatrix(filter, matrix, sourceBounds,
                             expectedLocalOutputQuad);
        matrix.setPerspX(0.001);
        matrix.setPerspY(0.001);
        ASSERT_TRUE(matrix.invert(nullptr));
        TestBoundsWithMatrix(filter, matrix, sourceBounds,
                             expectedLocalOutputQuad);
      }
    }
  }
}

◆ TestBounds() [2/2]

static void flutter::testing::TestBounds	(	const DlImageFilter &	filter,
		const SkRect &	sourceBounds,
		const SkRect &	expectedLocalOutputBounds
	)

static

Definition at line 144 of file dl_image_filter_unittests.cc.

                                                                {
  SkPoint expected_local_output_quad[4];
  expectedLocalOutputBounds.toQuad(expected_local_output_quad);
  TestBounds(filter, sourceBounds, expected_local_output_quad);
}

◆ TestBoundsWithMatrix()

static void flutter::testing::TestBoundsWithMatrix	(	const DlImageFilter &	filter,
		const SkMatrix &	matrix,
		const SkRect &	sourceBounds,
		const SkPoint	expectedLocalOutputQuad[4]
	)

static

Definition at line 64 of file dl_image_filter_unittests.cc.

                                                                           {
  SkRect device_input_bounds = matrix.mapRect(sourceBounds);
  SkPoint expected_output_quad[4];
  matrix.mapPoints(expected_output_quad, expectedLocalOutputQuad, 4);
 
  SkIRect device_filter_ibounds;
  ASSERT_EQ(filter.map_device_bounds(device_input_bounds.roundOut(), matrix,
                                     device_filter_ibounds),
            &device_filter_ibounds);
  ASSERT_TRUE(containsInclusive(device_filter_ibounds, expected_output_quad));
 
  SkIRect reverse_input_ibounds;
  ASSERT_EQ(filter.get_input_device_bounds(device_filter_ibounds, matrix,
                                           reverse_input_ibounds),
            &reverse_input_ibounds);
  ASSERT_TRUE(containsInclusive(reverse_input_ibounds, device_input_bounds));
}

◆ TestDartVmFlags()

static void flutter::testing::TestDartVmFlags ( std::vector< const char * > & flags )

static

Definition at line 369 of file shell_unittests.cc.

                                                           {
  std::string flags_string = CreateFlagsString(flags);
  const std::vector<fml::CommandLine::Option> options = {
      fml::CommandLine::Option("dart-flags", flags_string)};
  fml::CommandLine command_line("", options, std::vector<std::string>());
  flutter::Settings settings = flutter::SettingsFromCommandLine(command_line);
  EXPECT_EQ(settings.dart_flags.size(), flags.size());
  for (size_t i = 0; i < flags.size(); ++i) {
    EXPECT_EQ(settings.dart_flags[i], flags[i]);
  }
}

◆ testEquals() [1/3]

void flutter::testing::testEquals	(	const std::shared_ptr< const DlMaskFilter > &	a,
		const std::shared_ptr< const DlMaskFilter > &	b
	)

Definition at line 82 of file dl_mask_filter_unittests.cc.

                                                            {
  // a and b have the same nullness or values
  ASSERT_TRUE(Equals(a, b));
  ASSERT_FALSE(NotEquals(a, b));
  ASSERT_TRUE(Equals(b, a));
  ASSERT_FALSE(NotEquals(b, a));
}

◆ testEquals() [2/3]

void flutter::testing::testEquals	(	const std::shared_ptr< const DlMaskFilter > &	a,
		DlMaskFilter *	b
	)

Definition at line 65 of file dl_mask_filter_unittests.cc.

                                                                             {
  // a and b have the same nullness or values
  ASSERT_TRUE(Equals(a, b));
  ASSERT_FALSE(NotEquals(a, b));
  ASSERT_TRUE(Equals(b, a));
  ASSERT_FALSE(NotEquals(b, a));
}

◆ testEquals() [3/3]

void flutter::testing::testEquals	(	DlMaskFilter *	a,
		DlMaskFilter *	b
	)

Definition at line 49 of file dl_mask_filter_unittests.cc.

                                                  {
  // a and b have the same nullness or values
  ASSERT_TRUE(Equals(a, b));
  ASSERT_FALSE(NotEquals(a, b));
  ASSERT_TRUE(Equals(b, a));
  ASSERT_FALSE(NotEquals(b, a));
}

◆ TestEquals()

template<class T >

static void flutter::testing::TestEquals	(	T &	source1,
		T &	source2
	)

static

Definition at line 16 of file dl_test_equality.h.

                                               {
  ASSERT_TRUE(source1 == source2);
  ASSERT_TRUE(source2 == source1);
  ASSERT_FALSE(source1 != source2);
  ASSERT_FALSE(source2 != source1);
  ASSERT_EQ(source1, source2);
  ASSERT_EQ(source2, source1);
  ASSERT_TRUE(Equals(&source1, &source2));
  ASSERT_TRUE(Equals(&source2, &source1));
}

◆ TestInvalidBounds()

static void flutter::testing::TestInvalidBounds	(	const DlImageFilter &	filter,
		const SkMatrix &	matrix,
		const SkRect &	localInputBounds
	)

static

Definition at line 85 of file dl_image_filter_unittests.cc.

                                                              {
  SkIRect device_input_bounds = matrix.mapRect(localInputBounds).roundOut();
 
  SkRect local_filter_bounds;
  ASSERT_EQ(filter.map_local_bounds(localInputBounds, local_filter_bounds),
            nullptr);
  ASSERT_EQ(local_filter_bounds, localInputBounds);
 
  SkIRect device_filter_ibounds;
  ASSERT_EQ(filter.map_device_bounds(device_input_bounds, matrix,
                                     device_filter_ibounds),
            nullptr);
  ASSERT_EQ(device_filter_ibounds, device_input_bounds);
 
  SkIRect reverse_input_ibounds;
  ASSERT_EQ(filter.get_input_device_bounds(device_input_bounds, matrix,
                                           reverse_input_ibounds),
            nullptr);
  ASSERT_EQ(reverse_input_ibounds, device_input_bounds);
}

◆ TestLabel()

std::string flutter::testing::TestLabel ( const ::testing::TestInfo & info )

Definition at line 36 of file logger_listener.cc.

                                                 {
  return std::string{info.test_suite_name()} + "." + info.name();
}

◆ testNotEquals() [1/3]

void flutter::testing::testNotEquals	(	const std::shared_ptr< const DlMaskFilter > &	a,
		const std::shared_ptr< const DlMaskFilter > &	b
	)

Definition at line 91 of file dl_mask_filter_unittests.cc.

                                                               {
  // a and b do not have the same nullness or values
  ASSERT_FALSE(Equals(a, b));
  ASSERT_TRUE(NotEquals(a, b));
  ASSERT_FALSE(Equals(b, a));
  ASSERT_TRUE(NotEquals(b, a));
}

◆ testNotEquals() [2/3]

void flutter::testing::testNotEquals	(	const std::shared_ptr< const DlMaskFilter > &	a,
		DlMaskFilter *	b
	)

Definition at line 73 of file dl_mask_filter_unittests.cc.

                                    {
  // a and b do not have the same nullness or values
  ASSERT_FALSE(Equals(a, b));
  ASSERT_TRUE(NotEquals(a, b));
  ASSERT_FALSE(Equals(b, a));
  ASSERT_TRUE(NotEquals(b, a));
}

◆ testNotEquals() [3/3]

void flutter::testing::testNotEquals	(	DlMaskFilter *	a,
		DlMaskFilter *	b
	)

Definition at line 57 of file dl_mask_filter_unittests.cc.

                                                     {
  // a and b do not have the same nullness or values
  ASSERT_FALSE(Equals(a, b));
  ASSERT_TRUE(NotEquals(a, b));
  ASSERT_FALSE(Equals(b, a));
  ASSERT_TRUE(NotEquals(b, a));
}

◆ TestNotEquals()

template<class T >

static void flutter::testing::TestNotEquals	(	T &	source1,
		T &	source2,
		const std::string &	label
	)

static

Definition at line 28 of file dl_test_equality.h.

                                                                          {
  ASSERT_FALSE(source1 == source2) << label;
  ASSERT_FALSE(source2 == source1) << label;
  ASSERT_TRUE(source1 != source2) << label;
  ASSERT_TRUE(source2 != source1) << label;
  ASSERT_NE(source1, source2) << label;
  ASSERT_NE(source2, source1) << label;
  ASSERT_TRUE(NotEquals(&source1, &source2));
  ASSERT_TRUE(NotEquals(&source2, &source1));
}

◆ TestSimulatedInputEvents()

static void flutter::testing::TestSimulatedInputEvents	(	ShellTest *	fixture,
		int	num_events,
		UnitlessTime	base_latency,
		Generator	delivery_time,
		UnitlessTime	frame_time,
		std::vector< UnitlessTime > &	events_consumed_at_frame,
		bool	restart_engine = `false`
	)

static

Simulate n input events where the i-th one is delivered at delivery_time(i).

Simulation results will be written into events_consumed_at_frame whose length will be equal to the number of frames drawn. Each element in the vector is the number of input events consumed up to that frame. (We can't return such vector because ASSERT_TRUE requires return type of void.)

We assume (and check) that the delivery latency is some base latency plus a random latency where the random latency must be within one frame:

latency = delivery_time(i) - j * frame_time = base_latency + random_latency
0 <= base_latency, 0 <= random_latency < frame_time

We also assume that there will be at least one input event per frame if there were no latency. Let j = floor( (delivery_time(i) - base_latency) / frame_time ) be the frame index if there were no latency. Then the set of j should be all integers from 0 to continuous_frame_count - 1 for some integer continuous_frame_count.

(Note that there coulds be multiple input events within one frame.)

The test here is insensitive to the choice of time unit as long as delivery_time and frame_time are in the same unit.

Definition at line 53 of file input_events_unittests.cc.

                                 {
  ///// Begin constructing shell ///////////////////////////////////////////////
  auto settings = fixture->CreateSettingsForFixture();
  std::unique_ptr<Shell> shell = fixture->CreateShell({
      .settings = settings,
      .platform_view_create_callback = ShellTestPlatformViewBuilder({
          .simulate_vsync = true,
      }),
  });
 
  auto configuration = RunConfiguration::InferFromSettings(settings);
  configuration.SetEntrypoint("onPointerDataPacketMain");
 
  // The following 4 variables are only accessed in the UI thread by
  // nativeOnPointerDataPacket and nativeOnBeginFrame between their
  // initializations and `shell.reset()`.
  events_consumed_at_frame.clear();
  bool will_draw_new_frame = true;
  int events_consumed = 0;
  int frame_drawn = 0;
  auto nativeOnPointerDataPacket = [&events_consumed_at_frame,
                                    &will_draw_new_frame, &events_consumed,
                                    &frame_drawn](Dart_NativeArguments args) {
    events_consumed += 1;
    if (will_draw_new_frame) {
      frame_drawn += 1;
      will_draw_new_frame = false;
      events_consumed_at_frame.push_back(events_consumed);
    } else {
      events_consumed_at_frame.back() = events_consumed;
    }
  };
  fixture->AddNativeCallback("NativeOnPointerDataPacket",
                             CREATE_NATIVE_ENTRY(nativeOnPointerDataPacket));
 
  ASSERT_TRUE(configuration.IsValid());
  fixture->RunEngine(shell.get(), std::move(configuration));
 
  if (restart_engine) {
    auto new_configuration = RunConfiguration::InferFromSettings(settings);
    new_configuration.SetEntrypoint("onPointerDataPacketMain");
    ASSERT_TRUE(new_configuration.IsValid());
    fixture->RestartEngine(shell.get(), std::move(new_configuration));
  }
  ///// End constructing shell /////////////////////////////////////////////////
 
  ASSERT_GE(base_latency, 0);
 
  // Check that delivery_time satisfies our assumptions.
  int continuous_frame_count = 0;
  for (int i = 0; i < num_events; i += 1) {
    // j is the frame index of event i if there were no latency.
    int j = static_cast<int>((delivery_time(i) - base_latency) / frame_time);
    if (j == continuous_frame_count) {
      continuous_frame_count += 1;
    }
    double random_latency = delivery_time(i) - j * frame_time - base_latency;
    ASSERT_GE(random_latency, 0);
    ASSERT_LT(random_latency, frame_time);
 
    // If there were no latency, there should be at least one event per frame.
    // Hence j should never skip any integer less than continuous_frame_count.
    ASSERT_LT(j, continuous_frame_count);
  }
 
  // This has to be running on a different thread than Platform thread to avoid
  // dead locks.
  auto simulation = std::async(std::launch::async, [&]() {
    // i is the input event's index.
    // j is the frame's index.
    for (int i = 0, j = 0; i < num_events; j += 1) {
      double t = j * frame_time;
      while (i < num_events && delivery_time(i) <= t) {
        // Use a different x every time for the pointer data converter to
        // generate non-empty events.
        ShellTest::DispatchFakePointerData(shell.get(), /*x=*/i);
        i += 1;
      }
      ShellTest::VSyncFlush(shell.get(), &will_draw_new_frame);
    }
    // Finally, issue a vsync for the pending event that may be generated duing
    // the last vsync.
    ShellTest::VSyncFlush(shell.get(), &will_draw_new_frame);
  });
 
  simulation.wait();
 
  TaskRunners task_runners = fixture->GetTaskRunnersForFixture();
  fml::AutoResetWaitableEvent latch;
  task_runners.GetPlatformTaskRunner()->PostTask([&shell, &latch]() mutable {
    shell.reset();
    latch.Signal();
  });
  latch.Wait();
 
  // Make sure that all events have been consumed so
  // https://github.com/flutter/flutter/issues/40863 won't happen again.
  ASSERT_GT(events_consumed_at_frame.size(), 0u);
  ASSERT_EQ(events_consumed_at_frame.back(), num_events);
}

◆ TestStatusAsString()

std::string flutter::testing::TestStatusAsString ( const ::testing::TestResult * result )

Definition at line 20 of file logger_listener.cc.

                                                              {
  if (result == nullptr) {
    return "UNKNOWN";
  }
  if (result->Passed()) {
    return "PASSED";
  }
  if (result->Skipped()) {
    return "SKIPPED";
  }
  if (result->Failed()) {
    return "FAILED";
  }
  return "UNKNOWN";
}

◆ TestTimeAsString()

std::string flutter::testing::TestTimeAsString ( const ::testing::TestResult * result )

Definition at line 40 of file logger_listener.cc.

                                                            {
  if (result == nullptr) {
    return "UNKNOWN";
  }
  return std::to_string(result->elapsed_time()) + " ms";
}

◆ TestUnboundedBounds()

static void flutter::testing::TestUnboundedBounds	(	DlImageFilter &	filter,
		const SkRect &	sourceBounds,
		const SkRect &	expectedOutputBounds,
		const SkRect &	expectedInputBounds
	)

static

Definition at line 548 of file dl_image_filter_unittests.cc.

                                                                   {
  SkRect bounds;
  EXPECT_EQ(filter.map_local_bounds(sourceBounds, bounds), nullptr);
  EXPECT_EQ(bounds, expectedOutputBounds);
 
  SkIRect ibounds;
  EXPECT_EQ(
      filter.map_device_bounds(sourceBounds.roundOut(), SkMatrix::I(), ibounds),
      nullptr);
  EXPECT_EQ(ibounds, expectedOutputBounds.roundOut());
 
  EXPECT_EQ(filter.get_input_device_bounds(sourceBounds.roundOut(),
                                           SkMatrix::I(), ibounds),
            nullptr);
  EXPECT_EQ(ibounds, expectedInputBounds.roundOut());
}

◆ UnpackPointerPacket()

void flutter::testing::UnpackPointerPacket	(	std::vector< PointerData > &	output,
		std::unique_ptr< PointerDataPacket >	packet
	)

Definition at line 159 of file pointer_data_packet_converter_unittests.cc.

                                                                  {
  for (size_t i = 0; i < packet->GetLength(); i++) {
    PointerData pointer_data = packet->GetPointerData(i);
    output.push_back(pointer_data);
  }
  packet.reset();
}

◆ UnserializeKeyEventDeviceType()

FlutterKeyEventDeviceType flutter::testing::UnserializeKeyEventDeviceType ( uint64_t source )

Definition at line 2874 of file embedder_unittests.cc.

                                                                         {
  switch (source) {
    case 1:
      return kFlutterKeyEventDeviceTypeKeyboard;
    case 2:
      return kFlutterKeyEventDeviceTypeDirectionalPad;
    case 3:
      return kFlutterKeyEventDeviceTypeGamepad;
    case 4:
      return kFlutterKeyEventDeviceTypeJoystick;
    case 5:
      return kFlutterKeyEventDeviceTypeHdmi;
    default:
      FML_UNREACHABLE();
      return kFlutterKeyEventDeviceTypeKeyboard;
  }
}

◆ UnserializeKeyEventType()

FlutterKeyEventType flutter::testing::UnserializeKeyEventType ( uint64_t kind )

Definition at line 2856 of file embedder_unittests.cc.

                                                           {
  switch (kind) {
    case 1:
      return kFlutterKeyEventTypeUp;
    case 2:
      return kFlutterKeyEventTypeDown;
    case 3:
      return kFlutterKeyEventTypeRepeat;
    default:
      FML_UNREACHABLE();
      return kFlutterKeyEventTypeUp;
  }
}

◆ ValidateDestroyPlatformView()

static void flutter::testing::ValidateDestroyPlatformView ( Shell * shell )

static

Definition at line 348 of file shell_unittests.cc.

                                                      {
  ASSERT_TRUE(shell != nullptr);
  ASSERT_TRUE(shell->IsSetup());
 
  ASSERT_FALSE(RasterizerIsTornDown(shell));
  ShellTest::PlatformViewNotifyDestroyed(shell);
  ASSERT_TRUE(RasterizerIsTornDown(shell));
}

◆ ValidateShell()

static bool flutter::testing::ValidateShell ( Shell * shell )

static

Definition at line 311 of file shell_unittests.cc.

                                        {
  if (!shell) {
    return false;
  }
 
  if (!shell->IsSetup()) {
    return false;
  }
 
  ShellTest::PlatformViewNotifyCreated(shell);
 
  {
    fml::AutoResetWaitableEvent latch;
    fml::TaskRunner::RunNowOrPostTask(
        shell->GetTaskRunners().GetPlatformTaskRunner(), [shell, &latch]() {
          shell->GetPlatformView()->NotifyDestroyed();
          latch.Signal();
        });
    latch.Wait();
  }
 
  return true;
}

◆ VerbToString()

std::string flutter::testing::VerbToString ( SkPath::Verb type )

Definition at line 619 of file dl_benchmarks.cc.

                                        {
  switch (type) {
    case SkPath::Verb::kLine_Verb:
      return "Lines";
    case SkPath::Verb::kQuad_Verb:
      return "Quads";
    case SkPath::Verb::kConic_Verb:
      return "Conics";
    case SkPath::Verb::kCubic_Verb:
      return "Cubics";
    default:
      return "Unknown";
  }
}

◆ VertexModeToString()

std::string flutter::testing::VertexModeToString ( DlVertexMode mode )

Definition at line 759 of file dl_benchmarks.cc.

                                                {
  switch (mode) {
    case DlVertexMode::kTriangleStrip:
      return "TriangleStrip";
    case DlVertexMode::kTriangleFan:
      return "TriangleFan";
    case DlVertexMode::kTriangles:
      return "Triangles";
  }
  return "Unknown";
}

◆ VietnameseTelexAddDiacriticWithSlowResponse()

void flutter::testing::VietnameseTelexAddDiacriticWithSlowResponse	(	WindowsTestContext &	context,
		bool	backspace_response
	)

Definition at line 2349 of file keyboard_unittests.cc.

                                                                          {
  // In this test, the user presses the following keys:
  //
  //   Key         Current text
  //  ===========================
  //   A           a
  //   F           à
  //
  // And the Backspace down event is responded slowly with `backspace_response`.
 
  KeyboardTester tester{context};
  tester.Responding(false);
 
  // US Keyboard layout
 
  // Press A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{'a', kScanCodeKeyA, kNotExtended, kWasUp}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 2);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalKeyA, kLogicalKeyA, "a", kNotSynthesized);
  EXPECT_CALL_IS_TEXT(tester.key_calls[1], u"a");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 2);
 
  // Release A
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyA, kScanCodeKeyA, kNotExtended}.Build(
          kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalKeyA, kLogicalKeyA, "", kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  std::vector<MockKeyResponseController::ResponseCallback> recorded_callbacks;
  tester.LateResponding(
      [&recorded_callbacks](
          const FlutterKeyEvent* event,
          MockKeyResponseController::ResponseCallback callback) {
        recorded_callbacks.push_back(callback);
      });
 
  // Press F, which is translated to:
  //
  // Backspace down, char & up, VK_PACKET('à').
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyDownInfo{VK_BACK, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmCharInfo{0x8, kScanCodeBackspace, kNotExtended, kWasUp}.Build(
          kWmResultZero),
      WmKeyUpInfo{VK_BACK, kScanCodeBackspace, kNotExtended}.Build(
          kWmResultZero),
      WmKeyDownInfo{VK_PACKET, 0, kNotExtended, kWasUp}.Build(kWmResultDefault),
      WmCharInfo{0xe0 /*'à'*/, 0, kNotExtended, kWasUp}.Build(kWmResultZero),
      WmKeyUpInfo{VK_PACKET, 0, kNotExtended}.Build(kWmResultDefault)});
 
  // The Backspace event has not responded yet, therefore the char message must
  // hold. This is because when the framework is handling the Backspace event,
  // it will send a setEditingState message that updates the text state that has
  // the last character deleted  (denoted by `string1`). Processing the char
  // message before then will cause the final text to set to `string1`.
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown,
                       kPhysicalBackspace, kLogicalBackspace, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
 
  EXPECT_EQ(recorded_callbacks.size(), 1);
  recorded_callbacks[0](backspace_response);
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeUp,
                       kPhysicalBackspace, kLogicalBackspace, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(),
            backspace_response ? 0 : 2);
 
  recorded_callbacks[1](false);
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_TEXT(tester.key_calls[0], u"à");
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 1);
 
  tester.Responding(false);
 
  // Release F
  tester.InjectKeyboardChanges(std::vector<KeyboardChange>{
      WmKeyUpInfo{kVirtualKeyF, kScanCodeKeyF, kNotExtended,
                  /* overwrite_prev_state_0 */ true}
          .Build(kWmResultZero)});
 
  EXPECT_EQ(tester.key_calls.size(), 1);
  EXPECT_CALL_IS_EVENT(tester.key_calls[0], kFlutterKeyEventTypeDown, 0, 0, "",
                       kNotSynthesized);
  tester.clear_key_calls();
  EXPECT_EQ(tester.RedispatchedMessageCountAndClear(), 0);
}

◆ WeakPtr()

template<class T >

auto flutter::testing::WeakPtr ( std::shared_ptr< T > pointer )

Definition at line 67 of file test_timeout_listener.cc.

                                       {
  return std::weak_ptr<T>{pointer};
}

◆ WriteImageToDisk()

bool flutter::testing::WriteImageToDisk	(	const fml::UniqueFD &	directory,
		const std::string &	name,
		const sk_sp< SkImage > &	image
	)

Definition at line 134 of file embedder_unittests_util.cc.

                                                   {
  if (!image) {
    return false;
  }
 
  auto data = SkPngEncoder::Encode(nullptr, image.get(), {});
 
  if (!data) {
    return false;
  }
 
  fml::NonOwnedMapping mapping(static_cast<const uint8_t*>(data->data()),
                               data->size());
  return WriteAtomically(directory, name.c_str(), mapping);
}

Variable Documentation

◆ allGroups

std::vector<testing::DisplayListInvocationGroup> flutter::testing::allGroups

static

Initial value:

=

CreateAllGroups()

flutter::testing::CreateAllGroups

std::vector< DisplayListInvocationGroup > CreateAllGroups()

Definition: dl_test_snippets.cc:971

Definition at line 47 of file display_list_unittests.cc.

◆ current_context

thread_local std::unique_ptr<int> flutter::testing::current_context

static

Definition at line 10 of file gl_context_switch_test.cc.

◆ gIsolateResolvers

std::map<Dart_Isolate, std::weak_ptr<TestDartNativeResolver> > flutter::testing::gIsolateResolvers

static

Definition at line 51 of file test_dart_native_resolver.cc.

◆ gIsolateResolversMutex

std::mutex flutter::testing::gIsolateResolversMutex

static

Definition at line 49 of file test_dart_native_resolver.cc.

◆ global_weak_persistent_value

tonic::DartWeakPersistentValue flutter::testing::global_weak_persistent_value

Initial value:

=

tonic::DartWeakPersistentValue()

Definition at line 137 of file dart_weak_persistent_handle_unittest.cc.

◆ gProcessArgs

fml::CommandLine flutter::testing::gProcessArgs

static

Definition at line 10 of file test_args.cc.

◆ isolate_data_map_

thread_local std::unique_ptr<IsolateDataMap> flutter::testing::isolate_data_map_

static

Definition at line 33 of file platform_isolate_manager_unittests.cc.

◆ kArcSweepSetsToDraw

constexpr size_t flutter::testing::kArcSweepSetsToDraw = 1000

constexpr

Definition at line 79 of file dl_benchmarks.cc.

◆ kCirclesToDraw

constexpr size_t flutter::testing::kCirclesToDraw = 5000

constexpr

Definition at line 76 of file dl_benchmarks.cc.

◆ kColors

const DlColor flutter::testing::kColors[]

Initial value:

= {
    DlColor::kGreen(),
    DlColor::kYellow(),
    DlColor::kBlue(),
}

Definition at line 30 of file dl_test_snippets.h.

◆ kDefaultAOTAppELFFileName

constexpr const char* flutter::testing::kDefaultAOTAppELFFileName = "app_elf_snapshot.so"

inlineconstexpr

Definition at line 17 of file elf_loader.h.

◆ kDefaultAOTAppELFSplitFileName

constexpr const char* flutter::testing::kDefaultAOTAppELFSplitFileName

inlineconstexpr

Initial value:

=

"app_elf_snapshot.so-2.part.so"

Definition at line 24 of file elf_loader.h.

◆ kDRRectsToDraw

constexpr size_t flutter::testing::kDRRectsToDraw = 2000

constexpr

Definition at line 78 of file dl_benchmarks.cc.

◆ kElfFileName

const std::string flutter::testing::kElfFileName = "plugin_registrant_app_elf_snapshot.so"

Definition at line 23 of file dart_plugin_registrant_unittests.cc.

◆ kEmojiFontFile

const std::string flutter::testing::kEmojiFontFile

static

Initial value:

=
 
    "NotoColorEmoji.ttf"

Definition at line 22 of file paragraph_unittests.cc.

◆ kEmojiFontName

const std::string flutter::testing::kEmojiFontName

static

Initial value:

=
 
    "Noto Color Emoji"

Definition at line 29 of file paragraph_unittests.cc.

◆ kEmptyDlRenderer

const DlRenderer flutter::testing::kEmptyDlRenderer = [](const DlRenderContext&) {}

static

Definition at line 363 of file dl_rendering_unittests.cc.

◆ kEmptyDlSetup

const DlSetup flutter::testing::kEmptyDlSetup = [](const DlSetupContext&) {}

static

Definition at line 362 of file dl_rendering_unittests.cc.

◆ kEmptyRect

constexpr SkRect flutter::testing::kEmptyRect = SkRect::MakeEmpty()

staticconstexpr

Definition at line 30 of file mock_canvas.h.

◆ kEmptySkRenderer

const SkRenderer flutter::testing::kEmptySkRenderer = [](const SkRenderContext&) {}

static

Definition at line 361 of file dl_rendering_unittests.cc.

◆ kEmptySkSetup

const SkSetup flutter::testing::kEmptySkSetup = [](const SkSetupContext&) {}

static

Definition at line 360 of file dl_rendering_unittests.cc.

◆ kEndPoints

constexpr SkPoint flutter::testing::kEndPoints[]

constexpr

Initial value:

= {
    {0, 0},
    {100, 100},
}

Definition at line 26 of file dl_test_snippets.h.

◆ kFixedCanvasSize

constexpr size_t flutter::testing::kFixedCanvasSize = 1024

constexpr

Definition at line 81 of file dl_benchmarks.cc.

◆ kHorizontalMiterDiamondPointCount

const int flutter::testing::kHorizontalMiterDiamondPointCount

Initial value:

=
    (sizeof(kHorizontalMiterDiamondPoints) /
     sizeof(kHorizontalMiterDiamondPoints[0]))

Definition at line 155 of file dl_rendering_unittests.cc.

◆ kHorizontalMiterDiamondPoints

const SkPoint flutter::testing::kHorizontalMiterDiamondPoints[]

Initial value:

= {
    
    
    
    
    SkPoint::Make(kRenderCenterX, kYOffsetU3),
    SkPoint::Make(kRenderLeft,    kYOffsetU2),
    SkPoint::Make(kRenderCenterX, kYOffsetU1),
    SkPoint::Make(kRenderLeft,    kYOffset0),
    SkPoint::Make(kRenderCenterX, kYOffsetD1),
    SkPoint::Make(kRenderLeft,    kYOffsetD2),
    SkPoint::Make(kRenderCenterX, kYOffsetD3),
    SkPoint::Make(kRenderRight,   kYOffsetD2),
    SkPoint::Make(kRenderCenterX, kYOffsetD1),
    SkPoint::Make(kRenderRight,   kYOffset0),
    SkPoint::Make(kRenderCenterX, kYOffsetU1),
    SkPoint::Make(kRenderRight,   kYOffsetU2),
    SkPoint::Make(kRenderCenterX, kYOffsetU3),
    
}

Definition at line 135 of file dl_rendering_unittests.cc.

◆ kImagesToDraw

constexpr size_t flutter::testing::kImagesToDraw = 500

constexpr

Definition at line 80 of file dl_benchmarks.cc.

◆ kImplicitViewId

constexpr int64_t flutter::testing::kImplicitViewId = 0

constexpr

Definition at line 26 of file animator_unittests.cc.

◆ kInvertColorMatrix

constexpr float flutter::testing::kInvertColorMatrix[20]

constexpr

Initial value:

= {
    -1.0,    0,    0, 1.0,   0,
       0, -1.0,    0, 1.0,   0,
       0,    0, -1.0, 1.0,   0,
     1.0,  1.0,  1.0, 1.0,   0,
}

Definition at line 48 of file dl_test_snippets.h.

◆ kKernelFileName

const std::string flutter::testing::kKernelFileName = "plugin_registrant_kernel_blob.bin"

Definition at line 22 of file dart_plugin_registrant_unittests.cc.

◆ kLinearSampling

DlImageSampling flutter::testing::kLinearSampling = DlImageSampling::kLinear

static

Definition at line 65 of file dl_test_snippets.h.

◆ kLinesToDraw

constexpr size_t flutter::testing::kLinesToDraw = 10000

constexpr

Definition at line 73 of file dl_benchmarks.cc.

◆ kMatrix

const float flutter::testing::kMatrix[20]

static

Initial value:

= {
    1,  2,  3,  4,  5,   
    6,  7,  8,  9,  10,  
    11, 12, 13, 14, 15,  
    16, 17, 18, 19, 20,  
}

Definition at line 11 of file dl_color_filter_unittests.cc.

◆ kMiter10DiamondOffsetX

constexpr SkScalar flutter::testing::kMiter10DiamondOffsetX = kRenderHeight * 0.051

constexpr

Definition at line 79 of file dl_rendering_unittests.cc.

◆ kMiter10DiamondOffsetY

constexpr SkScalar flutter::testing::kMiter10DiamondOffsetY = kRenderWidth * 0.051

constexpr

Definition at line 85 of file dl_rendering_unittests.cc.

◆ kMiter4DiamondOffsetX

constexpr SkScalar flutter::testing::kMiter4DiamondOffsetX = kRenderHeight * 0.14

constexpr

Definition at line 80 of file dl_rendering_unittests.cc.

◆ kMiter4DiamondOffsetY

constexpr SkScalar flutter::testing::kMiter4DiamondOffsetY = kRenderWidth * 0.14

constexpr

Definition at line 86 of file dl_rendering_unittests.cc.

◆ kMiterExtremeDiamondOffsetX

constexpr SkScalar flutter::testing::kMiterExtremeDiamondOffsetX = kRenderHeight * 0.04

constexpr

Definition at line 78 of file dl_rendering_unittests.cc.

◆ kMiterExtremeDiamondOffsetY

constexpr SkScalar flutter::testing::kMiterExtremeDiamondOffsetY = kRenderWidth * 0.04

constexpr

Definition at line 84 of file dl_rendering_unittests.cc.

◆ kNearestSampling

DlImageSampling flutter::testing::kNearestSampling = DlImageSampling::kNearestNeighbor

static

Definition at line 64 of file dl_test_snippets.h.

◆ kOvalsToDraw

constexpr size_t flutter::testing::kOvalsToDraw = 1000

constexpr

Definition at line 75 of file dl_benchmarks.cc.

◆ kRectsToDraw

constexpr size_t flutter::testing::kRectsToDraw = 5000

constexpr

Definition at line 74 of file dl_benchmarks.cc.

◆ kRenderBottom

constexpr int flutter::testing::kRenderBottom = kRenderTop + kRenderHeight

constexpr

Definition at line 57 of file dl_rendering_unittests.cc.

◆ kRenderBounds

constexpr SkRect flutter::testing::kRenderBounds

constexpr

Initial value:

=

SkRect::MakeLTRB(kRenderLeft, kRenderTop, kRenderRight, kRenderBottom)

Definition at line 65 of file dl_rendering_unittests.cc.

◆ kRenderCenterX

constexpr int flutter::testing::kRenderCenterX = (kRenderLeft + kRenderRight) / 2

constexpr

Definition at line 58 of file dl_rendering_unittests.cc.

◆ kRenderCenterY

constexpr int flutter::testing::kRenderCenterY = (kRenderTop + kRenderBottom) / 2

constexpr

Definition at line 59 of file dl_rendering_unittests.cc.

◆ kRenderCornerRadius

constexpr SkScalar flutter::testing::kRenderCornerRadius = kRenderRadius / 5.0

constexpr

Definition at line 61 of file dl_rendering_unittests.cc.

◆ kRenderHalfHeight

constexpr int flutter::testing::kRenderHalfHeight = 50

constexpr

Definition at line 53 of file dl_rendering_unittests.cc.

◆ kRenderHalfWidth

constexpr int flutter::testing::kRenderHalfWidth = 50

constexpr

Definition at line 52 of file dl_rendering_unittests.cc.

◆ kRenderHeight

constexpr int flutter::testing::kRenderHeight = 100

constexpr

Definition at line 51 of file dl_rendering_unittests.cc.

◆ kRenderLeft

constexpr int flutter::testing::kRenderLeft = (kTestWidth - kRenderWidth) / 2

constexpr

Definition at line 54 of file dl_rendering_unittests.cc.

◆ kRenderRadius

constexpr SkScalar flutter::testing::kRenderRadius = std::min(kRenderWidth, kRenderHeight) / 2.0

constexpr

Definition at line 60 of file dl_rendering_unittests.cc.

◆ kRenderRight

constexpr int flutter::testing::kRenderRight = kRenderLeft + kRenderWidth

constexpr

Definition at line 56 of file dl_rendering_unittests.cc.

◆ kRenderTop

constexpr int flutter::testing::kRenderTop = (kTestHeight - kRenderHeight) / 2

constexpr

Definition at line 55 of file dl_rendering_unittests.cc.

◆ kRenderWidth

constexpr int flutter::testing::kRenderWidth = 100

constexpr

Definition at line 50 of file dl_rendering_unittests.cc.

◆ kRotateColorMatrix

constexpr float flutter::testing::kRotateColorMatrix[20]

constexpr

Initial value:

= {
    0, 1, 0, 0, 0,
    0, 0, 1, 0, 0,
    1, 0, 0, 0, 0,
    0, 0, 0, 1, 0,
}

Definition at line 42 of file dl_test_snippets.h.

◆ kRRectsToDraw

constexpr size_t flutter::testing::kRRectsToDraw = 5000

constexpr

Definition at line 77 of file dl_benchmarks.cc.

◆ kScanCodeKeyA

constexpr uint64_t flutter::testing::kScanCodeKeyA = 0x1e

constexpr

Definition at line 42 of file flutter_windows_view_unittests.cc.

◆ kSize

constexpr SkISize flutter::testing::kSize = SkISize::Make(64, 64)

constexpr

Definition at line 17 of file mock_canvas.cc.

◆ kStops

constexpr float flutter::testing::kStops[]

constexpr

Initial value:

= {
    0.0,
    0.5,
    1.0,
}

Definition at line 35 of file dl_test_snippets.h.

◆ kTestAlphaColors

const DlColor flutter::testing::kTestAlphaColors[kTestStopCount]

static

Initial value:

= {
    DlColor::kBlue().withAlpha(0x7F),
    DlColor::kRed().withAlpha(0x2F),
    DlColor::kGreen().withAlpha(0xCF),
}

Definition at line 65 of file dl_color_source_unittests.cc.

◆ kTestAlphaImage1

const sk_sp<DlImage> flutter::testing::kTestAlphaImage1

static

Initial value:

=

MakeTestImage(10, 10, SK_ColorTRANSPARENT)

SK_ColorTRANSPARENT

constexpr SkColor SK_ColorTRANSPARENT

Definition: SkColor.h:99

flutter::testing::MakeTestImage

static sk_sp< DlImage > MakeTestImage(int w, int h, SkColor color)

Definition: dl_color_source_unittests.cc:21

Definition at line 47 of file dl_color_source_unittests.cc.

◆ kTestBounds

constexpr SkRect flutter::testing::kTestBounds = SkRect::MakeLTRB(10, 10, 50, 60)

constexpr

Definition at line 179 of file dl_test_snippets.h.

◆ kTestBounds2

constexpr SkRect flutter::testing::kTestBounds2 = SkRect::MakeWH(kTestWidth, kTestHeight)

constexpr

Definition at line 64 of file dl_rendering_unittests.cc.

◆ kTestCenter

constexpr SkPoint flutter::testing::kTestCenter = SkPoint::Make(kTestWidth / 2, kTestHeight / 2)

constexpr

Definition at line 63 of file dl_rendering_unittests.cc.

◆ kTestColors [1/2]

const DlColor flutter::testing::kTestColors[2]

static

Initial value:

= {DlColor(0xFF000000),

DlColor(0xFFFFFFFF)}

Definition at line 27 of file dl_sk_paint_dispatcher_unittests.cc.

◆ kTestColors [2/2]

constexpr DlColor flutter::testing::kTestColors[kTestStopCount]

staticconstexpr

Initial value:

= {
    DlColor::kRed(),
    DlColor::kGreen(),
    DlColor::kBlue(),
}

Definition at line 60 of file dl_color_source_unittests.cc.

◆ kTestHeight

constexpr int flutter::testing::kTestHeight = 200

constexpr

Definition at line 49 of file dl_rendering_unittests.cc.

◆ kTestImage1

const sk_sp<DlImage> flutter::testing::kTestImage1 = MakeTestImage(10, 10, SK_ColorGREEN)

static

Definition at line 46 of file dl_color_source_unittests.cc.

◆ kTestInnerRRect

const SkRRect flutter::testing::kTestInnerRRect

static

Initial value:

=

SkRRect::MakeRectXY(kTestBounds.makeInset(5, 5), 2, 2)

Definition at line 182 of file dl_test_snippets.h.

◆ kTestLinearGradient

const auto flutter::testing::kTestLinearGradient

static

Initial value:

=
    DlColorSource::MakeLinear(SkPoint::Make(0.0f, 0.0f),
                              SkPoint::Make(100.0f, 100.0f),
                              2,
                              kTestColors,
                              kTestStops,
                              DlTileMode::kClamp,
                              nullptr)

Definition at line 30 of file dl_sk_paint_dispatcher_unittests.cc.

◆ kTestMatrix1 [1/2]

const SkMatrix flutter::testing::kTestMatrix1

static

Initial value:

=
    SkMatrix::MakeAll(2, 0, 10,
                      0, 3, 12,
                      0, 0, 1)

Definition at line 50 of file dl_color_source_unittests.cc.

◆ kTestMatrix1 [2/2]

const SkMatrix flutter::testing::kTestMatrix1 = SkMatrix::Scale(2, 2)

static

Definition at line 192 of file dl_test_snippets.h.

◆ kTestMatrix2 [1/2]

const SkMatrix flutter::testing::kTestMatrix2

static

Initial value:

=
    SkMatrix::MakeAll(4, 0, 15,
                      0, 7, 17,
                      0, 0, 1)

Definition at line 54 of file dl_color_source_unittests.cc.

◆ kTestMatrix2 [2/2]

const SkMatrix flutter::testing::kTestMatrix2 = SkMatrix::RotateDeg(45)

static

Definition at line 193 of file dl_test_snippets.h.

◆ kTestPath1

const SkPath flutter::testing::kTestPath1

static

Initial value:

=

SkPath::Polygon({{0, 0}, {10, 10}, {10, 0}, {0, 10}}, true)

SkPath::Polygon

static SkPath Polygon(const SkPoint pts[], int count, bool isClosed, SkPathFillType=SkPathFillType::kWinding, bool isVolatile=false)

Definition: SkPath.cpp:3614

Definition at line 186 of file dl_test_snippets.h.

◆ kTestPath2

const SkPath flutter::testing::kTestPath2

static

Initial value:

=

SkPath::Polygon({{0, 0}, {10, 10}, {0, 10}, {10, 0}}, true)

Definition at line 188 of file dl_test_snippets.h.

◆ kTestPath3

const SkPath flutter::testing::kTestPath3

static

Initial value:

=

SkPath::Polygon({{0, 0}, {10, 10}, {10, 0}, {0, 10}}, false)

Definition at line 190 of file dl_test_snippets.h.

◆ kTestPathOval

const SkPath flutter::testing::kTestPathOval = SkPath::Oval(kTestBounds)

static

Definition at line 185 of file dl_test_snippets.h.

◆ kTestPathRect

const SkPath flutter::testing::kTestPathRect = SkPath::Rect(kTestBounds)

static

Definition at line 184 of file dl_test_snippets.h.

◆ kTestPoints

constexpr SkPoint flutter::testing::kTestPoints

staticconstexpr

Initial value:

= {
    SkPoint::Make(5, 15),
    SkPoint::Make(7, 18),
}

Definition at line 80 of file dl_color_source_unittests.cc.

◆ kTestPoints2

constexpr SkPoint flutter::testing::kTestPoints2[2]

staticconstexpr

Initial value:

= {
    SkPoint::Make(100, 115),
    SkPoint::Make(107, 118),
}

Definition at line 84 of file dl_color_source_unittests.cc.

◆ kTestRRect

const SkRRect flutter::testing::kTestRRect = SkRRect::MakeRectXY(kTestBounds, 5, 5)

static

Definition at line 180 of file dl_test_snippets.h.

◆ kTestRRectRect

const SkRRect flutter::testing::kTestRRectRect = SkRRect::MakeRect(kTestBounds)

static

Definition at line 181 of file dl_test_snippets.h.

◆ kTestRuntimeEffect1

const sk_sp<DlRuntimeEffect> flutter::testing::kTestRuntimeEffect1

static

Initial value:

=
    DlRuntimeEffect::MakeSkia(
        SkRuntimeEffect::MakeForShader(
            SkString("vec4 main(vec2 p) { return vec4(0); }"))
            .effect)

Definition at line 35 of file dl_color_source_unittests.cc.

◆ kTestRuntimeEffect2

const sk_sp<DlRuntimeEffect> flutter::testing::kTestRuntimeEffect2

static

Initial value:

=
    DlRuntimeEffect::MakeSkia(
        SkRuntimeEffect::MakeForShader(
            SkString("vec4 main(vec2 p) { return vec4(1); }"))
            .effect)

Definition at line 40 of file dl_color_source_unittests.cc.

◆ kTestSource2

const std::shared_ptr<DlColorSource> flutter::testing::kTestSource2

static

Initial value:

=
    DlColorSource::MakeLinear(kEndPoints[0],
                              kEndPoints[1],
                              3,
                              kColors,
                              kStops,
                              DlTileMode::kMirror)

Definition at line 95 of file dl_test_snippets.h.

◆ kTestSource3

const std::shared_ptr<DlColorSource> flutter::testing::kTestSource3

static

Initial value:

=
    DlColorSource::MakeRadial(kEndPoints[0],
                              10.0,
                              3,
                              kColors,
                              kStops,
                              DlTileMode::kMirror)

Definition at line 102 of file dl_test_snippets.h.

◆ kTestSource4

const std::shared_ptr<DlColorSource> flutter::testing::kTestSource4

static

Initial value:

=
    DlColorSource::MakeConical(kEndPoints[0],
                               10.0,
                               kEndPoints[1],
                               200.0,
                               3,
                               kColors,
                               kStops,
                               DlTileMode::kDecal)

Definition at line 109 of file dl_test_snippets.h.

◆ kTestSource5

const std::shared_ptr<DlColorSource> flutter::testing::kTestSource5

static

Initial value:

=
    DlColorSource::MakeSweep(kEndPoints[0],
                             0.0,
                             360.0,
                             3,
                             kColors,
                             kStops,
                             DlTileMode::kDecal)

Definition at line 118 of file dl_test_snippets.h.

◆ kTestStopCount

constexpr int flutter::testing::kTestStopCount = 3

staticconstexpr

Definition at line 59 of file dl_color_source_unittests.cc.

◆ kTestStops [1/2]

const float flutter::testing::kTestStops[2] = {0.0f, 1.0f}

static

Definition at line 29 of file dl_sk_paint_dispatcher_unittests.cc.

◆ kTestStops [2/2]

constexpr float flutter::testing::kTestStops[kTestStopCount]

staticconstexpr

Initial value:

= {
    0.0f,
    0.7f,
    1.0f,
}

Definition at line 70 of file dl_color_source_unittests.cc.

◆ kTestStops2

constexpr float flutter::testing::kTestStops2[kTestStopCount]

staticconstexpr

Initial value:

= {
    0.0f,
    0.3f,
    1.0f,
}

Definition at line 75 of file dl_color_source_unittests.cc.

◆ kTestWidth

constexpr int flutter::testing::kTestWidth = 200

constexpr

Definition at line 48 of file dl_rendering_unittests.cc.

◆ kTooltip

constexpr char flutter::testing::kTooltip[] = "tooltip"

staticconstexpr

Definition at line 32 of file embedder_a11y_unittests.cc.

◆ kVerticalMiterDiamondPointCount

const int flutter::testing::kVerticalMiterDiamondPointCount

Initial value:

=
    sizeof(kVerticalMiterDiamondPoints) /
    sizeof(kVerticalMiterDiamondPoints[0])

Definition at line 124 of file dl_rendering_unittests.cc.

◆ kVerticalMiterDiamondPoints

constexpr SkPoint flutter::testing::kVerticalMiterDiamondPoints[]

constexpr

Initial value:

= {
    
    
    
    
    
    
    
    
    SkPoint::Make(kXOffsetL3, kRenderCenterY),
    SkPoint::Make(kXOffsetL2, kRenderTop),
    SkPoint::Make(kXOffsetL1, kRenderCenterY),
    SkPoint::Make(kXOffset0,  kRenderTop),
    SkPoint::Make(kXOffsetR1, kRenderCenterY),
    SkPoint::Make(kXOffsetR2, kRenderTop),
    SkPoint::Make(kXOffsetR3, kRenderCenterY),
    SkPoint::Make(kXOffsetR2, kRenderBottom),
    SkPoint::Make(kXOffsetR1, kRenderCenterY),
    SkPoint::Make(kXOffset0,  kRenderBottom),
    SkPoint::Make(kXOffsetL1, kRenderCenterY),
    SkPoint::Make(kXOffsetL2, kRenderBottom),
    SkPoint::Make(kXOffsetL3, kRenderCenterY),
    
}

Definition at line 100 of file dl_rendering_unittests.cc.

◆ kVirtualKeyA

constexpr uint64_t flutter::testing::kVirtualKeyA = 0x41

constexpr

Definition at line 43 of file flutter_windows_view_unittests.cc.

◆ kWmResultDefault

constexpr LRESULT flutter::testing::kWmResultDefault = 0xDEADC0DE

constexpr

Definition at line 15 of file wm_builders.h.

◆ kWmResultDontCheck

constexpr LRESULT flutter::testing::kWmResultDontCheck = 0xFFFF1234

constexpr

Definition at line 16 of file wm_builders.h.

◆ kWmResultZero

constexpr LRESULT flutter::testing::kWmResultZero = 0

constexpr

Definition at line 14 of file wm_builders.h.

◆ kXOffset0

constexpr SkScalar flutter::testing::kXOffset0 = kRenderCenterX + 0.5

constexpr

Definition at line 93 of file dl_rendering_unittests.cc.

◆ kXOffsetL1

constexpr SkScalar flutter::testing::kXOffsetL1 = kXOffset0 - kMiter4DiamondOffsetX

constexpr

Definition at line 94 of file dl_rendering_unittests.cc.

◆ kXOffsetL2

constexpr SkScalar flutter::testing::kXOffsetL2 = kXOffsetL1 - kMiter10DiamondOffsetX

constexpr

Definition at line 95 of file dl_rendering_unittests.cc.

◆ kXOffsetL3

constexpr SkScalar flutter::testing::kXOffsetL3 = kXOffsetL2 - kMiter10DiamondOffsetX

constexpr

Definition at line 96 of file dl_rendering_unittests.cc.

◆ kXOffsetR1

constexpr SkScalar flutter::testing::kXOffsetR1 = kXOffset0 + kMiter4DiamondOffsetX

constexpr

Definition at line 97 of file dl_rendering_unittests.cc.

◆ kXOffsetR2

constexpr SkScalar flutter::testing::kXOffsetR2 = kXOffsetR1 + kMiterExtremeDiamondOffsetX

constexpr

Definition at line 98 of file dl_rendering_unittests.cc.

◆ kXOffsetR3

constexpr SkScalar flutter::testing::kXOffsetR3 = kXOffsetR2 + kMiterExtremeDiamondOffsetX

constexpr

Definition at line 99 of file dl_rendering_unittests.cc.

◆ kYOffset0

constexpr SkScalar flutter::testing::kYOffset0 = kRenderCenterY + 0.5

constexpr

Definition at line 128 of file dl_rendering_unittests.cc.

◆ kYOffsetD1

constexpr SkScalar flutter::testing::kYOffsetD1 = kXOffset0 + kMiter4DiamondOffsetY

constexpr

Definition at line 132 of file dl_rendering_unittests.cc.

◆ kYOffsetD2

constexpr SkScalar flutter::testing::kYOffsetD2 = kYOffsetD1 + kMiterExtremeDiamondOffsetY

constexpr

Definition at line 133 of file dl_rendering_unittests.cc.

◆ kYOffsetD3

constexpr SkScalar flutter::testing::kYOffsetD3 = kYOffsetD2 + kMiterExtremeDiamondOffsetY

constexpr

Definition at line 134 of file dl_rendering_unittests.cc.

◆ kYOffsetU1

constexpr SkScalar flutter::testing::kYOffsetU1 = kXOffset0 - kMiter4DiamondOffsetY

constexpr

Definition at line 129 of file dl_rendering_unittests.cc.

◆ kYOffsetU2

constexpr SkScalar flutter::testing::kYOffsetU2 = kYOffsetU1 - kMiter10DiamondOffsetY

constexpr

Definition at line 130 of file dl_rendering_unittests.cc.

◆ kYOffsetU3

constexpr SkScalar flutter::testing::kYOffsetU3 = kYOffsetU2 - kMiter10DiamondOffsetY

constexpr

Definition at line 131 of file dl_rendering_unittests.cc.

◆ raster_cache_items_

std::vector<RasterCacheItem*> flutter::testing::raster_cache_items_

static

Definition at line 49 of file mock_raster_cache.h.

◆ stored_response_controller

std::shared_ptr<MockKeyResponseController> flutter::testing::stored_response_controller

static

Definition at line 93 of file test_keyboard.cc.

◆ TestDisplayList1

sk_sp<DisplayList> flutter::testing::TestDisplayList1

static

Initial value:

=

MakeTestDisplayList(20, 20, SK_ColorGREEN)

Definition at line 213 of file dl_test_snippets.h.

◆ TestDisplayList2

sk_sp<DisplayList> flutter::testing::TestDisplayList2

static

Initial value:

=

MakeTestDisplayList(25, 25, SK_ColorBLUE)

Definition at line 215 of file dl_test_snippets.h.

◆ TestImage1

auto flutter::testing::TestImage1 = MakeTestImage(40, 40, 5)

static

Definition at line 87 of file dl_test_snippets.h.

◆ TestImage2

auto flutter::testing::TestImage2 = MakeTestImage(50, 50, 5)

static

Definition at line 88 of file dl_test_snippets.h.

◆ TestSkImage

auto flutter::testing::TestSkImage = MakeTestImage(30, 30, 5)->skia_image()

static

Definition at line 89 of file dl_test_snippets.h.

◆ TestVertices1

std::shared_ptr<const DlVertices> flutter::testing::TestVertices1

static

Initial value:

=
    DlVertices::Make(DlVertexMode::kTriangles,  
                     3,
                     kTestPoints,
                     nullptr,
                     kColors)

Definition at line 195 of file dl_test_snippets.h.

◆ TestVertices2

std::shared_ptr<const DlVertices> flutter::testing::TestVertices2

static

Initial value:

=
    DlVertices::Make(DlVertexMode::kTriangleFan,  
                     3,
                     kTestPoints,
                     nullptr,
                     kColors)

Definition at line 201 of file dl_test_snippets.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BackdropFilterLayerTest

◆ BackdropLayerDiffTest

◆ BackendType

◆ Builder

◆ CanvasTest

◆ ChannelUpdateCallback

◆ ClipOp

◆ ClipPathLayerTest

◆ ClipRectLayerTest

◆ ClipRRectLayerTest

◆ ColorFilterLayerTest

◆ ContainerLayerDiffTest

◆ ContainerLayerTest

◆ Continuation

◆ CreateVsyncWaiter

◆ DartLifecycleTest

◆ DartState

◆ DartVMTest

◆ DisplayListLayerDiffTest

◆ DisplayListLayerTest

◆ DisplayListRendering

◆ DisplayListTest

◆ DlGoldenTest

◆ DlInvoker

◆ DlRenderContext

◆ DlRenderer

◆ DlSetup

◆ DlSetupContext

◆ EmbedderA11yTest

◆ EmbedderTest

◆ EnginePtr

◆ FileLoaderTest

◆ FlutterChannelKeyResponderTest

◆ FlutterEmbedderExternalTextureTest

◆ FlutterViewControllerMockEngineTest

◆ FlutterViewControllerTest

◆ FrameContent

◆ Generator

◆ HooksTest

◆ ImageFilterLayerDiffTest

◆ ImageFilterLayerTest

◆ IntPipeline

◆ IsolateDataMap

◆ LayerTest

◆ LayerTreeBuilder

◆ LogMessageCallback

◆ MetalScreenshotter

◆ MockCanvasTest

◆ MockLayerTest

◆ NativeEntry

◆ OpacityLayerDiffTest

◆ OpacityLayerTest

◆ PainterTest

◆ PerformanceOverlayLayerTest

◆ PersistentCacheTest

◆ PixelFormat

◆ PlatformViewLayerTest

◆ PointMode

◆ RasterCacheTest

◆ SemanticsActionCallback

◆ SemanticsNodeCallback

◆ SemanticsUpdateBuilderTest

◆ SemanticsUpdateCallback

◆ SemanticsUpdateCallback2

◆ ShaderMaskLayerTest

◆ SkRenderContext

◆ SkRenderer

◆ SkSetup

◆ SkSetupContext

◆ TextureLayerDiffTest

◆ TextureLayerTest

◆ TransformLayerLayerDiffTest

◆ TransformLayerTest