Classes
struct	AOTDataDeleter

class	AutoDestroyChildLayerId

class	AutoIsolateShutdown

class	CanvasTestBase

class	ConstantFiringVsyncWaiter

class	DartIsolateTest

class	DartSecondaryIsolateTest

class	DummyPlatformConfigurationClient

struct	ELFAOTSymbols

class	EmbedderConfigBuilder

class	EmbedderTest

class	EmbedderTestBackingStoreProducer

class	EmbedderTestCompositor

class	EmbedderTestCompositorGL

class	EmbedderTestCompositorSoftware

class	EmbedderTestContext

class	EmbedderTestContextGL

class	EmbedderTestContextSoftware

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

class	FixtureTest

class	FuchsiaShellTest

class	GLContextSwitchTest

class	ImageDecoderFixtureTest

class	ImageDisposeTest

class	LayerTestBase

class	LayerTreeTest

struct	LoadedELFDeleter

class	MockCanvas

class	MockLayer

class	MockRasterCache
	A RasterCache implementation that simulates the act of rendering a Layer or SkPicture 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 SkPicture without the overhead of storage. More...

class	MockSession

class	MockSessionWrapper

class	MockTexture

class	MockWin32Window
	Mock for the Win32Window base class. More...

class	PendingTests

class	ScopedStubFlutterApi

class	ScopedStubFlutterGlfwApi

class	ScopedStubFlutterWindowsApi

class	ShellTest

class	ShellTestPlatformView

class	ShellTestPlatformViewGL

class	ShellTestPlatformViewVulkan

class	ShellTestVsyncClock

class	ShellTestVsyncWaiter

class	SkiaGPUObjectLayerTest

class	SkiaGpuObjectTest

class	StubFlutterApi

class	StubFlutterGlfwApi

class	StubFlutterWindowsApi

class	SurfaceMock

class	TestAndroidSurfaceFactory

struct	TestContext

class	TestDartNativeResolver

class	TestGLSurface

class	TestIOManager

class	TestSkObject

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

class	TestTimeoutListener

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	Win32FlutterWindowTest
	Test class for Win32FlutterWindow. More...

Typedefs
using	BackdropFilterLayerTest = LayerTest

using	CheckerBoardLayerTest = LayerTest

using	ClipPathLayerTest = LayerTest

using	ClipRectLayerTest = LayerTest

using	ClipRRectLayerTest = LayerTest

using	ColorFilterLayerTest = LayerTest

using	ContainerLayerTest = LayerTest

using	FuchsiaLayerTest = ::testing::Test

using	ImageFilterLayerTest = LayerTest

using	OpacityLayerTest = LayerTest

using	PerformanceOverlayLayerTest = LayerTest

using	PhysicalShapeLayerTest = LayerTest

using	PictureLayerTest = SkiaGPUObjectLayerTest

using	PlatformViewLayerTest = LayerTest

using	ShaderMaskLayerTest = LayerTest

using	TextureLayerTest = LayerTest

using	TransformLayerTest = LayerTest

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

using	MockLayerTest = LayerTest

using	DartLifecycleTest = FixtureTest

using	DartVMTest = FixtureTest

using	UnitlessTime = int

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

using	IntPipeline = Pipeline< int >

using	Continuation = IntPipeline::ProducerContinuation

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

using	Embedder11yTest = testing::EmbedderTest

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

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

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

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

using	EmbedderTest = testing::EmbedderTest

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

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

using	MockCanvasTest = CanvasTest

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

Enumerations
enum	DebuggerStatus { DebuggerStatus::kDontKnow, DebuggerStatus::kAttached }

enum	MemsetPatternOp { MemsetPatternOp::kMemsetPatternOpSetBuffer, MemsetPatternOp::kMemsetPatternOpCheckBuffer }

Functions
	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, MultipleChildren)

	TEST_F (BackdropFilterLayerTest, Nested)

	TEST_F (BackdropFilterLayerTest, Readback)

	TEST_F (CheckerBoardLayerTest, ClipRectSaveLayerNotCheckBoard)

	TEST_F (CheckerBoardLayerTest, ClipRectSaveLayerCheckBoard)

	TEST_F (CheckerBoardLayerTest, ClipPathSaveLayerNotCheckBoard)

	TEST_F (CheckerBoardLayerTest, ClipPathSaveLayerCheckBoard)

	TEST_F (CheckerBoardLayerTest, ClipRRectSaveLayerNotCheckBoard)

	TEST_F (CheckerBoardLayerTest, ClipRRectSaveLayerCheckBoard)

	TEST_F (CheckerBoardLayerTest, PhysicalSaveLayerNotCheckBoard)

	TEST_F (CheckerBoardLayerTest, PhysicalSaveLayerCheckBoard)

	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, std::shared_ptr< Layer > child, bool before)

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

	TEST_F (ClipRRectLayerTest, PaintBeforePreollDies)

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

	TEST_F (ContainerLayerTest, LayerWithParentHasPlatformView)

	TEST_F (ContainerLayerTest, Simple)

	TEST_F (ContainerLayerTest, Multiple)

	TEST_F (ContainerLayerTest, MultipleWithEmpty)

	TEST_F (ContainerLayerTest, NeedsSystemComposite)

	TEST_F (ContainerLayerTest, MergedOneChild)

	TEST_F (ContainerLayerTest, MergedMultipleChildren)

std::unique_ptr< TestContext >	InitTest ()

zx_koid_t	GetChildLayerId ()

	TEST_F (FuchsiaLayerTest, DISABLED_PhysicalShapeLayersAndChildSceneLayers)

	TEST_F (FuchsiaLayerTest, DISABLED_OpacityAndTransformLayer)

	TEST_F (ImageFilterLayerTest, SimpleFilterBounds)

	TEST_F (ImageFilterLayerTest, ChildIsCached)

	TEST_F (ImageFilterLayerTest, ChildrenNotCached)

	TEST_F (LayerTreeTest, PaintingEmptyLayerDies)

	TEST_F (LayerTreeTest, PaintBeforePreollDies)

	TEST_F (LayerTreeTest, Simple)

	TEST_F (LayerTreeTest, Multiple)

	TEST_F (LayerTreeTest, MultipleWithEmpty)

	TEST_F (LayerTreeTest, NeedsSystemComposite)

	TEST_F (OpacityLayerTest, LeafLayer)

	TEST_F (OpacityLayerTest, FullyOpaque)

	TEST_F (OpacityLayerTest, FullyTransparent)

	TEST_F (OpacityLayerTest, HalfTransparent)

	TEST_F (OpacityLayerTest, CullRectIsTransformed)

	TEST_F (PerformanceOverlayLayerTest, InvalidOptions)

	TEST_F (PerformanceOverlayLayerTest, SimpleRasterizerStatistics)

	TEST (PerformanceOverlayLayerDefault, Gold)

	TEST (PerformanceOverlayLayer90fps, Gold)

	TEST (PerformanceOverlayLayer120fps, Gold)

	TEST_F (PhysicalShapeLayerTest, NonEmptyLayer)

	TEST_F (PhysicalShapeLayerTest, ChildrenLargerThanPath)

	TEST_F (PhysicalShapeLayerTest, ElevationSimple)

	TEST_F (PhysicalShapeLayerTest, ElevationComplex)

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

	TEST_F (PictureLayerTest, PaintBeforePrerollInvalidPictureDies)

	TEST_F (PictureLayerTest, PaintBeforePreollDies)

	TEST_F (PictureLayerTest, PaintingEmptyLayerDies)

	TEST_F (PictureLayerTest, InvalidPictureDies)

	TEST_F (PictureLayerTest, SimplePicture)

	TEST_F (PlatformViewLayerTest, NullViewEmbedderDoesntPrerollCompositeOrPaint)

	TEST_F (TextureLayerTest, InvalidTexture)

	TEST_F (TextureLayerTest, PaintingWithLowFilterQuality)

	TEST_F (TransformLayerTest, Identity)

	TEST_F (TransformLayerTest, NestedSeparated)

	TEST (MatrixDecomposition, Rotation)

	TEST (MatrixDecomposition, Scale)

	TEST (MatrixDecomposition, Translate)

	TEST (MatrixDecomposition, Combination)

	TEST (MatrixDecomposition, ScaleFloatError)

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

	TEST (MutatorsStack, Traversal)

	TEST (MutatorsStack, Equality)

	TEST (Mutator, Initialization)

	TEST (Mutator, CopyConstructor)

	TEST (Mutator, Equality)

	TEST (Mutator, UnEquality)

	TEST (RasterCache, SimpleInitialization)

	TEST (RasterCache, ThresholdIsRespected)

	TEST (RasterCache, AccessThresholdOfZeroDisablesCaching)

	TEST (RasterCache, PictureCacheLimitPerFrameIsRespectedWhenZero)

	TEST (RasterCache, SweepsRemoveUnusedFrames)

	TEST (RasterCache, DeviceRectRoundOut)

	TEST (RTree, searchNonOverlappingDrawnRectsNoIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsSingleRectIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsIgnoresNonDrawingRecords)

	TEST (RTree, searchNonOverlappingDrawnRectsMultipleRectIntersection)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase1)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase2)

	TEST (RTree, searchNonOverlappingDrawnRectsJoinRectsWhenIntersectedCase3)

	TEST_F (SkiaGpuObjectTest, QueueSimple)

	TEST_F (SkiaGpuObjectTest, ObjectDestructor)

	TEST_F (SkiaGpuObjectTest, ObjectReset)

	TEST_F (SkiaGpuObjectTest, ObjectResetTwice)

	TEST_F (MockLayerTest, SimpleParams)

	TEST_F (MockLayerTest, FakePlatformView)

	TEST_F (MockLayerTest, FakeSystemComposite)

bool	operator== (const MockTexture::PaintCall &a, const MockTexture::PaintCall &b)

std::ostream &	operator<< (std::ostream &os, const MockTexture::PaintCall &data)

	TEST (MockTextureTest, Callbacks)

	TEST (MockTextureTest, PaintCalls)

	TEST (MockTextureTest, PaintCallsWithLowFilterQuality)

	TEST (TextureRegistryTest, UnregisterTextureCallbackTriggered)

	TEST (TextureRegistryTest, GrContextCallbackTriggered)

	TEST (TextureRegistryTest, RegisterTextureTwice)

	TEST (TextureRegistryTest, ReuseSameTextureSlot)

static sk_sp< SkData >	OpenFixtureAsSkData (const char *name)

	TEST_F (ImageDecoderFixtureTest, CanCreateImageDecoder)

	TEST_F (ImageDecoderFixtureTest, InvalidImageResultsError)

	TEST_F (ImageDecoderFixtureTest, ValidImageResultsInSuccess)

	TEST_F (ImageDecoderFixtureTest, ExifDataIsRespectedOnDecode)

	TEST_F (ImageDecoderFixtureTest, CanDecodeWithoutAGPUContext)

	TEST_F (ImageDecoderFixtureTest, CanDecodeWithResizes)

	TEST_F (ImageDecoderFixtureTest, CanResizeWithoutDecode)

	TEST (ImageDecoderTest, VerifyCodecRepeatCountsForGifAndWebPAreConsistentWithLoopCounts)

	TEST (ImageDecoderTest, VerifySimpleDecoding)

	TEST (ImageDecoderTest, VerifySubpixelDecodingPreservesExifOrientation)

	TEST_F (ImageDecoderFixtureTest, MultiFrameCodecCanBeCollectedBeforeIOTasksFinish)

	TEST_F (ImageDisposeTest, ImageReleasedAfterFrame)

	TEST_F (ShellTest, EncodeImageGivesExternalTypedData)

	TEST_F (ShellTest, VerticesAccuratelyReportsSize)

	TEST_F (ShellTest, PlatformConfigurationInitialization)

	TEST_F (ShellTest, PlatformConfigurationWindowMetricsUpdate)

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

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)

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

	TEST (PointerDataPacketConverterTest, CanConvetPointerDataPacket)

	TEST (PointerDataPacketConverterTest, CanSynthesizeDownAndUp)

	TEST (PointerDataPacketConverterTest, CanUpdatePointerIdentifier)

	TEST (PointerDataPacketConverterTest, AlwaysForwardMoveEvent)

	TEST (PointerDataPacketConverterTest, CanWorkWithDifferentDevices)

	TEST (PointerDataPacketConverterTest, CanSynthesizeAdd)

	TEST (PointerDataPacketConverterTest, CanHandleThreeFingerGesture)

	TEST (PointerDataPacketConverterTest, CanConvetScroll)

	TEST_F (DartIsolateTest, RootIsolateCreationAndShutdown)

	TEST_F (DartIsolateTest, IsolateShutdownCallbackIsInIsolateScope)

	TEST_F (DartIsolateTest, IsolateCanLoadAndRunDartCode)

	TEST_F (DartIsolateTest, IsolateCannotLoadAndRunUnknownDartEntrypoint)

	TEST_F (DartIsolateTest, CanRunDartCodeCodeSynchronously)

	TEST_F (DartIsolateTest, CanRegisterNativeCallback)

	TEST_F (DartIsolateTest, CanSaveCompilationTrace)

	TEST_F (DartSecondaryIsolateTest, CanLaunchSecondaryIsolates)

	TEST_F (DartIsolateTest, CanRecieveArguments)

	TEST_F (DartIsolateTest, CanCreateServiceIsolate)

	TEST_F (DartIsolateTest, RootIsolateCreateCallbackIsMadeOnceAndBeforeIsolateRunning)

	TEST_F (DartIsolateTest, IsolateCreateCallbacksTakeInstanceSettingsInsteadOfVMSettings)

	TEST_F (DartLifecycleTest, CanStartAndShutdownVM)

	TEST_F (DartLifecycleTest, CanStartAndShutdownVMOverAndOver)

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

	TEST_F (DartLifecycleTest, DISABLED_ShuttingDownTheVMShutsDownAllIsolates)

	TEST_F (DartVMTest, SimpleInitialization)

	TEST_F (DartVMTest, SimpleIsolateNameServer)

	TEST_F (DartVMTest, OldGenHeapSize)

	TEST_F (TypeConversionsTest, TestFixture)

	TEST_F (TypeConversionsTest, CanConvertEmptyList)

	TEST_F (TypeConversionsTest, CanConvertListOfStrings)

	TEST_F (TypeConversionsTest, CanConvertListOfDoubles)

	TEST_F (TypeConversionsTest, CanConvertListOfInts)

	TEST_F (TypeConversionsTest, CanConvertListOfFloatsToListOfDartDoubles)

	TEST_F (ShellTest, VSyncTargetTime)

	TEST (CanvasSpyTest, DrawingIsTracked)

	TEST (CanvasSpyTest, SpiedCanvasIsDrawing)

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	WaitForIO (Shell *shell)

	TEST_F (ShellTest, CacheSkSLWorks)

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

static void	ResetAssetManager ()

static void	CheckTwoSkSLsAreLoaded ()

	TEST_F (ShellTest, CanLoadSkSLsFromAsset)

	TEST_F (ShellTest, CanRemoveOldPersistentCache)

	TEST_F (ShellTest, CanPurgePersistentCache)

	TEST_F (ShellTest, PurgeAllowsFutureSkSLCache)

	TEST (PipelineTest, ConsumeOneVal)

	TEST (PipelineTest, ContinuationCanOnlyBeUsedOnce)

	TEST (PipelineTest, PushingMoreThanDepthCompletesFirstSubmission)

	TEST (PipelineTest, PushingMultiProcessesInOrder)

	TEST (PipelineTest, ProduceIfEmptyDoesNotConsumeWhenQueueIsNotEmpty)

	TEST (PipelineTest, ProduceIfEmptySuccessfulIfQueueIsEmpty)

static bool	ValidateShell (Shell *shell)

static void	RunCoroutineWithRetry (int retries, fml::AutoResetWaitableEvent tick, fml::AutoResetWaitableEvent tock, std::function< bool()> f)

	TEST_F (FuchsiaShellTest, LocaltimesVaryOnTimezoneChanges)

static bool	ValidateShell (Shell *shell)

static bool	RasterizerHasLayerTree (Shell *shell)

static void	ValidateDestroyPlatformView (Shell *shell)

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

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

	TEST_F (ShellTest, InitializeWithInvalidThreads)

	TEST_F (ShellTest, InitializeWithDifferentThreads)

	TEST_F (ShellTest, InitializeWithSingleThread)

	TEST_F (ShellTest, InitializeWithSingleThreadWhichIsTheCallingThread)

	TEST_F (ShellTest, InitializeWithMultipleThreadButCallingThreadAsPlatformThread)

	TEST_F (ShellTest, InitializeWithGPUAndPlatformThreadsTheSame)

	TEST_F (ShellTest, FixturesAreFunctional)

	TEST_F (ShellTest, SecondaryIsolateBindingsAreSetupViaShellSettings)

	TEST_F (ShellTest, LastEntrypoint)

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

	TEST_F (ShellTest, FrameRasterizedCallbackIsCalled)

	TEST_F (ShellTest, ExternalEmbedderNoThreadMerger)

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

	TEST_F (ShellTest, ResubmitFrame)

	TEST (SettingsTest, FrameTimingSetsAndGetsProperly)

	TEST_F (ShellTest, ReportTimingsIsCalledSoonerInNonReleaseMode)

	TEST_F (ShellTest, ReportTimingsIsCalledImmediatelyAfterTheFirstFrame)

	TEST_F (ShellTest, ReloadSystemFonts)

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

	TEST_F (ShellTest, SetResourceCacheSizeEarly)

	TEST_F (ShellTest, SetResourceCacheSizeNotifiesDart)

	TEST_F (ShellTest, CanCreateImagefromDecompressedBytes)

	TEST_F (ShellTest, TextureFrameMarkedAvailableAndUnregister)

	TEST_F (ShellTest, IsolateCanAccessPersistentIsolateData)

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

	TEST_F (ShellTest, Screenshot)

	TEST_F (ShellTest, CanConvertToAndFromMappings)

	TEST_F (ShellTest, LocaltimesMatch)

	TEST_F (ShellTest, CanDecompressImageFromAsset)

	TEST_F (ShellTest, OnServiceProtocolGetSkSLsWorks)

	TEST_F (ShellTest, RasterizerScreenshot)

	TEST_F (ShellTest, RasterizerMakeRasterSnapshot)

static sk_sp< SkPicture >	MakeSizedPicture (int width, int height)

	TEST_F (ShellTest, OnServiceProtocolEstimateRasterCacheMemoryWorks)

	TEST_F (ShellTest, DiscardLayerTreeOnResize)

	TEST_F (ShellTest, IgnoresInvalidMetrics)

	TEST_F (ShellTest, OnServiceProtocolSetAssetBundlePathWorks)

	TEST_F (ShellTest, EngineRootIsolateLaunchesDontTakeVMDataSettings)

fml::RefPtr< fml::RasterThreadMerger >	GetThreadMergerFromPlatformThread (bool merged=false)

fml::RefPtr< fml::RasterThreadMerger >	GetThreadMergerFromRasterThread ()

	TEST (AndroidExternalViewEmbedder, GetCurrentCanvases)

	TEST (AndroidExternalViewEmbedder, GetCurrentCanvases__CompositeOrder)

	TEST (AndroidExternalViewEmbedder, CompositeEmbeddedView)

	TEST (AndroidExternalViewEmbedder, CancelFrame)

	TEST (AndroidExternalViewEmbedder, RasterizerRunsOnPlatformThread)

	TEST (AndroidExternalViewEmbedder, RasterizerRunsOnRasterizerThread)

	TEST (AndroidExternalViewEmbedder, PlatformViewRect)

	TEST (AndroidExternalViewEmbedder, PlatformViewRect__ChangedParams)

	TEST (AndroidExternalViewEmbedder, SubmitFrame)

	TEST (AndroidExternalViewEmbedder, DoesNotCallJNIPlatformThreadOnlyMethods)

	TEST (AndroidExternalViewEmbedder, DestroyOverlayLayersOnSizeChange)

	TEST (AndroidExternalViewEmbedder, DoesNotDestroyOverlayLayersOnSizeChange)

	TEST (AndroidExternalViewEmbedder, SupportsDynamicThreadMerging)

	TEST (AndroidExternalViewEmbedder, DisableThreadMerger)

	TEST (SurfacePool, GetLayer__AllocateOneLayer)

	TEST (SurfacePool, GetUnusedLayers)

	TEST (SurfacePool, GetLayer__Recycle)

	TEST (SurfacePool, GetLayer__AllocateTwoLayers)

	TEST (SurfacePool, DestroyLayers)

	TEST (SurfacePool, DestroyLayers__frameSizeChanged)

	TEST (JNIMock, FlutterViewHandlePlatformMessage)

	TEST (PlatformViewShell, UpdateSemanticsDoesFlutterViewUpdateSemantics)

	TEST (PlatformViewShell, UpdateSemanticsDoesFlutterViewUpdateCustomAccessibilityActions)

	TEST (FlutterEngineTest, FlutterEngineCanLaunch)

id	mockViewController (NSString *pasteboardString)

	TEST (FlutterViewControllerTest, HasStringsWhenPasteboardEmpty)

	TEST (FlutterViewControllerTest, HasStringsWhenPasteboardFull)

	TEST_F (Embedder11yTest, DISABLED_A11yTreeIsConsistent)

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

	TEST_F (EmbedderTest, DartEntrypointArgs)

	TEST_F (EmbedderTest, VMAndIsolateSnapshotSizesAreRedundantInAOTMode)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownSceneWithSoftwareCompositor)

	TEST_F (EmbedderTest, CanCreateInitializedEngine)

	TEST_F (EmbedderTest, CanRunInitializedEngine)

	TEST_F (EmbedderTest, CaDeinitializeAnEngine)

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

	TEST_F (EmbedderTest, MustPreventEngineLaunchWhenRequiredCompositorArgsAreAbsent)

	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_F (EmbedderTest, CanRenderGradientWithoutCompositor)

	TEST_F (EmbedderTest, CanRenderGradientWithoutCompositorWithXform)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositor)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositorWithXform)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositorOnNonRootLayer)

	TEST_F (EmbedderTest, CanRenderGradientWithCompositorOnNonRootLayerWithXform)

	TEST_F (EmbedderTest, VerifyB141980393)

	TEST_F (EmbedderTest, CanCreateEmbedderWithCustomRenderTaskRunner)

	TEST_F (EmbedderTest, CanCreateEmbedderWithCustomRenderTaskRunnerTheSameAsPlatformTaskRunner)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurface)

	TEST_F (EmbedderTest, CompositorMustBeAbleToRenderKnownScenePixelRatioOnSurfaceWithRootSurfaceXformation)

	TEST_F (EmbedderTest, PushingMutlipleFramesSetsUpNewRecordingCanvasWithCustomCompositor)

	TEST_F (EmbedderTest, PushingMutlipleFramesSetsUpNewRecordingCanvasWithoutCustomCompositor)

	TEST_F (EmbedderTest, 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, PresentInfoContainsValidFBOId)

	TEST_F (EmbedderTest, SetSingleDisplayConfigurationWithDisplayId)

	TEST_F (EmbedderTest, SetSingleDisplayConfigurationWithoutDisplayId)

	TEST_F (EmbedderTest, SetValidMultiDisplayConfiguration)

	TEST_F (EmbedderTest, MultipleDisplaysWithSingleDisplayTrueIsInvalid)

	TEST_F (EmbedderTest, MultipleDisplaysWithSameDisplayIdIsInvalid)

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

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

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

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

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

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

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

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

SkMatrix	GetTotalMutationTransformationMatrix (const FlutterPlatformView *view)

	TEST (FlutterProjectBundle, BasicPropertiesAbsolutePaths)

	TEST (FlutterProjectBundle, BasicPropertiesRelativePaths)

	TEST (FlutterProjectBundle, SwitchesEmpty)

	TEST (FlutterProjectBundle, Switches)

	TEST (StringConversion, Utf16FromUtf8Empty)

	TEST (StringConversion, Utf16FromUtf8Ascii)

	TEST (StringConversion, Utf16FromUtf8Unicode)

	TEST (StringConversion, Utf8FromUtf16Empty)

	TEST (StringConversion, Utf8FromUtf16Ascii)

	TEST (StringConversion, Utf8FromUtf16Unicode)

	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 (DpiUtilsTest, NonZero)

	TEST (DpiUtilsTest, NullHwndUsesPrimaryMonitor)

	TEST (Win32FlutterWindowTest, CreateDestroy)

	TEST (Win32WindowProcDelegateManagerTest, CallsCorrectly)

	TEST (Win32WindowProcDelegateManagerTest, ReplacementRegister)

	TEST (Win32WindowProcDelegateManagerTest, RegisterMultiple)

	TEST (Win32WindowProcDelegateManagerTest, ConflictingDelegates)

	TEST (Win32WindowProcDelegateManagerTest, Unregister)

	TEST (MockWin32Window, CreateDestroy)

	TEST (MockWin32Window, GetDpiAfterCreate)

	TEST (MockWin32Window, VerticalScroll)

	TEST (MockWin32Window, HorizontalScroll)

bool	NumberNear (double a, double b)

std::ostream &	operator<< (std::ostream &os, const SkClipOp &o)

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

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

std::ostream &	operator<< (std::ostream &os, const SkVector3 &v)

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

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

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

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

std::ostream &	operator<< (std::ostream &os, const SkISize &size)

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

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

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 &fixtures_path, fml::WeakPtr< IOManager > io_manager)

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 &fixtures_path, fml::WeakPtr< IOManager > io_manager)

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={})

DebuggerStatus	GetDebuggerStatus ()

ELFAOTSymbols	LoadELFSymbolFromFixturesIfNeccessary ()
	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...

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...

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::ConcatMatrix44Data &a, const MockCanvas::ConcatMatrix44Data &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::ConcatMatrix44Data &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::DrawPictureData &a, const MockCanvas::DrawPictureData &b)

std::ostream &	operator<< (std::ostream &os, const MockCanvas::DrawPictureData &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)

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::DrawPaint &a, const MockCanvas::DrawPaint &b)

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

	TEST_F (MockCanvasTest, DrawRRectDies)

	TEST_F (MockCanvasTest, DrawCalls)

static const uint8_t *	DartNativeEntrySymbolCallback (Dart_NativeFunction function)

static std::string	GetEGLError ()

	TEST (TestMetalSurface, EmptySurfaceIsInvalid)

	TEST (TestMetalSurface, CanCreateValidTestMetalSurface)

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...

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

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

std::unique_ptr< fml::Mapping >	OpenFixtureAsMapping (std::string fixture_name)
	Opens a fixture of the given file name and returns a mapping to 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 *	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...

Variables
FML_THREAD_LOCAL fml::ThreadLocalUniquePtr< int >	current_context

constexpr const char *	kAOTAppELFFileName = "app_elf_snapshot.so"

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

static constexpr SkRect	kEmptyRect = SkRect::MakeEmpty()

static std::mutex	gIsolateResolversMutex

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

Typedef Documentation

◆ BackdropFilterLayerTest

using flutter::testing::BackdropFilterLayerTest = typedef LayerTest

Definition at line 17 of file backdrop_filter_layer_unittests.cc.

◆ CanvasTest

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

Definition at line 28 of file canvas_test.h.

◆ CheckerBoardLayerTest

using flutter::testing::CheckerBoardLayerTest = typedef LayerTest

Definition at line 18 of file checkerboard_layertree_unittests.cc.

◆ ClipPathLayerTest

using flutter::testing::ClipPathLayerTest = typedef LayerTest

Definition at line 15 of file clip_path_layer_unittests.cc.

◆ ClipRectLayerTest

using flutter::testing::ClipRectLayerTest = typedef LayerTest

Definition at line 15 of file clip_rect_layer_unittests.cc.

◆ ClipRRectLayerTest

using flutter::testing::ClipRRectLayerTest = typedef LayerTest

Definition at line 15 of file clip_rrect_layer_unittests.cc.

◆ ColorFilterLayerTest

using flutter::testing::ColorFilterLayerTest = typedef LayerTest

Definition at line 17 of file color_filter_layer_unittests.cc.

◆ ContainerLayerTest

using flutter::testing::ContainerLayerTest = typedef LayerTest

Definition at line 15 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 15 of file vsync_waiters_test.h.

◆ DartLifecycleTest

using flutter::testing::DartLifecycleTest = typedef FixtureTest

Definition at line 17 of file dart_lifecycle_unittests.cc.

◆ DartVMTest

using flutter::testing::DartVMTest = typedef FixtureTest

Definition at line 14 of file dart_vm_unittests.cc.

◆ Embedder11yTest

using flutter::testing::Embedder11yTest = typedef testing::EmbedderTest

Definition at line 22 of file embedder_a11y_unittests.cc.

◆ EmbedderTest

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

Definition at line 34 of file embedder_unittests.cc.

◆ FuchsiaLayerTest

using flutter::testing::FuchsiaLayerTest = typedef ::testing::Test

Definition at line 30 of file fuchsia_layer_unittests.cc.

◆ Generator

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

Definition at line 17 of file input_events_unittests.cc.

◆ ImageFilterLayerTest

using flutter::testing::ImageFilterLayerTest = typedef LayerTest

Definition at line 16 of file image_filter_layer_unittests.cc.

◆ IntPipeline

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

Definition at line 18 of file pipeline_unittests.cc.

◆ LayerTest

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

Definition at line 151 of file layer_test.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 28 of file test_dart_native_resolver.h.

◆ OpacityLayerTest

using flutter::testing::OpacityLayerTest = typedef LayerTest

Definition at line 16 of file opacity_layer_unittests.cc.

◆ PerformanceOverlayLayerTest

using flutter::testing::PerformanceOverlayLayerTest = typedef LayerTest

Definition at line 121 of file performance_overlay_layer_unittests.cc.

◆ PhysicalShapeLayerTest

using flutter::testing::PhysicalShapeLayerTest = typedef LayerTest

Definition at line 15 of file physical_shape_layer_unittests.cc.

◆ PictureLayerTest

using flutter::testing::PictureLayerTest = typedef SkiaGPUObjectLayerTest

Definition at line 21 of file picture_layer_unittests.cc.

◆ PlatformViewLayerTest

using flutter::testing::PlatformViewLayerTest = typedef LayerTest

Definition at line 15 of file platform_view_layer_unittests.cc.

◆ SemanticsActionCallback

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

Definition at line 29 of file embedder_test_context.h.

◆ SemanticsNodeCallback

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

Definition at line 27 of file embedder_test_context.h.

◆ ShaderMaskLayerTest

using flutter::testing::ShaderMaskLayerTest = typedef LayerTest

Definition at line 17 of file shader_mask_layer_unittests.cc.

◆ TextureLayerTest

using flutter::testing::TextureLayerTest = typedef LayerTest

Definition at line 16 of file texture_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 39 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 23 of file elf_loader.h.

◆ UnitlessTime

using flutter::testing::UnitlessTime = typedef int

Definition at line 13 of file input_events_unittests.cc.

Enumeration Type Documentation

◆ DebuggerStatus

enum flutter::testing::DebuggerStatus

strong

Enumerator
kDontKnow
kAttached

Definition at line 13 of file debugger_detection.h.

                           {
   kDontKnow,
   kAttached,
 };

◆ MemsetPatternOp

enum flutter::testing::MemsetPatternOp

strong

Enumerator
kMemsetPatternOpSetBuffer
kMemsetPatternOpCheckBuffer

Definition at line 66 of file testing.h.

                            {
   kMemsetPatternOpSetBuffer,
   kMemsetPatternOpCheckBuffer,
 };

Function Documentation

◆ CheckFrameTimings()

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

static

Definition at line 376 of file shell_unittests.cc.

References flutter::FrameTiming::kPhases, and phase.

Referenced by TEST_F().

                                                    {
   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) {
       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);
     }
   }
 }

◆ CheckTextSkData()

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

static

Definition at line 135 of file persistent_cache_unittests.cc.

Referenced by TEST_F().

                                                                            {
   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 146 of file persistent_cache_unittests.cc.

References flutter::PersistentCache::GetCacheForProcess(), and flutter::PersistentCache::LoadSkSLs().

Referenced by TEST_F().

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

◆ CreateAndRunRootIsolate()

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

static

Definition at line 46 of file dart_lifecycle_unittests.cc.

References flutter::DartIsolate::CreateRunningRootIsolate(), FML_CHECK, FML_LOG, flutter::DartVMData::GetIsolateSnapshot(), flutter::DartVMData::GetSettings(), flutter::IsolateConfiguration::InferFromSettings(), flutter::Settings::isolate_create_callback, and flutter::Settings::isolate_shutdown_callback.

Referenced by TEST_F().

                           {
   FML_CHECK(entrypoint.size() > 0);
   TaskRunners runners("io.flutter.test", task_runner, task_runner, task_runner,
                       task_runner);
 
   auto isolate_configuration =
       IsolateConfiguration::InferFromSettings(settings);
 
   auto isolate =
       DartIsolate::CreateRunningRootIsolate(
           vm.GetSettings(),                    // settings
           vm.GetIsolateSnapshot(),             // isolate_snapshot
           runners,                             // task_runners
           {},                                  // window
           {},                                  // snapshot_delegate
           {},                                  // hint_freed_delegate
           {},                                  // io_manager
           {},                                  // unref_queue
           {},                                  // image_decoder
           "main.dart",                         // advisory_script_uri
           entrypoint.c_str(),                  // advisory_script_entrypoint
           DartIsolate::Flags{},                // flags
           settings.isolate_create_callback,    // isolate create callback
           settings.isolate_shutdown_callback,  // isolate shutdown callback,
           entrypoint,                          // dart entrypoint
           std::nullopt,                        // dart entrypoint library
           std::move(isolate_configuration)     // isolate configuration
           )
           .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 95 of file shell_unittests.cc.

Referenced by TestDartVmFlags().

                                                                   {
   if (flags.size() == 0) {
     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;
 }

◆ CreateRenderSurface()

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

Definition at line 12 of file embedder_unittests_util.cc.

References FML_CHECK, FlutterSize::height, FlutterLayer::size, and FlutterSize::width.

Referenced by TEST_F().

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

◆ 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
	)

Definition at line 49 of file pointer_data_packet_converter_unittests.cc.

Referenced by TEST().

                                                             {
   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 = 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 = scroll_delta_x;
   data.scroll_delta_y = scroll_delta_y;
 }

◆ CreateSimulatedPointerData() [1/2]

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

Definition at line 14 of file pointer_data_packet_converter_unittests.cc.

Referenced by TEST(), and TEST_F().

                                            {
   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 = 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;
 }

◆ CreateSimulatedPointerData() [2/2]

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

Definition at line 144 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;
 }

◆ DartNativeEntrySymbolCallback()

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

static

Definition at line 63 of file test_dart_native_resolver.cc.

Referenced by flutter::testing::TestDartNativeResolver::SetNativeResolverForIsolate().

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

◆ FilterMutationsByType() [1/2]

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

Definition at line 141 of file embedder_unittests_util.cc.

References FlutterPlatformViewMutation::type.

Referenced by FilterMutationsByType(), GetTotalMutationTransformationMatrix(), and TEST_F().

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

◆ FilterMutationsByType() [2/2]

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

Definition at line 160 of file embedder_unittests_util.cc.

References FilterMutationsByType(), FlutterPlatformView::mutations, and FlutterPlatformView::mutations_count.

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

◆ GetChildLayerId()

zx_koid_t flutter::testing::GetChildLayerId ( )

Definition at line 313 of file fuchsia_layer_unittests.cc.

Referenced by TEST_F().

                             {
   static zx_koid_t sChildLayerId = 17324;
   return sChildLayerId++;
 }

◆ 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 12 of file testing.cc.

Referenced by flutter::testing::TypeConversionsTest::RunWithEntrypoint(), and TEST_F().

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

◆ GetDebuggerStatus()

DebuggerStatus flutter::testing::GetDebuggerStatus ( )

Definition at line 25 of file debugger_detection.cc.

References FML_CHECK, kAttached, kDontKnow, and fml::size().

Referenced by main().

                                    {
 #if 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 OS_WIN
   return ::IsDebuggerPresent() ? DebuggerStatus::kAttached
                                : DebuggerStatus::kDontKnow;
 
 #else
   return DebuggerStatus::kDontKnow;
 #endif
 }  // namespace testing

◆ GetEGLError()

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

static

Definition at line 22 of file test_gl_surface.cc.

References eglGetError(), and error.

Referenced by flutter::testing::TestGLSurface::ClearCurrent(), flutter::testing::TestGLSurface::MakeCurrent(), flutter::testing::TestGLSurface::MakeResourceCurrent(), flutter::testing::TestGLSurface::Present(), flutter::testing::TestGLSurface::TestGLSurface(), and flutter::testing::TestGLSurface::~TestGLSurface().

                                {
   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.

Referenced by flutter::BM_PlatformMessageResponseDartComplete(), flutter::testing::EmbedderTest::GetFixturesDirectory(), ImageMatchesFixture(), LoadELFSymbolFromFixturesIfNeccessary(), main(), mockViewController(), OpenFixture(), OpenFixtureAsSkData(), OpenFixturesDirectory(), flutter::testing::TypeConversionsTest::RunWithEntrypoint(), flutter::testing::EmbedderTestContext::SetupAOTDataIfNecessary(), flutter::StartupAndShutdownShell(), TEST(), and TEST_F().

◆ GetRasterizerResourceCacheBytesSync()

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

static

Definition at line 1331 of file shell_unittests.cc.

References flutter::Shell::GetRasterizer(), flutter::TaskRunners::GetRasterTaskRunner(), flutter::Shell::GetTaskRunners(), fml::TaskRunner::RunNowOrPostTask(), fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

Referenced by TEST_F().

                                                                       {
   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;
 }

◆ GetTestNameFromTestInfo()

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

static

Definition at line 86 of file test_timeout_listener.cc.

References name, fml::TimePoint::Now(), fml::TaskRunner::PostTask(), and WeakPtr().

                                       {
   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();
 }

◆ GetThreadMergerFromPlatformThread()

fml::RefPtr<fml::RasterThreadMerger> flutter::testing::GetThreadMergerFromPlatformThread ( bool merged = false )

Definition at line 66 of file external_view_embedder_unittests.cc.

References fml::MessageLoop::EnsureInitializedForCurrentThread(), and fml::MessageLoop::GetCurrentTaskQueueId().

Referenced by TEST().

                          {
   // Assume the current thread is the platform thread.
   fml::MessageLoop::EnsureInitializedForCurrentThread();
   auto platform_queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
 
   if (merged) {
     return fml::MakeRefCounted<fml::RasterThreadMerger>(platform_queue_id,
                                                         platform_queue_id);
   }
   auto rasterizer_thread = new fml::Thread("rasterizer");
   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 ( )

Definition at line 83 of file external_view_embedder_unittests.cc.

References fml::MessageLoop::EnsureInitializedForCurrentThread(), and fml::MessageLoop::GetCurrentTaskQueueId().

Referenced by TEST().

                                                                    {
   auto platform_thread = new fml::Thread("rasterizer");
   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 FlutterPlatformViewMutation **	mutations,
		size_t	count
	)

Definition at line 168 of file embedder_unittests_util.cc.

References FilterMutationsByType(), kFlutterPlatformViewMutationTypeTransformation, and SkMatrixMake().

Referenced by GetTotalMutationTransformationMatrix(), and TEST_F().

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

◆ GetTotalMutationTransformationMatrix() [2/2]

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

Definition at line 182 of file embedder_unittests_util.cc.

References GetTotalMutationTransformationMatrix(), FlutterPlatformView::mutations, and FlutterPlatformView::mutations_count.

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

◆ ImageMatchesFixture() [1/2]

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

Definition at line 82 of file embedder_unittests_util.cc.

References FML_CHECK, FML_LOG, GetFixturesPath(), fml::FileMapping::GetMapping(), fml::FileMapping::GetSize(), fml::paths::JoinPaths(), OpenFixture(), OpenFixturesDirectory(), RasterImagesAreSame(), and WriteImageToDisk().

Referenced by ImageMatchesFixture(), and TEST_F().

                                                      {
   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 =
       SkImage::MakeFromEncoded(std::move(encoded_image))->makeRasterImage();
 
   FML_CHECK(fixture_image) << "Could not create image from fixture: "
                            << fixture_file_name;
 
   auto scene_image_subset = scene_image->makeSubset(
       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 136 of file embedder_unittests_util.cc.

References ImageMatchesFixture().

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

◆ InitTest()

std::unique_ptr<TestContext> flutter::testing::InitTest ( )

Definition at line 273 of file fuchsia_layer_unittests.cc.

References flutter::kGiantRect.

Referenced by TEST_F().

                                       {
   std::unique_ptr<TestContext> context = std::make_unique<TestContext>();
 
   // Init message loop.
   context->loop = fml::MakeRefCounted<fml::MessageLoopFuchsia>();
   context->task_runner = fml::MakeRefCounted<fml::TaskRunner>(context->loop);
 
   // Init Session.
   fuchsia::ui::scenic::SessionPtr session_ptr;
   fuchsia::ui::scenic::SessionListenerPtr listener;
   context->listener_request = listener.NewRequest();
   context->mock_session.Bind(session_ptr.NewRequest(), std::move(listener));
   context->mock_session_wrapper =
       std::make_unique<MockSessionWrapper>(std::move(session_ptr));
 
   // Init SceneUpdateContext.
   context->scene_update_context = std::make_shared<SceneUpdateContext>(
       "fuchsia_layer_unittest", fuchsia::ui::views::ViewToken(),
       scenic::ViewRefPair::New(), *(context->mock_session_wrapper));
 
   // Init PrerollContext.
   context->preroll_context = std::unique_ptr<PrerollContext>(new PrerollContext{
       nullptr,                    // raster_cache (don't consult the cache)
       nullptr,                    // gr_context  (used for the raster cache)
       nullptr,                    // external view embedder
       context->unused_stack,      // mutator stack
       nullptr,                    // SkColorSpace* dst_color_space
       kGiantRect,                 // SkRect cull_rect
       false,                      // layer reads from surface
       context->unused_stopwatch,  // frame time (dont care)
       context->unused_stopwatch,  // engine time (dont care)
       context->unused_texture_registry,  // texture registry (not
                                          // supported)
       false,                             // checkerboard_offscreen_layers
       1.f                                // ratio between logical and physical
   });
 
   return context;
 }

◆ InvokeAllCallbacks()

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

static

Definition at line 22 of file embedder_test_compositor.cc.

Referenced by flutter::testing::EmbedderTestCompositor::CollectBackingStore(), flutter::testing::EmbedderTestCompositor::CreateBackingStore(), and flutter::testing::EmbedderTestCompositor::Present().

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

◆ LoadELFSymbolFromFixturesIfNeccessary()

ELFAOTSymbols flutter::testing::LoadELFSymbolFromFixturesIfNeccessary ( )

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.

Returns: The loaded ELF symbols.

Definition at line 15 of file elf_loader.cc.

References error, FML_LOG, GetFixturesPath(), fml::IsFile(), flutter::DartVM::IsRunningPrecompiledCode(), fml::paths::JoinPaths(), kAOTAppELFFileName, flutter::testing::ELFAOTSymbols::loaded_elf, flutter::testing::ELFAOTSymbols::vm_isolate_data, flutter::testing::ELFAOTSymbols::vm_isolate_instrs, flutter::testing::ELFAOTSymbols::vm_snapshot_data, and flutter::testing::ELFAOTSymbols::vm_snapshot_instrs.

Referenced by flutter::StartupAndShutdownShell().

                                                       {
   if (!DartVM::IsRunningPrecompiledCode()) {
     return {};
   }
 
   const auto elf_path =
       fml::paths::JoinPaths({GetFixturesPath(), kAOTAppELFFileName});
 
   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;
 
   // Must not be freed.
   const char* error = nullptr;
 
 #if OS_FUCHSIA
   // TODO(gw280): https://github.com/flutter/flutter/issues/50285
   // Dart doesn't implement Dart_LoadELF on Fuchsia
   auto loaded_elf = nullptr;
 #else
   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)
       );
 #endif
 
   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;
 }

◆ LogSkData()

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

static

Definition at line 1616 of file shell_unittests.cc.

References FML_LOG.

Referenced by TEST_F().

                                                              {
   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();
     }
   }
 }

◆ MakeSizedPicture()

static sk_sp<SkPicture> flutter::testing::MakeSizedPicture	(	int	width,
		int	height
	)

static

Definition at line 1929 of file shell_unittests.cc.

Referenced by TEST_F().

                                                                 {
   SkPictureRecorder recorder;
   SkCanvas* recording_canvas =
       recorder.beginRecording(SkRect::MakeXYWH(0, 0, width, height));
   recording_canvas->drawRect(SkRect::MakeXYWH(0, 0, width, height),
                              SkPaint(SkColor4f::FromColor(SK_ColorRED)));
   return recorder.finishRecordingAsPicture();
 }

◆ MemsetPatternSetOrCheck() [1/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 56 of file testing.cc.

References kMemsetPatternOpCheckBuffer, and kMemsetPatternOpSetBuffer.

Referenced by MemsetPatternSetOrCheck(), and TEST_F().

                                                                                {
   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;
 }

◆ MemsetPatternSetOrCheck() [2/2]

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

Definition at line 97 of file testing.cc.

References MemsetPatternSetOrCheck().

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

◆ mockViewController()

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

Definition at line 18 of file FlutterViewControllerTest.mm.

References GetFixturesPath().

Referenced by TEST().

                                                   {
   NSString* fixtures = @(testing::GetFixturesPath());
   FlutterDartProject* project = [[FlutterDartProject alloc]
       initWithAssetsPath:fixtures
              ICUDataPath:[fixtures stringByAppendingString:@"/icudtl.dat"]];
   FlutterViewController* viewController = [[FlutterViewController alloc] initWithProject:project];
 
   // Mock pasteboard so that this test will work in environments without a
   // real pasteboard.
   id pasteboardMock = OCMClassMock([NSPasteboard class]);
   OCMExpect([pasteboardMock stringForType:[OCMArg any]]).andDo(^(NSInvocation* invocation) {
     NSString* returnValue = pasteboardString.length > 0 ? pasteboardString : nil;
     [invocation setReturnValue:&returnValue];
   });
   id viewControllerMock = OCMPartialMock(viewController);
   OCMStub([viewControllerMock pasteboard]).andReturn(pasteboardMock);
   return viewControllerMock;
 }

◆ NumberNear()

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

inline

Definition at line 13 of file assertions.h.

Referenced by operator==().

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

◆ OpenFixture()

fml::UniqueFD flutter::testing::OpenFixture ( 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 30 of file testing.cc.

References FML_LOG, GetFixturesPath(), fml::kRead, fml::OpenFile(), and OpenFixturesDirectory().

Referenced by ImageMatchesFixture(), and OpenFixtureAsMapping().

                                                 {
   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 ( 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 52 of file testing.cc.

References fml::FileMapping::CreateReadOnly(), and OpenFixture().

Referenced by TEST_F().

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

◆ OpenFixtureAsSkData()

static sk_sp<SkData> flutter::testing::OpenFixtureAsSkData ( const char * name )

static

Definition at line 95 of file image_decoder_unittests.cc.

References fml::FileMapping::CreateReadOnly(), GetFixturesPath(), fml::kRead, and fml::OpenDirectory().

Referenced by TEST(), and TEST_F().

                                                            {
   auto fixtures_directory =
       fml::OpenDirectory(GetFixturesPath(), false, fml::FilePermission::kRead);
   if (!fixtures_directory.is_valid()) {
     return nullptr;
   }
 
   auto fixture_mapping =
       fml::FileMapping::CreateReadOnly(fixtures_directory, name);
 
   if (!fixture_mapping) {
     return nullptr;
   }
 
   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) {
     return nullptr;
   }
   // The data is now owned by Skia.
   fixture_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 16 of file testing.cc.

References FML_LOG, GetFixturesPath(), fml::kRead, and fml::OpenDirectory().

Referenced by ImageMatchesFixture(), and OpenFixture().

                                     {
   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/29]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkClipOp &	o
	)

Definition at line 10 of file assertions_skia.cc.

                                                           {
   switch (o) {
     case SkClipOp::kDifference:
       os << "ClipOpDifference";
       break;
     case SkClipOp::kIntersect:
       os << "ClipOpIntersect";
       break;
 #ifdef SK_SUPPORT_DEPRECATED_CLIPOPS
     case SkClipOp::kUnion_deprecated:
       os << "ClipOpUnion_deprecated";
       break;
     case SkClipOp::kXOR_deprecated:
       os << "ClipOpXOR_deprecated";
       break;
     case SkClipOp::kReverseDifference_deprecated:
       os << "ClipOpReverseDifference_deprecated";
       break;
     case SkClipOp::kReplace_deprecated:
       os << "ClipOpReplace_deprectaed";
       break;
 #else
     case SkClipOp::kExtraEnumNeedInternallyPleaseIgnoreWillGoAway2:
       os << "ClipOpReserved2";
       break;
     case SkClipOp::kExtraEnumNeedInternallyPleaseIgnoreWillGoAway3:
       os << "ClipOpReserved3";
       break;
     case SkClipOp::kExtraEnumNeedInternallyPleaseIgnoreWillGoAway4:
       os << "ClipOpReserved4";
       break;
     case SkClipOp::kExtraEnumNeedInternallyPleaseIgnoreWillGoAway5:
       os << "ClipOpReserved5";
       break;
 #endif
   }
   return os;
 }

◆ operator<<() [2/29]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const MockTexture::PaintCall &	data
	)

Definition at line 28 of file mock_texture.cc.

References flutter::testing::MockTexture::PaintCall::bounds, flutter::testing::MockTexture::PaintCall::canvas, flutter::testing::MockTexture::PaintCall::context, flutter::testing::MockTexture::PaintCall::filter_quality, and flutter::testing::MockTexture::PaintCall::freeze.

Referenced by flutter::testing::MockCanvas::didRestore(), and flutter::testing::MockTexture::unregistered().

                                                                          {
   return os << &data.canvas << " " << data.bounds << " " << data.context << " "
             << data.freeze << " " << data.filter_quality;
 }

◆ operator<<() [3/29]

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

Definition at line 49 of file assertions_skia.cc.

                                                           {
   os << std::endl;
   os << "Scale X: " << m[SkMatrix::kMScaleX] << ", ";
   os << "Skew  X: " << m[SkMatrix::kMSkewX] << ", ";
   os << "Trans X: " << m[SkMatrix::kMTransX] << std::endl;
   os << "Skew  Y: " << m[SkMatrix::kMSkewY] << ", ";
   os << "Scale Y: " << m[SkMatrix::kMScaleY] << ", ";
   os << "Trans Y: " << m[SkMatrix::kMTransY] << std::endl;
   os << "Persp X: " << m[SkMatrix::kMPersp0] << ", ";
   os << "Persp Y: " << m[SkMatrix::kMPersp1] << ", ";
   os << "Persp Z: " << m[SkMatrix::kMPersp2];
   os << std::endl;
   return os;
 }

◆ operator<<() [4/29]

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

Definition at line 64 of file assertions_skia.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<<() [5/29]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkVector3 &	v
	)

Definition at line 76 of file assertions_skia.cc.

                                                            {
   return os << v.x() << ", " << v.y() << ", " << v.z();
 }

◆ operator<<() [6/29]

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

Definition at line 80 of file assertions_skia.cc.

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

◆ operator<<() [7/29]

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

Definition at line 85 of file assertions_skia.cc.

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

◆ operator<<() [8/29]

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

Definition at line 90 of file assertions_skia.cc.

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

◆ operator<<() [9/29]

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

Definition at line 96 of file assertions_skia.cc.

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

◆ operator<<() [10/29]

std::ostream & flutter::testing::operator<<	(	std::ostream &	os,
		const SkISize &	size
	)

Definition at line 100 of file assertions_skia.cc.

                                                             {
   return os << size.width() << ", " << size.height();
 }

◆ operator<<() [11/29]

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

Definition at line 104 of file assertions_skia.cc.

                                                            {
   return os << r.fR << ", " << r.fG << ", " << r.fB << ", " << r.fA;
 }

◆ operator<<() [12/29]

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

Definition at line 108 of file assertions_skia.cc.

                                                          {
   return os << "Color: " << r.getColor4f() << ", Style: " << r.getStyle()
             << ", AA: " << r.isAntiAlias() << ", Shader: " << r.getShader();
 }

◆ operator<<() [13/29]

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

Definition at line 298 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SaveData::save_to_layer.

                                                                        {
   return os << data.save_to_layer;
 }

◆ operator<<() [14/29]

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

Definition at line 309 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SaveLayerData::backdrop_filter, flutter::testing::MockCanvas::SaveLayerData::restore_paint, flutter::testing::MockCanvas::SaveLayerData::save_bounds, and flutter::testing::MockCanvas::SaveLayerData::save_to_layer.

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

◆ operator<<() [15/29]

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

Definition at line 320 of file mock_canvas.cc.

References flutter::testing::MockCanvas::RestoreData::restore_to_layer.

                                                             {
   return os << data.restore_to_layer;
 }

◆ operator<<() [16/29]

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

Definition at line 330 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ConcatMatrixData::matrix.

                                                                  {
   return os << data.matrix;
 }

◆ operator<<() [17/29]

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

Definition at line 340 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ConcatMatrix44Data::matrix.

                                                                    {
   return os << data.matrix;
 }

◆ operator<<() [18/29]

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

Definition at line 350 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SetMatrixData::matrix.

                                                               {
   return os << data.matrix;
 }

◆ operator<<() [19/29]

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

Definition at line 360 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawRectData::paint, and flutter::testing::MockCanvas::DrawRectData::rect.

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

◆ operator<<() [20/29]

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

Definition at line 370 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPathData::paint, and flutter::testing::MockCanvas::DrawPathData::path.

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

◆ operator<<() [21/29]

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

Definition at line 381 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawTextData::offset, flutter::testing::MockCanvas::DrawTextData::paint, and flutter::testing::MockCanvas::DrawTextData::serialized_text.

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

◆ operator<<() [22/29]

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

Definition at line 392 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPictureData::matrix, flutter::testing::MockCanvas::DrawPictureData::paint, and flutter::testing::MockCanvas::DrawPictureData::serialized_picture.

                                                                 {
   return os << data.serialized_picture << " " << data.paint << " "
             << data.matrix;
 }

◆ operator<<() [23/29]

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

Definition at line 403 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawShadowData::path.

                                                                {
   return os << data.path;
 }

◆ operator<<() [24/29]

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

Definition at line 413 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipRectData::clip_op, flutter::testing::MockCanvas::ClipRectData::rect, and flutter::testing::MockCanvas::ClipRectData::style.

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

◆ operator<<() [25/29]

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

Definition at line 423 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipRRectData::clip_op, flutter::testing::MockCanvas::ClipRRectData::rrect, and flutter::testing::MockCanvas::ClipRRectData::style.

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

◆ operator<<() [26/29]

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

Definition at line 433 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipPathData::clip_op, flutter::testing::MockCanvas::ClipPathData::path, and flutter::testing::MockCanvas::ClipPathData::style.

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

◆ operator<<() [27/29]

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

Definition at line 438 of file mock_canvas.cc.

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

◆ operator<<() [28/29]

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

Definition at line 448 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawCall::data, and flutter::testing::MockCanvas::DrawCall::layer.

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

◆ operator<<() [29/29]

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

Definition at line 457 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPaint::paint.

                                                                         {
   return os << data.paint;
 }

◆ operator==() [1/17]

bool flutter::testing::operator==	(	const MockTexture::PaintCall &	a,
		const MockTexture::PaintCall &	b
	)

Definition at line 21 of file mock_texture.cc.

References flutter::testing::MockTexture::PaintCall::bounds, flutter::testing::MockTexture::PaintCall::canvas, flutter::testing::MockTexture::PaintCall::context, flutter::testing::MockTexture::PaintCall::filter_quality, and flutter::testing::MockTexture::PaintCall::freeze.

Referenced by flutter::testing::MockCanvas::didRestore(), and flutter::testing::MockTexture::unregistered().

                                                {
   return &a.canvas == &b.canvas && a.bounds == b.bounds &&
          a.context == b.context && a.freeze == b.freeze &&
          a.filter_quality == b.filter_quality;
 }

◆ operator==() [2/17]

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

Definition at line 294 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SaveData::save_to_layer.

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

◆ operator==() [3/17]

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

Definition at line 302 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SaveLayerData::backdrop_filter, flutter::testing::MockCanvas::SaveLayerData::restore_paint, flutter::testing::MockCanvas::SaveLayerData::save_bounds, and flutter::testing::MockCanvas::SaveLayerData::save_to_layer.

                                                   {
   return a.save_bounds == b.save_bounds && a.restore_paint == b.restore_paint &&
          a.backdrop_filter == b.backdrop_filter &&
          a.save_to_layer == b.save_to_layer;
 }

◆ operator==() [4/17]

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

Definition at line 315 of file mock_canvas.cc.

References flutter::testing::MockCanvas::RestoreData::restore_to_layer.

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

◆ operator==() [5/17]

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

Definition at line 325 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ConcatMatrixData::matrix.

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

◆ operator==() [6/17]

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

Definition at line 335 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ConcatMatrix44Data::matrix.

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

◆ operator==() [7/17]

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

Definition at line 345 of file mock_canvas.cc.

References flutter::testing::MockCanvas::SetMatrixData::matrix.

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

◆ operator==() [8/17]

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

Definition at line 355 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawRectData::paint, and flutter::testing::MockCanvas::DrawRectData::rect.

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

◆ operator==() [9/17]

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

Definition at line 365 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPathData::paint, and flutter::testing::MockCanvas::DrawPathData::path.

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

◆ operator==() [10/17]

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

Definition at line 375 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawTextData::offset, flutter::testing::MockCanvas::DrawTextData::paint, and flutter::testing::MockCanvas::DrawTextData::serialized_text.

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

◆ operator==() [11/17]

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

Definition at line 386 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPictureData::matrix, flutter::testing::MockCanvas::DrawPictureData::paint, and flutter::testing::MockCanvas::DrawPictureData::serialized_picture.

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

◆ operator==() [12/17]

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

Definition at line 398 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawShadowData::path.

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

◆ operator==() [13/17]

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

Definition at line 408 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipRectData::clip_op, flutter::testing::MockCanvas::ClipRectData::rect, and flutter::testing::MockCanvas::ClipRectData::style.

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

◆ operator==() [14/17]

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

Definition at line 418 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipRRectData::clip_op, flutter::testing::MockCanvas::ClipRRectData::rrect, and flutter::testing::MockCanvas::ClipRRectData::style.

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

◆ operator==() [15/17]

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

Definition at line 428 of file mock_canvas.cc.

References flutter::testing::MockCanvas::ClipPathData::clip_op, flutter::testing::MockCanvas::ClipPathData::path, and flutter::testing::MockCanvas::ClipPathData::style.

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

◆ operator==() [16/17]

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

Definition at line 444 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawCall::data, and flutter::testing::MockCanvas::DrawCall::layer.

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

◆ operator==() [17/17]

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

Definition at line 452 of file mock_canvas.cc.

References flutter::testing::MockCanvas::DrawPaint::paint.

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

◆ 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

Definition at line 63 of file elf_loader.cc.

References flutter::Settings::isolate_snapshot_data, flutter::Settings::isolate_snapshot_instr, flutter::DartVM::IsRunningPrecompiledCode(), flutter::testing::ELFAOTSymbols::vm_isolate_data, flutter::testing::ELFAOTSymbols::vm_isolate_instrs, flutter::testing::ELFAOTSymbols::vm_snapshot_data, flutter::Settings::vm_snapshot_data, flutter::Settings::vm_snapshot_instr, and flutter::testing::ELFAOTSymbols::vm_snapshot_instrs.

Referenced by flutter::testing::FixtureTest::SetSnapshotsAndAssets(), and flutter::StartupAndShutdownShell().

                                                                     {
   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;
 }

◆ RasterImagesAreSame()

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

Definition at line 31 of file embedder_unittests_util.cc.

References FML_CHECK, and FML_LOG.

Referenced by ImageMatchesFixture().

                                                              {
   FML_CHECK(!a->isTextureBacked());
   FML_CHECK(!b->isTextureBacked());
 
   if (!a || !b) {
     return false;
   }
 
   SkPixmap pixmapA;
   SkPixmap pixmapB;
 
   if (!a->peekPixels(&pixmapA)) {
     FML_LOG(ERROR) << "Could not peek pixels of image A.";
     return false;
   }
 
   if (!b->peekPixels(&pixmapB)) {
     FML_LOG(ERROR) << "Could not peek pixels of image B.";
 
     return false;
   }
 
   const auto sizeA = pixmapA.rowBytes() * pixmapA.height();
   const auto sizeB = pixmapB.rowBytes() * pixmapB.height();
 
   if (sizeA != sizeB) {
     FML_LOG(ERROR) << "Pixmap sizes were inconsistent.";
     return false;
   }
 
   return ::memcmp(pixmapA.addr(), pixmapB.addr(), sizeA) == 0;
 }

◆ RasterizerHasLayerTree()

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

static

Definition at line 69 of file shell_unittests.cc.

References flutter::Shell::GetRasterizer(), flutter::TaskRunners::GetRasterTaskRunner(), flutter::Shell::GetTaskRunners(), and fml::TaskRunner::RunNowOrPostTask().

Referenced by ValidateDestroyPlatformView().

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

◆ ReadbackResult() [1/4]

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

static

Definition at line 193 of file clip_rect_layer_unittests.cc.

References flutter::antiAlias, flutter::antiAliasWithSaveLayer, flutter::hardEdge, flutter::path, ReadbackResult(), flutter::PrerollContext::surface_needs_readback, and TEST_F().

                                         {
   const SkMatrix initial_matrix = SkMatrix();
   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, initial_matrix);
   return context->surface_needs_readback;
 }

◆ ReadbackResult() [2/4]

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

static

Definition at line 195 of file clip_path_layer_unittests.cc.

References flutter::antiAlias, flutter::antiAliasWithSaveLayer, flutter::hardEdge, flutter::path, flutter::PrerollContext::surface_needs_readback, and TEST_F().

Referenced by ReadbackResult().

                                         {
   const SkMatrix initial_matrix = SkMatrix();
   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, initial_matrix);
   return context->surface_needs_readback;
 }

◆ ReadbackResult() [3/4]

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

static

Definition at line 198 of file clip_rrect_layer_unittests.cc.

References flutter::antiAlias, flutter::antiAliasWithSaveLayer, flutter::hardEdge, flutter::path, ReadbackResult(), flutter::PrerollContext::surface_needs_readback, and TEST_F().

                                         {
   const SkMatrix initial_matrix = SkMatrix();
   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, initial_matrix);
   return context->surface_needs_readback;
 }

◆ ReadbackResult() [4/4]

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

static

Definition at line 216 of file physical_shape_layer_unittests.cc.

References flutter::antiAlias, flutter::antiAliasWithSaveLayer, flutter::hardEdge, flutter::path, ReadbackResult(), flutter::PrerollContext::surface_needs_readback, and TEST_F().

                                         {
   const SkMatrix initial_matrix = SkMatrix();
   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<PhysicalShapeLayer>(SK_ColorGREEN, SK_ColorBLACK,
                                            0.0f,  // elevation
                                            layer_path, clip_behavior);
   if (child != nullptr) {
     layer->Add(child);
   }
   context->surface_needs_readback = before;
   layer->Preroll(context, initial_matrix);
   return context->surface_needs_readback;
 }

◆ ResetAssetManager()

static void flutter::testing::ResetAssetManager ( )

static

Definition at line 141 of file persistent_cache_unittests.cc.

References flutter::PersistentCache::GetCacheForProcess(), flutter::PersistentCache::SetAssetManager(), and fml::size().

Referenced by TEST_F().

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

◆ RunCoroutineWithRetry()

static void flutter::testing::RunCoroutineWithRetry	(	int	retries,
		fml::AutoResetWaitableEvent *	tick,
		fml::AutoResetWaitableEvent *	tock,
		std::function< bool()>	f
	)

static

Definition at line 131 of file shell_fuchsia_unittests.cc.

References FML_LOG, fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

Referenced by TEST_F().

                                                          {
   for (; retries > 0; retries--) {
     // Do a single coroutine step.
     tick->Signal();
     tock->Wait();
     if (f()) {
       break;
     }
     FML_LOG(INFO) << "Retries left: " << retries;
     sleep(1);
   }
 }

◆ RunDartCodeInIsolate() [1/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 = `{}`
	)

◆ RunDartCodeInIsolate() [2/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 &	fixtures_path,
		fml::WeakPtr< IOManager >	io_manager
	)

Definition at line 142 of file dart_isolate_runner.cc.

References flutter::TaskRunners::GetUITaskRunner(), fml::MakeCopyable(), RunDartCodeInIsolateOnUITaskRunner(), fml::TaskRunner::RunNowOrPostTask(), fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

Referenced by flutter::BM_PlatformMessageResponseDartComplete(), flutter::testing::AutoIsolateShutdown::get(), flutter::testing::TypeConversionsTest::RunWithEntrypoint(), and TEST_F().

                                       {
   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, fixtures_path,
             io_manager);
         latch.Signal();
       }));
   latch.Wait();
   return result;
 }

◆ 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 &	fixtures_path,
		fml::WeakPtr< IOManager >	io_manager
	)

Definition at line 52 of file dart_isolate_runner.cc.

References args, flutter::DartIsolate::CreateRunningRootIsolate(), flutter::Settings::dart_entrypoint_args, FML_CHECK, FML_LOG, flutter::TaskRunners::GetUITaskRunner(), flutter::DartVMRef::GetVMData(), flutter::IsolateConfiguration::InferFromSettings(), fml::IsFile(), flutter::DartVM::IsRunningPrecompiledCode(), fml::paths::JoinPaths(), fml::kRead, fml::MakeCopyable(), fml::OpenFile(), and fml::TaskRunner::RunsTasksOnCurrentThread().

Referenced by RunDartCodeInIsolate().

                                       {
   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;
 
   settings.dart_entrypoint_args = args;
 
   if (!DartVM::IsRunningPrecompiledCode()) {
     auto kernel_file_path =
         fml::paths::JoinPaths({fixtures_path, "kernel_blob.bin"});
 
     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 setup 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);
 
   auto isolate =
       DartIsolate::CreateRunningRootIsolate(
           settings,                            // settings
           vm_data->GetIsolateSnapshot(),       // isolate snapshot
           std::move(task_runners),             // task runners
           nullptr,                             // window
           {},                                  // snapshot delegate
           {},                                  // hint freed delegate
           io_manager,                          // io manager
           {},                                  // unref queue
           {},                                  // image decoder
           "main.dart",                         // advisory uri
           entrypoint.c_str(),                  // advisory entrypoint
           DartIsolate::Flags{},                // flags
           settings.isolate_create_callback,    // isolate create callback
           settings.isolate_shutdown_callback,  // isolate shutdown callback
           entrypoint,                          // entrypoint
           std::nullopt,                        // library
           std::move(isolate_configuration)     // isolate configuration
           )
           .lock();
 
   if (!isolate) {
     FML_LOG(ERROR) << "Could not create running isolate.";
     return nullptr;
   }
 
   return std::make_unique<AutoIsolateShutdown>(isolate,
                                                task_runners.GetUITaskRunner());
 }

◆ TEST() [1/130]

flutter::testing::TEST	(	MutatorsStack	,
		Initialization
	)

Definition at line 11 of file mutators_stack_unittests.cc.

                                     {
   MutatorsStack stack;
   ASSERT_TRUE(true);
 }

◆ TEST() [2/130]

flutter::testing::TEST	(	FlutterProjectBundle	,
		BasicPropertiesAbsolutePaths
	)

Definition at line 11 of file flutter_project_bundle_unittests.cc.

References flutter::FlutterProjectBundle::assets_path(), FlutterDesktopEngineProperties::assets_path, flutter::FlutterProjectBundle::HasValidPaths(), FlutterDesktopEngineProperties::icu_data_path, and flutter::FlutterProjectBundle::icu_path().

                                                          {
   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() [3/130]

flutter::testing::TEST	(	Win32FlutterWindowTest	,
		CreateDestroy
	)

Definition at line 11 of file win32_flutter_window_unittests.cc.

References TRUE.

                                             {
   Win32FlutterWindowTest window(800, 600);
   ASSERT_TRUE(TRUE);
 }

◆ TEST() [4/130]

flutter::testing::TEST	(	MockWin32Window	,
		CreateDestroy
	)

Definition at line 11 of file win32_window_unittests.cc.

References TRUE.

                                      {
   MockWin32Window window;
   ASSERT_TRUE(TRUE);
 }

◆ TEST() [5/130]

flutter::testing::TEST	(	TestMetalSurface	,
		EmptySurfaceIsInvalid
	)

Definition at line 11 of file test_metal_surface_unittests.cc.

References flutter::TestMetalSurface::Create(), and flutter::TestMetalSurface::PlatformSupportsMetal().

                                               {
   if (!TestMetalSurface::PlatformSupportsMetal()) {
     GTEST_SKIP();
   }
 
   auto surface = TestMetalSurface::Create();
   ASSERT_NE(surface, nullptr);
   ASSERT_FALSE(surface->IsValid());
 }

◆ TEST() [6/130]

flutter::testing::TEST	(	FlutterEngineTest	,
		FlutterEngineCanLaunch
	)

Definition at line 12 of file FlutterEngineUnittests.mm.

References engine, and GetFixturesPath().

                                                 {
   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];
   ASSERT_TRUE([engine runWithEntrypoint:@"main"]);
   ASSERT_TRUE(engine.running);
   [engine shutDownEngine];
 }

◆ TEST() [7/130]

flutter::testing::TEST	(	StringConversion	,
		Utf16FromUtf8Empty
	)

Definition at line 12 of file string_conversion_unittests.cc.

References flutter::Utf16FromUtf8().

                                            {
   EXPECT_EQ(Utf16FromUtf8(""), L"");
 }

◆ TEST() [8/130]

flutter::testing::TEST	(	MockTextureTest	,
		Callbacks
	)

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

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithNoMutations
	)

Definition at line 12 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect().

                                                                        {
   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() [10/130]

flutter::testing::TEST	(	JNIMock	,
		FlutterViewHandlePlatformMessage
	)

Definition at line 13 of file jni_mock_unittest.cc.

References flutter::PlatformViewAndroidJNI::FlutterViewHandlePlatformMessage().

                                                 {
   JNIMock mock;
 
   auto message =
       fml::MakeRefCounted<PlatformMessage>("<channel-name>", nullptr);
   auto response_id = 1;
 
   EXPECT_CALL(mock, FlutterViewHandlePlatformMessage(message, response_id));
 
   mock.FlutterViewHandlePlatformMessage(message, response_id);
 }

◆ TEST() [11/130]

flutter::testing::TEST	(	SystemUtils	,
		GetPreferredLanguageInfo
	)

Definition at line 13 of file system_utils_unittests.cc.

References flutter::GetPreferredLanguageInfo().

                                             {
   std::vector<LanguageInfo> languages = GetPreferredLanguageInfo();
   // 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() [12/130]

flutter::testing::TEST	(	DpiUtilsTest	,
		NonZero
	)

Definition at line 13 of file win32_dpi_utils_unittests.cc.

References flutter::GetDpiForHWND(), and flutter::GetDpiForMonitor().

                             {
   ASSERT_GT(GetDpiForHWND(nullptr), 0);
   ASSERT_GT(GetDpiForMonitor(nullptr), 0);
 };

◆ TEST() [13/130]

flutter::testing::TEST	(	TextureRegistryTest	,
		UnregisterTextureCallbackTriggered
	)

Definition at line 13 of file texture_unittests.cc.

References flutter::TextureRegistry::GetTexture(), flutter::TextureRegistry::RegisterTexture(), and flutter::TextureRegistry::UnregisterTexture().

                                                               {
   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() [14/130]

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.label = "label";
   update.insert(std::make_pair(0, std::move(node0)));
 
   std::vector<uint8_t> expected_buffer(164);
   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.label
   expected_strings.push_back(node0.label);
   buffer_int32[position++] = -1;  // node0.value
   buffer_int32[position++] = -1;  // node0.increasedValue
   buffer_int32[position++] = -1;  // node0.decreasedValue
   buffer_int32[position++] = -1;  // node0.hint
   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));
   // Creates empty custom actions.
   flutter::CustomAccessibilityActionUpdates actions;
   delegate->UpdateSemantics(update, actions);
 }

◆ TEST() [15/130]

flutter::testing::TEST	(	MatrixDecomposition	,
		Rotation
	)

Definition at line 14 of file matrix_decomposition_unittests.cc.

References flutter::MatrixDecomposition::IsValid(), and flutter::MatrixDecomposition::rotation().

                                     {
   SkM44 matrix;
 
   const auto angle = M_PI_4;
   matrix.setRotate({0.0, 0.0, 1.0}, angle);
 
   flutter::MatrixDecomposition decomposition(matrix);
   ASSERT_TRUE(decomposition.IsValid());
 
   const auto sine = sin(angle * 0.5);
 
   ASSERT_FLOAT_EQ(0, decomposition.rotation().x);
   ASSERT_FLOAT_EQ(0, decomposition.rotation().y);
   ASSERT_FLOAT_EQ(sine, decomposition.rotation().z);
   ASSERT_FLOAT_EQ(cos(angle * 0.5), decomposition.rotation().w);
 }

◆ TEST() [16/130]

flutter::testing::TEST	(	CanvasSpyTest	,
		DrawingIsTracked
	)

Definition at line 14 of file canvas_spy_unittests.cc.

References flutter::CanvasSpy::DidDrawIntoCanvas(), and flutter::CanvasSpy::GetSpyingCanvas().

                                       {
   SkPictureRecorder picture_recorder;
   SkCanvas* canvas = picture_recorder.beginRecording(100, 100);
   CanvasSpy canvas_spy = CanvasSpy(canvas);
   SkCanvas* spy = canvas_spy.GetSpyingCanvas();
 
   ASSERT_FALSE(canvas_spy.DidDrawIntoCanvas());
 
   spy->translate(128, 128);
   spy->clear(SK_ColorTRANSPARENT);
   ASSERT_FALSE(canvas_spy.DidDrawIntoCanvas());
 
   SkPaint paint;
   spy->drawCircle(0, 0, 60, paint);
   ASSERT_TRUE(canvas_spy.DidDrawIntoCanvas());
 }

◆ TEST() [17/130]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsNoIntersection
	)

Definition at line 14 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() [18/130]

flutter::testing::TEST	(	MutatorsStack	,
		CopyConstructor
	)

Definition at line 16 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::PushClipRect(), and flutter::MutatorsStack::PushClipRRect().

                                      {
   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() [19/130]

flutter::testing::TEST	(	StringConversion	,
		Utf16FromUtf8Ascii
	)

Definition at line 16 of file string_conversion_unittests.cc.

References flutter::Utf16FromUtf8().

                                            {
   EXPECT_EQ(Utf16FromUtf8("abc123"), L"abc123");
 }

◆ TEST() [20/130]

flutter::testing::TEST	(	MockWin32Window	,
		GetDpiAfterCreate
	)

Definition at line 16 of file win32_window_unittests.cc.

References flutter::testing::MockWin32Window::GetDpi().

                                          {
   MockWin32Window window;
   ASSERT_TRUE(window.GetDpi() > 0);
 }

◆ TEST() [21/130]

flutter::testing::TEST	(	GLContextSwitchTest	,
		SwitchKeepsContextCurrentWhileInScope
	)

Definition at line 18 of file gl_context_switch_unittests.cc.

References flutter::testing::TestSwitchableGLContext::GetCurrentContext().

                                                                  {
   {
     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() [22/130]

flutter::testing::TEST	(	DpiUtilsTest	,
		NullHwndUsesPrimaryMonitor
	)

Definition at line 18 of file win32_dpi_utils_unittests.cc.

References flutter::GetDpiForHWND(), and flutter::GetDpiForMonitor().

                                                {
   const POINT target_point = {0, 0};
   HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTOPRIMARY);
   ASSERT_EQ(GetDpiForHWND(nullptr), GetDpiForMonitor(monitor));
 };

◆ TEST() [23/130]

flutter::testing::TEST	(	StringConversion	,
		Utf16FromUtf8Unicode
	)

Definition at line 20 of file string_conversion_unittests.cc.

References flutter::Utf16FromUtf8().

                                              {
   EXPECT_EQ(Utf16FromUtf8("\xe2\x98\x83"), L"\x2603");
 }

◆ TEST() [24/130]

flutter::testing::TEST	(	PipelineTest	,
		ConsumeOneVal
	)

Definition at line 21 of file pipeline_unittests.cc.

References flutter::Pipeline< R >::ProducerContinuation::Complete(), flutter::Pipeline< R >::Consume(), flutter::Done, and flutter::Pipeline< R >::Produce().

                                   {
   fml::RefPtr<IntPipeline> pipeline = fml::MakeRefCounted<IntPipeline>(2);
 
   Continuation continuation = pipeline->Produce();
 
   const int test_val = 1;
   bool result = continuation.Complete(std::make_unique<int>(test_val));
   ASSERT_EQ(result, 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() [25/130]

flutter::testing::TEST	(	SystemUtils	,
		GetPreferredLanguages
	)

Definition at line 21 of file system_utils_unittests.cc.

References flutter::GetPreferredLanguages(), and fml::size().

                                          {
   std::vector<std::wstring> languages = GetPreferredLanguages();
   // 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()));
 }

◆ TEST() [26/130]

flutter::testing::TEST	(	MockWin32Window	,
		VerticalScroll
	)

Definition at line 21 of file win32_window_unittests.cc.

References flutter::testing::MockWin32Window::InjectWindowMessage().

                                       {
   MockWin32Window 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)).Times(1);
 
   window.InjectWindowMessage(WM_MOUSEWHEEL, MAKEWPARAM(0, scroll_amount), 0);
 }

◆ TEST() [27/130]

flutter::testing::TEST	(	TestMetalSurface	,
		CanCreateValidTestMetalSurface
	)

Definition at line 21 of file test_metal_surface_unittests.cc.

References flutter::TestMetalSurface::Create(), and flutter::TestMetalSurface::PlatformSupportsMetal().

                                                        {
   if (!TestMetalSurface::PlatformSupportsMetal()) {
     GTEST_SKIP();
   }
 
   auto surface = TestMetalSurface::Create(SkISize::Make(100, 100));
   ASSERT_NE(surface, nullptr);
   ASSERT_TRUE(surface->IsValid());
   ASSERT_NE(surface->GetSurface(), nullptr);
   ASSERT_NE(surface->GetGrContext(), nullptr);
 }

◆ TEST() [28/130]

flutter::testing::TEST	(	FlutterProjectBundle	,
		BasicPropertiesRelativePaths
	)

Definition at line 23 of file flutter_project_bundle_unittests.cc.

References flutter::FlutterProjectBundle::assets_path(), FlutterDesktopEngineProperties::assets_path, flutter::FlutterProjectBundle::HasValidPaths(), FlutterDesktopEngineProperties::icu_data_path, and flutter::FlutterProjectBundle::icu_path().

                                                          {
   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() [29/130]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithScale
	)

Definition at line 24 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect(), and flutter::MutatorsStack::PushTransform().

                                                                  {
   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() [30/130]

flutter::testing::TEST	(	StringConversion	,
		Utf8FromUtf16Empty
	)

Definition at line 24 of file string_conversion_unittests.cc.

References flutter::Utf8FromUtf16().

                                            {
   EXPECT_EQ(Utf8FromUtf16(L""), "");
 }

◆ TEST() [31/130]

flutter::testing::TEST	(	MutatorsStack	,
		CopyAndUpdateTheCopy
	)

Definition at line 26 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::clip_rect, flutter::clip_rrect, flutter::MutatorsStack::is_empty(), flutter::MutatorsStack::Pop(), flutter::MutatorsStack::PushClipRect(), and flutter::MutatorsStack::PushClipRRect().

                                           {
   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::clip_rrect);
   ASSERT_TRUE(iter->get()->GetRRect() == rrect);
   ++iter;
   ASSERT_TRUE(iter->get()->GetType() == MutatorType::clip_rect);
   ASSERT_TRUE(iter->get()->GetRect() == rect);
 }

◆ TEST() [32/130]

flutter::testing::TEST	(	StringConversion	,
		Utf8FromUtf16Ascii
	)

Definition at line 28 of file string_conversion_unittests.cc.

References flutter::Utf8FromUtf16().

                                            {
   EXPECT_EQ(Utf8FromUtf16(L"abc123"), "abc123");
 }

◆ TEST() [33/130]

flutter::testing::TEST	(	MockTextureTest	,
		PaintCalls
	)

Definition at line 28 of file mock_texture_unittests.cc.

                                   {
   SkCanvas canvas;
   const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
   const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
   const auto expected_paint_calls =
       std::vector{MockTexture::PaintCall{canvas, paint_bounds1, false, nullptr,
                                          kNone_SkFilterQuality},
                   MockTexture::PaintCall{canvas, paint_bounds2, true, nullptr,
                                          kNone_SkFilterQuality}};
   auto texture = std::make_shared<MockTexture>(0);
 
   texture->Paint(canvas, paint_bounds1, false, nullptr, kNone_SkFilterQuality);
   texture->Paint(canvas, paint_bounds2, true, nullptr, kNone_SkFilterQuality);
   EXPECT_EQ(texture->paint_calls(), expected_paint_calls);
 }

◆ TEST() [34/130]

flutter::testing::TEST	(	RasterCache	,
		SimpleInitialization
	)

Definition at line 29 of file raster_cache_unittests.cc.

                                         {
   flutter::RasterCache cache;
   ASSERT_TRUE(true);
 }

◆ TEST() [35/130]

flutter::testing::TEST	(	MatrixDecomposition	,
		Scale
	)

Definition at line 31 of file matrix_decomposition_unittests.cc.

References flutter::MatrixDecomposition::IsValid(), and flutter::MatrixDecomposition::scale().

                                  {
   SkM44 matrix;
 
   const auto scale = 5.0;
   matrix.setScale(scale + 0, scale + 1, scale + 2);
 
   flutter::MatrixDecomposition decomposition(matrix);
   ASSERT_TRUE(decomposition.IsValid());
 
   ASSERT_FLOAT_EQ(scale + 0, decomposition.scale().x);
   ASSERT_FLOAT_EQ(scale + 1, decomposition.scale().y);
   ASSERT_FLOAT_EQ(scale + 2, decomposition.scale().z);
 }

◆ TEST() [36/130]

flutter::testing::TEST	(	CanvasSpyTest	,
		SpiedCanvasIsDrawing
	)

Definition at line 31 of file canvas_spy_unittests.cc.

References flutter::CanvasSpy::DidDrawIntoCanvas(), flutter::CanvasSpy::GetSpyingCanvas(), and fml::size().

                                           {
   auto actual_surface =
       SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100));
   SkCanvas* actual_canvas = actual_surface->getCanvas();
 
   auto expected_surface =
       SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(100, 100));
   SkCanvas* expected_canvas = expected_surface->getCanvas();
 
   CanvasSpy canvas_spy = CanvasSpy(actual_canvas);
   SkCanvas* spy = canvas_spy.GetSpyingCanvas();
 
   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() [37/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameGeneric
	)

Definition at line 31 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                             {
   LanguageInfo info = ParseLanguageName(L"en");
   EXPECT_EQ(info.language, "en");
   EXPECT_TRUE(info.region.empty());
   EXPECT_TRUE(info.script.empty());
 }

◆ TEST() [38/130]

flutter::testing::TEST	(	MockWin32Window	,
		HorizontalScroll
	)

Definition at line 31 of file win32_window_unittests.cc.

References flutter::testing::MockWin32Window::InjectWindowMessage().

                                         {
   MockWin32Window 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)).Times(1);
 
   window.InjectWindowMessage(WM_MOUSEHWHEEL, MAKEWPARAM(0, scroll_amount), 0);
 }

◆ TEST() [39/130]

flutter::testing::TEST	(	StringConversion	,
		Utf8FromUtf16Unicode
	)

Definition at line 32 of file string_conversion_unittests.cc.

References flutter::Utf8FromUtf16().

                                              {
   EXPECT_EQ(Utf8FromUtf16(L"\x2603"), "\xe2\x98\x83");
 }

◆ TEST() [40/130]

flutter::testing::TEST	(	RasterCache	,
		ThresholdIsRespected
	)

Definition at line 34 of file raster_cache_unittests.cc.

References flutter::RasterCache::Draw(), flutter::RasterCache::Prepare(), and flutter::RasterCache::SweepAfterFrame().

                                         {
   size_t threshold = 2;
   flutter::RasterCache cache(threshold);
 
   SkMatrix matrix = SkMatrix::I();
 
   auto picture = GetSamplePicture();
 
   sk_sp<SkImage> image;
 
   SkCanvas dummy_canvas;
 
   sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
   ASSERT_FALSE(
       cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, false));
   // 1st access.
   ASSERT_FALSE(cache.Draw(*picture, dummy_canvas));
 
   cache.SweepAfterFrame();
 
   ASSERT_FALSE(
       cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, false));
 
   // 2nd access.
   ASSERT_FALSE(cache.Draw(*picture, dummy_canvas));
 
   cache.SweepAfterFrame();
 
   // Now Prepare should cache it.
   ASSERT_TRUE(
       cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, false));
   ASSERT_TRUE(cache.Draw(*picture, dummy_canvas));
 }

◆ TEST() [41/130]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsSingleRectIntersection
	)

Definition at line 34 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() [42/130]

flutter::testing::TEST	(	PipelineTest	,
		ContinuationCanOnlyBeUsedOnce
	)

Definition at line 36 of file pipeline_unittests.cc.

References flutter::Pipeline< R >::ProducerContinuation::Complete(), flutter::Pipeline< R >::Consume(), flutter::Done, flutter::NoneAvailable, and flutter::Pipeline< R >::Produce().

                                                   {
   fml::RefPtr<IntPipeline> pipeline = fml::MakeRefCounted<IntPipeline>(2);
 
   Continuation continuation = pipeline->Produce();
 
   const int test_val = 1;
   bool result = continuation.Complete(std::make_unique<int>(test_val));
   ASSERT_EQ(result, 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, 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, false);
   ASSERT_EQ(consume_result_2, PipelineConsumeResult::NoneAvailable);
 }

◆ TEST() [43/130]

flutter::testing::TEST	(	EmbedderTestNoFixture	,
		MustNotRunWithInvalidArgs
	)

Definition at line 36 of file embedder_unittests.cc.

References engine, flutter::testing::EmbedderConfigBuilder::kNoInitialize, and flutter::testing::EmbedderConfigBuilder::LaunchEngine().

                                                        {
   EmbedderTestContextSoftware context;
   EmbedderConfigBuilder builder(
       context, EmbedderConfigBuilder::InitializationPreference::kNoInitialize);
   auto engine = builder.LaunchEngine();
   ASSERT_FALSE(engine.is_valid());
 }

◆ TEST() [44/130]

flutter::testing::TEST	(	TextureRegistryTest	,
		GrContextCallbackTriggered
	)

Definition at line 36 of file texture_unittests.cc.

References flutter::TextureRegistry::OnGrContextCreated(), flutter::TextureRegistry::OnGrContextDestroyed(), flutter::TextureRegistry::RegisterTexture(), and flutter::TextureRegistry::UnregisterTexture().

                                                       {
   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() [45/130]

flutter::testing::TEST	(	FlutterViewControllerTest	,
		HasStringsWhenPasteboardEmpty
	)

Definition at line 37 of file FlutterViewControllerTest.mm.

References mockViewController().

                                                                {
   // Mock FlutterViewController so that it behaves like the pasteboard is empty.
   id viewControllerMock = mockViewController(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];
   [viewControllerMock handleMethodCall:methodCallAfterClear result:resultAfterClear];
   ASSERT_TRUE(calledAfterClear);
   ASSERT_FALSE(valueAfterClear);
 }

◆ TEST() [46/130]

flutter::testing::TEST	(	FlutterProjectBundle	,
		SwitchesEmpty
	)

Definition at line 37 of file flutter_project_bundle_unittests.cc.

References FlutterDesktopEngineProperties::assets_path, flutter::FlutterProjectBundle::GetSwitches(), and FlutterDesktopEngineProperties::icu_data_path.

                                           {
   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() [47/130]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithTranslate
	)

Definition at line 37 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect(), and flutter::MutatorsStack::PushTransform().

                                                                      {
   MutatorsStack stack;
   SkMatrix matrix = SkMatrix::MakeTrans(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() [48/130]

flutter::testing::TEST	(	SurfacePool	,
		GetLayer__AllocateOneLayer
	)

Definition at line 38 of file surface_pool_unittests.cc.

References flutter::kSoftware.

                                               {
   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_NE(nullptr, layer);
   ASSERT_EQ(reinterpret_cast<intptr_t>(gr_context.get()),
             layer->gr_context_key);
 }

◆ TEST() [49/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithRegion
	)

Definition at line 38 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                                {
   LanguageInfo info = ParseLanguageName(L"hu-HU");
   EXPECT_EQ(info.language, "hu");
   EXPECT_EQ(info.region, "HU");
   EXPECT_TRUE(info.script.empty());
 }

◆ TEST() [50/130]

flutter::testing::TEST	(	MockTextureTest	,
		PaintCallsWithLowFilterQuality
	)

Definition at line 44 of file mock_texture_unittests.cc.

                                                       {
   SkCanvas canvas;
   const SkRect paint_bounds1 = SkRect::MakeWH(1.0f, 1.0f);
   const SkRect paint_bounds2 = SkRect::MakeWH(2.0f, 2.0f);
   const auto expected_paint_calls =
       std::vector{MockTexture::PaintCall{canvas, paint_bounds1, false, nullptr,
                                          kLow_SkFilterQuality},
                   MockTexture::PaintCall{canvas, paint_bounds2, true, nullptr,
                                          kLow_SkFilterQuality}};
   auto texture = std::make_shared<MockTexture>(0);
 
   texture->Paint(canvas, paint_bounds1, false, nullptr, kLow_SkFilterQuality);
   texture->Paint(canvas, paint_bounds2, true, nullptr, kLow_SkFilterQuality);
   EXPECT_EQ(texture->paint_calls(), expected_paint_calls);
 }

◆ TEST() [51/130]

flutter::testing::TEST	(	MatrixDecomposition	,
		Translate
	)

Definition at line 45 of file matrix_decomposition_unittests.cc.

References flutter::MatrixDecomposition::IsValid(), and flutter::MatrixDecomposition::translation().

                                      {
   SkM44 matrix;
 
   const auto translate = 125.0;
   matrix.setTranslate(translate + 0, translate + 1, translate + 2);
 
   flutter::MatrixDecomposition decomposition(matrix);
   ASSERT_TRUE(decomposition.IsValid());
 
   ASSERT_FLOAT_EQ(translate + 0, decomposition.translation().x);
   ASSERT_FLOAT_EQ(translate + 1, decomposition.translation().y);
   ASSERT_FLOAT_EQ(translate + 2, decomposition.translation().z);
 }

◆ TEST() [52/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithScript
	)

Definition at line 45 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                                {
   LanguageInfo info = ParseLanguageName(L"us-Latn");
   EXPECT_EQ(info.language, "us");
   EXPECT_TRUE(info.region.empty());
   EXPECT_EQ(info.script, "Latn");
 }

◆ TEST() [53/130]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipRect
	)

Definition at line 46 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::clip_rect, and flutter::MutatorsStack::PushClipRect().

                                   {
   MutatorsStack stack;
   auto rect = SkRect::MakeEmpty();
   stack.PushClipRect(rect);
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter->get()->GetType() == MutatorType::clip_rect);
   ASSERT_TRUE(iter->get()->GetRect() == rect);
 }

◆ TEST() [54/130]

flutter::testing::TEST	(	Win32WindowProcDelegateManagerTest	,
		CallsCorrectly
	)

Definition at line 47 of file win32_window_proc_delegate_manager_unittests.cc.

References flutter::Win32WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::Win32WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

                                                          {
   Win32WindowProcDelegateManager 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() [55/130]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithRotation90
	)

Definition at line 50 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect(), FML_DLOG, and flutter::MutatorsStack::PushTransform().

                                                                       {
   MutatorsStack stack;
   SkMatrix matrix;
   matrix.setRotate(90);
   stack.PushTransform(matrix);
 
   EmbeddedViewParams params(matrix, SkSize::Make(1, 1), stack);
   const SkRect& rect = params.finalBoundingRect();
 
   FML_DLOG(ERROR) << rect.x();
   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() [56/130]

flutter::testing::TEST	(	FlutterProjectBundle	,
		Switches
	)

Definition at line 51 of file flutter_project_bundle_unittests.cc.

References FlutterDesktopEngineProperties::assets_path, flutter::FlutterProjectBundle::GetSwitches(), and FlutterDesktopEngineProperties::icu_data_path.

                                      {
   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() [57/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithRegionAndScript
	)

Definition at line 52 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                                         {
   LanguageInfo info = ParseLanguageName(L"uz-Latn-UZ");
   EXPECT_EQ(info.language, "uz");
   EXPECT_EQ(info.region, "UZ");
   EXPECT_EQ(info.script, "Latn");
 }

◆ TEST() [58/130]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipRRect
	)

Definition at line 55 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::clip_rrect, and flutter::MutatorsStack::PushClipRRect().

                                    {
   MutatorsStack stack;
   auto rrect = SkRRect::MakeEmpty();
   stack.PushClipRRect(rrect);
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter->get()->GetType() == MutatorType::clip_rrect);
   ASSERT_TRUE(iter->get()->GetRRect() == rrect);
 }

◆ TEST() [59/130]

flutter::testing::TEST	(	FlutterViewControllerTest	,
		HasStringsWhenPasteboardFull
	)

Definition at line 56 of file FlutterViewControllerTest.mm.

References mockViewController(), and value.

                                                               {
   // Mock FlutterViewController so that it behaves like the pasteboard has a
   // valid string.
   id viewControllerMock = mockViewController(@"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];
   [viewControllerMock handleMethodCall:methodCall result:result];
   ASSERT_TRUE(called);
   ASSERT_TRUE(value);
 }

◆ TEST() [60/130]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsIgnoresNonDrawingRecords
	)

Definition at line 56 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() [61/130]

flutter::testing::TEST	(	TextureRegistryTest	,
		RegisterTextureTwice
	)

Definition at line 58 of file texture_unittests.cc.

References flutter::TextureRegistry::GetTexture(), flutter::TextureRegistry::RegisterTexture(), and flutter::TextureRegistry::UnregisterTexture().

                                                 {
   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() [62/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithSuplementalLanguage
	)

Definition at line 59 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                                             {
   LanguageInfo info = ParseLanguageName(L"en-US-x-fabricam");
   EXPECT_EQ(info.language, "en");
   EXPECT_EQ(info.region, "US");
   EXPECT_TRUE(info.script.empty());
 }

◆ TEST() [63/130]

flutter::testing::TEST	(	MatrixDecomposition	,
		Combination
	)

Definition at line 59 of file matrix_decomposition_unittests.cc.

References flutter::MatrixDecomposition::IsValid(), flutter::MatrixDecomposition::rotation(), flutter::MatrixDecomposition::scale(), and flutter::MatrixDecomposition::translation().

                                        {
   const auto rotation = M_PI_4;
   const auto scale = 5;
   const auto translate = 125.0;
 
   SkM44 m1;
   m1.setRotate({0, 0, 1}, rotation);
 
   SkM44 m2;
   m2.setScale(scale, scale, scale);
 
   SkM44 m3;
   m3.setTranslate(translate, translate, translate);
 
   SkM44 combined = m3 * m2 * m1;
 
   flutter::MatrixDecomposition decomposition(combined);
   ASSERT_TRUE(decomposition.IsValid());
 
   ASSERT_FLOAT_EQ(translate, decomposition.translation().x);
   ASSERT_FLOAT_EQ(translate, decomposition.translation().y);
   ASSERT_FLOAT_EQ(translate, decomposition.translation().z);
 
   ASSERT_FLOAT_EQ(scale, decomposition.scale().x);
   ASSERT_FLOAT_EQ(scale, decomposition.scale().y);
   ASSERT_FLOAT_EQ(scale, decomposition.scale().z);
 
   const auto sine = sin(rotation * 0.5);
 
   ASSERT_FLOAT_EQ(0, decomposition.rotation().x);
   ASSERT_FLOAT_EQ(0, decomposition.rotation().y);
   ASSERT_FLOAT_EQ(sine, decomposition.rotation().z);
   ASSERT_FLOAT_EQ(cos(rotation * 0.5), decomposition.rotation().w);
 }

◆ TEST() [64/130]

flutter::testing::TEST	(	PipelineTest	,
		PushingMoreThanDepthCompletesFirstSubmission
	)

Definition at line 60 of file pipeline_unittests.cc.

References flutter::Pipeline< R >::ProducerContinuation::Complete(), flutter::Pipeline< R >::Consume(), flutter::Done, and flutter::Pipeline< R >::Produce().

                                                                  {
   const int depth = 1;
   fml::RefPtr<IntPipeline> pipeline = fml::MakeRefCounted<IntPipeline>(depth);
 
   Continuation continuation_1 = pipeline->Produce();
   Continuation continuation_2 = pipeline->Produce();
 
   const int test_val_1 = 1, test_val_2 = 2;
   bool result = continuation_1.Complete(std::make_unique<int>(test_val_1));
   ASSERT_EQ(result, true);
   result = continuation_2.Complete(std::make_unique<int>(test_val_2));
   ASSERT_EQ(result, 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() [65/130]

flutter::testing::TEST	(	MutatorsStack	,
		PushClipPath
	)

Definition at line 64 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::clip_path, flutter::path, and flutter::MutatorsStack::PushClipPath().

                                   {
   MutatorsStack stack;
   SkPath path;
   stack.PushClipPath(path);
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter->get()->GetType() == flutter::MutatorType::clip_path);
   ASSERT_TRUE(iter->get()->GetPath() == path);
 }

◆ TEST() [66/130]

flutter::testing::TEST	(	PlatformViewShell	,
		UpdateSemanticsDoesFlutterViewUpdateCustomAccessibilityActions
	)

Definition at line 65 of file platform_view_android_delegate_unittests.cc.

References flutter::CustomAccessibilityAction::hint, flutter::CustomAccessibilityAction::id, flutter::CustomAccessibilityAction::label, and flutter::CustomAccessibilityAction::overrideId.

                                                                      {
   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, std::move(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() [67/130]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithRotation45
	)

Definition at line 66 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect(), and flutter::MutatorsStack::PushTransform().

                                                                       {
   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() [68/130]

flutter::testing::TEST	(	SystemUtils	,
		ParseLanguageNameWithThreeCharacterLanguage
	)

Definition at line 67 of file system_utils_unittests.cc.

References flutter::LanguageInfo::language, flutter::ParseLanguageName(), flutter::LanguageInfo::region, and flutter::LanguageInfo::script.

                                                                {
   LanguageInfo info = ParseLanguageName(L"ale-ZZ");
   EXPECT_EQ(info.language, "ale");
   EXPECT_EQ(info.region, "ZZ");
   EXPECT_TRUE(info.script.empty());
 }

◆ TEST() [69/130]

flutter::testing::TEST	(	SurfacePool	,
		GetUnusedLayers
	)

Definition at line 68 of file surface_pool_unittests.cc.

References flutter::kSoftware.

                                    {
   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_EQ(1UL, pool->GetUnusedLayers().size());
   ASSERT_EQ(layer, pool->GetUnusedLayers()[0]);
 }

◆ TEST() [70/130]

flutter::testing::TEST	(	RasterCache	,
		AccessThresholdOfZeroDisablesCaching
	)

Definition at line 68 of file raster_cache_unittests.cc.

References flutter::RasterCache::Draw(), and flutter::RasterCache::Prepare().

                                                         {
   size_t threshold = 0;
   flutter::RasterCache cache(threshold);
 
   SkMatrix matrix = SkMatrix::I();
 
   auto picture = GetSamplePicture();
 
   sk_sp<SkImage> image;
 
   SkCanvas dummy_canvas;
 
   sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
   ASSERT_FALSE(
       cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, false));
 
   ASSERT_FALSE(cache.Draw(*picture, dummy_canvas));
 }

◆ TEST() [71/130]

flutter::testing::TEST	(	Win32WindowProcDelegateManagerTest	,
		ReplacementRegister
	)

Definition at line 69 of file win32_window_proc_delegate_manager_unittests.cc.

References flutter::Win32WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::Win32WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

                                                               {
   Win32WindowProcDelegateManager 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() [72/130]

flutter::testing::TEST	(	MutatorsStack	,
		PushTransform
	)

Definition at line 73 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::MutatorsStack::PushTransform(), and flutter::transform.

                                    {
   MutatorsStack stack;
   SkMatrix matrix;
   matrix.setIdentity();
   stack.PushTransform(matrix);
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter->get()->GetType() == MutatorType::transform);
   ASSERT_TRUE(iter->get()->GetMatrix() == matrix);
 }

◆ TEST() [73/130]

flutter::testing::TEST	(	TextureRegistryTest	,
		ReuseSameTextureSlot
	)

Definition at line 76 of file texture_unittests.cc.

References flutter::TextureRegistry::GetTexture(), flutter::TextureRegistry::RegisterTexture(), and flutter::TextureRegistry::UnregisterTexture().

                                                 {
   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() [74/130]

flutter::testing::TEST	(	PipelineTest	,
		PushingMultiProcessesInOrder
	)

Definition at line 79 of file pipeline_unittests.cc.

References flutter::Pipeline< R >::ProducerContinuation::Complete(), flutter::Pipeline< R >::Consume(), flutter::Done, flutter::MoreAvailable, and flutter::Pipeline< R >::Produce().

                                                  {
   const int depth = 2;
   fml::RefPtr<IntPipeline> pipeline = fml::MakeRefCounted<IntPipeline>(depth);
 
   Continuation continuation_1 = pipeline->Produce();
   Continuation continuation_2 = pipeline->Produce();
 
   const int test_val_1 = 1, test_val_2 = 2;
   bool result = continuation_1.Complete(std::make_unique<int>(test_val_1));
   ASSERT_EQ(result, true);
   result = continuation_2.Complete(std::make_unique<int>(test_val_2));
   ASSERT_EQ(result, 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::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() [75/130]

flutter::testing::TEST	(	EmbeddedViewParams	,
		GetBoundingRectAfterMutationsWithTranslateScaleAndRotation
	)

Definition at line 80 of file embedded_view_params_unittests.cc.

References flutter::EmbeddedViewParams::finalBoundingRect(), and flutter::MutatorsStack::PushTransform().

                                                                  {
   SkMatrix matrix = SkMatrix::MakeTrans(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() [76/130]

flutter::testing::TEST	(	MutatorsStack	,
		PushOpacity
	)

Definition at line 83 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::opacity, and flutter::MutatorsStack::PushOpacity().

                                  {
   MutatorsStack stack;
   int alpha = 240;
   stack.PushOpacity(alpha);
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter->get()->GetType() == MutatorType::opacity);
   ASSERT_TRUE(iter->get()->GetAlpha() == 240);
 }

◆ TEST() [77/130]

flutter::testing::TEST	(	RTree	,
		searchNonOverlappingDrawnRectsMultipleRectIntersection
	)

Definition at line 84 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() [78/130]

flutter::testing::TEST	(	RasterCache	,
		PictureCacheLimitPerFrameIsRespectedWhenZero
	)

Definition at line 87 of file raster_cache_unittests.cc.

References flutter::RasterCache::Draw(), and flutter::RasterCache::Prepare().

                                                                 {
   size_t picture_cache_limit_per_frame = 0;
   flutter::RasterCache cache(3, picture_cache_limit_per_frame);
 
   SkMatrix matrix = SkMatrix::I();
 
   auto picture = GetSamplePicture();
 
   sk_sp<SkImage> image;
 
   SkCanvas dummy_canvas;
 
   sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
   ASSERT_FALSE(
       cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, false));
 
   ASSERT_FALSE(cache.Draw(*picture, dummy_canvas));
 }

◆ TEST() [79/130]

flutter::testing::TEST	(	MutatorsStack	,
		Pop
	)

Definition at line 92 of file mutators_stack_unittests.cc.

References flutter::MutatorsStack::Bottom(), flutter::MutatorsStack::Pop(), flutter::MutatorsStack::PushTransform(), and flutter::MutatorsStack::Top().

                          {
   MutatorsStack stack;
   SkMatrix matrix;
   matrix.setIdentity();
   stack.PushTransform(matrix);
   stack.Pop();
   auto iter = stack.Bottom();
   ASSERT_TRUE(iter == stack.Top());
 }

◆ TEST() [80/130]

flutter::testing::TEST	(	MatrixDecomposition	,
		ScaleFloatError
	)

Definition at line 94 of file matrix_decomposition_unittests.cc.

References flutter::MatrixDecomposition::IsValid(), flutter::MatrixDecomposition::rotation(), and flutter::MatrixDecomposition::scale().

                                            {
   constexpr float scale_increment = 0.00001f;
   float scale = 0.0001f;
   while (scale < 2.0f) {
     SkM44 matrix;
     matrix.setScale(scale, scale, 1.0f);
 
     flutter::MatrixDecomposition decomposition3(matrix);
     ASSERT_TRUE(decomposition3.IsValid());
 
     ASSERT_FLOAT_EQ(scale, decomposition3.scale().x);
     ASSERT_FLOAT_EQ(scale, decomposition3.scale().y);
     ASSERT_FLOAT_EQ(1.f, decomposition3.scale().z);
     ASSERT_FLOAT_EQ(0, decomposition3.rotation().x);
     ASSERT_FLOAT_EQ(0, decomposition3.rotation().y);
     ASSERT_FLOAT_EQ(0, decomposition3.rotation().z);
     scale += scale_increment;
   }
 
   SkM44 matrix;
   const auto scale1 = 1.7734375f;
   matrix.setScale(scale1, scale1, 1.f);
 
   // Bug upper bound (empirical)
   const auto scale2 = 1.773437559603f;
   SkM44 matrix2;
   matrix2.setScale(scale2, scale2, 1.f);
 
   // Bug lower bound (empirical)
   const auto scale3 = 1.7734374403954f;
   SkM44 matrix3;
   matrix3.setScale(scale3, scale3, 1.f);
 
   flutter::MatrixDecomposition decomposition(matrix);
   ASSERT_TRUE(decomposition.IsValid());
 
   flutter::MatrixDecomposition decomposition2(matrix2);
   ASSERT_TRUE(decomposition2.IsValid());
 
   flutter::MatrixDecomposition decomposition3(matrix3);
   ASSERT_TRUE(decomposition3.IsValid());
 
   ASSERT_FLOAT_EQ(scale1, decomposition.scale().x);
   ASSERT_FLOAT_EQ(scale1, decomposition.scale().y);
   ASSERT_FLOAT_EQ(1.f, decomposition.scale().z);
   ASSERT_FLOAT_EQ(0, decomposition.rotation().x);
   ASSERT_FLOAT_EQ(0, decomposition.rotation().y);
   ASSERT_FLOAT_EQ(0, decomposition.rotation().z);
 
   ASSERT_FLOAT_EQ(scale2, decomposition2.scale().x);
   ASSERT_FLOAT_EQ(scale2, decomposition2.scale().y);
   ASSERT_FLOAT_EQ(1.f, decomposition2.scale().z);
   ASSERT_FLOAT_EQ(0, decomposition2.rotation().x);
   ASSERT_FLOAT_EQ(0, decomposition2.rotation().y);
   ASSERT_FLOAT_EQ(0, decomposition2.rotation().z);
 
   ASSERT_FLOAT_EQ(scale3, decomposition3.scale().x);
   ASSERT_FLOAT_EQ(scale3, decomposition3.scale().y);
   ASSERT_FLOAT_EQ(1.f, decomposition3.scale().z);
   ASSERT_FLOAT_EQ(0, decomposition3.rotation().x);
   ASSERT_FLOAT_EQ(0, decomposition3.rotation().y);
   ASSERT_FLOAT_EQ(0, decomposition3.rotation().z);
 }

◆ TEST() [81/130]

flutter::testing::TEST	(	AndroidExternalViewEmbedder	,
		GetCurrentCanvases
	)

Definition at line 95 of file external_view_embedder_unittests.cc.

References GetThreadMergerFromPlatformThread().

                                                       {
   auto jni_mock = std::make_shared<JNIMock>();
 
   auto embedder =
       std::make_unique<AndroidExternalViewEmbedder>(nullptr, jni_mock, nullptr);
   auto raster_thread_merger = GetThreadMergerFromPlatformThread();
 
   EXPECT_CALL(*jni_mock, FlutterViewBeginFrame());
   embedder->BeginFrame(SkISize::Make(10, 20), nullptr, 1.0,
                        raster_thread_merger);
 
   embedder->PrerollCompositeEmbeddedView(
       0, std::make_unique<EmbeddedViewParams>());
   embedder->PrerollCompositeEmbeddedView(
       1, std::make_unique<EmbeddedViewParams>());
 
   auto canvases = embedder->GetCurrentCanvases();
   ASSERT_EQ(2UL, canvases.size());
   ASSERT_EQ(SkISize::Make(10, 20), canvases[0]->getBaseLayerSize());
   ASSERT_EQ(SkISize::Make(10, 20), canvases[1]->getBaseLayerSize());
 }

◆ TEST() [82/130]

flutter::testing::TEST	(	Win32WindowProcDelegateManagerTest	,
		RegisterMultiple
	)

Definition at line 95 of file win32_window_proc_delegate_manager_unittests.cc.

References flutter::Win32WindowProcDelegateManager::OnTopLevelWindowProc(), and flutter::Win32WindowProcDelegateManager::RegisterTopLevelWindowProcDelegate().

                                                            {
   Win32WindowProcDelegateManager 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() [83/130]

flutter::testing::TEST	(	SurfacePool	,
		GetLayer__Recycle
	)

Definition at line 100 of file surface_pool_unittests.cc.

References flutter::kSoftware.

                                      {
   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);

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BackdropFilterLayerTest

◆ CanvasTest

◆ CheckerBoardLayerTest

◆ ClipPathLayerTest

◆ ClipRectLayerTest

◆ ClipRRectLayerTest

◆ ColorFilterLayerTest

◆ ContainerLayerTest

◆ Continuation

◆ CreateVsyncWaiter

◆ DartLifecycleTest

◆ DartVMTest

◆ Embedder11yTest

◆ EmbedderTest

◆ FuchsiaLayerTest

◆ Generator

◆ ImageFilterLayerTest

◆ IntPipeline

◆ LayerTest

◆ MockCanvasTest

◆ MockLayerTest

◆ NativeEntry

◆ OpacityLayerTest

◆ PerformanceOverlayLayerTest

◆ PhysicalShapeLayerTest

◆ PictureLayerTest

◆ PlatformViewLayerTest

◆ SemanticsActionCallback

◆ SemanticsNodeCallback

◆ ShaderMaskLayerTest

◆ TextureLayerTest

◆ TransformLayerTest

◆ UniqueAOTData

◆ UniqueEngine

◆ UniqueLoadedELF

◆ UnitlessTime

Enumeration Type Documentation

◆ DebuggerStatus

◆ MemsetPatternOp

Function Documentation

◆ CheckFrameTimings()

◆ CheckTextSkData()

◆ CheckTwoSkSLsAreLoaded()

◆ CreateAndRunRootIsolate()

◆ CreateFlagsString()

◆ CreateRenderSurface()

◆ CreateSimulatedMousePointerData()

◆ CreateSimulatedPointerData() [1/2]

◆ CreateSimulatedPointerData() [2/2]

◆ DartNativeEntrySymbolCallback()

◆ FilterMutationsByType() [1/2]

◆ FilterMutationsByType() [2/2]

◆ GetChildLayerId()

◆ GetCurrentTestName()

◆ GetDebuggerStatus()

◆ GetEGLError()

◆ GetFixturesPath()

◆ GetRasterizerResourceCacheBytesSync()

◆ GetTestNameFromTestInfo()

◆ GetThreadMergerFromPlatformThread()

◆ GetThreadMergerFromRasterThread()

◆ GetTotalMutationTransformationMatrix() [1/2]

◆ GetTotalMutationTransformationMatrix() [2/2]

◆ ImageMatchesFixture() [1/2]

◆ ImageMatchesFixture() [2/2]

◆ InitTest()

◆ InvokeAllCallbacks()

◆ LoadELFSymbolFromFixturesIfNeccessary()

◆ LogSkData()

◆ MakeSizedPicture()

◆ MemsetPatternSetOrCheck() [1/2]

◆ MemsetPatternSetOrCheck() [2/2]

◆ mockViewController()

◆ NumberNear()