Classes
class	BlendFilterContentsTest

struct	BlendModeSelection

struct	CheckSameSignature

struct	CheckSameSignature< Ret(Args...), Ret(Args...)>

struct	ColorBlendTestData

class	CompareFunctionUIData

struct	CVTest

struct	DiscardFrameBufferParams

class	FailingAllocator

class	FlushTestAllocator

class	FlushTestContentContext

class	FlushTestDeviceBuffer

struct	Foo

class	GaussianBlurFilterContentsTest

class	GoldenDigest
	Manages a global variable for tracking instances of golden images. More...

class	GoldenDigestManager

class	GoldenScreenshotter

class	GoldenTests

class	IMockGLESImpl

struct	MaskBlurTestConfig

class	MatrixFilterContentsTest

class	MetalGoldenScreenshotter

class	MetalScreenshot
	A screenshot that was produced from `MetalScreenshotter`. More...

class	MetalScreenshotter

class	MockAllocator

class	MockBlitPass

class	MockCapabilities

class	MockCommandBuffer

class	MockCommandQueue

class	MockDeviceBuffer

class	MockDeviceHolder

class	MockFence

class	MockGLES
	Provides a mocked version of the \|ProcTableGLES\| class. More...

class	MockGLESImpl

class	MockIdleWaiter

class	MockImpellerContext

class	MockPathVertexWriter

class	MockPipelineLibrary

class	MockRenderPass

class	MockSampler

class	MockSamplerLibrary

class	MockSegmentReceiver

class	MockTexture

class	MockVulkanContextBuilder

class	MockWorker

class	MorphologyFilterContentsTest

class	RecordingRenderPass

class	RendererDartTest

class	RenderPassGLESCommandTest

class	RenderPassGLESWithDiscardFrameBufferExtTest

struct	RWFoo

class	Screenshot

class	Screenshotter

class	TestAllocator

class	TestPipelineCompileQueue

class	TestReactorGLES

class	TestWorker

struct	TextRenderOptions

class	VulkanGoldenScreenshotter

class	VulkanScreenshotter

class	WorkingDirectory

Typedefs
using	AiksTest = AiksPlaygroundWithGoldens

using	DisplayListTest = DlPlayground

using	HostBufferTest = EntityPlayground

using	TextContentsTest = PlaygroundTest

using	EntityTest = EntityPlayground

using	EntityPassTargetTest = EntityPlayground

using	RenderTargetCacheTest = EntityPlayground

using	SaveLayerUtilsTest = ::testing::Test

using	PipelineLibraryGLESTest = PlaygroundTest

using	SurfaceGLESTest = PlaygroundTest

using	TextureGLESTest = PlaygroundTest

using	AllocatorMTLTest = PlaygroundTest

using	ContextMTLTest = PlaygroundTest

using	SwapchainTransientsMTLTest = PlaygroundTest

using	DriverInfoVKTest = PlaygroundTest

using	PipelineCacheDataVKPlaygroundTest = PlaygroundTest

using	RendererTest = PlaygroundTest

using	BlitPassTest = AiksTest

using	ComputeTest = ComputePlaygroundTest

using	DeviceBufferTest = Playground

using	RendererGoldenTest = PlaygroundTestWithGoldens

using	RuntimeStageTest = RuntimeStagePlayground

using	TessellatorPlaygroundTest = PlaygroundTest

using	TypographerTest = PlaygroundTest

Functions
	TEST (AllocationSizeTest, CanCreateTypedAllocations)

	TEST (AllocationSizeTest, CanCreateTypedAllocationsWithLiterals)

	TEST (AllocationSizeTest, CanConvert)

	TEST (AllocationSizeTest, ConversionsAreNonTruncating)

	TEST (AllocationSizeTest, CanGetFloatValues)

	TEST (AllocationSizeTest, RelationalOperatorsAreFunctional)

	TEST (AllocationSizeTest, CanCast)

	TEST (AllocationSizeTest, CanPerformSimpleArithmetic)

	TEST (AllocationSizeTest, CanConstructWithArith)

	TEST (AllocationTest, ReserveNPOTPotentialOverflow)

	TEST (AllocationTest, NextPowerOfTwoSize)

	TEST (ThreadTest, CanCreateMutex)

	TEST (ThreadTest, CanCreateMutexLock)

	TEST (ThreadTest, CanCreateRWMutex)

	TEST (ThreadTest, CanCreateRWMutexLock)

	TEST (ConditionVariableTest, WaitUntil)

	TEST (ConditionVariableTest, WaitFor)

	TEST (ConditionVariableTest, WaitForever)

	TEST (ConditionVariableTest, TestsCriticalSectionAfterWaitForUntil)

	TEST (ConditionVariableTest, TestsCriticalSectionAfterWait)

	TEST (BaseTest, NoExceptionPromiseValue)

	TEST (BaseTest, NoExceptionPromiseEmpty)

	TEST (BaseTest, CanUseTypedMasks)

	TEST (AllocatorTest, TextureDescriptorCompatibility)

	TEST (AllocatorTest, RangeTest)

	TEST (AllocatorTest, CompressedFormatClassification)

	TEST (AllocatorTest, CompressedFormatBlockMath)

	TEST (AllocatorTest, CompressedFormatRegionByteSizes)

	TEST (AllocatorTest, CompressedTextureDescriptorByteSizes)

	TEST (BufferViewTest, Empty)

	TEST (BufferViewTest, TakeRaw)

	TEST (SamplerDescriptorTest, ToKeyIncludesAllFields)

	TEST (ShaderTypesTest, VertexAttributeFormatFloat32)

	TEST (ShaderTypesTest, VertexAttributeFormatHalfFloat)

	TEST (ShaderTypesTest, VertexAttributeFormatIntegers)

	TEST (ShaderTypesTest, VertexAttributeFormatRejectsMatrices)

	TEST (ShaderTypesTest, VertexAttributeFormatRejectsBadComponentCount)

	TEST (ShaderTypesTest, VertexAttributeFormatRejectsBadBitWidth)

	TEST (ShaderTypesTest, VertexAttributeFormatRejectsUnsupportedScalarKinds)

	TEST_P (AiksTest, DrawAtlasNoColor)

	TEST_P (AiksTest, DrawAtlasWithColorAdvanced)

	TEST_P (AiksTest, DrawAtlasWithColorSimple)

	TEST_P (AiksTest, DrawAtlasWithOpacity)

	TEST_P (AiksTest, DrawAtlasNoColorFullSize)

	TEST_P (AiksTest, DrawAtlasAdvancedAndTransform)

	TEST_P (AiksTest, DrawAtlasWithColorAdvancedAndTransform)

	TEST_P (AiksTest, DrawAtlasPlusWideGamut)

	TEST_P (AiksTest, DlAtlasGeometryNoBlendRenamed)

	TEST_P (AiksTest, DlAtlasGeometryBlend)

	TEST_P (AiksTest, DlAtlasGeometryColorButNoBlend)

	TEST_P (AiksTest, DlAtlasGeometrySkip)

	TEST_P (AiksTest, DrawImageRectWithBlendColorFilter)

	TEST_P (AiksTest, DrawImageRectWithMatrixColorFilter)

	TEST_P (AiksTest, DrawAtlasWithColorBurn)

	TEST_P (AiksTest, CanRenderColoredRect)

	TEST_P (AiksTest, CanRenderColoredRectPrimitive)

	TEST_P (AiksTest, CanRenderWideStrokedRectWithoutOverlap)

	TEST_P (AiksTest, CanRenderWideStrokedRectPathWithoutOverlap)

	TEST_P (AiksTest, CanRenderImage)

	TEST_P (AiksTest, CanRenderInvertedImageWithColorFilter)

	TEST_P (AiksTest, CanRenderColorFilterWithInvertColors)

	TEST_P (AiksTest, CanRenderColorFilterWithInvertColorsDrawPaint)

	TEST_P (AiksTest, CanRenderTiledTextureClamp)

	TEST_P (AiksTest, CanRenderTiledTextureRepeat)

	TEST_P (AiksTest, CanRenderTiledTextureMirror)

	TEST_P (AiksTest, CanRenderTiledTextureDecal)

	TEST_P (AiksTest, CanRenderTiledTextureClampWithTranslate)

	TEST_P (AiksTest, CanRenderImageRect)

	TEST_P (AiksTest, DrawImageRectSrcOutsideBounds)

	TEST_P (AiksTest, CanRenderSimpleClips)

	TEST_P (AiksTest, CanSaveLayerStandalone)

	TEST_P (AiksTest, CanRenderDifferentShapesWithSameColorSource)

	TEST_P (AiksTest, CanRenderRoundedRectWithNonUniformRadii)

	TEST_P (AiksTest, CanRenderRoundedRectWithUniformRadii)

	TEST_P (AiksTest, CanDrawPaint)

	TEST_P (AiksTest, CanDrawPaintMultipleTimes)

	TEST_P (AiksTest, StrokedRectsRenderCorrectly)

	TEST_P (AiksTest, FilledCirclesRenderCorrectly)

	TEST_P (AiksTest, DrawThinStrokedCircle)

	TEST_P (AiksTest, StrokedCirclesRenderCorrectly)

	TEST_P (AiksTest, ZoomedStrokedPathRendersCorrectly)

	TEST_P (AiksTest, StrokedPathWithLargeStrokeWidthRendersCorrectly)

	TEST_P (AiksTest, FilledEllipsesRenderCorrectly)

	TEST_P (AiksTest, FilledArcsRenderCorrectly)

	TEST_P (AiksTest, TranslucentFilledArcsRenderCorrectly)

	TEST_P (AiksTest, FilledArcsRenderCorrectlyWithCenter)

	TEST_P (AiksTest, NonSquareFilledArcsRenderCorrectly)

	TEST_P (AiksTest, NonSquareFilledArcsRenderCorrectlyWithCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithButtEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithTranslucencyAndSquareEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithRoundEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithTranslucencyAndRoundEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithBevelJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithMiterJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithRoundJoinsAndCenter)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareAndButtEnds)

	TEST_P (AiksTest, StrokedArcsRenderCorrectlyWithSquareAndButtAndRoundEnds)

	TEST_P (AiksTest, StrokedArcsCoverFullArcWithButtEnds)

	TEST_P (AiksTest, FilledRoundRectsRenderCorrectly)

	TEST_P (AiksTest, SolidColorCirclesOvalsRRectsMaskBlurCorrectly)

	TEST_P (AiksTest, CanRenderClippedBackdropFilter)

	TEST_P (AiksTest, CanDrawPerspectiveTransformWithClips)

	TEST_P (AiksTest, ImageColorSourceEffectTransform)

	TEST_P (AiksTest, SubpassWithClearColorOptimization)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen)

	TEST_P (AiksTest, MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen)

	TEST_P (AiksTest, ClearColorOptimizationWhenSubpassIsBiggerThanParentPass)

	TEST_P (AiksTest, EmptySaveLayerIgnoresPaint)

	TEST_P (AiksTest, EmptySaveLayerRendersWithClear)

	TEST_P (AiksTest, CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated)

	TEST_P (AiksTest, FormatWideGamut)

	TEST_P (AiksTest, FormatSRGB)

	TEST_P (AiksTest, CoordinateConversionsAreCorrect)

	TEST_P (AiksTest, CanPerformFullScreenMSAA)

	TEST_P (AiksTest, CanPerformSkew)

	TEST_P (AiksTest, CanPerformSaveLayerWithBounds)

	TEST_P (AiksTest, FilledRoundRectPathsRenderCorrectly)

	TEST_P (AiksTest, CoverageOriginShouldBeAccountedForInSubpasses)

	TEST_P (AiksTest, SaveLayerDrawsBehindSubsequentEntities)

	TEST_P (AiksTest, SiblingSaveLayerBoundsAreRespected)

	TEST_P (AiksTest, CanRenderClippedLayers)

	TEST_P (AiksTest, SaveLayerFiltersScaleWithTransform)

	TEST_P (AiksTest, FastEllipticalRRectMaskBlursRenderCorrectly)

	TEST_P (AiksTest, PipelineBlendSingleParameter)

	TEST_P (AiksTest, MassiveScalingMatrixImageFilter)

	TEST_P (AiksTest, NoDimplesInRRectPath)

	TEST_P (AiksTest, BackdropFilterOverUnclosedClip)

	TEST_P (AiksTest, PerspectiveRectangle)

	TEST_P (AiksTest, CanRenderFilledRoundSuperellipses)

	TEST_P (AiksTest, CanRenderAsymmetricRoundSuperellipses)

	TEST_P (AiksTest, CanRenderStrokedRoundSuperellipses)

	TEST_P (AiksTest, CanRenderSmallRadiusRoundSuperellipses)

	TEST_P (AiksTest, CanRenderThickStrokedRoundSuperellipses)

	TEST_P (AiksTest, CanRenderRoundSuperellipseGrid)

	TEST_P (AiksTest, CanRenderTransformedRoundSuperellipse)

	TEST_P (AiksTest, CompareAntiAliasAndNonAntiAlias)

	TEST_P (AiksTest, CompareDiffRoundRectAndRoundRect)

	TEST_P (AiksTest, CanRenderLinesWithCapsAnglesAndAlphas)

static BlendModeSelection	GetBlendModeSelection ()

	TEST_P (AiksTest, CanRenderAdvancedBlendColorFilterWithSaveLayer)

	TEST_P (AiksTest, BlendModeShouldCoverWholeScreen)

	TEST_P (AiksTest, CanDrawPaintWithAdvancedBlend)

	TEST_P (AiksTest, DrawPaintWithAdvancedBlendOverFilter)

	TEST_P (AiksTest, DrawAdvancedBlendPartlyOffscreen)

	TEST_P (AiksTest, PaintBlendModeIsRespected)

	TEST_P (AiksTest, ColorFilterBlend)

	TEST_P (AiksTest, ColorFilterAdvancedBlend)

	TEST_P (AiksTest, ColorFilterAdvancedBlendNoFbFetch)

	TEST_P (AiksTest, BlendModePlusAlphaWideGamut)

	TEST_P (AiksTest, BlendModePlusAlphaColorFilterWideGamut)

	TEST_P (AiksTest, ForegroundBlendSubpassCollapseOptimization)

	TEST_P (AiksTest, ClearBlend)

static sk_sp< DisplayList >	BlendModeTest (AiksTest *test, Vector2 content_scale, BlendMode blend_mode, const sk_sp< DlImageImpeller > &src_image, const sk_sp< DlImageImpeller > &dst_image, Scalar src_alpha)

	TEST_P (AiksTest, CanDrawPaintMultipleTimesInteractive)

	TEST_P (AiksTest, ForegroundPipelineBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, ForegroundAdvancedBlendAppliesTransformCorrectly)

	TEST_P (AiksTest, FramebufferAdvancedBlendCoverage)

	TEST_P (AiksTest, ColorWheel)

	TEST_P (AiksTest, DestructiveBlendColorFilterFloodsClip)

	TEST_P (AiksTest, AdvancedBlendColorFilterWithDestinationOpacity)

	TEST_P (AiksTest, EmulatedAdvancedBlendRestore)

	TEST_P (AiksTest, SolidColorOvalsMaskBlurTinySigma)

sk_sp< flutter::DisplayList >	DoGradientOvalStrokeMaskBlur (Vector2 content_Scale, Scalar sigma, DlBlurStyle style)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlur)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurSigmaZero)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurOuter)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurInner)

	TEST_P (AiksTest, GradientOvalStrokeMaskBlurSolid)

	TEST_P (AiksTest, SolidColorCircleMaskBlurTinySigma)

	TEST_P (AiksTest, CanRenderMaskBlurHugeSigma)

	TEST_P (AiksTest, CanRenderForegroundBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderForegroundAdvancedBlendWithMaskBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurInteractive)

	TEST_P (AiksTest, CanRenderBackdropBlur)

	TEST_P (AiksTest, CanRenderBackdropBlurWithSingleBackdropId)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropId)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropIdAndDistinctFilters)

	TEST_P (AiksTest, CanRenderBackdropBlurHugeSigma)

	TEST_P (AiksTest, CanRenderBoundedBlur)

	TEST_P (AiksTest, CanRenderClippedBlur)

	TEST_P (AiksTest, ComposePaintBlurOuter)

	TEST_P (AiksTest, ComposePaintBlurInner)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectlyInteractive)

	TEST_P (AiksTest, ClippedBlurFilterRendersCorrectly)

	TEST_P (AiksTest, ClearBlendWithBlur)

	TEST_P (AiksTest, BlurHasNoEdge)

	TEST_P (AiksTest, MaskBlurWithZeroSigmaIsSkipped)

	TEST_P (AiksTest, MaskBlurOnZeroDimensionIsSkippedWideGamut)

static sk_sp< DisplayList >	MaskBlurVariantTest (const AiksTest &test_context, const MaskBlurTestConfig &config)

	TEST_P (AiksTest, GaussianBlurStyleInner)

	TEST_P (AiksTest, GaussianBlurStyleOuter)

	TEST_P (AiksTest, GaussianBlurStyleSolid)

	TEST_P (AiksTest, MaskBlurTexture)

	TEST_P (AiksTest, MaskBlurDoesntStretchContents)

	TEST_P (AiksTest, GaussianBlurAtPeripheryVertical)

	TEST_P (AiksTest, GaussianBlurAtPeripheryHorizontal)

	TEST_P (AiksTest, GaussianBlurAnimatedBackdrop)

	TEST_P (AiksTest, GaussianBlurStyleInnerGradient)

	TEST_P (AiksTest, GaussianBlurStyleSolidGradient)

	TEST_P (AiksTest, GaussianBlurStyleOuterGradient)

	TEST_P (AiksTest, GaussianBlurScaledAndClipped)

	TEST_P (AiksTest, GaussianBlurRotatedAndClippedInteractive)

	TEST_P (AiksTest, GaussianBlurOneDimension)

	TEST_P (AiksTest, GaussianBlurRotatedAndClipped)

	TEST_P (AiksTest, GaussianBlurRotatedNonUniform)

	TEST_P (AiksTest, BlurredRectangleWithShader)

	TEST_P (AiksTest, GaussianBlurSolidColorTinyMipMap)

	TEST_P (AiksTest, GaussianBlurBackdropTinyMipMap)

	TEST_P (AiksTest, CanRenderMultipleBackdropBlurWithSingleBackdropIdDifferentLayers)

	TEST_P (AiksTest, BlurGradientWithOpacity)

	TEST_P (AiksTest, CanRenderNestedBackdropBlur)

	TEST_P (AiksTest, GaussianBlurFlipped)

	TEST_P (AiksTest, CanRenderNestedClips)

	TEST_P (AiksTest, CanRenderDifferenceClips)

	TEST_P (AiksTest, CanRenderWithContiguousClipRestores)

	TEST_P (AiksTest, ClipsUseCurrentTransform)

	TEST_P (AiksTest, FramebufferBlendsRespectClips)

	TEST_P (AiksTest, CanRenderLinearGradientClamp)

	TEST_P (AiksTest, CanRenderLinearGradientRepeat)

	TEST_P (AiksTest, CanRenderLinearGradientMirror)

	TEST_P (AiksTest, CanRenderLinearGradientDecal)

	TEST_P (AiksTest, CanRenderLinearGradientDecalWithColorFilter)

	TEST_P (AiksTest, CanRenderLinearGradientWithImageFilter)

static void	CanRenderLinearGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderLinearGradientWithDitheringEnabled)

static void	CanRenderRadialGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderRadialGradientWithDitheringEnabled)

static void	CanRenderSweepGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderSweepGradientWithDitheringEnabled)

static void	CanRenderConicalGradientWithDithering (AiksTest *aiks_test)

	TEST_P (AiksTest, CanRenderConicalGradientWithDitheringEnabled)

	TEST_P (AiksTest, CanRenderLinearGradientWithOverlappingStopsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderRadialGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderConicalGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderSweepGradientWithIncompleteStops)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsRepeat)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsMirror)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsDecal)

	TEST_P (AiksTest, CanRenderLinearGradientWayManyColorsClamp)

	TEST_P (AiksTest, CanRenderLinearGradientManyColorsUnevenStops)

	TEST_P (AiksTest, CanRenderLinearGradientMaskBlur)

	TEST_P (AiksTest, CanRenderRadialGradient)

	TEST_P (AiksTest, CanRenderRadialGradientManyColors)

	TEST_P (AiksTest, CanRenderSweepGradientClamp)

	TEST_P (AiksTest, CanRenderSweepGradientRepeat)

	TEST_P (AiksTest, CanRenderSweepGradientMirror)

	TEST_P (AiksTest, CanRenderSweepGradientDecal)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsClamp)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsRepeat)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsMirror)

	TEST_P (AiksTest, CanRenderSweepGradientManyColorsDecal)

	TEST_P (AiksTest, CanRenderConicalGradient)

	TEST_P (AiksTest, CanRenderGradientDecalWithBackground)

	TEST_P (AiksTest, GradientStrokesRenderCorrectly)

	TEST_P (AiksTest, FastGradientTestHorizontal)

	TEST_P (AiksTest, FastGradientTestVertical)

	TEST_P (AiksTest, FastGradientTestHorizontalReversed)

	TEST_P (AiksTest, FastGradientTestVerticalReversed)

	TEST_P (AiksTest, VerifyNonOptimizedGradient)

	TEST_P (AiksTest, DrawOpacityPeephole)

	TEST_P (AiksTest, CanRenderGroupOpacity)

	TEST_P (AiksTest, CanRenderGroupOpacityToSavelayer)

	TEST_P (AiksTest, RotateColorFilteredPath)

	TEST_P (AiksTest, CanRenderStrokes)

	TEST_P (AiksTest, CanRenderCurvedStrokes)

	TEST_P (AiksTest, CanRenderThickCurvedStrokes)

	TEST_P (AiksTest, CanRenderThinCurvedStrokes)

	TEST_P (AiksTest, CanRenderStrokePathThatEndsAtSharpTurn)

	TEST_P (AiksTest, CanRenderStrokePathWithCubicLine)

	TEST_P (AiksTest, CanRenderQuadraticStrokeWithInstantTurn)

	TEST_P (AiksTest, CanRenderFilledConicPaths)

	TEST_P (AiksTest, CanRenderStrokedConicPaths)

	TEST_P (AiksTest, DrawLinesWithPath)

	TEST_P (AiksTest, DrawLinesWithDrawLine)

	TEST_P (AiksTest, DrawLinesWithFilledRects)

	TEST_P (AiksTest, DrawLinesWithFilledRoundRects)

	TEST_P (AiksTest, CanRenderTightConicPath)

	TEST_P (AiksTest, CanRenderDifferencePaths)

	TEST_P (AiksTest, CanDrawAnOpenPath)

	TEST_P (AiksTest, CanDrawAnOpenPathThatIsntARect)

	TEST_P (AiksTest, SolidStrokesRenderCorrectly)

	TEST_P (AiksTest, DrawLinesRenderCorrectly)

	TEST_P (AiksTest, DrawRectStrokesRenderCorrectly)

	TEST_P (AiksTest, DrawRectStrokesWithBevelJoinRenderCorrectly)

	TEST_P (AiksTest, CanDrawMultiContourConvexPath)

	TEST_P (AiksTest, ArcWithZeroSweepAndBlur)

	TEST_P (AiksTest, CanRenderClips)

	TEST_P (AiksTest, FatStrokeArc)

	TEST_P (AiksTest, CanRenderOverlappingMultiContourPath)

	TEST_P (AiksTest, TwoContourPathWithSinglePointContour)

	TEST_P (AiksTest, TwoContourPathWithConnectingLines)

	TEST_P (AiksTest, StrokeCapsAndJoins)

	TEST_P (AiksTest, BlurredCircleWithStrokeWidth)

	TEST_P (AiksTest, PrimitiveShapePlayground)

	TEST_P (AiksTest, CanRenderSkewedCircleHairline)

	TEST_P (AiksTest, CanRenderClippedRuntimeEffects)

	TEST_P (AiksTest, DrawPaintTransformsBounds)

	TEST_P (AiksTest, CanRenderRuntimeEffectFilter)

	TEST_P (AiksTest, RuntimeEffectWithInvalidSamplerDoesNotCrash)

	TEST_P (AiksTest, ComposePaintRuntimeOuter)

	TEST_P (AiksTest, ComposePaintRuntimeInner)

	TEST_P (AiksTest, ComposeBackdropRuntimeOuterBlurInner)

	TEST_P (AiksTest, ComposeBackdropRuntimeOuterBlurInnerSmallSigma)

	TEST_P (AiksTest, ClippedComposeBackdropRuntimeOuterBlurInnerSmallSigma)

	TEST_P (AiksTest, ClippedBackdropFilterWithShader)

	TEST_P (AiksTest, RuntimeEffectImageFilterRotated)

	TEST_P (AiksTest, RuntimeEffectVectorArray)

	TEST_P (AiksTest, DrawShadowDoesNotOptimizeHourglass)

	TEST_P (AiksTest, DrawShadowDoesNotOptimizeInnerOuterSpiral)

	TEST_P (AiksTest, DrawShadowDoesNotOptimizeOuterInnerSpiral)

	TEST_P (AiksTest, DrawShadowDoesNotOptimizeMultipleContours)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseTriangle)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseTriangle)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseCircle)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseCircle)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseOval)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseOval)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseUniformRoundRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseUniformRoundRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseMultiRadiiRoundRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseMultiRadiiRoundRect)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseQuadratic)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseQuadratic)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseConic)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseConic)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseCubic)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseCubic)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseOctagon)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseOctagon)

	TEST_P (AiksTest, DrawShadowCanOptimizeWithExtraneousMoveTos)

	TEST_P (AiksTest, DrawShadowCanOptimizeClockwiseWithExtraColinearVertices)

	TEST_P (AiksTest, DrawShadowCanOptimizeCounterClockwiseWithExtraColinearVertices)

	TEST_P (AiksTest, CanDrawPerspectiveConvexShadow)

	TEST_P (AiksTest, CanDrawRotatedConvexShadow)

	TEST_P (AiksTest, CanDrawNonuniformScaleConvexShadow)

bool	RenderTextInCanvasSkia (const std::shared_ptr< Context > &context, DisplayListBuilder &canvas, const std::string &text, const std::string_view &font_fixture, const TextRenderOptions &options={}, const std::optional< SkFont > &font=std::nullopt)

	TEST_P (AiksTest, CanRenderTextFrame)

	TEST_P (AiksTest, CanRenderTextFrameWithInvertedTransform)

	TEST_P (AiksTest, CanRenderStrokedTextFrame)

	TEST_P (AiksTest, CanRenderTextStrokeWidth)

	TEST_P (AiksTest, CanRenderTextFrameWithHalfScaling)

	TEST_P (AiksTest, ScaledK)

	TEST_P (AiksTest, MassiveScaleConvertToPath)

	TEST_P (AiksTest, CanRenderTextFrameWithScalingOverflow)

	TEST_P (AiksTest, CanRenderTextFrameWithFractionScaling)

	TEST_P (AiksTest, TextRotated180Degrees)

	TEST_P (AiksTest, TextFrameSubpixelAlignment)

	TEST_P (AiksTest, CanRenderItalicizedText)

	TEST_P (AiksTest, CanRenderEmojiTextFrame)

	TEST_P (AiksTest, CanRenderEmojiTextFrameWithBlur)

	TEST_P (AiksTest, CanRenderEmojiTextFrameWithAlpha)

	TEST_P (AiksTest, CanRenderTextInSaveLayer)

	TEST_P (AiksTest, CanRenderTextOutsideBoundaries)

	TEST_P (AiksTest, TextRotated)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveNoSaveLayer)

	TEST_P (AiksTest, DrawScaledTextWithPerspectiveSaveLayer)

	TEST_P (AiksTest, CanRenderTextWithLargePerspectiveTransform)

	TEST_P (AiksTest, CanRenderTextWithPerspectiveTransformInSublist)

	TEST_P (AiksTest, TextForegroundShaderWithTransform)

	TEST_P (AiksTest, DifferenceClipsMustRenderIdenticallyAcrossBackends)

	TEST_P (AiksTest, TextContentsMismatchedTransformTest)

	TEST_P (AiksTest, CanRenderTextFrameWithThinLightAndDarkColors)

	TEST_P (AiksTest, TextWithShadowCache)

	TEST_P (AiksTest, MultipleTextWithShadowCache)

	TEST_P (AiksTest, MultipleColorWithShadowCache)

	TEST_P (AiksTest, SingleIconShadowTest)

	TEST_P (AiksTest, VarietyOfTextScalesShowingRasterAndPath)

	TEST_P (AiksTest, TextFramesDoNotShareRenderDataBigSmall)

	TEST_P (AiksTest, TextFramesDoNotShareRenderDataSmallBig)

	TEST_P (AiksTest, TextWithNonUniformScale)

	TEST_P (AiksTest, TextGammaCorrectionGoldenTest)

	TEST_P (AiksTest, TextWithShadowAndPosition)

	TEST_P (AiksTest, CollapsedDrawPaintInSubpass)

	TEST_P (AiksTest, CollapsedDrawPaintInSubpassBackdropFilter)

	TEST_P (AiksTest, ColorMatrixFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, LinearToSrgbFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, SrgbToLinearFilterSubpassCollapseOptimization)

	TEST_P (AiksTest, TranslucentSaveLayerDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly)

	TEST_P (AiksTest, ImageFilteredUnboundedSaveLayerWithUnboundedContents)

	TEST_P (AiksTest, TranslucentSaveLayerImageDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly)

	TEST_P (AiksTest, TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly)

	TEST_P (AiksTest, CanRenderTinyOverlappingSubpasses)

	TEST_P (AiksTest, CanRenderDestructiveSaveLayer)

	TEST_P (AiksTest, CanDrawPoints)

	TEST_P (AiksTest, CanDrawPointsWithTextureMap)

	TEST_P (AiksTest, MipmapGenerationWorksCorrectly)

	TEST_P (AiksTest, StrokedPathWithMoveToThenCloseDrawnCorrectly)

	TEST_P (AiksTest, SetContentsWithRegion)

	TEST_P (AiksTest, ReleasesTextureOnTeardown)

	TEST_P (AiksTest, MatrixImageFilterMagnify)

	TEST_P (AiksTest, ImageFilteredSaveLayerWithUnboundedContents)

	TEST_P (AiksTest, MatrixBackdropFilter)

	TEST_P (AiksTest, MatrixSaveLayerFilter)

	TEST_P (AiksTest, CanDrawScaledPointsSmallScaleLargeRadius)

	TEST_P (AiksTest, CanDrawScaledPointsLargeScaleSmallRadius)

	TEST_P (AiksTest, TransparentShadowProducesCorrectColor)

	TEST_P (AiksTest, DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists)

	TEST_P (AiksTest, BackdropRestoreUsesCorrectCoverageForFirstRestoredClip)

	TEST_P (AiksTest, CanPictureConvertToImage)

	TEST_P (AiksTest, CanEmptyPictureConvertToImage)

	TEST_P (AiksTest, DepthValuesForLineMode)

	TEST_P (AiksTest, DepthValuesForPolygonMode)

	TEST_P (AiksTest, ToImageFromImage)

	TEST_P (AiksTest, DisplayListToTextureAllocationFailure)

	TEST_P (AiksTest, DisplayListToTextureWithMipGeneration)

	TEST_P (AiksTest, VerticesGeometryUVPositionData)

	TEST_P (AiksTest, VerticesGeometryUVPositionDataWithTranslate)

	TEST_P (AiksTest, VerticesGeometryColorUVPositionData)

	TEST_P (AiksTest, VerticesGeometryColorUVPositionDataAdvancedBlend)

	TEST_P (AiksTest, CanConvertTriangleFanToTriangles)

	TEST_P (AiksTest, DrawVerticesSolidColorTrianglesWithoutIndices)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithoutIndices)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithTextureCoordinates)

	TEST_P (AiksTest, DrawVerticesImageSourceWithTextureCoordinates)

	TEST_P (AiksTest, DrawVerticesImageSourceWithTextureCoordinatesAndColorBlending)

	TEST_P (AiksTest, DrawVerticesSolidColorTrianglesWithIndices)

	TEST_P (AiksTest, DrawVerticesPremultipliesColors)

	TEST_P (AiksTest, DrawVerticesWithInvalidIndices)

	TEST_P (AiksTest, DrawVerticesTextureCoordinatesWithFragmentShader)

	TEST_P (AiksTest, DrawVerticesTextureCoordinatesWithFragmentShaderNonZeroOrigin)

	TEST_P (AiksTest, VerticesGeometryWithMaskFilter)

	INSTANTIATE_PLAYGROUND_SUITE (AiksTest)

std::unique_ptr< Canvas >	CreateTestCanvas (ContentContext &context, std::optional< Rect > cull_rect=std::nullopt, bool requires_readback=false)

	TEST_P (AiksTest, TransformMultipliesCorrectly)

	TEST_P (AiksTest, CanvasCanPushPopCTM)

	TEST_P (AiksTest, CanvasCTMCanBeUpdated)

	TEST_P (AiksTest, BackdropCountDownNormal)

	TEST_P (AiksTest, BackdropCountDownBackdropId)

	TEST_P (AiksTest, BackdropCountDownBackdropIdMixed)

	TEST_P (AiksTest, BackdropCountDownWithNestedSaveLayers)

	TEST_P (AiksTest, DrawVerticesLinearGradientWithEmptySize)

	TEST_P (AiksTest, DrawVerticesWithEmptyTextureCoordinates)

	TEST_P (AiksTest, SupportsBlitToOnscreen)

	TEST_P (AiksTest, RoundSuperellipseShadowComparison)

	TEST_P (AiksTest, ImageTextureCacheBehavesCorrectly)

	TEST_P (AiksTest, BlendModeCompatibilityWithSDFRendering)

	TEST (CanvasTest, NonAntialiasedPaintIncompatibleWithSDFRendering)

	TEST (CanvasTest, AntialiasedPaintCompatibleWithSDFRendering)

flutter::DlColor	toColor (const float *components)

	INSTANTIATE_PLAYGROUND_SUITE (DisplayListTest)

	TEST_P (DisplayListTest, CanDrawRect)

	TEST_P (DisplayListTest, CanDrawTextBlob)

	TEST_P (DisplayListTest, CanDrawTextBlobWithGradient)

	TEST_P (DisplayListTest, CanDrawTextWithSaveLayer)

	TEST_P (DisplayListTest, CanDrawImage)

	TEST_P (DisplayListTest, CanDrawCapsAndJoins)

	TEST_P (DisplayListTest, CanDrawArc)

	TEST_P (DisplayListTest, StrokedPathsDrawCorrectly)

	TEST_P (DisplayListTest, CanDrawWithOddPathWinding)

	TEST_P (DisplayListTest, CanDrawAnOpenPath)

	TEST_P (DisplayListTest, CanDrawWithMaskBlur)

	TEST_P (DisplayListTest, CanDrawStrokedText)

	TEST_P (DisplayListTest, StrokedTextNotOffsetFromNormalText)

	TEST_P (DisplayListTest, IgnoreMaskFilterWhenSavingLayer)

	TEST_P (DisplayListTest, CanDrawWithBlendColorFilter)

	TEST_P (DisplayListTest, CanDrawWithColorFilterImageFilter)

	TEST_P (DisplayListTest, CanDrawWithImageBlurFilter)

	TEST_P (DisplayListTest, CanDrawWithComposeImageFilter)

	TEST_P (DisplayListTest, CanClampTheResultingColorOfColorMatrixFilter)

	TEST_P (DisplayListTest, CanDrawBackdropFilter)

	TEST_P (DisplayListTest, CanDrawBoundedBlur)

	TEST_P (DisplayListTest, CanDrawNinePatchImage)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterWidthBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterHeightBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCenterBiggerThanDest)

	TEST_P (DisplayListTest, CanDrawNinePatchImageCornersScaledDown)

	TEST_P (DisplayListTest, NinePatchImagePrecision)

	TEST_P (DisplayListTest, NinePatchImageColorFilter)

	TEST_P (DisplayListTest, CanDrawPoints)

	TEST_P (DisplayListTest, CanDrawZeroLengthLine)

	TEST_P (DisplayListTest, CanDrawShadow)

	TEST_P (DisplayListTest, CanDrawZeroWidthLine)

	TEST_P (DisplayListTest, CanDrawWithMatrixFilter)

	TEST_P (DisplayListTest, CanDrawWithMatrixFilterWhenSavingLayer)

	TEST_P (DisplayListTest, CanDrawRectWithLinearToSrgbColorFilter)

	TEST_P (DisplayListTest, CanDrawPaintWithColorSource)

	TEST_P (DisplayListTest, CanBlendDstOverAndDstCorrectly)

	TEST_P (DisplayListTest, CanDrawCorrectlyWithColorFilterAndImageFilter)

	TEST_P (DisplayListTest, MaskBlursApplyCorrectlyToColorSources)

	TEST_P (DisplayListTest, DrawShapes)

	TEST_P (DisplayListTest, DrawCirclesWithTransformations)

	TEST_P (DisplayListTest, ClipDrawRRectWithNonCircularRadii)

	TEST_P (DisplayListTest, DrawVerticesBlendModes)

	TEST_P (DisplayListTest, DrawPaintIgnoresMaskFilter)

	TEST_P (DisplayListTest, DrawMaskBlursThatMightUseSaveLayers)

	TEST (PaintTest, OptionalStrokeWithFill)

	TEST (PaintTest, OptionalStrokeWithStroke)

	TEST (PaintTest, GradientStopConversion)

	TEST (PaintTest, GradientMissing0)

	TEST (PaintTest, GradientMissingLastValue)

	TEST (PaintTest, GradientStopGreaterThan1)

	TEST (PaintTest, GradientConversionNonMonotonic)

	TEST (SkiaConversionTest, ToSamplerDescriptor)

	TEST (SkiaConversionsTest, ToColor)

	TEST (EntityPassClipStackTest, CanPushAndPopEntities)

	TEST (EntityPassClipStackTest, CanPopEntitiesSafely)

	TEST (EntityPassClipStackTest, AppendAndRestoreClipCoverage)

	TEST (EntityPassClipStackTest, AppendAndRestoreClipCoverageNonAA)

	TEST (EntityPassClipStackTest, AppendLargerClipCoverage)

	TEST (EntityPassClipStackTest, AppendLargerClipCoverageWithDifferenceOrNonSquare)

	TEST (EntityPassClipStackTest, AppendDecreasingSizeClipCoverage)

	TEST (EntityPassClipStackTest, AppendIncreasingSizeClipCoverage)

	TEST (EntityPassClipStackTest, UnbalancedRestore)

	TEST (EntityPassClipStackTest, ClipAndRestoreWithSubpasses)

	TEST (EntityPassClipStackTest, ClipAndRestoreWithSubpassesNonAA)

	INSTANTIATE_PLAYGROUND_SUITE (BlendFilterContentsTest)

	TEST_P (BlendFilterContentsTest, AdvancedBlendColorAlignsColorTo4)

	INSTANTIATE_PLAYGROUND_SUITE (GaussianBlurFilterContentsTest)

	TEST (GaussianBlurFilterContentsTest, Create)

	TEST (GaussianBlurFilterContentsTest, CoverageEmpty)

	TEST (GaussianBlurFilterContentsTest, CoverageSimple)

	TEST (GaussianBlurFilterContentsTest, CoverageWithSigma)

	TEST_P (GaussianBlurFilterContentsTest, CoverageWithTexture)

	TEST_P (GaussianBlurFilterContentsTest, CoverageWithEffectTransform)

	TEST (GaussianBlurFilterContentsTest, FilterSourceCoverage)

	TEST (GaussianBlurFilterContentsTest, FilterSourceCoverageNegativeScale)

	TEST (GaussianBlurFilterContentsTest, CalculateSigmaValues)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverage)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverageTranslate)

	TEST_P (GaussianBlurFilterContentsTest, RenderCoverageMatchesGetCoverageRotated)

	TEST_P (GaussianBlurFilterContentsTest, CalculateUVsSimple)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithDestinationRect)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithDestinationRectScaled)

	TEST_P (GaussianBlurFilterContentsTest, TextureContentsWithEffectTransform)

	TEST (GaussianBlurFilterContentsTest, CalculateSigmaForBlurRadius)

	TEST (GaussianBlurFilterContentsTest, Coefficients)

	TEST (GaussianBlurFilterContentsTest, LerpHackKernelSamplesSimple)

	TEST (GaussianBlurFilterContentsTest, LerpHackKernelSamplesComplex)

	TEST (GaussianBlurFilterContentsTest, ChopHugeBlurs)

	TEST (FilterInputTest, CanSetLocalTransformForTexture)

	INSTANTIATE_PLAYGROUND_SUITE (MatrixFilterContentsTest)

	TEST (MatrixFilterContentsTest, CoverageEmpty)

	TEST (MatrixFilterContentsTest, CoverageSimple)

	TEST (MatrixFilterContentsTest, Coverage2x)

	TEST (MatrixFilterContentsTest, Coverage2xEffect)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageIdentity)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageTranslate)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageClippedSubpassTranslate)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageScale)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageClippedSubpassScale)

	TEST_P (MatrixFilterContentsTest, RenderCoverageMatchesGetCoverageSubpassScale)

	INSTANTIATE_PLAYGROUND_SUITE (MorphologyFilterContentsTest)

	TEST_P (MorphologyFilterContentsTest, RenderCoverageMatchesGetCoverage)

	TEST_P (MorphologyFilterContentsTest, RenderDilateWithFractionalCoverageIsSymmetric)

	TEST_P (MorphologyFilterContentsTest, RenderDilateYWithFractionalCoverageIsSymmetric)

	INSTANTIATE_PLAYGROUND_SUITE (HostBufferTest)

	TEST_P (HostBufferTest, IdleWaiter)

	TEST_P (HostBufferTest, CanEmplace)

	TEST_P (HostBufferTest, CanEmplaceWithAlignment)

	TEST_P (HostBufferTest, HostBufferInitialState)

	TEST_P (HostBufferTest, ResetIncrementsFrameCounter)

	TEST_P (HostBufferTest, EmplacingLargerThanBlockSizeCreatesOneOffBufferCallback)

	TEST_P (HostBufferTest, EmplacingLargerThanBlockSizeCreatesOneOffBuffer)

	TEST_P (HostBufferTest, UnusedBuffersAreDiscardedWhenResetting)

	TEST_P (HostBufferTest, EmplaceWithProcIsAligned)

	TEST (GpuSubmissionTrackerTest, WatermarkHandlesOutOfOrderCompletion)

	TEST_P (HostBufferTest, PendingEntriesAreReplacedNotReused)

	TEST_P (HostBufferTest, CompletedEntriesAreReusedWithoutTrackerChurn)

	TEST_P (HostBufferTest, EmplaceWithFailingAllocationDoesntCrash)

	INSTANTIATE_PLAYGROUND_SUITE (TextContentsTest)

	TEST_P (TextContentsTest, SimpleComputeVertexData)

	TEST_P (TextContentsTest, SimpleComputeVertexData2x)

	TEST_P (TextContentsTest, MaintainsShape)

	TEST_P (TextContentsTest, SimpleSubpixel)

	TEST_P (TextContentsTest, SimpleSubpixel3x)

	TEST_P (TextContentsTest, SimpleSubpixel26)

	TEST_P (TextContentsTest, SimpleSubpixel80)

	TEST_P (EntityTest, TiledTextureContentsRendersWithCorrectPipeline)

	TEST_P (EntityTest, TiledTextureContentsRendersWithCorrectPipelineExternalOES)

	TEST (UberSDFContentsTest, ApplyColorFilter)

	TEST (UberSDFContentsTest, AsBackgroundColor)

	TEST (UberSDFContentsTest, AsBackgroundColorExactSize)

	TEST (UberSDFContentsTest, AsBackgroundColorNonRect)

	TEST (UberSDFContentsTest, AsBackgroundColorStrokedRect)

	TEST (UberSDFParametersTest, MakeFillRect)

	TEST (UberSDFParametersTest, MakeStrokeRect)

	TEST (UberSDFParametersTest, MakeStrokeRectLowMiterLimitBecomesBevel)

	TEST (UberSDFParametersTest, MakeFillCircle)

	TEST (UberSDFParametersTest, MakeStrokeCircle)

	TEST (UberSDFParametersTest, MakeFillOval)

	TEST (UberSDFParametersTest, MakeStrokeOval)

	TEST (UberSDFParametersTest, MakeRoundedRect)

	TEST (UberSDFParametersTest, MakeRoundedSuperellipse)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithNoClips)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithClips)

	TEST (DrawOrderResolverTest, GetSortedDrawsRespectsSkipCounts)

	TEST (DrawOrderResolverTest, GetSortedDrawsReturnsCorrectOrderWithFlush)

	TEST_P (EntityPassTargetTest, SwapWithMSAATexture)

	TEST_P (EntityPassTargetTest, SwapWithMSAAImplicitResolve)

	TEST_P (EntityTest, CanCreateEntity)

	TEST_P (EntityTest, FilterCoverageRespectsCropRect)

	TEST_P (EntityTest, GeometryBoundsAreTransformed)

	TEST_P (EntityTest, ThreeStrokesInOnePath)

	TEST_P (EntityTest, StrokeWithTextureContents)

	TEST_P (EntityTest, TriangleInsideASquare)

	TEST_P (EntityTest, StrokeCapAndJoinTest)

	TEST_P (EntityTest, CubicCurveTest)

	TEST_P (EntityTest, CanDrawCorrectlyWithRotatedTransform)

	TEST_P (EntityTest, CubicCurveAndOverlapTest)

	TEST_P (EntityTest, SolidColorContentsStrokeSetStrokeCapsAndJoins)

	TEST_P (EntityTest, SolidColorContentsStrokeSetMiterLimit)

	TEST_P (EntityTest, BlendingModeOptions)

	TEST_P (EntityTest, BezierCircleScaled)

	TEST_P (EntityTest, Filters)

	TEST_P (EntityTest, GaussianBlurFilter)

	TEST_P (EntityTest, MorphologyFilter)

	TEST_P (EntityTest, SetBlendMode)

	TEST_P (EntityTest, ContentsGetBoundsForEmptyPathReturnsNullopt)

	TEST (EntityTest, UberSDFContentsCoverageFillRect)

	TEST (EntityTest, UberSDFContentsCoverageStrokeRect)

	TEST (EntityTest, UberSDFContentsCoverageFillCircle)

	TEST (EntityTest, UberSDFContentsCoverageStrokeCircle)

	TEST_P (EntityTest, SolidStrokeCoverageIsCorrect)

	TEST_P (EntityTest, BorderMaskBlurCoverageIsCorrect)

	TEST_P (EntityTest, SolidFillCoverageIsCorrect)

	TEST_P (EntityTest, RRectShadowTest)

	TEST_P (EntityTest, ColorMatrixFilterCoverageIsCorrect)

	TEST_P (EntityTest, ColorMatrixFilterEditable)

	TEST_P (EntityTest, LinearToSrgbFilterCoverageIsCorrect)

	TEST_P (EntityTest, LinearToSrgbFilter)

	TEST_P (EntityTest, SrgbToLinearFilterCoverageIsCorrect)

	TEST_P (EntityTest, SrgbToLinearFilter)

static Vector3	RGBToYUV (Vector3 rgb, YUVColorSpace yuv_color_space)

static std::vector< std::shared_ptr< Texture > >	CreateTestYUVTextures (Context *context, YUVColorSpace yuv_color_space)

	TEST_P (EntityTest, YUVToRGBFilter)

	TEST_P (EntityTest, RuntimeEffect)

	TEST_P (EntityTest, RuntimeEffectCanSuccessfullyRender)

	TEST_P (EntityTest, RuntimeEffectCanPrecache)

	TEST_P (EntityTest, RuntimeEffectSetsRightSizeWhenUniformIsStruct)

	TEST_P (EntityTest, ColorFilterWithForegroundColorAdvancedBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorClearBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorSrcBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorDstBlend)

	TEST_P (EntityTest, ColorFilterWithForegroundColorSrcInBlend)

	TEST_P (EntityTest, CoverageForStrokePathWithNegativeValuesInTransform)

	TEST_P (EntityTest, SolidColorContentsIsOpaque)

	TEST_P (EntityTest, ConicalGradientContentsIsOpaque)

	TEST_P (EntityTest, LinearGradientContentsIsOpaque)

	TEST_P (EntityTest, RadialGradientContentsIsOpaque)

	TEST_P (EntityTest, SweepGradientContentsIsOpaque)

	TEST_P (EntityTest, TiledTextureContentsIsOpaque)

	TEST_P (EntityTest, PointFieldGeometryCoverage)

	TEST_P (EntityTest, ColorFilterContentsWithLargeGeometry)

	TEST_P (EntityTest, TextContentsCeilsGlyphScaleToDecimal)

	TEST_P (EntityTest, SpecializationConstantsAreAppliedToVariants)

	TEST_P (EntityTest, DecalSpecializationAppliedToMorphologyFilter)

	TEST_P (EntityTest, ContentContextOptionsHasReasonableHashFunctions)

	TEST_P (EntityTest, FillPathGeometryGetPositionBufferReturnsExpectedMode)

	TEST_P (EntityTest, StrokeArcGeometryGetPositionBufferReturnsExpectedMode)

	TEST_P (EntityTest, FailOnValidationError)

	TEST_P (EntityTest, CanComputeGeometryForEmptyPathsWithoutCrashing)

	TEST_P (EntityTest, CanRenderEmptyPathsWithoutCrashing)

	TEST_P (EntityTest, DrawSuperEllipse)

	TEST_P (EntityTest, DrawRoundSuperEllipse)

	TEST_P (EntityTest, DrawRoundSuperEllipseWithLargeN)

	TEST_P (EntityTest, CanDrawRoundSuperEllipseWithTinyRadius)

	TEST_P (EntityTest, CanDrawRoundSuperEllipseWithJustEnoughRadius)

	TEST_P (EntityTest, SolidColorApplyColorFilter)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Linear)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Radial)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Conical)

	APPLY_COLOR_FILTER_GRADIENT_TEST (Sweep)

	TEST_P (EntityTest, GiantStrokePathAllocation)

	TEST_P (EntityTest, RoundSuperellipseGetPositionBufferFlushes)

	TEST (EntityGeometryTest, RectGeometryCoversArea)

	TEST (EntityGeometryTest, UberSDFGeometryPaddingIsAdjustedByInverseMaxBasis)

	TEST (EntityGeometryTest, FillPathGeometryCoversArea)

	TEST (EntityGeometryTest, FillPathGeometryCoversAreaNoInnerRect)

	TEST (EntityGeometryTest, FillArcGeometryCoverage)

	TEST (EntityGeometryTest, StrokeArcGeometryCoverage)

	TEST (EntityGeometryTest, FillRoundRectGeometryCoversArea)

	TEST (EntityGeometryTest, LineGeometryCoverage)

	TEST (EntityGeometryTest, RoundRectGeometryCoversArea)

	TEST (EntityGeometryTest, GeometryResultHasReasonableDefaults)

	TEST (EntityGeometryTest, AlphaCoverageStrokePaths)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesButtCap)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesRoundCap)

	TEST (EntityGeometryTest, SimpleTwoLineStrokeVerticesSquareCap)

	TEST (EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesBevelJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesBevelJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsInDifferentContoursAreNotJoined)

	TEST (EntityGeometryTest, TwoLineSegmentsRightTurnStrokeVerticesMiterJoin)

	TEST (EntityGeometryTest, TwoLineSegmentsLeftTurnStrokeVerticesMiterJoin)

	TEST (EntityGeometryTest, TinyQuadGeneratesCaps)

	TEST (EntityGeometryTest, TinyConicGeneratesCaps)

	TEST (EntityGeometryTest, TinyCubicGeneratesCaps)

	TEST (EntityGeometryTest, TwoLineSegmentsMiterLimit)

	TEST (EntityGeometryTest, TwoLineSegments180DegreeJoins)

	TEST (EntityGeometryTest, TightQuadratic180DegreeJoins)

	TEST (EntityGeometryTest, TightConic180DegreeJoins)

	TEST (EntityGeometryTest, TightCubic180DegreeJoins)

	TEST (EntityGeometryTest, RotatedFilledCircleGeometryCoverage)

	TEST (EntityGeometryTest, RotatedStrokedCircleGeometryCoverage)

	TEST (ShadowPathGeometryTest, EmptyPathTest)

	TEST (ShadowPathGeometryTest, MoveToOnlyTest)

	TEST (ShadowPathGeometryTest, OnePathSegmentTest)

	TEST (ShadowPathGeometryTest, TwoColinearSegmentsTest)

	TEST (ShadowPathGeometryTest, EmptyRectTest)

	TEST (ShadowPathGeometryTest, GetAndTakeVertices)

	TEST (ShadowPathGeometryTest, ClockwiseTriangleTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseTriangleTest)

	TEST (ShadowPathGeometryTest, ClockwiseRectTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseRectTest)

	TEST (ShadowPathGeometryTest, ClockwiseRectExtraColinearPointsTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseRectExtraColinearPointsTest)

	TEST (ShadowPathGeometryTest, ClockwiseRectTrickyColinearPointsTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseRectTrickyColinearPointsTest)

	TEST (ShadowPathGeometryTest, ClockwiseRectTrickyDupColinearPointsTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseRectTrickyDupColinearPointsTest)

	TEST (ShadowPathGeometryTest, ClockwiseRectNearlyColinearPointsTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseRectNearlyColinearPointsTest)

	TEST (ShadowPathGeometryTest, ScaledRectTest)

	TEST (ShadowPathGeometryTest, EllipseTest)

	TEST (ShadowPathGeometryTest, RoundRectTest)

	TEST (ShadowPathGeometryTest, HourglassSelfIntersectingTest)

	TEST (ShadowPathGeometryTest, ReverseHourglassSelfIntersectingTest)

	TEST (ShadowPathGeometryTest, InnerToOuterOverturningSpiralTest)

	TEST (ShadowPathGeometryTest, ReverseInnerToOuterOverturningSpiralTest)

	TEST (ShadowPathGeometryTest, OuterToInnerOverturningSpiralTest)

	TEST (ShadowPathGeometryTest, ReverseOuterToInnerOverturningSpiralTest)

	TEST (ShadowPathGeometryTest, ClockwiseOctagonCollapsedUmbraPolygonTest)

	TEST (ShadowPathGeometryTest, CounterClockwiseOctagonCollapsedUmbraPolygonTest)

	TEST (ShadowPathGeometryTest, MultipleContoursTest)

	TEST_P (RenderTargetCacheTest, CachesUsedTexturesAcrossFrames)

	TEST_P (RenderTargetCacheTest, CachesUsedTexturesAcrossFramesWithKeepAlive)

	TEST_P (RenderTargetCacheTest, DoesNotPersistFailedAllocations)

	TEST_P (RenderTargetCacheTest, CachedTextureGetsNewAttachmentConfig)

	TEST_P (RenderTargetCacheTest, CreateWithEmptySize)

	TEST (SaveLayerUtilsTest, SimplePaintComputedCoverage)

	TEST (SaveLayerUtilsTest, BackdropFiterComputedCoverage)

	TEST (SaveLayerUtilsTest, ImageFiterComputedCoverage)

	TEST (SaveLayerUtilsTest, ImageFiterSmallScaleComputedCoverageLargerThanBoundsLimit)

	TEST (SaveLayerUtilsTest, ImageFiterLargeScaleComputedCoverageLargerThanBoundsLimit)

	TEST (SaveLayerUtilsTest, DisjointCoverage)

	TEST (SaveLayerUtilsTest, DisjointCoverageTransformedByImageFilter)

	TEST (SaveLayerUtilsTest, DisjointCoveragTransformedByCTM)

	TEST (SaveLayerUtilsTest, BasicEmptyCoverage)

	TEST (SaveLayerUtilsTest, ImageFilterEmptyCoverage)

	TEST (SaveLayerUtilsTest, BackdropFilterEmptyCoverage)

	TEST (SaveLayerUtilsTest, FloodInputCoverage)

	TEST (SaveLayerUtilsTest, FloodInputCoverageWithImageFilter)

	TEST (SaveLayerUtilsTest, FloodInputCoverageWithImageFilterWithNoCoverageProducesNoCoverage)

	TEST (SaveLayerUtilsTest, CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageSmallerWithImageFilter)

	TEST (SaveLayerUtilsTest, CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageLargerWithImageFilter)

	TEST (SaveLayerUtilsTest, CoverageLimitRespectedIfSubstantiallyDifferentFromContentCoverage)

	TEST (SaveLayerUtilsTest, RoundUpCoverageWhenCloseToCoverageLimit)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitWidth)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitHeight)

	TEST (SaveLayerUtilsTest, DontRoundUpCoverageWhenNotCloseToCoverageLimitWidthHeight)

	TEST (ArcTest, ArcIterationsFullCircle)

	TEST (ArcTest, ArcIterationsVariousStartAnglesNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsVariousEndAnglesNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsVariousTinyArcsNearQuadrantAxis)

	TEST (ArcTest, ArcIterationsOnlyFirstQuadrant)

	TEST (ArcTest, ArcIterationsOnlySecondQuadrant)

	TEST (ArcTest, ArcIterationsOnlyThirdQuadrant)

	TEST (ArcTest, ArcIterationsOnlyFourthQuadrant)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromFirst)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromSecond)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromThird)

	TEST (ArcTest, ArcIterationsAllQuadrantsFromFourth)

	TEST (GeometryTest, ScalarNearlyEqual)

	TEST (GeometryTest, MakeColumn)

	TEST (GeometryTest, MakeRow)

	TEST (GeometryTest, RotationMatrix)

	TEST (GeometryTest, InvertMultMatrix)

	TEST (GeometryTest, MatrixBasis)

	TEST (GeometryTest, MutliplicationMatrix)

	TEST (GeometryTest, DeterminantTest)

	TEST (GeometryTest, InvertMatrix)

	TEST (GeometryTest, TestDecomposition)

	TEST (GeometryTest, TestDecomposition2)

	TEST (GeometryTest, TestRecomposition)

	TEST (GeometryTest, TestRecomposition2)

	TEST (GeometryTest, MatrixVectorMultiplication)

	TEST (GeometryTest, MatrixMakeRotationFromQuaternion)

	TEST (GeometryTest, MatrixTransformDirection)

	TEST (GeometryTest, MatrixGetMaxBasisLengthXY)

	TEST (GeometryTest, MatrixMakeOrthographic)

	TEST (GeometryTest, MatrixMakePerspective)

	TEST (GeometryTest, MatrixGetBasisVectors)

	TEST (GeometryTest, MatrixGetDirectionScale)

	TEST (GeometryTest, MatrixTranslationScaleOnly)

	TEST (GeometryTest, MatrixLookAt)

	TEST (GeometryTest, QuaternionLerp)

	TEST (GeometryTest, QuaternionVectorMultiply)

	TEST (GeometryTest, CanGenerateMipCounts)

	TEST (GeometryTest, CanConvertTTypesExplicitly)

	TEST (GeometryTest, CanPerformAlgebraicPointOps)

	TEST (GeometryTest, CanPerformAlgebraicPointOpsWithArithmeticTypes)

	TEST (GeometryTest, PointIntegerCoercesToFloat)

	TEST (GeometryTest, SizeCoercesToPoint)

	TEST (GeometryTest, CanUsePointAssignmentOperators)

	TEST (GeometryTest, PointDotProduct)

	TEST (GeometryTest, PointCrossProduct)

	TEST (GeometryTest, PointReflect)

	TEST (GeometryTest, PointAbs)

	TEST (GeometryTest, PointRotate)

	TEST (GeometryTest, PointAngleTo)

	TEST (GeometryTest, PointMin)

	TEST (GeometryTest, Vector4IsFinite)

	TEST (GeometryTest, Vector3Min)

	TEST (GeometryTest, Vector4Min)

	TEST (GeometryTest, PointMax)

	TEST (GeometryTest, Vector3Max)

	TEST (GeometryTest, Vector4Max)

	TEST (GeometryTest, PointFloor)

	TEST (GeometryTest, Vector3Floor)

	TEST (GeometryTest, Vector4Floor)

	TEST (GeometryTest, PointCeil)

	TEST (GeometryTest, Vector3Ceil)

	TEST (GeometryTest, Vector4Ceil)

	TEST (GeometryTest, PointRound)

	TEST (GeometryTest, Vector3Round)

	TEST (GeometryTest, Vector4Round)

	TEST (GeometryTest, PointLerp)

	TEST (GeometryTest, Vector3Lerp)

	TEST (GeometryTest, Vector4Lerp)

	TEST (GeometryTest, SeparatedVector2NormalizesWithConstructor)

	TEST (GeometryTest, SeparatedVector2GetVector)

	TEST (GeometryTest, SeparatedVector2GetAlignment)

	TEST (GeometryTest, SeparatedVector2AngleTo)

	TEST (GeometryTest, CanUseVector3AssignmentOperators)

	TEST (GeometryTest, CanPerformAlgebraicVector3Ops)

	TEST (GeometryTest, CanPerformAlgebraicVector3OpsWithArithmeticTypes)

	TEST (GeometryTest, ColorPremultiply)

	TEST (GeometryTest, ColorR8G8B8A8)

	TEST (GeometryTest, ColorLerp)

	TEST (GeometryTest, ColorClamp01)

	TEST (GeometryTest, ColorMakeRGBA8)

	TEST (GeometryTest, ColorApplyColorMatrix)

	TEST (GeometryTest, ColorLinearToSRGB)

	TEST (GeometryTest, ColorSRGBToLinear)

	TEST (GeometryTest, ColorBlendReturnsExpectedResults)

	TEST (GeometryTest, BlendModeToString)

	TEST (GeometryTest, CanConvertBetweenDegressAndRadians)

	TEST (GeometryTest, MatrixPrinting)

	TEST (GeometryTest, PointPrinting)

	TEST (GeometryTest, Vector3Printing)

	TEST (GeometryTest, Vector4Printing)

	TEST (GeometryTest, ColorPrinting)

	TEST (GeometryTest, ToIColor)

	TEST (GeometryTest, Gradient)

	TEST (GeometryTest, HalfConversions)

	TEST (MatrixTest, Multiply)

	TEST (MatrixTest, Equals)

	TEST (MatrixTest, NotEquals)

	TEST (MatrixTest, HasPerspective2D)

	TEST (MatrixTest, HasPerspective)

	TEST (MatrixTest, HasTranslation)

	TEST (MatrixTest, IsTranslationOnly)

	TEST (MatrixTest, IsTranslationScaleOnly)

	TEST (MatrixTest, IsInvertibleGetDeterminant)

	TEST (MatrixTest, IsFinite)

	TEST (MatrixTest, IsAligned2D)

	TEST (MatrixTest, IsAligned)

	TEST (MatrixTest, TransformHomogenous)

	TEST (MatrixTest, GetMaxBasisXYNegativeScale)

	TEST (MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactor)

	TEST (MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactorNonScaleTranslate)

	TEST (MatrixTest, GetBasisXYScale2D)

	TEST (MatrixTest, TranslateWithPerspective)

	TEST (MatrixTest, MakeScaleTranslate)

	TEST (MatrixTest, To3x3)

	TEST (MatrixTest, MinMaxScales2D)

	TEST (PathSourceTest, RectSourceTest)

	TEST (PathSourceTest, EllipseSourceTest)

	TEST (PathSourceTest, RoundRectSourceTest)

	TEST (PathSourceTest, DiffRoundRectSourceTest)

	TEST (PathSourceTest, DashedLinePathSource)

	TEST (PathSourceTest, EmptyDashedLinePathSource)

	TEST (PathSourceTest, DashedLinePathSourceZeroOffGaps)

	TEST (PathSourceTest, DashedLinePathSourceInvalidOffGaps)

	TEST (PathSourceTest, DashedLinePathSourceInvalidOnRegion)

	TEST (PathSourceTest, PathTransformerRectSourceTest)

	TEST (PathSourceTest, PathTransformerAllSegmentsTest)

	TEST (PointTest, Length)

	TEST (PointTest, Distance)

	TEST (PointTest, PerpendicularLeft)

	TEST (PointTest, PerpendicularRight)

	TEST (PointTest, PointToSegment)

	TEST (PointTest, CrossProductThreePoints)

	TEST (RectTest, RectEmptyDeclaration)

	TEST (RectTest, IRectEmptyDeclaration)

	TEST (RectTest, RectDefaultConstructor)

	TEST (RectTest, IRectDefaultConstructor)

	TEST (RectTest, RectSimpleLTRB)

	TEST (RectTest, IRectSimpleLTRB)

	TEST (RectTest, RectSimpleXYWH)

	TEST (RectTest, IRectSimpleXYWH)

	TEST (RectTest, RectSimpleWH)

	TEST (RectTest, IRectSimpleWH)

	TEST (RectTest, RectFromIRect)

	TEST (RectTest, RectMakeCircleBounds)

	TEST (RectTest, RectMakeCircleBoundsNegativeRadius)

	TEST (RectTest, IRectMakeCircleBounds)

	TEST (RectTest, IRectMakeCircleBoundsNegativeRadius)

	TEST (RectTest, RectMakeEllipseBoundsSize)

	TEST (RectTest, RectMakeEllipseBoundsNegativeSize)

	TEST (RectTest, RectMakeEllipseBoundsPoint)

	TEST (RectTest, RectMakeEllipseBoundsNegativePoint)

	TEST (RectTest, IRectMakeEllipseBoundsSize)

	TEST (RectTest, IRectMakeEllipseBoundsNegativeSize)

	TEST (RectTest, IRectMakeEllipseBoundsPoint)

	TEST (RectTest, IRectMakeEllipseBoundsNegativePoint)

	TEST (RectTest, RectOverflowXYWH)

	TEST (RectTest, IRectOverflowXYWH)

	TEST (RectTest, RectOverflowLTRB)

	TEST (RectTest, IRectOverflowLTRB)

	TEST (RectTest, RectMakeSize)

	TEST (RectTest, RectMakeMaximum)

	TEST (RectTest, IRectMakeMaximum)

	TEST (RectTest, RectFromRect)

	TEST (RectTest, IRectFromIRect)

	TEST (RectTest, RectCopy)

	TEST (RectTest, IRectCopy)

	TEST (RectTest, RectOriginSizeXYWHGetters)

	TEST (RectTest, IRectOriginSizeXYWHGetters)

	TEST (RectTest, RectRoundOutEmpty)

	TEST (RectTest, RectRoundOutSimple)

	TEST (RectTest, RectRoundOutToIRectHuge)

	TEST (RectTest, RectDoesNotIntersectEmpty)

	TEST (RectTest, IRectDoesNotIntersectEmpty)

	TEST (RectTest, EmptyRectDoesNotIntersect)

	TEST (RectTest, EmptyIRectDoesNotIntersect)

	TEST (RectTest, RectScale)

	TEST (RectTest, IRectScale)

	TEST (RectTest, RectArea)

	TEST (RectTest, IRectArea)

	TEST (RectTest, RectGetNormalizingTransform)

	TEST (RectTest, IRectGetNormalizingTransform)

	TEST (RectTest, RectXYWHIsEmpty)

	TEST (RectTest, IRectXYWHIsEmpty)

	TEST (RectTest, MakePointBoundsQuad)

	TEST (RectTest, IsSquare)

	TEST (RectTest, GetCenter)

	TEST (RectTest, RectExpand)

	TEST (RectTest, IRectExpand)

	TEST (RectTest, RectExpandToMinTransformedSizeNullForScaledToZero)

	TEST (RectTest, RectExpandToMinTransformedSizeReturnsUnmodifiedWhenLargeEnough)

	TEST (RectTest, RectExpandToMinTransformedSizeReturnsUnmodifiedWhenLargeEnoughWithFractionalSize)

	TEST (RectTest, RectExpandToMinTransformedSizeRectWithIdentityTransform)

	TEST (RectTest, RectExpandToMinTransformedSizeRectWithScalingTransform)

	TEST (RectTest, ContainsFloatingPoint)

	TEST (RectTest, FloatContainsInteger)

template<typename R >
static constexpr R	flip_lr (R rect)

template<typename R >
static constexpr R	flip_tb (R rect)

template<typename R >
static constexpr R	flip_lrtb (R rect)

static constexpr Rect	swap_nan (const Rect &rect, int index)

static constexpr Point	swap_nan (const Point &point, int index)

	TEST (RectTest, RectUnion)

	TEST (RectTest, OptRectUnion)

	TEST (RectTest, IRectUnion)

	TEST (RectTest, OptIRectUnion)

	TEST (RectTest, RectIntersection)

	TEST (RectTest, OptRectIntersection)

	TEST (RectTest, IRectIntersection)

	TEST (RectTest, OptIRectIntersection)

	TEST (RectTest, RectIntersectsWithRect)

	TEST (RectTest, IRectIntersectsWithRect)

	TEST (RectTest, RectContainsPoint)

	TEST (RectTest, IRectContainsIPoint)

	TEST (RectTest, RectContainsInclusivePoint)

	TEST (RectTest, IRectContainsInclusiveIPoint)

	TEST (RectTest, RectContainsRect)

	TEST (RectTest, IRectContainsIRect)

	TEST (RectTest, RectCutOut)

	TEST (RectTest, IRectCutOut)

	TEST (RectTest, RectGetPoints)

	TEST (RectTest, RectShift)

	TEST (RectTest, RectGetTransformedPoints)

	TEST (RectTest, RectMakePointBounds)

	TEST (RectTest, RectGetPositive)

	TEST (RectTest, RectDirections)

	TEST (RectTest, RectProject)

	TEST (RectTest, RectRoundOut)

	TEST (RectTest, IRectRoundOut)

	TEST (RectTest, RectRound)

	TEST (RectTest, IRectRound)

	TEST (RectTest, TransformAndClipBoundsNoCornersClipped)

	TEST (RectTest, TransformAndClipBoundsOneCornerClipped)

	TEST (RectTest, TransformAndClipBoundsTwoCornersClipped)

	TEST (RectTest, TransformAndClipBoundsThreeCornersClipped)

	TEST (RectTest, TransformAndClipBoundsAllFourCornersClipped)

	TEST (RoundRectTest, EmptyDeclaration)

	TEST (RoundRectTest, DefaultConstructor)

	TEST (RoundRectTest, EmptyRectConstruction)

	TEST (RoundRectTest, RectConstructor)

	TEST (RoundRectTest, InvertedRectConstruction)

	TEST (RoundRectTest, EmptyOvalConstruction)

	TEST (RoundRectTest, OvalConstructor)

	TEST (RoundRectTest, InvertedOvalConstruction)

	TEST (RoundRectTest, RectRadiusConstructor)

	TEST (RoundRectTest, RectXYConstructor)

	TEST (RoundRectTest, RectSizeConstructor)

	TEST (RoundRectTest, RectRadiiConstructor)

	TEST (RoundRectTest, RectRadiiOverflowWidthConstructor)

	TEST (RoundRectTest, RectRadiiOverflowHeightConstructor)

	TEST (RoundRectTest, Shift)

	TEST (RoundRectTest, ExpandScalar)

	TEST (RoundRectTest, ExpandTwoScalars)

	TEST (RoundRectTest, ExpandFourScalars)

	TEST (RoundRectTest, ContractScalar)

	TEST (RoundRectTest, ContractTwoScalars)

	TEST (RoundRectTest, ContractFourScalars)

	TEST (RoundRectTest, ContractAndRequireRadiiAdjustment)

	TEST (RoundRectTest, NoCornerRoundRectContains)

	TEST (RoundRectTest, TinyCornerRoundRectContains)

	TEST (RoundRectTest, UniformCircularRoundRectContains)

	TEST (RoundRectTest, UniformEllipticalRoundRectContains)

	TEST (RoundRectTest, DifferingCornersRoundRectContains)

	TEST (RoudingRadiiTest, RoundingRadiiEmptyDeclaration)

	TEST (RoudingRadiiTest, RoundingRadiiDefaultConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiScalarConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiEmptyScalarConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiSizeConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiEmptySizeConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiNamedSizesConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiPartialNamedSizesConstructor)

	TEST (RoudingRadiiTest, RoundingRadiiMultiply)

	TEST (RoudingRadiiTest, RoundingRadiiEquals)

	TEST (RoudingRadiiTest, RoundingRadiiNotEquals)

	TEST (RoudingRadiiTest, RoundingRadiiCornersSameTolerance)

	TEST (RSTransformTest, Construction)

	TEST (RSTransformTest, CompareToMatrix)

	TEST (SaturatedMath, ExplicitAddOfSignedInts)

	TEST (SaturatedMath, ImplicitAddOfSignedInts)

	TEST (SaturatedMath, ExplicitAddOfFloatingPoint)

	TEST (SaturatedMath, ImplicitAddOfFloatingPoint)

	TEST (SaturatedMath, ExplicitSubOfSignedInts)

	TEST (SaturatedMath, ImplicitSubOfSignedInts)

	TEST (SaturatedMath, ExplicitSubOfFloatingPoint)

	TEST (SaturatedMath, ImplicitSubOfFloatingPoint)

	TEST (SaturatedMath, ExplicitAverageScalarOfSignedInts)

	TEST (SaturatedMath, ImplicitAverageScalarOfSignedInts)

	TEST (SaturatedMath, ExplicitAverageScalarOfFloatingPoint)

	TEST (SaturatedMath, ImplicitAverageScalarOfFloatingPoint)

	TEST (SaturatedMath, CastingFiniteDoubleToFloatStaysFinite)

	TEST (SaturatedMath, CastingInfiniteDoubleToFloatStaysInfinite)

	TEST (SaturatedMath, CastingNaNDoubleToFloatStaysNaN)

	TEST (SaturatedMath, CastingLargeScalarToSignedIntProducesLimit)

	TEST (SaturatedMath, CastingInfiniteScalarToSignedIntProducesLimit)

	TEST (SaturatedMath, CastingNaNScalarToSignedIntProducesZero)

	TEST (SizeTest, SizeIsEmpty)

	TEST (SizeTest, ISizeIsEmpty)

	TEST (SizeTest, IsSquare)

	TEST (SizeTest, MaxDimension)

	TEST (SizeTest, NegationOperator)

	TEST (TrigTest, TrigAngles)

	TEST (TrigTest, MultiplyByScalarRadius)

	TEST (WangsFormulaTest, Cubic)

	TEST (WangsFormulaTest, Quadratic)

	TEST_F (GoldenTests, ConicalGradient)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandGLESRGBA)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandGLESBGRA)

	TEST (BlitCommandGLESTest, BlitCopyTextureToBufferCommandGLESBindsFramebuffer)

	TEST (BlitCommandGLESTest, BlitCopyTextureToBufferCommandGLESRGBA)

	TEST (BlitCommandGLESTest, BlitCopyTextureToBufferCommandGLESBGRA)

	TEST (BlitCommandGLESTest, BlitCopyTextureToBufferCommandGLESUnsupportedPixelFormats)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandAllocatesOnlyTheRequestedBaseMip)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandAllocatesNonZeroMipLevelOnFirstUpload)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandAllocatesEachMipLevelOnFirstWrite)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandDoesNotReallocateOnSubsequentUpload)

	TEST (BlitCommandGLESTest, BlitCopyBufferToTextureCommandUsesCubemapFaceTargetForCubemap)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindUniformData)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindArrayData)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindUniformDataVerticesAndMatrices)

	FML_TEST_CLASS (BufferBindingsGLESTest, BindUniformFailsWithoutFloatType)

	TEST (BufferBindingsGLESTest, ToVertexAttribTypeSupportedFormats)

	TEST (BufferBindingsGLESTest, ToVertexAttribTypeRejectsUnsupportedFormats)

	TEST (BufferBindingsGLESTest, BindUniformData)

	TEST (BufferBindingsGLESTest, BindArrayData)

	TEST (BufferBindingsGLESTest, BindUniformDataVerticesAndMatrices)

	TEST (BufferBindingsGLESTest, BindUniformFailsWithoutFloatType)

	TEST (BufferBindingsGLESTest, BindVertexAttributesSetsInstanceRateDivisor)

	TEST (CommandBufferGLES, SubmitWithoutCurrentContextIsAcceptedAndCompletesAfterReaction)

	TEST (CommandBufferGLES, SubmitWithoutCallbackIsAcceptedWithoutCurrentContext)

	TEST (CommandBufferGLES, DeferredSubmitCallbackErrorsIfReactorIsDestroyed)

	TEST (CommandBufferGLES, DeferredSubmitCompletesAfterPreviouslyQueuedWork)

	TEST (CommandBufferGLES, LaterCurrentSubmitDrainsPreviouslyDeferredWork)

	TEST (CommandBufferGLES, BufferToTextureBlitCanBeSubmittedBeforeContextCurrent)

	TEST (DeviceBufferGLESTest, FlushDuringUploadIsNotDiscarded)

	TEST (DeviceBufferGLESTest, BindUniformData)

	TEST_P (RenderPassGLESWithDiscardFrameBufferExtTest, DiscardFramebufferExt)

	INSTANTIATE_TEST_SUITE_P (FrameBufferObject, RenderPassGLESWithDiscardFrameBufferExtTest, ::testing::ValuesIn(std::vector< DiscardFrameBufferParams >{ {.frame_buffer_id=0,.expected_attachments={GL_COLOR_EXT, GL_DEPTH_EXT, GL_STENCIL_EXT}}, {.frame_buffer_id=1,.expected_attachments={GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT}}}), [](const ::testing::TestParamInfo< DiscardFrameBufferParams > &info) { return(info.param.frame_buffer_id==0) ? "Default" :"NonDefault";})

	TEST_P (RenderPassGLESWithDiscardFrameBufferExtTest, InvalidateFramebuffer)

	TEST (RenderPassGLESTest, ResolvingMultisampleTextureCachesResolveFBO)

	TEST_F (RenderPassGLESCommandTest, ViewportCachedAcrossCommands)

	TEST_F (RenderPassGLESCommandTest, CommandsWithoutViewportGetRenderPassViewport)

	TEST_F (RenderPassGLESCommandTest, ViewportWithNonZeroXOffsetReachesGL)

	TEST_F (RenderPassGLESCommandTest, HardwareInstancedArrayDraw)

	TEST_F (RenderPassGLESCommandTest, HardwareInstancedElementsDraw)

	TEST_F (RenderPassGLESCommandTest, EmulatedInstancedArrayDraw)

	TEST_F (RenderPassGLESCommandTest, EmulatedInstancedElementsDraw)

	TEST_F (RenderPassGLESCommandTest, NonInstancedDrawIssuesSingleDrawArrays)

	TEST_F (RenderPassGLESCommandTest, ZeroInstanceCountIssuesNoDraw)

	TEST (CapabilitiesGLES, CanInitializeWithDefaults)

	TEST (CapabilitiesGLES, SupportsDecalSamplerAddressMode)

	TEST (CapabilitiesGLES, SupportsDecalSamplerAddressModeNotOES)

	TEST (CapabilitiesGLES, SupportsFramebufferFetch)

	TEST (CapabilitiesGLES, SupportsMSAA)

	TEST (CapabilitiesGLES, MaxSamplerAnisotropyUnsupportedByDefault)

	TEST (CapabilitiesGLES, MaxSamplerAnisotropyWithExtension)

	TEST (FormatsGLES, CanFormatFramebufferErrorMessage)

void	doNothing ()

const unsigned char *	mockGetString (GLenum name)

const unsigned char *	mockGetStringi (GLenum name, GLuint index)

void	mockGetIntegerv (GLenum name, int *value)

GLenum	mockGetError ()

void	mockPopDebugGroupKHR ()

void	mockPushDebugGroupKHR (GLenum source, GLuint id, GLsizei length, const GLchar *message)

void	mockGenQueriesEXT (GLsizei n, GLuint *ids)

void	mockBeginQueryEXT (GLenum target, GLuint id)

void	mockEndQueryEXT (GLuint id)

void	mockGetQueryObjectuivEXT (GLuint id, GLenum target, GLuint *result)

void	mockGetQueryObjectui64vEXT (GLuint id, GLenum target, GLuint64 *result)

void	mockDeleteQueriesEXT (GLsizei size, const GLuint *queries)

void	mockDeleteTextures (GLsizei size, const GLuint *queries)

void	mockUniform1fv (GLint location, GLsizei count, const GLfloat *value)

void	mockUniform2fv (GLint location, GLsizei count, const GLfloat *value)

void	mockUniform3fv (GLint location, GLsizei count, const GLfloat *value)

void	mockUniform4fv (GLint location, GLsizei count, const GLfloat *value)

void	mockUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

void	mockUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

void	mockUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

void	mockGenTextures (GLsizei n, GLuint *textures)

void	mockGenBuffers (GLsizei n, GLuint *buffers)

void	mockBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data)

void	mockObjectLabelKHR (GLenum identifier, GLuint name, GLsizei length, const GLchar *label)

void	mockTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)

void	mockTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)

void	mockBindTexture (GLenum target, GLuint texture)

GLboolean	mockIsTexture (GLuint texture)

GLenum	mockCheckFramebufferStatus (GLenum target)

void	mockGenFramebuffers (GLsizei n, GLuint *ids)

void	mockBindFramebuffer (GLenum target, GLuint framebuffer)

void	mockReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *data)

void	mockDiscardFramebufferEXT (GLenum target, GLsizei numAttachments, const GLenum *attachments)

void	mockViewport (GLint x, GLint y, GLsizei width, GLsizei height)

void	mockInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments)

void	mockDrawArrays (GLenum mode, GLint first, GLsizei count)

void	mockDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices)

void	mockDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)

void	mockDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)

void	mockVertexAttribDivisor (GLuint index, GLuint divisor)

	TEST (MockGLES, CanInitialize)

	TEST (MockGLES, CanCallUnmockedFunction)

	TEST (PipelineCompileQueueGLESTest, CreateReturnsNullWithNullTaskRunner)

	TEST (PipelineCompileQueueGLESTest, CreateSucceedsWithValidTaskRunner)

	TEST (PipelineCompileQueueGLESTest, PostJobDoesNothingWithNullClosure)

	TEST (PipelineCompileQueueGLESTest, OnJobAddedProcessesJobsSequentially)

	TEST (PipelineCompileQueueGLESTest, PostJobForDescriptorWithDuplicateRunsEagerly)

	TEST (PipelineCompileQueueGLESTest, IsProcessingResetsAfterAllJobsComplete)

	TEST (PipelineCompileQueueGLESTest, DestroyQueueWithPendingTasks)

	INSTANTIATE_OPENGLES_PLAYGROUND_SUITE (PipelineLibraryGLESTest)

	TEST_P (PipelineLibraryGLESTest, ProgramHandlesAreReused)

	TEST_P (PipelineLibraryGLESTest, ChangingSpecConstantsCausesNewProgramObject)

	TEST_P (PipelineLibraryGLESTest, ClearingPipelineWillAlsoClearProgramHandle)

	TEST (ProcTableGLES, ResolvesCorrectClearDepthProcOnES)

	TEST (ProcTableGLES, ResolvesCorrectClearDepthProcOnDesktopGL)

	TEST (ProcTableGLES, CheckFrameBufferStatusDebugOnly)

	TEST (ProcTableGLES, GLES2VertexAttribDivisor)

	TEST (ProcTableGLES, GLES3VertexAttribDivisor)

	TEST (GLErrorToString, ReturnsCorrectStringForKnownErrors)

	TEST (GLErrorToString, ReturnsUnknownForInvalidError)

	TEST (GLErrorToString, ReturnValueIsValidStringView)

	TEST (GLProc, NameFieldWorksWithStringView)

	TEST (ReactorGLES, CanAttachCleanupCallbacksToHandles)

	TEST (ReactorGLES, DeletesHandlesDuringShutdown)

	TEST (ReactorGLES, UntrackedHandle)

	TEST (ReactorGLES, NameUntrackedHandle)

	TEST (ReactorGLES, PerThreadOperationQueues)

	TEST (ReactorGLES, CanDeferOperations)

	TEST (ReactorGLES, FramebufferDeletedOnOwnerThread)

	TEST (SpecConstant, CanCreateShaderWithSpecializationConstant)

	TEST (SpecConstant, CanCreateShaderWithSpecializationConstantMultipleValues)

	TEST_P (SurfaceGLESTest, CanWrapNonZeroFBO)

	TEST_P (TextureGLESTest, CanSetSyncFence)

	TEST_P (TextureGLESTest, TextureDtorDeletesFence)

	TEST_P (TextureGLESTest, Binds2DTexture)

	TEST_P (TextureGLESTest, Leak)

	TEST_P (TextureGLESTest, CreatingAndBindingEmptyTexturesDoesNotCrash)

	TEST (UniqueHandleGLES, MakeUntracked)

	INSTANTIATE_METAL_PLAYGROUND_SUITE (AllocatorMTLTest)

	TEST_P (AllocatorMTLTest, DebugTraceMemoryStatistics)

	TEST_P (AllocatorMTLTest, ManagedMemory)

	TEST_P (ContextMTLTest, FlushTask)

	TEST_P (ContextMTLTest, FlushTaskWithGPULoss)

	TEST_P (SwapchainTransientsMTLTest, CanAllocateSwapchainTextures)

	TEST (AllocatorVKTest, ToVKImageUsageFlags)

	TEST (AllocatorVKTest, MemoryTypeSelectionSingleHeap)

	TEST (AllocatorVKTest, MemoryTypeSelectionTwoHeap)

	TEST (AllocatorVKTest, ImageResourceKeepsVulkanDeviceAlive)

	TEST (AllocatorVKTest, RetriesUncompressedOnCompressionExhausted)

	TEST (CommandEncoderVKTest, DeleteEncoderAfterThreadDies)

	TEST (CommandEncoderVKTest, CleanupAfterSubmit)

	TEST (CommandPoolRecyclerVKTest, GetsACommandPoolPerThread)

	TEST (CommandPoolRecyclerVKTest, GetsTheSameCommandPoolOnSameThread)

	TEST (CommandPoolRecyclerVKTest, ReclaimMakesCommandPoolAvailable)

	TEST (CommandPoolRecyclerVKTest, CommandBuffersAreRecycled)

	TEST (CommandPoolRecyclerVKTest, ExtraCommandBufferAllocationsTriggerTrim)

	TEST (CommandPoolRecyclerVKTest, RecyclerGlobalPoolMapSize)

	TEST (CommandPoolVKTest, DestroysCleanlyIfDeviceIsDestroyed)

	TEST (CommandQueueVKTest, QueueSubmit)

	TEST (CommandQueueVKTest, SubmitAfterFenceWaiterTerminated)

	TEST (ContextVKTest, CommonHardwareConcurrencyConfigurations)

	TEST (ContextVKTest, DeletesCommandPools)

	TEST (ContextVKTest, DeletesCommandPoolsOnAllThreads)

	TEST (ContextVKTest, ThreadLocalCleanupDeletesCommandPool)

	TEST (ContextVKTest, DeletePipelineAfterContext)

	TEST (ContextVKTest, DeleteShaderFunctionAfterContext)

	TEST (ContextVKTest, DeletePipelineLibraryAfterContext)

	TEST (ContextVKTest, CanCreateContextInAbsenceOfValidationLayers)

	TEST (ContextVKTest, CanCreateContextWithValidationLayers)

	TEST (CapabilitiesVKTest, ContextInitializesWithNoStencilFormat)

	TEST (CapabilitiesVKTest, ContextFailsInitializationForNoCombinedDepthStencilFormat)

	TEST (ContextVKTest, WarmUpFunctionCreatesRenderPass)

	TEST (ContextVKTest, FatalMissingValidations)

	TEST (ContextVKTest, HasDefaultColorFormat)

	TEST (ContextVKTest, EmbedderOverridesUsesInstanceExtensions)

	TEST (ContextVKTest, EmbedderOverrides)

	TEST (ContextVKTest, BatchSubmitCommandBuffersOnArm)

	TEST (ContextVKTest, BatchSubmitCommandBuffersOnNonArm)

	TEST (ContextVKTest, AHBSwapchainCapabilitiesCanBeMissing)

	TEST (ContextVKTest, HashIsUniqueAcrossThreads)

	TEST (DescriptorPoolRecyclerVKTest, GetDescriptorPoolRecyclerCreatesNewPools)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimMakesDescriptorPoolAvailable)

	TEST (DescriptorPoolRecyclerVKTest, ReclaimDropsDescriptorPoolIfSizeIsExceeded)

	TEST (DescriptorPoolRecyclerVKTest, MultipleCommandBuffersShareDescriptorPool)

	TEST (DescriptorPoolRecyclerVKTest, DescriptorsAreRecycled)

	INSTANTIATE_VULKAN_PLAYGROUND_SUITE (DriverInfoVKTest)

	TEST_P (DriverInfoVKTest, CanQueryDriverInfo)

	TEST_P (DriverInfoVKTest, CanDumpToLog)

	TEST (DriverInfoVKTest, CanIdentifyBadMaleoonDriver)

bool	IsBadVersionTest (std::string_view driver_name, bool qc=true)

bool	CanBatchSubmitTest (std::string_view driver_name, bool qc=true)

	TEST (DriverInfoVKTest, CanBatchSubmitCommandBuffers)

bool	CanUsePrimitiveRestartSubmitTest (std::string_view driver_name, bool qc=true)

	TEST (DriverInfoVKTest, CanUsePrimitiveRestart)

bool	CanUseMipgeneration (std::string_view driver_name, bool qc=true)

	TEST (DriverInfoVKTest, CanGenerateMipMaps)

	TEST (DriverInfoVKTest, DriverParsingMali)

	TEST (DriverInfoVKTest, DriverParsingAdreno)

	TEST (DriverInfoVKTest, DisabledDevices)

	TEST (DriverInfoVKTest, EnabledDevicesMali)

	TEST (DriverInfoVKTest, EnabledDevicesAdreno)

bool	CanUseFramebufferFetch (std::string_view driver_name, bool qc=true)

	TEST (DriverInfoVKTest, CanUseFramebufferFetch)

	TEST (DriverInfoVKTest, DisableOldXclipseDriver)

	TEST (DriverInfoVKTest, OldPowerVRDisabled)

	TEST (DriverInfoVKTest, NewPowerVREnabled)

	TEST (DriverInfoVKTest, PowerVRBSeries)

	TEST (FenceWaiterVKTest, IgnoresNullFence)

	TEST (FenceWaiterVKTest, IgnoresNullCallback)

	TEST (FenceWaiterVKTest, ReturnsSubmitError)

	TEST (FenceWaiterVKTest, ExecutesFenceCallback)

	TEST (FenceWaiterVKTest, ExecutesFenceCallbackX2)

	TEST (FenceWaiterVKTest, ExecutesNewFenceThenOldFence)

	TEST (FenceWaiterVKTest, AddFenceDoesNothingIfTerminating)

	TEST (FenceWaiterVKTest, InProgressFencesStillWaitIfTerminated)

	TEST (FormatsVKTest, DescriptorMapping)

	TEST (PipelineCacheDataVKTest, CanTestHeaderCompatibility)

	TEST (PipelineCacheDataVKTest, CanCreateFromDeviceProperties)

	TEST (PipelineCacheDataVKTest, WritesIncompleteCacheData)

	TEST_P (PipelineCacheDataVKPlaygroundTest, CanPersistAndRetrievePipelineCache)

	TEST_P (PipelineCacheDataVKPlaygroundTest, IntegrityChecksArePerformedOnPersistedData)

	TEST (RenderPassBuilder, CreatesRenderPassWithNoDepthStencil)

	TEST (RenderPassBuilder, RenderPassWithLoadOpUsesCurrentLayout)

	TEST (RenderPassBuilder, CreatesRenderPassWithCombinedDepthStencil)

	TEST (RenderPassBuilder, CreatesRenderPassWithOnlyStencil)

	TEST (RenderPassBuilder, CreatesMSAAResolveWithCorrectStore)

	TEST_P (RendererTest, CachesRenderPassAndFramebuffer)

	TEST_P (RendererTest, CachesRenderPassAndFramebufferNonMSAA)

	TEST_P (RendererTest, CachesRenderPassAndFramebufferMixed)

	TEST (RenderPassVK, DoesNotRedundantlySetStencil)

	TEST (RenderPassVK, SetViewportPropagatesAllUserSuppliedFields)

	TEST (ResourceManagerVKTest, CreatesANewInstance)

	TEST (ResourceManagerVKTest, ReclaimMovesAResourceAndDestroysIt)

	TEST (ResourceManagerVKTest, TerminatesWhenOutOfScope)

	TEST (ResourceManagerVKTest, IsThreadSafe)

	TEST (SurfaceContextVK, TearsDownSwapchain)

std::shared_ptr< std::vector< std::string > >	GetMockVulkanFunctions (VkDevice device)

void	SetSwapchainImageSize (ISize size)
	Override the image size returned by all swapchain images.

std::vector< VkImageMemoryBarrier > &	GetImageMemoryBarriers (VkCommandBuffer buffer)

const std::vector< VkViewport > &	GetRecordedViewports (VkCommandBuffer buffer)
	Returns the viewports passed to `vkCmdSetViewport` calls on the given command buffer, in call order.

	TEST (MockVulkanContextTest, IsThreadSafe)

	TEST (MockVulkanContextTest, DefaultFenceAlwaysReportsSuccess)

	TEST (MockVulkanContextTest, MockedFenceReportsStatus)

	TEST (PipelineCompileQueueVulkanTest, CreateSucceedsWithValidTaskRunner)

	TEST (PipelineCompileQueueVulkanTest, PostJobDoesNothingWithNullClosure)

	TEST (PipelineCompileQueueVulkanTest, OnJobAddedProcessesJobsInParallel)

	TEST (PipelineCompileQueueVulkanTest, PostJobForDescriptorWithDuplicateRunsEagerly)

	TEST (PipelineCompileQueueVulkanTest, MultipleJobsCompleteSuccessfully)

	TEST (SamplerLibraryVK, WorkaroundsCanDisableReadingFromMipLevels)

	TEST (SamplerLibraryVK, MaxAnisotropyIsClampedToTheDeviceLimit)

	TEST (SamplerLibraryVK, MaxAnisotropyIsDisabledWhenUnsupported)

vk::UniqueSurfaceKHR	CreateSurface (const ContextVK &context)

	TEST (SwapchainTest, CanCreateSwapchain)

	TEST (SwapchainTest, RecreateSwapchainWhenSizeChanges)

	TEST (SwapchainTest, CachesRenderPassOnSwapchainImage)

	TEST (SwapchainTest, NoFenceWaitAfterAcquireNextImageFailure)

	TEST_P (BlitPassTest, BlitAcrossDifferentPixelFormatsFails)

	TEST_P (BlitPassTest, BlitAcrossDifferentSampleCountsFails)

	TEST_P (BlitPassTest, BlitPassesForMatchingFormats)

	TEST_P (BlitPassTest, ChecksInvalidSliceParameters)

	TEST_P (BlitPassTest, CanBlitSmallRegionToUninitializedTexture)

	TEST_P (BlitPassTest, ChecksInvalidMipLevelParameter)

	TEST_P (BlitPassTest, CanBlitToHigherTextureMipLevels)

	TEST_P (BlitPassTest, CanResizeTextures)

	TEST_P (BlitPassTest, CanResizeTexturesPlayground)

	CAPABILITY_TEST (SupportsOffscreenMSAA, false)

	CAPABILITY_TEST (SupportsSSBO, false)

	CAPABILITY_TEST (SupportsTextureToTextureBlits, false)

	CAPABILITY_TEST (SupportsFramebufferFetch, false)

	CAPABILITY_TEST (SupportsCompute, false)

	CAPABILITY_TEST (SupportsComputeSubgroups, false)

	CAPABILITY_TEST (SupportsReadFromResolve, false)

	CAPABILITY_TEST (SupportsDecalSamplerAddressMode, false)

	CAPABILITY_TEST (SupportsDeviceTransientTextures, false)

	CAPABILITY_TEST (SupportsTriangleFan, false)

	CAPABILITY_TEST (SupportsExtendedRangeFormats, false)

	CAPABILITY_TEST (NeedsPartitionedHostBuffer, false)

	TEST (CapabilitiesTest, DefaultColorFormat)

	TEST (CapabilitiesTest, DefaultStencilFormat)

	TEST (CapabilitiesTest, DefaultDepthStencilFormat)

	TEST (CapabilitiesTest, DefaultGlyphAtlasFormat)

	TEST (CapabilitiesTest, MaxRenderPassAttachmentSize)

	TEST (CapabilitiesTest, SupportsTextureCompression)

	TEST (CapabilitiesTest, MinUniformAlignment)

	TEST (CapabilitiesTest, MaxSamplerAnisotropy)

	INSTANTIATE_COMPUTE_SUITE (ComputeTest)

	TEST_P (ComputeTest, CapabilitiesReportSupport)

	TEST_P (ComputeTest, CanCreateComputePass)

	TEST_P (ComputeTest, CanComputePrefixSum)

	TEST_P (ComputeTest, 1DThreadgroupSizingIsCorrect)

	TEST_P (ComputeTest, 3DWorkgroupDispatchIsCorrect)

	TEST_P (ComputeTest, CanComputePrefixSumLargeInteractive)

	TEST_P (ComputeTest, MultiStageInputAndOutput)

	TEST_P (ComputeTest, CanCompute1DimensionalData)

	TEST_P (ComputeTest, ReturnsEarlyWhenAnyGridDimensionIsZero)

	TEST (PipelineCompileQueueTest, AddJobReturnsTrueForNewDescriptor)

	TEST (PipelineCompileQueueTest, AddJobReturnsFalseForDuplicateDescriptor)

	TEST (PipelineCompileQueueTest, HasPendingJobsReturnsCorrectState)

	TEST (PipelineCompileQueueTest, PerformJobEagerlyExecutesJob)

	TEST (PipelineCompileQueueTest, FinishAllJobsDrainsQueue)

	TEST (PipelineDescriptorTest, PrimitiveTypeHashEquality)

	TEST (MockPipelineLibrary, LogAndGetPipelineUsageSinglePipeline)

	TEST (MockPipelineLibrary, LogAndGetPipelineUsageMultiplePipelines)

	TEST (PoolTest, Simple)

	TEST (PoolTest, Overload)

static void	InstantiateTestShaderLibrary (Context::BackendType backend_type)

static bool	DrainMicrotasks ()

	INSTANTIATE_PLAYGROUND_SUITE (RendererDartTest)

	TEST_P (RendererDartTest, CanRunDartInPlaygroundFrame)

	TEST_P (RendererDartTest, CanInstantiateFlutterGPUContext)

	TEST_P (RendererDartTest, CanCreateShaderLibrary)

	TEST_P (RendererDartTest, CanReflectUniformStructs)

	TEST_P (RendererDartTest, CanCreateRenderPassAndSubmit)

	INSTANTIATE_PLAYGROUND_SUITE (RendererGoldenTest)

	TEST_P (RendererGoldenTest, BabysFirstTriangle)

	TEST_P (RendererGoldenTest, CanRenderInstancedWithVertexAttributes)

static void	DrawCompressedTextureGolden (RendererGoldenTest &test, PixelFormat format, const std::vector< uint8_t > &block_data, ISize size)

	TEST_P (RendererGoldenTest, CanRenderBC1CompressedTexture)

	TEST_P (RendererGoldenTest, CanRenderETC2CompressedTexture)

	TEST_P (RendererGoldenTest, CanRenderASTCCompressedTexture)

static void	DrawManuallyMippedTextureGolden (RendererGoldenTest &test, float lod)

	TEST_P (RendererGoldenTest, CanSampleManuallyMippedTexture)

	TEST_P (RendererGoldenTest, CanSampleManuallyMippedTextureLod1)

	TEST_P (RendererTest, CanCreateBoxPrimitive)

	TEST_P (RendererTest, CanRenderPerspectiveCube)

	TEST_P (RendererTest, CanRenderMultiplePrimitives)

	TEST_P (RendererTest, CanRenderToTexture)

	TEST_P (RendererTest, CanRenderInstanced)

	TEST_P (RendererTest, CanBlitTextureToTexture)

	TEST_P (RendererTest, CanBlitTextureToBuffer)

	TEST_P (RendererTest, CanGenerateMipmaps)

	TEST_P (RendererTest, TheImpeller)

	TEST_P (RendererTest, Planet)

	TEST_P (RendererTest, ArrayUniforms)

	TEST_P (RendererTest, InactiveUniforms)

	TEST_P (RendererTest, DefaultIndexSize)

	TEST_P (RendererTest, DefaultIndexBehavior)

	TEST_P (RendererTest, VertexBufferBuilder)

static const CompareFunctionUIData &	CompareFunctionUI ()

	TEST_P (RendererTest, StencilMask)

	TEST_P (RendererTest, CanLookupRenderTargetProperties)

	TEST_P (RendererTest, RenderTargetCreateOffscreenMSAASetsDefaultDepthStencilFormat)

template<class VertexShader , class FragmentShader >
std::shared_ptr< Pipeline< PipelineDescriptor > >	CreateDefaultPipeline (RendererTest *test, const std::shared_ptr< Context > &context)

	TEST_P (RendererTest, CanSepiaToneWithSubpasses)

	TEST_P (RendererTest, CanSepiaToneThenSwizzleWithSubpasses)

	TEST_P (RendererTest, BindingNullTexturesDoesNotCrash)

	TEST_P (RendererTest, CanRenderToTextureSlice)

	TEST_P (RendererTest, CanRenderToMipLevel)

	TEST_P (RendererTest, AttachmentRejectsOutOfRangeSubresource)

	INSTANTIATE_PLAYGROUND_SUITE (RuntimeStageTest)

	TEST_P (RuntimeStageTest, CanReadValidBlob)

	TEST_P (RuntimeStageTest, RejectInvalidFormatVersion)

	TEST_P (RuntimeStageTest, CanRejectInvalidBlob)

	TEST_P (RuntimeStageTest, RejectsCorruptBufferWithValidIdentifier)

	TEST_P (RuntimeStageTest, CanReadUniforms)

	TEST_P (RuntimeStageTest, CanReadUniformsSamplerBeforeUBO)

	TEST_P (RuntimeStageTest, CanReadUniformsSamplerAfterUBO)

	TEST_P (RuntimeStageTest, CanRegisterStage)

	TEST_P (RuntimeStageTest, CanCreatePipelineFromRuntimeStage)

	TEST_P (RuntimeStageTest, ContainsExpectedShaderTypes)

	TEST_P (RuntimeStageTest, ContainsExpectedShaderTypesNoSksl)

	TEST (ShaderKeyTest, MakeUserScopedNameProducesScopedString)

	TEST (ShaderKeyTest, MakeUserScopedNameContainsColonSeparator)

	TEST (ShaderKeyTest, MakeUserScopedNameDifferentLibraryIdsDoNotCollide)

	TEST (ShaderKeyTest, MakeUserScopedNameDifferentScopesDoNotCollide)

	TEST (ShaderKeyTest, MakeUserScopedNameHandlesLongInputs)

	TEST_P (RuntimeStageTest, RuntimeStageHasUniqueLibraryIdByDefault)

	TEST_P (RuntimeStageTest, RuntimeStageLibraryIdCanBeOverridden)

static std::shared_ptr< fml::Mapping >	CreateMappingFromString (std::string p_string)

const std::string	CreateStringFromMapping (const fml::Mapping &mapping)

	TEST (ShaderArchiveTest, CanReadAndWriteBlobs)

	TEST (ShaderArchiveTest, ReturnsErrorOnInvalidVersion)

	TEST (ShaderArchiveTest, RejectsCorruptBufferWithValidIdentifier)

	TEST (PathTessellatorTest, EmptyPath)

	TEST (PathTessellatorTest, EmptyPathMultipleMoveTo)

	TEST (PathTessellatorTest, SimpleClosedPath)

	TEST (PathTessellatorTest, SimpleUnclosedPath)

	TEST (PathTessellatorTest, SimplePathTrailingMoveTo)

	TEST (PathTessellatorTest, DegenerateSegmentsPath)

	TEST (PathTessellatorTest, QuadToLineToOptimization)

	TEST (PathTessellatorTest, ConicToLineToOptimization)

	TEST (PathTessellatorTest, ConicToQuadToOptimization)

	TEST (PathTessellatorTest, SimplePathMultipleMoveTo)

	TEST (PathTessellatorTest, ComplexPath)

	TEST (PathTessellatorTest, ComplexPathTrailingMoveTo)

	TEST (PathTessellatorTest, LinearQuadToPointCount)

	TEST (PathTessellatorTest, LinearConicToPointCount)

	TEST (PathTessellatorTest, LinearCubicToPointCount)

template<typename T >
std::vector< T >	CopyBufferView (const BufferView &vertex_buffer)

	TEST_P (TessellatorPlaygroundTest, TessellateConvex16or32Bit)

	TEST (TessellatorTest, TessellatorBuilderReturnsCorrectResultStatus)

	TEST (TessellatorTest, TessellateConvex)

	TEST (TessellatorTest, TessellateConvexUnclosedPath)

	TEST (TessellatorTest, CircleVertexCounts)

	TEST (TessellatorTest, FilledCircleTessellationVertices)

	TEST (TessellatorTest, StrokedCircleTessellationVertices)

	TEST (TessellatorTest, FilledArcStripTessellationVertices)

	TEST (TessellatorTest, RoundCapLineTessellationVertices)

	TEST (TessellatorTest, FilledEllipseTessellationVertices)

	TEST (TessellatorTest, FilledRoundRectTessellationVertices)

	TEST (TessellatorTest, EarlyReturnEmptyConvexShape)

void	ImpellerUnittestSetup ()

static std::shared_ptr< GlyphAtlas >	CreateGlyphAtlas (Context &context, const TypographerContext *typographer_context, HostBuffer &data_host_buffer, GlyphAtlas::Type type, const Matrix &transform, const std::shared_ptr< GlyphAtlasContext > &atlas_context, const std::shared_ptr< TextFrame > &frame)

static std::shared_ptr< GlyphAtlas >	CreateGlyphAtlas (Context &context, const TypographerContext *typographer_context, HostBuffer &data_host_buffer, GlyphAtlas::Type type, const Matrix &transform, const std::shared_ptr< GlyphAtlasContext > &atlas_context, const std::vector< std::shared_ptr< TextFrame > > &frames, const std::vector< GlyphProperties > &properties)

	TEST_P (TypographerTest, CanConvertTextBlob)

	TEST_P (TypographerTest, CanCreateRenderContext)

	TEST_P (TypographerTest, CanCreateGlyphAtlas)

	TEST_P (TypographerTest, LazyAtlasTracksColor)

	TEST_P (TypographerTest, GlyphAtlasWithOddUniqueGlyphSize)

	TEST_P (TypographerTest, GlyphAtlasIsRecycledIfUnchanged)

	TEST_P (TypographerTest, GlyphAtlasWithLotsOfdUniqueGlyphSize)

	TEST_P (TypographerTest, GlyphAtlasTextureIsRecycledIfUnchanged)

	TEST_P (TypographerTest, GlyphColorIsPartOfCacheKey)

	TEST_P (TypographerTest, GlyphColorIsIgnoredForNonEmojiFonts)

	TEST_P (TypographerTest, GlyphIsLightIsPartOfCacheKey)

	TEST_P (TypographerTest, RectanglePackerAddsNonoverlapingRectangles)

	TEST (TypographerTest, RectanglePackerFillsRows)

	TEST_P (TypographerTest, GlyphAtlasTextureWillGrowTilMaxTextureSize)

	TEST_P (TypographerTest, InvalidAtlasForcesRepopulation)

	TEST_P (TypographerTest, ColorBitmapAtlasSkiaBitmapIsRGBA8888)

	TEST_P (TypographerTest, AlphaBitmapAtlasSkiaBitmapIsA8)

	TEST_P (TypographerTest, AlphaBitmapAtlasWithLightGlyphsSkiaBitmapIsRGBA8888)

Variables
static const std::map< std::string, MaskBlurTestConfig >	kPaintVariations

static constexpr std::string_view	kFontFixture

static constexpr const size_t	kMagicFailingAllocation = 1024000 * 2

std::vector< Point >	golden_cubic_and_quad_points

static std::mutex	g_test_lock

static std::weak_ptr< MockGLES >	g_mock_gles

static std::vector< const char * >	g_extensions

static const char *	g_version

static std::string	g_extensions_string

auto const	kMockVendor = "MockGLES"

const auto	kMockShadingLanguageVersion = "GLSL ES 1.0"

auto const	kExtensions

const ProcTableGLES::Resolver	kMockResolverGLES

const ProcTableGLES::Resolver	kMockResolverGLESWithoutInstancing

Typedef Documentation

◆ AiksTest

using impeller::testing::AiksTest = typedef AiksPlaygroundWithGoldens

Definition at line 17 of file aiks_unittests.h.

◆ AllocatorMTLTest

using impeller::testing::AllocatorMTLTest = typedef PlaygroundTest

Definition at line 25 of file allocator_mtl_unittests.mm.

◆ BlitPassTest

using impeller::testing::BlitPassTest = typedef AiksTest

Definition at line 27 of file blit_pass_unittests.cc.

◆ ComputeTest

using impeller::testing::ComputeTest = typedef ComputePlaygroundTest

Definition at line 42 of file compute_unittests.cc.

◆ ContextMTLTest

using impeller::testing::ContextMTLTest = typedef PlaygroundTest

Definition at line 25 of file context_mtl_unittests.mm.

◆ DeviceBufferTest

using impeller::testing::DeviceBufferTest = typedef Playground

Definition at line 12 of file device_buffer_unittests.cc.

◆ DisplayListTest

using impeller::testing::DisplayListTest = typedef DlPlayground

Definition at line 45 of file dl_unittests.cc.

◆ DriverInfoVKTest

using impeller::testing::DriverInfoVKTest = typedef PlaygroundTest

Definition at line 14 of file driver_info_vk_unittests.cc.

◆ EntityPassTargetTest

using impeller::testing::EntityPassTargetTest = typedef EntityPlayground

Definition at line 16 of file entity_pass_target_unittests.cc.

◆ EntityTest

typedef EntityPlayground impeller::testing::EntityTest

Definition at line 19 of file tiled_texture_contents_unittests.cc.

◆ HostBufferTest

using impeller::testing::HostBufferTest = typedef EntityPlayground

Definition at line 24 of file host_buffer_unittests.cc.

◆ PipelineCacheDataVKPlaygroundTest

using impeller::testing::PipelineCacheDataVKPlaygroundTest = typedef PlaygroundTest

Definition at line 114 of file pipeline_cache_data_vk_unittests.cc.

◆ PipelineLibraryGLESTest

using impeller::testing::PipelineLibraryGLESTest = typedef PlaygroundTest

Definition at line 15 of file pipeline_library_gles_unittests.cc.

◆ RendererGoldenTest

using impeller::testing::RendererGoldenTest = typedef PlaygroundTestWithGoldens

Definition at line 48 of file renderer_golden_unittests.cc.

◆ RendererTest

typedef PlaygroundTest impeller::testing::RendererTest

Definition at line 16 of file render_pass_cache_unittests.cc.

◆ RenderTargetCacheTest

using impeller::testing::RenderTargetCacheTest = typedef EntityPlayground

Definition at line 20 of file render_target_cache_unittests.cc.

◆ RuntimeStageTest

using impeller::testing::RuntimeStageTest = typedef RuntimeStagePlayground

Definition at line 31 of file runtime_stage_unittests.cc.

◆ SaveLayerUtilsTest

using impeller::testing::SaveLayerUtilsTest = typedef ::testing::Test

Definition at line 15 of file save_layer_utils_unittests.cc.

◆ SurfaceGLESTest

using impeller::testing::SurfaceGLESTest = typedef PlaygroundTest

Definition at line 13 of file surface_gles_unittests.cc.

◆ SwapchainTransientsMTLTest

using impeller::testing::SwapchainTransientsMTLTest = typedef PlaygroundTest

Definition at line 24 of file swapchain_transients_mtl_unittests.mm.

◆ TessellatorPlaygroundTest

using impeller::testing::TessellatorPlaygroundTest = typedef PlaygroundTest

Definition at line 15 of file tessellator_playground_unittests.cc.

◆ TextContentsTest

using impeller::testing::TextContentsTest = typedef PlaygroundTest

Definition at line 20 of file text_contents_unittests.cc.

◆ TextureGLESTest

using impeller::testing::TextureGLESTest = typedef PlaygroundTest

Definition at line 19 of file texture_gles_unittests.cc.

◆ TypographerTest

using impeller::testing::TypographerTest = typedef PlaygroundTest

Definition at line 29 of file typographer_unittests.cc.

Function Documentation

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [1/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Conical )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [2/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Linear )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [3/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Radial )

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [4/4]

impeller::testing::APPLY_COLOR_FILTER_GRADIENT_TEST ( Sweep )

◆ BlendModeTest()

static sk_sp< DisplayList > impeller::testing::BlendModeTest	(	AiksTest *	test,
		Vector2	content_scale,
		BlendMode	blend_mode,
		const sk_sp< DlImageImpeller > &	src_image,
		const sk_sp< DlImageImpeller > &	dst_image,
		Scalar	src_alpha
	)

static

Save layer blending (top squares).

CPU blend modes (bottom squares).

Image blending (bottom images).

Compare these results with the images in the Flutter blend mode documentation: https://api.flutter.dev/flutter/dart-ui/BlendMode.html

Definition at line 509 of file aiks_dl_blend_unittests.cc.

                                                          {
  if (test->IsPlaygroundEnabled()) {
    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
    ImGui::SliderFloat("Source alpha", &src_alpha, 0, 1);
    ImGui::End();
  }
 
  Color destination_color = Color::CornflowerBlue().WithAlpha(0.75);
  auto source_colors = std::vector<Color>({Color::White().WithAlpha(0.75),
                                           Color::LimeGreen().WithAlpha(0.75),
                                           Color::Black().WithAlpha(0.75)});
 
  DisplayListBuilder builder;
  {
    DlPaint paint;
    paint.setColor(DlColor::kBlack());
    builder.DrawPaint(paint);
  }
  // TODO(bdero): Why does this cause the left image to double scale on high DPI
  //              displays.
  // builder.Scale(content_scale);
 
  //----------------------------------------------------------------------------
  /// 1. Save layer blending (top squares).
  ///
 
  builder.Save();
  for (const auto& color : source_colors) {
    builder.Save();
    {
      builder.ClipRect(DlRect::MakeXYWH(25, 25, 100, 100));
      // Perform the blend in a SaveLayer so that the initial backdrop color is
      // fully transparent black. SourceOver blend the result onto the parent
      // pass.
      builder.SaveLayer(std::nullopt);
      {
        DlPaint draw_paint;
        draw_paint.setColor(
            DlColor::RGBA(destination_color.red, destination_color.green,
                          destination_color.blue, destination_color.alpha));
        builder.DrawPaint(draw_paint);
 
        // Draw the source color in an offscreen pass and blend it to the parent
        // pass.
        DlPaint save_paint;
        save_paint.setBlendMode(static_cast<DlBlendMode>(blend_mode));
        builder.SaveLayer(std::nullopt, &save_paint);
        {  //
          DlPaint paint;
          paint.setColor(
              DlColor::RGBA(color.red, color.green, color.blue, color.alpha));
          builder.DrawRect(DlRect::MakeXYWH(25, 25, 100, 100), paint);
        }
        builder.Restore();
      }
      builder.Restore();
    }
    builder.Restore();
    builder.Translate(100, 0);
  }
  builder.RestoreToCount(0);
 
  //----------------------------------------------------------------------------
  /// 2. CPU blend modes (bottom squares).
  ///
 
  builder.Save();
  builder.Translate(0, 100);
  // Perform the blend in a SaveLayer so that the initial backdrop color is
  // fully transparent black. SourceOver blend the result onto the parent pass.
  builder.SaveLayer(std::nullopt);
  for (const auto& color : source_colors) {
    // Simply write the CPU blended color to the pass.
    DlPaint paint;
    auto dest = destination_color.Blend(color, blend_mode);
    paint.setColor(DlColor::RGBA(dest.red, dest.green, dest.blue, dest.alpha));
    paint.setBlendMode(DlBlendMode::kSrcOver);
    builder.DrawRect(DlRect::MakeXYWH(25, 25, 100, 100), paint);
    builder.Translate(100, 0);
  }
  builder.Restore();
  builder.Restore();
 
  //----------------------------------------------------------------------------
  /// 3. Image blending (bottom images).
  ///
  /// Compare these results with the images in the Flutter blend mode
  /// documentation: https://api.flutter.dev/flutter/dart-ui/BlendMode.html
  ///
 
  builder.Translate(0, 250);
 
  // Draw grid behind the images.
  {
    DlPaint paint;
    paint.setColor(DlColor::RGBA(41 / 255.0, 41 / 255.0, 41 / 255.0, 1));
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 800, 400), paint);
  }
 
  DlPaint square_paint;
  square_paint.setColor(DlColor::RGBA(15 / 255.0, 15 / 255.0, 15 / 255.0, 1));
  for (int y = 0; y < 400 / 8; y++) {
    for (int x = 0; x < 800 / 16; x++) {
      builder.DrawRect(DlRect::MakeXYWH(x * 16 + (y % 2) * 8, y * 8, 8, 8),
                       square_paint);
    }
  }
 
  // Uploaded image source (left image).
  DlPaint paint;
  paint.setBlendMode(DlBlendMode::kSrcOver);
  builder.Save();
  builder.SaveLayer(std::nullopt, &paint);
  {
    builder.DrawImage(dst_image, DlPoint(0, 0), DlImageSampling::kMipmapLinear,
                      &paint);
 
    paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
    paint.setBlendMode(static_cast<DlBlendMode>(blend_mode));
    builder.DrawImage(src_image, DlPoint(0, 0), DlImageSampling::kMipmapLinear,
                      &paint);
  }
  builder.Restore();
  builder.Restore();
 
  // Rendered image source (right image).
  builder.Save();
 
  DlPaint save_paint;
  builder.SaveLayer(std::nullopt, &save_paint);
  {
    builder.DrawImage(dst_image, DlPoint(400, 0),
                      DlImageSampling::kMipmapLinear, nullptr);
 
    DlPaint save_paint;
    save_paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
    save_paint.setBlendMode(static_cast<DlBlendMode>(blend_mode));
    builder.SaveLayer(std::nullopt, &save_paint);
    {
      builder.DrawImage(src_image, DlPoint(400, 0),
                        DlImageSampling::kMipmapLinear, nullptr);
    }
    builder.Restore();
  }
  builder.Restore();
  builder.Restore();
 
  return builder.Build();
}

References impeller::Color::alpha, impeller::Color::Black(), impeller::Color::Blend(), impeller::Color::blue, impeller::Color::CornflowerBlue(), impeller::Color::green, impeller::Playground::IsPlaygroundEnabled(), flutter::DlColor::kBlack(), flutter::DlColor::kWhite(), impeller::Color::LimeGreen(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::red, flutter::DlColor::RGBA(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), impeller::Color::White(), impeller::Color::WithAlpha(), flutter::DlColor::withAlpha(), x, and y.

◆ CanBatchSubmitTest()

bool impeller::testing::CanBatchSubmitTest	(	std::string_view	driver_name,
		bool	qc = `true`
	)

Definition at line 71 of file driver_info_vk_unittests.cc.

                                                                    {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [&driver_name, qc](VkPhysicalDevice device,
                                 VkPhysicalDeviceProperties* prop) {
                if (qc) {
                  prop->vendorID = 0x168C;  // Qualcomm
                } else {
                  prop->vendorID = 0x13B5;  // ARM
                }
                driver_name.copy(prop->deviceName, driver_name.size());
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
  return !GetWorkaroundsFromDriverInfo(*context->GetDriverInfo())
              .batch_submit_command_buffer_timeout;
}

References impeller::WorkaroundsVK::batch_submit_command_buffer_timeout, context, device, impeller::GetWorkaroundsFromDriverInfo(), and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

Referenced by TEST().

◆ CanRenderConicalGradientWithDithering()

static void impeller::testing::CanRenderConicalGradientWithDithering ( AiksTest * aiks_test )

static

Definition at line 175 of file aiks_dl_gradient_unittests.cc.

                                                                       {
  DisplayListBuilder builder;
  builder.Scale(aiks_test->GetContentScale().x, aiks_test->GetContentScale().y);
  DlPaint paint;
  builder.Translate(100.0, 100.0);
 
  // #FFF -> #000
  std::vector<DlColor> colors = {DlColor(Color{1.0, 1.0, 1.0, 1.0}.ToARGB()),
                                 DlColor(Color{0.0, 0.0, 0.0, 1.0}.ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeConical({0, 1}, 0, {100, 100}, 100, 2,
                                                  colors.data(), stops.data(),
                                                  DlTileMode::kMirror));
 
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::Playground::GetContentScale(), flutter::DlColorSource::MakeConical(), impeller::TRect< Scalar >::MakeXYWH(), impeller::AiksPlayground::OpenPlaygroundHere(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), flutter::Point::x(), and flutter::Point::y().

Referenced by TEST_P().

◆ CanRenderLinearGradientWithDithering()

static void impeller::testing::CanRenderLinearGradientWithDithering ( AiksTest * aiks_test )

static

Definition at line 112 of file aiks_dl_gradient_unittests.cc.

                                                                      {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0, 100.0);
 
  // 0xffcccccc --> 0xff333333, taken from
  // https://github.com/flutter/flutter/issues/118073#issue-1521699748
  std::vector<DlColor> colors = {DlColor(0xFFCCCCCC), DlColor(0xFF333333)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear(
      {0, 0}, {800, 500}, 2, colors.data(), stops.data(), DlTileMode::kClamp));
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 800, 500), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), impeller::AiksPlayground::OpenPlaygroundHere(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

Referenced by TEST_P().

◆ CanRenderRadialGradientWithDithering()

static void impeller::testing::CanRenderRadialGradientWithDithering ( AiksTest * aiks_test )

static

Definition at line 132 of file aiks_dl_gradient_unittests.cc.

                                                                      {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0, 100.0);
 
  // #FFF -> #000
  std::vector<DlColor> colors = {DlColor(Color{1.0, 1.0, 1.0, 1.0}.ToARGB()),
                                 DlColor(Color{0.0, 0.0, 0.0, 1.0}.ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeRadial(
      {600, 600}, 600, 2, colors.data(), stops.data(), DlTileMode::kClamp));
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 1200, 1200), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColorSource::MakeRadial(), impeller::TRect< Scalar >::MakeXYWH(), impeller::AiksPlayground::OpenPlaygroundHere(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), and flutter::DisplayListBuilder::Translate().

Referenced by TEST_P().

◆ CanRenderSweepGradientWithDithering()

static void impeller::testing::CanRenderSweepGradientWithDithering ( AiksTest * aiks_test )

static

Definition at line 152 of file aiks_dl_gradient_unittests.cc.

                                                                     {
  DisplayListBuilder builder;
  builder.Scale(aiks_test->GetContentScale().x, aiks_test->GetContentScale().y);
  DlPaint paint;
  builder.Translate(100.0, 100.0);
 
  // #FFF -> #000
  std::vector<DlColor> colors = {DlColor(Color{1.0, 1.0, 1.0, 1.0}.ToARGB()),
                                 DlColor(Color{0.0, 0.0, 0.0, 1.0}.ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeSweep(
      {100, 100}, /*start=*/45, /*end=*/135, 2, colors.data(), stops.data(),
      DlTileMode::kMirror));
 
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(aiks_test->OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::Playground::GetContentScale(), flutter::DlColorSource::MakeSweep(), impeller::TRect< Scalar >::MakeXYWH(), impeller::AiksPlayground::OpenPlaygroundHere(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), flutter::Point::x(), and flutter::Point::y().

Referenced by TEST_P().

◆ CanUseFramebufferFetch()

bool impeller::testing::CanUseFramebufferFetch	(	std::string_view	driver_name,
		bool	qc = `true`
	)

Definition at line 197 of file driver_info_vk_unittests.cc.

                                                                        {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [&driver_name, qc](VkPhysicalDevice device,
                                 VkPhysicalDeviceProperties* prop) {
                if (qc) {
                  prop->vendorID = 0x168C;  // Qualcomm
                } else {
                  prop->vendorID = 0x13B5;  // ARM
                }
                driver_name.copy(prop->deviceName, driver_name.size());
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
  return !GetWorkaroundsFromDriverInfo(*context->GetDriverInfo())
              .input_attachment_self_dependency_broken;
}

References context, device, impeller::GetWorkaroundsFromDriverInfo(), impeller::WorkaroundsVK::input_attachment_self_dependency_broken, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

Referenced by TEST().

◆ CanUseMipgeneration()

bool impeller::testing::CanUseMipgeneration	(	std::string_view	driver_name,
		bool	qc = `true`
	)

Definition at line 127 of file driver_info_vk_unittests.cc.

                                                                     {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [&driver_name, qc](VkPhysicalDevice device,
                                 VkPhysicalDeviceProperties* prop) {
                if (qc) {
                  prop->vendorID = 0x168C;  // Qualcomm
                } else {
                  prop->vendorID = 0x13B5;  // ARM
                }
                driver_name.copy(prop->deviceName, driver_name.size());
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
  return !GetWorkaroundsFromDriverInfo(*context->GetDriverInfo())
              .broken_mipmap_generation;
}

References impeller::WorkaroundsVK::broken_mipmap_generation, context, device, impeller::GetWorkaroundsFromDriverInfo(), and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

Referenced by TEST().

◆ CanUsePrimitiveRestartSubmitTest()

bool impeller::testing::CanUsePrimitiveRestartSubmitTest	(	std::string_view	driver_name,
		bool	qc = `true`
	)

Definition at line 98 of file driver_info_vk_unittests.cc.

                                                      {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [&driver_name, qc](VkPhysicalDevice device,
                                 VkPhysicalDeviceProperties* prop) {
                if (qc) {
                  prop->vendorID = 0x168C;  // Qualcomm
                } else {
                  prop->vendorID = 0x13B5;  // ARM
                }
                driver_name.copy(prop->deviceName, driver_name.size());
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
  return !GetWorkaroundsFromDriverInfo(*context->GetDriverInfo())
              .slow_primitive_restart_performance;
}

References context, device, impeller::GetWorkaroundsFromDriverInfo(), impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback(), and impeller::WorkaroundsVK::slow_primitive_restart_performance.

Referenced by TEST().

◆ CAPABILITY_TEST() [1/12]

impeller::testing::CAPABILITY_TEST	(	NeedsPartitionedHostBuffer	,
		false
	)

◆ CAPABILITY_TEST() [2/12]

impeller::testing::CAPABILITY_TEST	(	SupportsCompute	,
		false
	)

◆ CAPABILITY_TEST() [3/12]

impeller::testing::CAPABILITY_TEST	(	SupportsComputeSubgroups	,
		false
	)

◆ CAPABILITY_TEST() [4/12]

impeller::testing::CAPABILITY_TEST	(	SupportsDecalSamplerAddressMode	,
		false
	)

◆ CAPABILITY_TEST() [5/12]

impeller::testing::CAPABILITY_TEST	(	SupportsDeviceTransientTextures	,
		false
	)

◆ CAPABILITY_TEST() [6/12]

impeller::testing::CAPABILITY_TEST	(	SupportsExtendedRangeFormats	,
		false
	)

◆ CAPABILITY_TEST() [7/12]

impeller::testing::CAPABILITY_TEST	(	SupportsFramebufferFetch	,
		false
	)

◆ CAPABILITY_TEST() [8/12]

impeller::testing::CAPABILITY_TEST	(	SupportsOffscreenMSAA	,
		false
	)

◆ CAPABILITY_TEST() [9/12]

impeller::testing::CAPABILITY_TEST	(	SupportsReadFromResolve	,
		false
	)

◆ CAPABILITY_TEST() [10/12]

impeller::testing::CAPABILITY_TEST	(	SupportsSSBO	,
		false
	)

◆ CAPABILITY_TEST() [11/12]

impeller::testing::CAPABILITY_TEST	(	SupportsTextureToTextureBlits	,
		false
	)

◆ CAPABILITY_TEST() [12/12]

impeller::testing::CAPABILITY_TEST	(	SupportsTriangleFan	,
		false
	)

◆ CompareFunctionUI()

static const CompareFunctionUIData & impeller::testing::CompareFunctionUI ( )

static

Definition at line 1176 of file renderer_unittests.cc.

                                                        {
  static CompareFunctionUIData data;
  return data;
}

References flutter::data.

Referenced by TEST_P().

◆ CopyBufferView()

template<typename T >

std::vector< T > impeller::testing::CopyBufferView ( const BufferView & vertex_buffer )

Definition at line 19 of file tessellator_playground_unittests.cc.

                                                             {
  Range range = vertex_buffer.GetRange();
  uint8_t* base_ptr = vertex_buffer.GetBuffer()->OnGetContents() + range.offset;
  return std::vector<T>(reinterpret_cast<T*>(base_ptr),
                        reinterpret_cast<T*>(base_ptr + range.length));
}

References impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), impeller::Range::length, impeller::Range::offset, and impeller::DeviceBuffer::OnGetContents().

◆ CreateDefaultPipeline()

template<class VertexShader , class FragmentShader >

std::shared_ptr< Pipeline< PipelineDescriptor > > impeller::testing::CreateDefaultPipeline	(	RendererTest *	test,
		const std::shared_ptr< Context > &	context
	)

Definition at line 1375 of file renderer_unittests.cc.

                                           {
  using TexturePipelineBuilder = PipelineBuilder<VertexShader, FragmentShader>;
  auto pipeline_desc =
      TexturePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  if (!pipeline_desc.has_value()) {
    return nullptr;
  }
  if (!test->InitializePipelineDescriptorForRendering(*pipeline_desc)) {
    return nullptr;
  }
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  if (!pipeline || !pipeline->IsValid()) {
    return nullptr;
  }
  return pipeline;
}

References context, impeller::Playground::InitializePipelineDescriptorForRendering(), and pipeline.

◆ CreateGlyphAtlas() [1/2]

static std::shared_ptr< GlyphAtlas > impeller::testing::CreateGlyphAtlas	(	Context &	context,
		const TypographerContext *	typographer_context,
		HostBuffer &	data_host_buffer,
		GlyphAtlas::Type	type,
		const Matrix &	transform,
		const std::shared_ptr< GlyphAtlasContext > &	atlas_context,
		const std::shared_ptr< TextFrame > &	frame
	)

static

Definition at line 32 of file typographer_unittests.cc.

                                           {
  RenderableText render_frame{
      .text_frame = frame,
      .origin_transform = transform,
      .properties = GlyphProperties{},
  };
  return typographer_context->CreateGlyphAtlas(context, type, data_host_buffer,
                                               atlas_context, {render_frame});
}

References context, impeller::TypographerContext::CreateGlyphAtlas(), impeller::RenderableText::text_frame, transform, and type.

Referenced by TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), and TEST_P().

◆ CreateGlyphAtlas() [2/2]

static std::shared_ptr< GlyphAtlas > impeller::testing::CreateGlyphAtlas	(	Context &	context,
		const TypographerContext *	typographer_context,
		HostBuffer &	data_host_buffer,
		GlyphAtlas::Type	type,
		const Matrix &	transform,
		const std::shared_ptr< GlyphAtlasContext > &	atlas_context,
		const std::vector< std::shared_ptr< TextFrame > > &	frames,
		const std::vector< GlyphProperties > &	properties
	)

static

Definition at line 49 of file typographer_unittests.cc.

                                                  {
  size_t offset = 0;
  std::vector<RenderableText> render_frames;
  render_frames.reserve(frames.size());
  for (auto& frame : frames) {
    render_frames.emplace_back(frame, transform, properties[offset++]);
  }
  return typographer_context->CreateGlyphAtlas(context, type, data_host_buffer,
                                               atlas_context, render_frames);
}

References context, impeller::TypographerContext::CreateGlyphAtlas(), transform, and type.

◆ CreateMappingFromString()

static std::shared_ptr< fml::Mapping > impeller::testing::CreateMappingFromString ( std::string p_string )

static

Definition at line 18 of file shader_archive_unittests.cc.

                        {
  auto string = std::make_shared<std::string>(std::move(p_string));
  return std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(string->data()), string->size(),
      [string](auto, auto) {});
}

Referenced by TEST().

◆ CreateStringFromMapping()

const std::string impeller::testing::CreateStringFromMapping ( const fml::Mapping & mapping )

Definition at line 26 of file shader_archive_unittests.cc.

                                                                   {
  return std::string{reinterpret_cast<const char*>(mapping.GetMapping()),
                     mapping.GetSize()};
}

References fml::Mapping::GetMapping(), and fml::Mapping::GetSize().

Referenced by TEST().

◆ CreateSurface()

vk::UniqueSurfaceKHR impeller::testing::CreateSurface ( const ContextVK & context )

Definition at line 16 of file swapchain_unittests.cc.

                                                           {
#if FML_OS_DARWIN
  impeller::vk::MetalSurfaceCreateInfoEXT createInfo = {};
  auto [result, surface] =
      context.GetInstance().createMetalSurfaceEXTUnique(createInfo);
  FML_DCHECK(result == vk::Result::eSuccess);
  return std::move(surface);
#else
  return {};
#endif  // FML_OS_DARWIN
}

References context, FML_DCHECK, and surface.

Referenced by TEST(), TEST(), TEST(), TEST(), and TEST().

◆ CreateTestCanvas()

std::unique_ptr< Canvas > impeller::testing::CreateTestCanvas	(	ContentContext &	context,
		std::optional< Rect >	cull_rect = `std::nullopt`,
		bool	requires_readback = `false`
	)

Definition at line 27 of file canvas_unittests.cc.

                                    {
  TextureDescriptor onscreen_desc;
  onscreen_desc.size = {100, 100};
  onscreen_desc.format =
      context.GetDeviceCapabilities().GetDefaultColorFormat();
  onscreen_desc.usage = TextureUsage::kRenderTarget;
  onscreen_desc.storage_mode = StorageMode::kDevicePrivate;
  onscreen_desc.sample_count = SampleCount::kCount1;
  std::shared_ptr<Texture> onscreen =
      context.GetContext()->GetResourceAllocator()->CreateTexture(
          onscreen_desc);
 
  ColorAttachment color0;
  color0.load_action = LoadAction::kClear;
  if (context.GetContext()->GetCapabilities()->SupportsOffscreenMSAA()) {
    TextureDescriptor onscreen_msaa_desc = onscreen_desc;
    onscreen_msaa_desc.sample_count = SampleCount::kCount4;
    onscreen_msaa_desc.storage_mode = StorageMode::kDeviceTransient;
    onscreen_msaa_desc.type = TextureType::kTexture2DMultisample;
 
    std::shared_ptr<Texture> onscreen_msaa =
        context.GetContext()->GetResourceAllocator()->CreateTexture(
            onscreen_msaa_desc);
    color0.resolve_texture = onscreen;
    color0.texture = onscreen_msaa;
    color0.store_action = StoreAction::kMultisampleResolve;
  } else {
    color0.texture = onscreen;
  }
 
  RenderTarget render_target;
  render_target.SetColorAttachment(color0, 0);
 
  if (cull_rect.has_value()) {
    return std::make_unique<Canvas>(
        context, render_target, /*is_onscreen=*/false,
        /*requires_readback=*/requires_readback, cull_rect.value());
  }
  return std::make_unique<Canvas>(context, render_target, /*is_onscreen=*/false,
                                  /*requires_readback=*/requires_readback);
}

References context, impeller::TextureDescriptor::format, impeller::kClear, impeller::kCount1, impeller::kCount4, impeller::kDevicePrivate, impeller::kDeviceTransient, impeller::kMultisampleResolve, impeller::kRenderTarget, impeller::kTexture2DMultisample, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::RenderTarget::SetColorAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, impeller::TextureDescriptor::type, and impeller::TextureDescriptor::usage.

Referenced by TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), and TEST_P().

◆ CreateTestYUVTextures()

static std::vector< std::shared_ptr< Texture > > impeller::testing::CreateTestYUVTextures	(	Context *	context,
		YUVColorSpace	yuv_color_space
	)

static

Definition at line 1702 of file entity_unittests.cc.

                                   {
  Vector3 red = {244.0 / 255.0, 67.0 / 255.0, 54.0 / 255.0};
  Vector3 green = {76.0 / 255.0, 175.0 / 255.0, 80.0 / 255.0};
  Vector3 blue = {33.0 / 255.0, 150.0 / 255.0, 243.0 / 255.0};
  Vector3 white = {1.0, 1.0, 1.0};
  Vector3 red_yuv = RGBToYUV(red, yuv_color_space);
  Vector3 green_yuv = RGBToYUV(green, yuv_color_space);
  Vector3 blue_yuv = RGBToYUV(blue, yuv_color_space);
  Vector3 white_yuv = RGBToYUV(white, yuv_color_space);
  std::vector<Vector3> yuvs{red_yuv, green_yuv, blue_yuv, white_yuv};
  std::vector<uint8_t> y_data;
  std::vector<uint8_t> uv_data;
  for (int i = 0; i < 4; i++) {
    auto yuv = yuvs[i];
    uint8_t y = std::round(yuv.x * 255.0);
    uint8_t u = std::round(yuv.y * 255.0);
    uint8_t v = std::round(yuv.z * 255.0);
    for (int j = 0; j < 16; j++) {
      y_data.push_back(y);
    }
    for (int j = 0; j < 8; j++) {
      uv_data.push_back(j % 2 == 0 ? u : v);
    }
  }
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  impeller::TextureDescriptor y_texture_descriptor;
  y_texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
  y_texture_descriptor.format = PixelFormat::kR8UNormInt;
  y_texture_descriptor.size = {8, 8};
  auto y_texture =
      context->GetResourceAllocator()->CreateTexture(y_texture_descriptor);
  auto y_mapping = std::make_shared<fml::DataMapping>(y_data);
  auto y_mapping_buffer =
      context->GetResourceAllocator()->CreateBufferWithCopy(*y_mapping);
 
  blit_pass->AddCopy(DeviceBuffer::AsBufferView(y_mapping_buffer), y_texture);
 
  impeller::TextureDescriptor uv_texture_descriptor;
  uv_texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
  uv_texture_descriptor.format = PixelFormat::kR8G8UNormInt;
  uv_texture_descriptor.size = {4, 4};
  auto uv_texture =
      context->GetResourceAllocator()->CreateTexture(uv_texture_descriptor);
  auto uv_mapping = std::make_shared<fml::DataMapping>(uv_data);
  auto uv_mapping_buffer =
      context->GetResourceAllocator()->CreateBufferWithCopy(*uv_mapping);
 
  blit_pass->AddCopy(DeviceBuffer::AsBufferView(uv_mapping_buffer), uv_texture);
 
  if (!blit_pass->EncodeCommands() ||
      !context->GetCommandQueue()->Submit({cmd_buffer}).ok()) {
    FML_DLOG(ERROR) << "Could not copy contents into Y/UV texture.";
  }
 
  return {y_texture, uv_texture};
}

References impeller::DeviceBuffer::AsBufferView(), context, FML_DLOG, impeller::TextureDescriptor::format, i, impeller::kHostVisible, impeller::kR8G8UNormInt, impeller::kR8UNormInt, RGBToYUV(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and y.

Referenced by TEST_P().

◆ DoGradientOvalStrokeMaskBlur()

sk_sp< flutter::DisplayList > impeller::testing::DoGradientOvalStrokeMaskBlur	(	Vector2	content_Scale,
		Scalar	sigma,
		DlBlurStyle	style
	)

Definition at line 63 of file aiks_dl_blur_unittests.cc.

                                                                            {
  DisplayListBuilder builder;
  builder.Scale(content_Scale.x, content_Scale.y);
 
  DlPaint background_paint;
  background_paint.setColor(DlColor(1, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
  builder.DrawPaint(background_paint);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue()};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  DlPaint paint;
  paint.setMaskFilter(DlBlurMaskFilter::Make(style, sigma));
  auto gradient = DlColorSource::MakeLinear(
      {0, 0}, {200, 200}, 2, colors.data(), stops.data(), DlTileMode::kClamp);
  paint.setColorSource(gradient);
  paint.setColor(DlColor::kWhite());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(20);
 
  builder.Save();
  builder.Translate(100, 100);
 
  {
    DlPaint line_paint;
    line_paint.setColor(DlColor::kWhite());
    builder.DrawLine(DlPoint(100, 0), DlPoint(100, 60), line_paint);
    builder.DrawLine(DlPoint(0, 30), DlPoint(200, 30), line_paint);
  }
 
  DlRoundRect rrect =
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 200.0f, 60.0f), 50, 100);
  builder.DrawRoundRect(rrect, paint);
  builder.Restore();
 
  return builder.Build();
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setMaskFilter(), flutter::DlPaint::setStrokeWidth(), flutter::DisplayListBuilder::Translate(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by TEST_P(), TEST_P(), TEST_P(), TEST_P(), and TEST_P().

◆ doNothing()

void impeller::testing::doNothing ( )

Definition at line 34 of file mock_gles.cc.

34{}

◆ DrainMicrotasks()

static bool impeller::testing::DrainMicrotasks ( )

static

Definition at line 48 of file renderer_dart_unittests.cc.

                              {
  auto* queue = tonic::DartMicrotaskQueue::GetForCurrentThread();
  if (queue == nullptr) {
    return true;
  }
  queue->RunMicrotasks();
  return queue->GetLastError() == tonic::kNoError;
}

References tonic::DartMicrotaskQueue::GetForCurrentThread(), tonic::kNoError, and queue.

Referenced by impeller::testing::RendererDartTest::GetRenderedTextureFromDart(), impeller::testing::RendererDartTest::RunDartFunction(), and impeller::testing::RendererDartTest::RunDartFunctionWithWindowSize().

◆ DrawCompressedTextureGolden()

static void impeller::testing::DrawCompressedTextureGolden	(	RendererGoldenTest &	test,
		PixelFormat	format,
		const std::vector< uint8_t > &	block_data,
		ISize	size
	)

static

Definition at line 207 of file renderer_golden_unittests.cc.

                                                    {
  using VS = TextureVertexShader;
  using FS = TextureFragmentShader;
 
  std::shared_ptr<Context> context = test.GetContext();
  ASSERT_TRUE(context);
 
  TextureDescriptor texture_desc;
  texture_desc.storage_mode = StorageMode::kHostVisible;
  texture_desc.format = format;
  texture_desc.size = size;
  texture_desc.mip_count = 1u;
  texture_desc.usage = TextureUsage::kShaderRead;
  auto texture = context->GetResourceAllocator()->CreateTexture(texture_desc);
  ASSERT_TRUE(texture);
  ASSERT_TRUE(texture->SetContents(block_data.data(), block_data.size()));
 
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(test.InitializePipelineDescriptorForRendering(*desc));
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline);
 
  // A fullscreen quad in normalized device coordinates with an identity MVP.
  VertexBufferBuilder<VS::PerVertexData> vertex_buffer_builder;
  vertex_buffer_builder.AddVertices({
      {{-1, -1, 0.0}, {0.0, 0.0}},
      {{1, -1, 0.0}, {1.0, 0.0}},
      {{1, 1, 0.0}, {1.0, 1.0}},
      {{-1, -1, 0.0}, {0.0, 0.0}},
      {{1, 1, 0.0}, {1.0, 1.0}},
      {{-1, 1, 0.0}, {0.0, 1.0}},
  });
  auto vertex_buffer = vertex_buffer_builder.CreateVertexBuffer(
      *context->GetResourceAllocator());
 
  const auto& sampler = context->GetSamplerLibrary()->GetSampler({});
 
  auto host_buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
 
  ASSERT_TRUE(test.OpenPlaygroundHere([&](RenderPass& pass) -> bool {
    host_buffer->Reset();
    pass.SetPipeline(pipeline);
    pass.SetVertexBuffer(vertex_buffer);
 
    VS::UniformBuffer uniforms;
    uniforms.mvp = Matrix();
    VS::BindUniformBuffer(pass, host_buffer->EmplaceUniform(uniforms));
    FS::BindTextureContents(pass, texture, sampler);
 
    return pass.Draw().ok();
  }));
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, format, impeller::Playground::GetContext(), impeller::Playground::InitializePipelineDescriptorForRendering(), impeller::kHostVisible, impeller::kShaderRead, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::TextureDescriptor::mip_count, impeller::Playground::OpenPlaygroundHere(), pipeline, impeller::TextureDescriptor::size, flutter::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::usage.

Referenced by TEST_P(), TEST_P(), and TEST_P().

◆ DrawManuallyMippedTextureGolden()

static void impeller::testing::DrawManuallyMippedTextureGolden	(	RendererGoldenTest &	test,
		float	lod
	)

static

Definition at line 380 of file renderer_golden_unittests.cc.

                                                       {
  using VS = MipmapsVertexShader;
  using FS = MipmapsFragmentShader;
 
  std::shared_ptr<Context> context = test.GetContext();
  ASSERT_TRUE(context);
 
  TextureDescriptor texture_desc;
  texture_desc.storage_mode = StorageMode::kHostVisible;
  texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_desc.size = ISize{8, 8};
  texture_desc.mip_count = 2u;  // base 8x8 + one 4x4 mip; populated by hand.
  texture_desc.usage = TextureUsage::kShaderRead;
  auto texture = context->GetResourceAllocator()->CreateTexture(texture_desc);
  ASSERT_TRUE(texture);
 
  // Base level: a 2x2 grid of red/green/blue/white quadrants.
  std::vector<uint8_t> base_data(8 * 8 * 4);
  for (int y = 0; y < 8; ++y) {
    for (int x = 0; x < 8; ++x) {
      const size_t i = (static_cast<size_t>(y) * 8 + x) * 4;
      const bool right = x >= 4;
      const bool bottom = y >= 4;
      uint8_t r = 0, g = 0, b = 0;
      if (!right && !bottom) {
        r = 0xFF;  // top-left: red.
      } else if (right && !bottom) {
        g = 0xFF;  // top-right: green.
      } else if (!right && bottom) {
        b = 0xFF;  // bottom-left: blue.
      } else {
        r = g = b = 0xFF;  // bottom-right: white.
      }
      base_data[i] = r;
      base_data[i + 1] = g;
      base_data[i + 2] = b;
      base_data[i + 3] = 0xFF;
    }
  }
  ASSERT_TRUE(texture->SetContents(base_data.data(), base_data.size()));
 
  // Second level (4x4), solid orange so it is distinct from the base and from
  // an empty level. Uploaded by hand via a blit copy rather than the
  // GenerateMipmap blit, which keeps NeedsMipmapGeneration() true. This
  // initializes the whole mip chain so the texture is complete on backends
  // that require it (OpenGL ES samples a mipmapped texture as incomplete
  // otherwise).
  std::vector<uint8_t> mip_data(4 * 4 * 4);
  for (size_t i = 0; i < mip_data.size(); i += 4) {
    mip_data[i] = 0xFF;      // r
    mip_data[i + 1] = 0x80;  // g
    mip_data[i + 2] = 0x00;  // b
    mip_data[i + 3] = 0xFF;  // a
  }
  auto mip_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
      mip_data.data(), mip_data.size());
  ASSERT_TRUE(mip_buffer);
  auto cmd_buffer = context->CreateCommandBuffer();
  ASSERT_TRUE(cmd_buffer);
  auto blit_pass = cmd_buffer->CreateBlitPass();
  ASSERT_TRUE(blit_pass);
  // The destination region must match the 4x4 second level, not the 8x8 base,
  // or the copy size check rejects the smaller source buffer.
  ASSERT_TRUE(
      blit_pass->AddCopy(DeviceBuffer::AsBufferView(mip_buffer), texture,
                         /*destination_region=*/IRect::MakeSize(ISize{4, 4}),
                         /*label=*/"Upload mip 1", /*mip_level=*/1u));
  ASSERT_TRUE(blit_pass->EncodeCommands());
  ASSERT_TRUE(context->GetCommandQueue()->Submit({cmd_buffer}).ok());
 
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(test.InitializePipelineDescriptorForRendering(*desc));
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline);
 
  // A fullscreen quad in normalized device coordinates with an identity MVP.
  VertexBufferBuilder<VS::PerVertexData> vertex_buffer_builder;
  vertex_buffer_builder.AddVertices({
      {{-1, -1}, {0.0, 0.0}},
      {{1, -1}, {1.0, 0.0}},
      {{1, 1}, {1.0, 1.0}},
      {{-1, -1}, {0.0, 0.0}},
      {{1, 1}, {1.0, 1.0}},
      {{-1, 1}, {0.0, 1.0}},
  });
  auto vertex_buffer = vertex_buffer_builder.CreateVertexBuffer(
      *context->GetResourceAllocator());
 
  const auto& sampler = context->GetSamplerLibrary()->GetSampler({});
 
  auto host_buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
 
  ASSERT_TRUE(test.OpenPlaygroundHere([&](RenderPass& pass) -> bool {
    host_buffer->Reset();
    pass.SetPipeline(pipeline);
    pass.SetVertexBuffer(vertex_buffer);
 
    VS::FrameInfo frame_info;
    frame_info.mvp = Matrix();
    VS::BindFrameInfo(pass, host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo frag_info;
    frag_info.lod = lod;
    FS::BindFragInfo(pass, host_buffer->EmplaceUniform(frag_info));
 
    FS::BindTex(pass, texture, sampler);
 
    return pass.Draw().ok();
  }));
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::DeviceBuffer::AsBufferView(), context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::Playground::GetContext(), i, impeller::Playground::InitializePipelineDescriptorForRendering(), impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::kShaderRead, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::TRect< T >::MakeSize(), impeller::TextureDescriptor::mip_count, impeller::Playground::OpenPlaygroundHere(), pipeline, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, impeller::TextureDescriptor::usage, x, and y.

Referenced by TEST_P(), and TEST_P().

◆ flip_lr()

template<typename R >

static constexpr R impeller::testing::flip_lr ( R rect )

inlinestaticconstexpr

Definition at line 1573 of file rect_unittests.cc.

                                          {
  return R::MakeLTRB(rect.GetRight(), rect.GetTop(),  //
                     rect.GetLeft(), rect.GetBottom());
}

Referenced by flip_lrtb(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ flip_lrtb()

template<typename R >

static constexpr R impeller::testing::flip_lrtb ( R rect )

inlinestaticconstexpr

Definition at line 1585 of file rect_unittests.cc.

                                            {
  return flip_lr(flip_tb(rect));
}

References flip_lr(), and flip_tb().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ flip_tb()

template<typename R >

static constexpr R impeller::testing::flip_tb ( R rect )

inlinestaticconstexpr

Definition at line 1579 of file rect_unittests.cc.

                                          {
  return R::MakeLTRB(rect.GetLeft(), rect.GetBottom(),  //
                     rect.GetRight(), rect.GetTop());
}

Referenced by flip_lrtb(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ FML_TEST_CLASS() [1/4]

impeller::testing::FML_TEST_CLASS	(	BufferBindingsGLESTest	,
		BindArrayData
	)

◆ FML_TEST_CLASS() [2/4]

impeller::testing::FML_TEST_CLASS	(	BufferBindingsGLESTest	,
		BindUniformData
	)

◆ FML_TEST_CLASS() [3/4]

impeller::testing::FML_TEST_CLASS	(	BufferBindingsGLESTest	,
		BindUniformDataVerticesAndMatrices
	)

◆ FML_TEST_CLASS() [4/4]

impeller::testing::FML_TEST_CLASS	(	BufferBindingsGLESTest	,
		BindUniformFailsWithoutFloatType
	)

◆ GetBlendModeSelection()

static BlendModeSelection impeller::testing::GetBlendModeSelection ( )

static

Definition at line 44 of file aiks_dl_blend_unittests.cc.

                                                  {
  std::vector<const char*> blend_mode_names;
  std::vector<BlendMode> blend_mode_values;
  {
    const std::vector<std::tuple<const char*, BlendMode>> blends = {
        IMPELLER_FOR_EACH_BLEND_MODE(BLEND_MODE_TUPLE)};
    assert(blends.size() ==
           static_cast<size_t>(Entity::kLastAdvancedBlendMode) + 1);
    for (const auto& [name, mode] : blends) {
      blend_mode_names.push_back(name);
      blend_mode_values.push_back(mode);
    }
  }
 
  return {blend_mode_names, blend_mode_values};
}

References BLEND_MODE_TUPLE, IMPELLER_FOR_EACH_BLEND_MODE, impeller::Entity::kLastAdvancedBlendMode, flutter::mode, and flutter::name.

Referenced by TEST_P(), and TEST_P().

◆ GetImageMemoryBarriers()

std::vector< VkImageMemoryBarrier > & impeller::testing::GetImageMemoryBarriers ( VkCommandBuffer buffer )

Definition at line 1339 of file mock_vulkan.cc.

                            {
  MockCommandBuffer* mock_command_buffer =
      reinterpret_cast<MockCommandBuffer*>(buffer);
  return mock_command_buffer->image_memory_barriers_;
}

References flutter::buffer.

Referenced by impeller::TEST().

◆ GetMockVulkanFunctions()

std::shared_ptr< std::vector< std::string > > impeller::testing::GetMockVulkanFunctions ( VkDevice device )

Definition at line 1329 of file mock_vulkan.cc.

                     {
  MockDevice* mock_device = MockDevice::Unwrap(device);
  return mock_device->GetCalledFunctions();
}

References device, and GetMockVulkanFunctions().

Referenced by GetMockVulkanFunctions(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ GetRecordedViewports()

const std::vector< VkViewport > & impeller::testing::GetRecordedViewports ( VkCommandBuffer buffer )

Returns the viewports passed to vkCmdSetViewport calls on the given command buffer, in call order.

Definition at line 1346 of file mock_vulkan.cc.

                                                                          {
  MockCommandBuffer* mock_command_buffer =
      reinterpret_cast<MockCommandBuffer*>(buffer);
  return mock_command_buffer->recorded_viewports_;
}

References flutter::buffer.

Referenced by TEST().

◆ ImpellerUnittestSetup()

void impeller::testing::ImpellerUnittestSetup ( )

Definition at line 13 of file impeller_unittest_suite.cc.

                             {
  ::impeller::PlaygroundTest::SetupTestEnvironment();
}

References impeller::PlaygroundTest::SetupTestEnvironment().

Referenced by main().

◆ INSTANTIATE_COMPUTE_SUITE()

impeller::testing::INSTANTIATE_COMPUTE_SUITE ( ComputeTest )

◆ INSTANTIATE_METAL_PLAYGROUND_SUITE()

impeller::testing::INSTANTIATE_METAL_PLAYGROUND_SUITE ( AllocatorMTLTest )

◆ INSTANTIATE_OPENGLES_PLAYGROUND_SUITE()

impeller::testing::INSTANTIATE_OPENGLES_PLAYGROUND_SUITE ( PipelineLibraryGLESTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [1/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( AiksTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [2/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( BlendFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [3/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( DisplayListTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [4/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( GaussianBlurFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [5/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( HostBufferTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [6/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( MatrixFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [7/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( MorphologyFilterContentsTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [8/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RendererDartTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [9/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RendererGoldenTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [10/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( RuntimeStageTest )

◆ INSTANTIATE_PLAYGROUND_SUITE() [11/11]

impeller::testing::INSTANTIATE_PLAYGROUND_SUITE ( TextContentsTest )

◆ INSTANTIATE_TEST_SUITE_P()

impeller::testing::INSTANTIATE_TEST_SUITE_P	(	FrameBufferObject	,
		RenderPassGLESWithDiscardFrameBufferExtTest	,
		::testing::ValuesIn(std::vector< DiscardFrameBufferParams >{ {.frame_buffer_id=0,.expected_attachments={GL_COLOR_EXT, GL_DEPTH_EXT, GL_STENCIL_EXT}}, {.frame_buffer_id=1,.expected_attachments={GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT}}})	,
		[] (const ::testing::TestParamInfo< DiscardFrameBufferParams > &info) { return(info.param.frame_buffer_id==0) ? "Default" :"NonDefault";}
	)

◆ INSTANTIATE_VULKAN_PLAYGROUND_SUITE()

impeller::testing::INSTANTIATE_VULKAN_PLAYGROUND_SUITE ( DriverInfoVKTest )

◆ InstantiateTestShaderLibrary()

static void impeller::testing::InstantiateTestShaderLibrary ( Context::BackendType backend_type )

static

Definition at line 35 of file renderer_dart_unittests.cc.

                                                                          {
  auto fixture =
      flutter::testing::OpenFixtureAsMapping("playground.shaderbundle");
  auto library = flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(
      backend_type, std::move(fixture));
  flutter::gpu::ShaderLibrary::SetOverride(library);
}

References flutter::gpu::ShaderLibrary::MakeFromFlatbuffer(), flutter::testing::OpenFixtureAsMapping(), and flutter::gpu::ShaderLibrary::SetOverride().

Referenced by impeller::testing::RendererDartTest::GetIsolate().

◆ IsBadVersionTest()

bool impeller::testing::IsBadVersionTest	(	std::string_view	driver_name,
		bool	qc = `true`
	)

Definition at line 53 of file driver_info_vk_unittests.cc.

                                                                  {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [&driver_name, qc](VkPhysicalDevice device,
                                 VkPhysicalDeviceProperties* prop) {
                if (qc) {
                  prop->vendorID = 0x168C;  // Qualcomm
                } else {
                  prop->vendorID = 0x13B5;  // ARM
                }
                driver_name.copy(prop->deviceName, driver_name.size());
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
  return context->GetDriverInfo()->IsKnownBadDriver();
}

References context, device, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

Referenced by TEST(), TEST(), and TEST().

◆ MaskBlurVariantTest()

static sk_sp< DisplayList > impeller::testing::MaskBlurVariantTest	(	const AiksTest &	test_context,
		const MaskBlurTestConfig &	config
	)

static

Definition at line 604 of file aiks_dl_blur_unittests.cc.

                                      {
  DisplayListBuilder builder;
  builder.Scale(test_context.GetContentScale().x,
                test_context.GetContentScale().y);
  builder.Scale(0.8f, 0.8f);
  builder.Translate(50.f, 50.f);
 
  DlPaint draw_paint;
  draw_paint.setColor(
      DlColor::RGBA(Color::AntiqueWhite().red, Color::AntiqueWhite().green,
                    Color::AntiqueWhite().blue, Color::AntiqueWhite().alpha));
  builder.DrawPaint(draw_paint);
 
  DlPaint paint;
  paint.setMaskFilter(DlBlurMaskFilter::Make(config.style, config.sigma));
  paint.setInvertColors(config.invert_colors);
  paint.setImageFilter(config.image_filter);
  paint.setBlendMode(config.blend_mode);
 
  const Scalar x = 50;
  const Scalar radius = 20.0f;
  const Scalar y_spacing = 100.0f;
  Scalar alpha = config.alpha * 255;
 
  Scalar y = 50;
  paint.setColor(DlColor::kCrimson().withAlpha(alpha));
  builder.DrawRect(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                    radius, 60.0f - radius),
                   paint);
 
  y += y_spacing;
  paint.setColor(DlColor::kBlue().withAlpha(alpha));
  builder.DrawCircle(DlPoint{x + 25, y + 25}, radius, paint);
 
  y += y_spacing;
  paint.setColor(DlColor::kGreen().withAlpha(alpha));
  builder.DrawOval(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                    radius, 60.0f - radius),
                   paint);
 
  y += y_spacing;
  paint.setColor(DlColor::kPurple().withAlpha(alpha));
  DlRoundRect rrect = DlRoundRect::MakeRectXY(
      DlRect::MakeXYWH(x, y, 60.0f, 60.0f), radius, radius);
  builder.DrawRoundRect(rrect, paint);
 
  y += y_spacing;
  paint.setColor(DlColor::kOrange().withAlpha(alpha));
 
  rrect = DlRoundRect::MakeRectXY(DlRect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                                  radius, 5.0);
  builder.DrawRoundRect(rrect, paint);
 
  y += y_spacing;
  paint.setColor(DlColor::kMaroon().withAlpha(alpha));
 
  {
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(x + 0, y + 60));
    path_builder.LineTo(DlPoint(x + 30, y + 0));
    path_builder.LineTo(DlPoint(x + 60, y + 60));
    path_builder.Close();
 
    builder.DrawPath(path_builder.TakePath(), paint);
  }
 
  y += y_spacing;
  paint.setColor(DlColor::kMaroon().withAlpha(alpha));
  {
    DlPath path = DlPath::MakeArc(Rect::MakeXYWH(x + 5, y, 50, 50),  //
                                  Degrees(90), Degrees(180), false) +
                  DlPath::MakeArc(Rect::MakeXYWH(x + 25, y, 50, 50),  //
                                  Degrees(90), Degrees(180), false);
    builder.DrawPath(path, paint);
  }
 
  return builder.Build();
}

◆ mockBeginQueryEXT()

void impeller::testing::mockBeginQueryEXT	(	GLenum	target,
		GLuint	id
	)

Definition at line 145 of file mock_gles.cc.

                                                 {
  CallMockMethod(&IMockGLESImpl::BeginQueryEXT, target, id);
}

References impeller::testing::IMockGLESImpl::BeginQueryEXT(), and target.

◆ mockBindFramebuffer()

void impeller::testing::mockBindFramebuffer	(	GLenum	target,
		GLuint	framebuffer
	)

Definition at line 327 of file mock_gles.cc.

                                                            {
  return CallMockMethod(&IMockGLESImpl::BindFramebuffer, target, framebuffer);
}

References impeller::testing::IMockGLESImpl::BindFramebuffer(), and target.

◆ mockBindTexture()

void impeller::testing::mockBindTexture	(	GLenum	target,
		GLuint	texture
	)

Definition at line 300 of file mock_gles.cc.

                                                    {
  CallMockMethod(&IMockGLESImpl::BindTexture, target, texture);
}

References impeller::testing::IMockGLESImpl::BindTexture(), target, and texture.

◆ mockBufferSubData()

void impeller::testing::mockBufferSubData	(	GLenum	target,
		GLintptr	offset,
		GLsizeiptr	size,
		const void *	data
	)

Definition at line 247 of file mock_gles.cc.

                                         {
  CallMockMethod(&IMockGLESImpl::BufferSubData, target, offset, size, data);
}

References impeller::testing::IMockGLESImpl::BufferSubData(), flutter::data, flutter::size, and target.

◆ mockCheckFramebufferStatus()

GLenum impeller::testing::mockCheckFramebufferStatus ( GLenum target )

Definition at line 313 of file mock_gles.cc.

                                                 {
  return CallMockMethod(&IMockGLESImpl::CheckFramebufferStatus, target);
}

References impeller::testing::IMockGLESImpl::CheckFramebufferStatus(), and target.

◆ mockDeleteQueriesEXT()

void impeller::testing::mockDeleteQueriesEXT	(	GLsizei	size,
		const GLuint *	queries
	)

Definition at line 173 of file mock_gles.cc.

                                                               {
  CallMockMethod(&IMockGLESImpl::DeleteQueriesEXT, size, queries);
}

References impeller::testing::IMockGLESImpl::DeleteQueriesEXT(), and flutter::size.

◆ mockDeleteTextures()

void impeller::testing::mockDeleteTextures	(	GLsizei	size,
		const GLuint *	queries
	)

Definition at line 177 of file mock_gles.cc.

                                                             {
  CallMockMethod(&IMockGLESImpl::DeleteTextures, size, queries);
}

References impeller::testing::IMockGLESImpl::DeleteTextures(), and flutter::size.

◆ mockDiscardFramebufferEXT()

void impeller::testing::mockDiscardFramebufferEXT	(	GLenum	target,
		GLsizei	numAttachments,
		const GLenum *	attachments
	)

Definition at line 345 of file mock_gles.cc.

                                                          {
  return CallMockMethod(&IMockGLESImpl::DiscardFramebufferEXT, target,
                        numAttachments, attachments);
}

References impeller::testing::IMockGLESImpl::DiscardFramebufferEXT(), and target.

◆ mockDrawArrays()

void impeller::testing::mockDrawArrays	(	GLenum	mode,
		GLint	first,
		GLsizei	count
	)

Definition at line 369 of file mock_gles.cc.

                                                             {
  CallMockMethod(&IMockGLESImpl::DrawArrays, mode, first, count);
}

References impeller::testing::IMockGLESImpl::DrawArrays(), and flutter::mode.

◆ mockDrawArraysInstanced()

void impeller::testing::mockDrawArraysInstanced	(	GLenum	mode,
		GLint	first,
		GLsizei	count,
		GLsizei	instancecount
	)

Definition at line 386 of file mock_gles.cc.

                                                    {
  CallMockMethod(&IMockGLESImpl::DrawArraysInstanced, mode, first, count,
                 instancecount);
}

References impeller::testing::IMockGLESImpl::DrawArraysInstanced(), and flutter::mode.

◆ mockDrawElements()

void impeller::testing::mockDrawElements	(	GLenum	mode,
		GLsizei	count,
		GLenum	type,
		const void *	indices
	)

Definition at line 376 of file mock_gles.cc.

                                           {
  CallMockMethod(&IMockGLESImpl::DrawElements, mode, count, type, indices);
}

References impeller::testing::IMockGLESImpl::DrawElements(), flutter::mode, and type.

◆ mockDrawElementsInstanced()

void impeller::testing::mockDrawElementsInstanced	(	GLenum	mode,
		GLsizei	count,
		GLenum	type,
		const void *	indices,
		GLsizei	instancecount
	)

Definition at line 397 of file mock_gles.cc.

                                                      {
  CallMockMethod(&IMockGLESImpl::DrawElementsInstanced, mode, count, type,
                 indices, instancecount);
}

References impeller::testing::IMockGLESImpl::DrawElementsInstanced(), flutter::mode, and type.

◆ mockEndQueryEXT()

void impeller::testing::mockEndQueryEXT ( GLuint id )

Definition at line 152 of file mock_gles.cc.

                                {
  CallMockMethod(&IMockGLESImpl::EndQueryEXT, id);
}

References impeller::testing::IMockGLESImpl::EndQueryEXT().

◆ mockGenBuffers()

void impeller::testing::mockGenBuffers	(	GLsizei	n,
		GLuint *	buffers
	)

Definition at line 243 of file mock_gles.cc.

                                                {
  CallMockMethod(&IMockGLESImpl::GenBuffers, n, buffers);
}

References impeller::testing::IMockGLESImpl::GenBuffers().

◆ mockGenFramebuffers()

void impeller::testing::mockGenFramebuffers	(	GLsizei	n,
		GLuint *	ids
	)

Definition at line 320 of file mock_gles.cc.

                                                 {
  return CallMockMethod(&IMockGLESImpl::GenFramebuffers, n, ids);
}

References impeller::testing::IMockGLESImpl::GenFramebuffers().

◆ mockGenQueriesEXT()

void impeller::testing::mockGenQueriesEXT	(	GLsizei	n,
		GLuint *	ids
	)

Definition at line 138 of file mock_gles.cc.

                                               {
  CallMockMethod(&IMockGLESImpl::GenQueriesEXT, n, ids);
}

References impeller::testing::IMockGLESImpl::GenQueriesEXT().

◆ mockGenTextures()

void impeller::testing::mockGenTextures	(	GLsizei	n,
		GLuint *	textures
	)

Definition at line 236 of file mock_gles.cc.

                                                  {
  CallMockMethod(&IMockGLESImpl::GenTextures, n, textures);
}

◆ mockGetError()

GLenum impeller::testing::mockGetError ( )

Definition at line 118 of file mock_gles.cc.

                      {
  return GL_NO_ERROR;
}

◆ mockGetIntegerv()

void impeller::testing::mockGetIntegerv	(	GLenum	name,
		int *	value
	)

Definition at line 95 of file mock_gles.cc.

                                              {
  switch (name) {
    case GL_NUM_EXTENSIONS: {
      *value = g_extensions.size();
    } break;
    case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
      *value = 8;
      break;
    case GL_MAX_LABEL_LENGTH_KHR:
      *value = 64;
      break;
    case GL_MAX_TEXTURE_SIZE:
      *value = 4096;
      break;
    default:
      CallMockMethod(&IMockGLESImpl::GetIntegerv, name, value);
      break;
  }
}

References g_extensions, impeller::testing::IMockGLESImpl::GetIntegerv(), flutter::name, and value.

◆ mockGetQueryObjectui64vEXT()

void impeller::testing::mockGetQueryObjectui64vEXT	(	GLuint	id,
		GLenum	target,
		GLuint64 *	result
	)

Definition at line 166 of file mock_gles.cc.

                                                                            {
  CallMockMethod(&IMockGLESImpl::GetQueryObjectui64vEXT, id, target, result);
}

References impeller::testing::IMockGLESImpl::GetQueryObjectui64vEXT(), and target.

◆ mockGetQueryObjectuivEXT()

void impeller::testing::mockGetQueryObjectuivEXT	(	GLuint	id,
		GLenum	target,
		GLuint *	result
	)

Definition at line 159 of file mock_gles.cc.

                                                                        {
  CallMockMethod(&IMockGLESImpl::GetQueryObjectuivEXT, id, target, result);
}

References impeller::testing::IMockGLESImpl::GetQueryObjectuivEXT(), and target.

◆ mockGetString()

const unsigned char * impeller::testing::mockGetString ( GLenum name )

Definition at line 63 of file mock_gles.cc.

                                                {
  switch (name) {
    case GL_VENDOR:
      return reinterpret_cast<const unsigned char*>(kMockVendor);
    case GL_VERSION:
      return reinterpret_cast<const unsigned char*>(g_version);
    case GL_EXTENSIONS:
      return reinterpret_cast<const unsigned char*>(
          g_extensions_string.c_str());
    case GL_SHADING_LANGUAGE_VERSION:
      return reinterpret_cast<const unsigned char*>(
          kMockShadingLanguageVersion);
    default:
      return reinterpret_cast<const unsigned char*>("");
  }
}

References g_extensions_string, g_version, kMockShadingLanguageVersion, kMockVendor, and flutter::name.

◆ mockGetStringi()

const unsigned char * impeller::testing::mockGetStringi	(	GLenum	name,
		GLuint	index
	)

Definition at line 83 of file mock_gles.cc.

                                                               {
  switch (name) {
    case GL_EXTENSIONS:
      return reinterpret_cast<const unsigned char*>(g_extensions[index]);
    default:
      return reinterpret_cast<const unsigned char*>("");
  }
}

References g_extensions, and flutter::name.

◆ mockInvalidateFramebuffer()

void impeller::testing::mockInvalidateFramebuffer	(	GLenum	target,
		GLsizei	numAttachments,
		const GLenum *	attachments
	)

Definition at line 359 of file mock_gles.cc.

                                                          {
  return CallMockMethod(&IMockGLESImpl::InvalidateFramebuffer, target,
                        numAttachments, attachments);
}

References impeller::testing::IMockGLESImpl::InvalidateFramebuffer(), and target.

◆ mockIsTexture()

GLboolean impeller::testing::mockIsTexture ( GLuint texture )

Definition at line 306 of file mock_gles.cc.

                                        {
  return CallMockMethod(&IMockGLESImpl::IsTexture, texture);
}

References impeller::testing::IMockGLESImpl::IsTexture(), and texture.

◆ mockObjectLabelKHR()

void impeller::testing::mockObjectLabelKHR	(	GLenum	identifier,
		GLuint	name,
		GLsizei	length,
		const GLchar *	label
	)

Definition at line 260 of file mock_gles.cc.

                                             {
  CallMockMethod(&IMockGLESImpl::ObjectLabelKHR, identifier, name, length,
                 label);
}

References length, flutter::name, and impeller::testing::IMockGLESImpl::ObjectLabelKHR().

◆ mockPopDebugGroupKHR()

void impeller::testing::mockPopDebugGroupKHR ( )

Definition at line 125 of file mock_gles.cc.

125{}

◆ mockPushDebugGroupKHR()

void impeller::testing::mockPushDebugGroupKHR	(	GLenum	source,
		GLuint	id,
		GLsizei	length,
		const GLchar *	message
	)

Definition at line 130 of file mock_gles.cc.

133 {}

◆ mockReadPixels()

void impeller::testing::mockReadPixels	(	GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		void *	data
	)

Definition at line 334 of file mock_gles.cc.

                                {
  return CallMockMethod(&IMockGLESImpl::ReadPixels, x, y, width, height, format,
                        type, data);
}

References flutter::data, format, height, impeller::testing::IMockGLESImpl::ReadPixels(), type, width, x, and y.

◆ mockTexImage2D()

void impeller::testing::mockTexImage2D	(	GLenum	target,
		GLint	level,
		GLint	internalformat,
		GLsizei	width,
		GLsizei	height,
		GLint	border,
		GLenum	format,
		GLenum	type,
		const void *	pixels
	)

Definition at line 285 of file mock_gles.cc.

                                        {
  CallMockMethod(&IMockGLESImpl::TexImage2D, target, level, internalformat,
                 width, height, border, format, type, pixels);
}

References format, height, target, impeller::testing::IMockGLESImpl::TexImage2D(), type, and width.

◆ mockTexSubImage2D()

void impeller::testing::mockTexSubImage2D	(	GLenum	target,
		GLint	level,
		GLint	xoffset,
		GLint	yoffset,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const void *	pixels
	)

Definition at line 270 of file mock_gles.cc.

                                           {
  CallMockMethod(&IMockGLESImpl::TexSubImage2D, target, level, xoffset, yoffset,
                 width, height, format, type, pixels);
}

References format, height, target, impeller::testing::IMockGLESImpl::TexSubImage2D(), type, and width.

◆ mockUniform1fv()

void impeller::testing::mockUniform1fv	(	GLint	location,
		GLsizei	count,
		const GLfloat *	value
	)

Definition at line 184 of file mock_gles.cc.

                                                                         {
  CallMockMethod(&IMockGLESImpl::Uniform1fv, location, count, value);
}

References location, impeller::testing::IMockGLESImpl::Uniform1fv(), and value.

◆ mockUniform2fv()

void impeller::testing::mockUniform2fv	(	GLint	location,
		GLsizei	count,
		const GLfloat *	value
	)

Definition at line 188 of file mock_gles.cc.

                                                                         {
  CallMockMethod(&IMockGLESImpl::Uniform2fv, location, count, value);
}

References location, impeller::testing::IMockGLESImpl::Uniform2fv(), and value.

◆ mockUniform3fv()

void impeller::testing::mockUniform3fv	(	GLint	location,
		GLsizei	count,
		const GLfloat *	value
	)

Definition at line 194 of file mock_gles.cc.

                                                                         {
  CallMockMethod(&IMockGLESImpl::Uniform3fv, location, count, value);
}

References location, impeller::testing::IMockGLESImpl::Uniform3fv(), and value.

◆ mockUniform4fv()

void impeller::testing::mockUniform4fv	(	GLint	location,
		GLsizei	count,
		const GLfloat *	value
	)

Definition at line 200 of file mock_gles.cc.

                                                                         {
  CallMockMethod(&IMockGLESImpl::Uniform4fv, location, count, value);
}

References location, impeller::testing::IMockGLESImpl::Uniform4fv(), and value.

◆ mockUniformMatrix2fv()

void impeller::testing::mockUniformMatrix2fv	(	GLint	location,
		GLsizei	count,
		GLboolean	transpose,
		const GLfloat *	value
	)

Definition at line 206 of file mock_gles.cc.

                                                {
  CallMockMethod(&IMockGLESImpl::UniformMatrix2fv, location, count, transpose,
                 value);
}

References location, impeller::testing::IMockGLESImpl::UniformMatrix2fv(), and value.

◆ mockUniformMatrix3fv()

void impeller::testing::mockUniformMatrix3fv	(	GLint	location,
		GLsizei	count,
		GLboolean	transpose,
		const GLfloat *	value
	)

Definition at line 216 of file mock_gles.cc.

                                                {
  CallMockMethod(&IMockGLESImpl::UniformMatrix3fv, location, count, transpose,
                 value);
}

References location, impeller::testing::IMockGLESImpl::UniformMatrix3fv(), and value.

◆ mockUniformMatrix4fv()

void impeller::testing::mockUniformMatrix4fv	(	GLint	location,
		GLsizei	count,
		GLboolean	transpose,
		const GLfloat *	value
	)

Definition at line 226 of file mock_gles.cc.

                                                {
  CallMockMethod(&IMockGLESImpl::UniformMatrix4fv, location, count, transpose,
                 value);
}

References location, impeller::testing::IMockGLESImpl::UniformMatrix4fv(), and value.

◆ mockVertexAttribDivisor()

void impeller::testing::mockVertexAttribDivisor	(	GLuint	index,
		GLuint	divisor
	)

Definition at line 409 of file mock_gles.cc.

                                                           {
  CallMockMethod(&IMockGLESImpl::VertexAttribDivisor, index, divisor);
}

References impeller::testing::IMockGLESImpl::VertexAttribDivisor().

◆ mockViewport()

void impeller::testing::mockViewport	(	GLint	x,
		GLint	y,
		GLsizei	width,
		GLsizei	height
	)

Definition at line 352 of file mock_gles.cc.

                                                                   {
  return CallMockMethod(&IMockGLESImpl::Viewport, x, y, width, height);
}

References height, impeller::testing::IMockGLESImpl::Viewport(), width, x, and y.

◆ RenderTextInCanvasSkia()

bool impeller::testing::RenderTextInCanvasSkia	(	const std::shared_ptr< Context > &	context,
		DisplayListBuilder &	canvas,
		const std::string &	text,
		const std::string_view &	font_fixture,
		const TextRenderOptions &	options = `{}`,
		const std::optional< SkFont > &	font = `std::nullopt`
	)

Definition at line 47 of file aiks_dl_text_unittests.cc.

                                                               {},
                            const std::optional<SkFont>& font = std::nullopt) {
  // Draw the baseline.
  DlPaint paint;
  paint.setColor(DlColor::kAqua().withAlpha(255 * 0.25));
  canvas.DrawRect(
      DlRect::MakeXYWH(options.position.x - 50, options.position.y, 900, 10),
      paint);
 
  // Mark the point at which the text is drawn.
  paint.setColor(DlColor::kRed().withAlpha(255 * 0.25));
  canvas.DrawCircle(options.position, 5.0, paint);
 
  // Construct the text blob.
  SkFont selected_font;
  if (!font.has_value()) {
    auto c_font_fixture = std::string(font_fixture);
    auto mapping =
        flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
    if (!mapping) {
      return false;
    }
    sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
    selected_font = SkFont(font_mgr->makeFromData(mapping), options.font_size);
    if (options.is_subpixel) {
      selected_font.setSubpixel(true);
    }
  } else {
    selected_font = font.value();
  }
  auto blob = SkTextBlob::MakeFromString(text.c_str(), selected_font);
  if (!blob) {
    return false;
  }
 
  // Create the Impeller text frame and draw it at the designated baseline.
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
 
  DlPaint text_paint;
  text_paint.setColor(options.color);
  text_paint.setMaskFilter(options.filter);
  text_paint.setStrokeWidth(options.stroke_width);
  text_paint.setDrawStyle(options.stroke ? DlDrawStyle::kStroke
                                         : DlDrawStyle::kFill);
  canvas.DrawText(DlTextImpeller::Make(frame), options.position.x,
                  options.position.y, text_paint);
  return true;
}

Referenced by TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), and TEST_P().

◆ RGBToYUV()

static Vector3 impeller::testing::RGBToYUV	(	Vector3	rgb,
		YUVColorSpace	yuv_color_space
	)

static

Definition at line 1685 of file entity_unittests.cc.

                                                                    {
  Vector3 yuv;
  switch (yuv_color_space) {
    case YUVColorSpace::kBT601FullRange:
      yuv.x = rgb.x * 0.299 + rgb.y * 0.587 + rgb.z * 0.114;
      yuv.y = rgb.x * -0.169 + rgb.y * -0.331 + rgb.z * 0.5 + 0.5;
      yuv.z = rgb.x * 0.5 + rgb.y * -0.419 + rgb.z * -0.081 + 0.5;
      break;
    case YUVColorSpace::kBT601LimitedRange:
      yuv.x = rgb.x * 0.257 + rgb.y * 0.516 + rgb.z * 0.100 + 0.063;
      yuv.y = rgb.x * -0.145 + rgb.y * -0.291 + rgb.z * 0.439 + 0.5;
      yuv.z = rgb.x * 0.429 + rgb.y * -0.368 + rgb.z * -0.071 + 0.5;
      break;
  }
  return yuv;
}

References impeller::kBT601FullRange, impeller::kBT601LimitedRange, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

Referenced by CreateTestYUVTextures().

◆ SetSwapchainImageSize()

void impeller::testing::SetSwapchainImageSize ( ISize size )

Override the image size returned by all swapchain images.

Definition at line 1335 of file mock_vulkan.cc.

                                       {
  currentImageSize = size;
}

References flutter::size.

Referenced by TEST(), TEST(), and TEST().

◆ swap_nan() [1/2]

static constexpr Point impeller::testing::swap_nan	(	const Point &	point,
		int	index
	)

inlinestaticconstexpr

Definition at line 1599 of file rect_unittests.cc.

                                                                      {
  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
  FML_DCHECK(index >= 0 && index <= 3);
  Scalar x = ((index & (1 << 0)) != 0) ? nan : point.x;
  Scalar y = ((index & (1 << 1)) != 0) ? nan : point.y;
  return Point(x, y);
}

References FML_DCHECK, x, flutter::Point::x(), flutter::Point::y(), and y.

◆ swap_nan() [2/2]

static constexpr Rect impeller::testing::swap_nan	(	const Rect &	rect,
		int	index
	)

inlinestaticconstexpr

Definition at line 1589 of file rect_unittests.cc.

                                                                   {
  Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
  FML_DCHECK(index >= 0 && index <= 15);
  Scalar l = ((index & (1 << 0)) != 0) ? nan : rect.GetLeft();
  Scalar t = ((index & (1 << 1)) != 0) ? nan : rect.GetTop();
  Scalar r = ((index & (1 << 2)) != 0) ? nan : rect.GetRight();
  Scalar b = ((index & (1 << 3)) != 0) ? nan : rect.GetBottom();
  return Rect::MakeLTRB(l, t, r, b);
}

References FML_DCHECK, and impeller::TRect< Scalar >::MakeLTRB().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ TEST() [1/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanCast
	)

Definition at line 77 of file allocation_size_unittests.cc.

                                  {
  using namespace allocation_size_literals;
  {
    auto a = KiloBytes{1500_bytes};
    ASSERT_DOUBLE_EQ(a.GetSize(), 1.5);
  }
  {
    auto a = KiloBytes{Bytes{1500}};
    ASSERT_DOUBLE_EQ(a.GetSize(), 1.5);
  }
 
  ASSERT_DOUBLE_EQ(MebiBytes{Bytes{4194304}}.GetSize(), 4);
}

References impeller::AllocationSize< Period >::GetSize().

◆ TEST() [2/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanConstructWithArith
	)

Definition at line 110 of file allocation_size_unittests.cc.

                                                {
  {
    KiloBytes a(1u);
    ASSERT_EQ(a.GetByteSize(), 1000u);
  }
  {
    KiloBytes a(1.5);
    ASSERT_EQ(a.GetByteSize(), 2000u);
  }
  {
    KiloBytes a(1.5f);
    ASSERT_EQ(a.GetByteSize(), 2000u);
  }
}

◆ TEST() [3/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanConvert
	)

Definition at line 44 of file allocation_size_unittests.cc.

                                     {
  using namespace allocation_size_literals;
  ASSERT_EQ((5_gb).ConvertTo<MegaBytes>().GetSize(), 5000u);
}

◆ TEST() [4/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanCreateTypedAllocations
	)

Definition at line 10 of file allocation_size_unittests.cc.

                                                    {
  auto bytes = Bytes{1024};
  ASSERT_EQ(bytes.GetByteSize(), 1024u);
 
  auto kilobytes = KiloBytes{5};
  ASSERT_EQ(kilobytes.GetByteSize(), 5u * 1e3);
 
  auto megabytes = MegaBytes{5};
  ASSERT_EQ(megabytes.GetByteSize(), 5u * 1e6);
 
  auto gigabytes = GigaBytes{5};
  ASSERT_EQ(gigabytes.GetByteSize(), 5u * 1e9);
 
  auto kibibytes = KibiBytes{1};
  ASSERT_EQ(kibibytes.GetByteSize(), 1024u);
 
  auto mebibytes = MebiBytes{1};
  ASSERT_EQ(mebibytes.GetByteSize(), 1048576u);
 
  auto gigibytes = GibiBytes{1};
  ASSERT_EQ(gigibytes.GetByteSize(), 1073741824u);
}

◆ TEST() [5/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanCreateTypedAllocationsWithLiterals
	)

Definition at line 33 of file allocation_size_unittests.cc.

                                                                {
  using namespace allocation_size_literals;
  ASSERT_EQ((1024_bytes).GetByteSize(), 1024u);
  ASSERT_EQ((5_kb).GetByteSize(), 5u * 1e3);
  ASSERT_EQ((5_mb).GetByteSize(), 5u * 1e6);
  ASSERT_EQ((5_gb).GetByteSize(), 5u * 1e9);
  ASSERT_EQ((1_kib).GetByteSize(), 1024u);
  ASSERT_EQ((1_mib).GetByteSize(), 1048576u);
  ASSERT_EQ((1_gib).GetByteSize(), 1073741824u);
}

◆ TEST() [6/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanGetFloatValues
	)

Definition at line 55 of file allocation_size_unittests.cc.

                                            {
  using namespace allocation_size_literals;
  ASSERT_DOUBLE_EQ((1500_bytes).ConvertTo<KiloBytes>().GetSize(), 1.5);
}

◆ TEST() [7/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		CanPerformSimpleArithmetic
	)

Definition at line 91 of file allocation_size_unittests.cc.

                                                     {
  using namespace allocation_size_literals;
  {
    auto a = 100_bytes;
    auto b = 200_bytes;
    ASSERT_EQ((a + b).GetByteSize(), 300u);
  }
  {
    auto a = 100_bytes;
    a += 200_bytes;
    ASSERT_EQ(a.GetByteSize(), 300u);
  }
  {
    auto a = 100_bytes;
    a -= 50_bytes;
    ASSERT_EQ(a.GetByteSize(), 50u);
  }
}

◆ TEST() [8/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		ConversionsAreNonTruncating
	)

Definition at line 49 of file allocation_size_unittests.cc.

                                                      {
  using namespace allocation_size_literals;
  ASSERT_DOUBLE_EQ((1500_bytes).ConvertTo<KiloBytes>().GetSize(), 1.5);
  ASSERT_EQ((1500_bytes).ConvertTo<KiloBytes>().GetByteSize(), 1500u);
}

◆ TEST() [9/689]

impeller::testing::TEST	(	AllocationSizeTest	,
		RelationalOperatorsAreFunctional
	)

Definition at line 60 of file allocation_size_unittests.cc.

                                                           {
  using namespace allocation_size_literals;
 
  auto a = 1500_bytes;
  auto b = 2500_bytes;
  auto c = 0_bytes;
 
  ASSERT_TRUE(a != b);
  ASSERT_FALSE(a == b);
  ASSERT_TRUE(b > a);
  ASSERT_TRUE(b >= a);
  ASSERT_TRUE(a < b);
  ASSERT_TRUE(a <= b);
  ASSERT_TRUE(a);
  ASSERT_FALSE(c);
}

References c.

◆ TEST() [10/689]

impeller::testing::TEST	(	AllocationTest	,
		NextPowerOfTwoSize
	)

Definition at line 41 of file allocation_unittests.cc.

                                         {
  EXPECT_EQ(*Allocation::NextPowerOfTwoSize((1ULL << 32) - 1), 1ULL << 32);
  EXPECT_EQ(*Allocation::NextPowerOfTwoSize((1ULL << 32) + 1), 1ULL << 33);
  EXPECT_EQ(*Allocation::NextPowerOfTwoSize(1ULL << 63), 1ULL << 63);
  EXPECT_EQ(Allocation::NextPowerOfTwoSize((1ULL << 63) + 1).status().code(),
            absl::StatusCode::kInvalidArgument);
  EXPECT_EQ(Allocation::NextPowerOfTwoSize(std::numeric_limits<uint64_t>::max())
                .status()
                .code(),
            absl::StatusCode::kInvalidArgument);
}

References impeller::Allocation::NextPowerOfTwoSize().

◆ TEST() [11/689]

impeller::testing::TEST	(	AllocationTest	,
		ReserveNPOTPotentialOverflow
	)

Definition at line 14 of file allocation_unittests.cc.

                                                   {
  std::vector<uint8_t> data(64, 0xff);
 
  auto allocate_and_write = [&](uint64_t size) {
    Allocation allocation;
 
    // Allocate a buffer with the size rounded up to the next power of two.
    if (!allocation.Truncate(Bytes{size})) {
      // Not enough memory available.
      return;
    }
 
    // If the allocation succeeded, then check that writes are safe.
    memcpy(allocation.GetBuffer(), data.data(), data.size());
    EXPECT_EQ(memcmp(allocation.GetBuffer(), data.data(), data.size()), 0);
  };
 
  // Try allocations with sizes around the maximum 32-bit value.
  allocate_and_write((1ULL << 32) + 1);
  allocate_and_write((1ULL << 32) - 1);
 
  // Test that an allocation size that is out of range fails immediately.
  Allocation max_allocation;
  EXPECT_FALSE(
      max_allocation.Truncate(Bytes{std::numeric_limits<uint64_t>::max()}));
}

References flutter::data, impeller::Allocation::GetBuffer(), flutter::size, and impeller::Allocation::Truncate().

◆ TEST() [12/689]

impeller::testing::TEST	(	AllocatorTest	,
		CompressedFormatBlockMath
	)

Definition at line 147 of file allocator_unittests.cc.

                                               {
  // Block dimensions: everything here is 4x4 except ASTC 8x8.
  EXPECT_EQ(CompressedBlockWidthForPixelFormat(PixelFormat::kBC1RGBAUNormInt),
            4u);
  EXPECT_EQ(CompressedBlockWidthForPixelFormat(PixelFormat::kASTC8x8LDR), 8u);
  EXPECT_EQ(CompressedBlockHeightForPixelFormat(PixelFormat::kASTC8x8LDR), 8u);
  EXPECT_EQ(CompressedBlockWidthForPixelFormat(PixelFormat::kASTC4x4HDR), 4u);
  EXPECT_EQ(CompressedBlockHeightForPixelFormat(PixelFormat::kASTC8x8HDR), 8u);
  // Uncompressed formats report a 1x1 block.
  EXPECT_EQ(CompressedBlockWidthForPixelFormat(PixelFormat::kR8G8B8A8UNormInt),
            1u);
 
  // Bytes per block: BC1/ETC2-RGB8 are 8 bytes, the rest here are 16.
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kBC1RGBAUNormInt), 8u);
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kETC2RGB8UNormInt), 8u);
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kBC3RGBAUNormInt), 16u);
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kASTC4x4LDR), 16u);
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kASTC8x8HDR), 16u);
  // Uncompressed falls back to bytes-per-pixel.
  EXPECT_EQ(BytesPerBlockForPixelFormat(PixelFormat::kR8G8B8A8UNormInt), 4u);
}

References impeller::BytesPerBlockForPixelFormat(), impeller::CompressedBlockHeightForPixelFormat(), impeller::CompressedBlockWidthForPixelFormat(), impeller::kASTC4x4HDR, impeller::kASTC4x4LDR, impeller::kASTC8x8HDR, impeller::kASTC8x8LDR, impeller::kBC1RGBAUNormInt, impeller::kBC3RGBAUNormInt, impeller::kETC2RGB8UNormInt, and impeller::kR8G8B8A8UNormInt.

◆ TEST() [13/689]

impeller::testing::TEST	(	AllocatorTest	,
		CompressedFormatClassification
	)

Definition at line 129 of file allocator_unittests.cc.

                                                    {
  EXPECT_FALSE(IsCompressed(PixelFormat::kR8G8B8A8UNormInt));
  EXPECT_FALSE(IsCompressed(PixelFormat::kR32Float));
  EXPECT_TRUE(IsCompressed(PixelFormat::kBC1RGBAUNormInt));
  EXPECT_TRUE(IsCompressed(PixelFormat::kETC2RGBA8UNormInt));
  EXPECT_TRUE(IsCompressed(PixelFormat::kASTC8x8LDR));
  EXPECT_TRUE(IsCompressed(PixelFormat::kASTC4x4HDR));
 
  EXPECT_EQ(CompressedTextureFamilyForFormat(PixelFormat::kBC7RGBAUNormInt),
            CompressedTextureFamily::kBC);
  EXPECT_EQ(CompressedTextureFamilyForFormat(PixelFormat::kETC2RGB8UNormInt),
            CompressedTextureFamily::kETC2);
  EXPECT_EQ(CompressedTextureFamilyForFormat(PixelFormat::kASTC4x4LDR),
            CompressedTextureFamily::kASTC);
  EXPECT_EQ(CompressedTextureFamilyForFormat(PixelFormat::kASTC8x8HDR),
            CompressedTextureFamily::kASTCHDR);
}

References impeller::CompressedTextureFamilyForFormat(), impeller::IsCompressed(), impeller::kASTC, impeller::kASTC4x4HDR, impeller::kASTC4x4LDR, impeller::kASTC8x8HDR, impeller::kASTC8x8LDR, impeller::kASTCHDR, impeller::kBC, impeller::kBC1RGBAUNormInt, impeller::kBC7RGBAUNormInt, impeller::kETC2, impeller::kETC2RGB8UNormInt, impeller::kETC2RGBA8UNormInt, impeller::kR32Float, and impeller::kR8G8B8A8UNormInt.

◆ TEST() [14/689]

impeller::testing::TEST	(	AllocatorTest	,
		CompressedFormatRegionByteSizes
	)

Definition at line 169 of file allocator_unittests.cc.

                                                     {
  // BC1: 4x4 blocks of 8 bytes. Dimensions round up to whole blocks.
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kBC1RGBAUNormInt, 4, 4), 8u);
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kBC1RGBAUNormInt, 8, 8), 32u);
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kBC1RGBAUNormInt, 5, 5), 32u);
  EXPECT_EQ(BytesPerRowForTextureWidth(PixelFormat::kBC1RGBAUNormInt, 8), 16u);
 
  // ASTC 8x8: a single 16-byte block covers up to 8x8 texels.
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kASTC8x8LDR, 8, 8), 16u);
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kASTC8x8LDR, 9, 9), 64u);
 
  // Uncompressed math is unchanged: width * height * bytes-per-pixel.
  EXPECT_EQ(BytesForTextureRegion(PixelFormat::kR8G8B8A8UNormInt, 100, 100),
            40000u);
  EXPECT_EQ(BytesPerRowForTextureWidth(PixelFormat::kR8G8B8A8UNormInt, 100),
            400u);
}

References impeller::BytesForTextureRegion(), impeller::BytesPerRowForTextureWidth(), impeller::kASTC8x8LDR, impeller::kBC1RGBAUNormInt, and impeller::kR8G8B8A8UNormInt.

◆ TEST() [15/689]

impeller::testing::TEST	(	AllocatorTest	,
		CompressedTextureDescriptorByteSizes
	)

Definition at line 187 of file allocator_unittests.cc.

                                                          {
  {
    TextureDescriptor desc = {.format = PixelFormat::kBC1RGBAUNormInt,
                              .size = ISize(8, 8)};
    EXPECT_EQ(desc.GetByteSizeOfBaseMipLevel(), 32u);
    EXPECT_EQ(desc.GetBytesPerRow(), 16u);
  }
  {
    TextureDescriptor desc = {.format = PixelFormat::kASTC8x8LDR,
                              .size = ISize(16, 16)};
    EXPECT_EQ(desc.GetByteSizeOfBaseMipLevel(), 64u);
  }
}

References impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::TextureDescriptor::GetBytesPerRow(), impeller::kASTC8x8LDR, and impeller::kBC1RGBAUNormInt.

◆ TEST() [16/689]

impeller::testing::TEST	(	AllocatorTest	,
		RangeTest
	)

Definition at line 82 of file allocator_unittests.cc.

                               {
  {
    Range a = Range{0, 10};
    Range b = Range{10, 20};
    auto merged = a.Merge(b);
 
    EXPECT_EQ(merged.offset, 0u);
    EXPECT_EQ(merged.length, 30u);
  }
 
  {
    Range a = Range{0, 10};
    Range b = Range{100, 20};
    auto merged = a.Merge(b);
 
    EXPECT_EQ(merged.offset, 0u);
    EXPECT_EQ(merged.length, 120u);
  }
 
  {
    Range a = Range{0, 10};
    Range b = Range{100, 20};
    auto merged = b.Merge(a);
 
    EXPECT_EQ(merged.offset, 0u);
    EXPECT_EQ(merged.length, 120u);
  }
 
  {
    Range a = Range{0, 10};
    Range b = Range{100, 0};
    auto merged = b.Merge(a);
 
    EXPECT_EQ(merged.offset, 0u);
    EXPECT_EQ(merged.length, 10u);
  }
 
  {
    Range a = Range{0, 10};
    Range b = Range{0, 10};
    auto merged = b.Merge(a);
 
    EXPECT_EQ(merged.offset, 0u);
    EXPECT_EQ(merged.length, 10u);
  }
}

References impeller::Range::Merge().

◆ TEST() [17/689]

impeller::testing::TEST	(	AllocatorTest	,
		TextureDescriptorCompatibility
	)

Definition at line 16 of file allocator_unittests.cc.

                                                    {
  // Size.
  {
    TextureDescriptor desc_a = {.size = ISize(100, 100)};
    TextureDescriptor desc_b = {.size = ISize(100, 100)};
    TextureDescriptor desc_c = {.size = ISize(101, 100)};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Storage Mode.
  {
    TextureDescriptor desc_a = {.storage_mode = StorageMode::kDevicePrivate};
    TextureDescriptor desc_b = {.storage_mode = StorageMode::kDevicePrivate};
    TextureDescriptor desc_c = {.storage_mode = StorageMode::kHostVisible};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Format.
  {
    TextureDescriptor desc_a = {.format = PixelFormat::kR8G8B8A8UNormInt};
    TextureDescriptor desc_b = {.format = PixelFormat::kR8G8B8A8UNormInt};
    TextureDescriptor desc_c = {.format = PixelFormat::kB10G10R10A10XR};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Sample Count.
  {
    TextureDescriptor desc_a = {.sample_count = SampleCount::kCount4};
    TextureDescriptor desc_b = {.sample_count = SampleCount::kCount4};
    TextureDescriptor desc_c = {.sample_count = SampleCount::kCount1};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Sample Count.
  {
    TextureDescriptor desc_a = {.type = TextureType::kTexture2DMultisample};
    TextureDescriptor desc_b = {.type = TextureType::kTexture2DMultisample};
    TextureDescriptor desc_c = {.type = TextureType::kTexture2D};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Compression.
  {
    TextureDescriptor desc_a = {.compression_type = CompressionType::kLossless};
    TextureDescriptor desc_b = {.compression_type = CompressionType::kLossless};
    TextureDescriptor desc_c = {.compression_type = CompressionType::kLossy};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
  // Mip Count.
  {
    TextureDescriptor desc_a = {.mip_count = 1};
    TextureDescriptor desc_b = {.mip_count = 1};
    TextureDescriptor desc_c = {.mip_count = 4};
 
    ASSERT_EQ(desc_a, desc_b);
    ASSERT_NE(desc_a, desc_c);
  }
}

References impeller::TextureDescriptor::compression_type, impeller::TextureDescriptor::format, impeller::kB10G10R10A10XR, impeller::kCount1, impeller::kCount4, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kLossless, impeller::kLossy, impeller::kR8G8B8A8UNormInt, impeller::kTexture2D, impeller::kTexture2DMultisample, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::type.

◆ TEST() [18/689]

impeller::testing::TEST	(	AllocatorVKTest	,
		ImageResourceKeepsVulkanDeviceAlive
	)

Definition at line 79 of file allocator_vk_unittests.cc.

                                                           {
  std::shared_ptr<Texture> texture;
  std::weak_ptr<Allocator> weak_allocator;
  {
    auto const context = MockVulkanContextBuilder().Build();
    weak_allocator = context->GetResourceAllocator();
    auto allocator = context->GetResourceAllocator();
 
    texture = allocator->CreateTexture(TextureDescriptor{
        .storage_mode = StorageMode::kDevicePrivate,
        .format = PixelFormat::kR8G8B8A8UNormInt,
        .size = {1, 1},
    });
    context->Shutdown();
  }
 
  ASSERT_TRUE(weak_allocator.lock());
}

References allocator, impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::storage_mode, and texture.

◆ TEST() [19/689]

impeller::testing::TEST	(	AllocatorVKTest	,
		MemoryTypeSelectionSingleHeap
	)

Definition at line 41 of file allocator_vk_unittests.cc.

                                                     {
  vk::PhysicalDeviceMemoryProperties properties;
  properties.memoryTypeCount = 1;
  properties.memoryHeapCount = 1;
  properties.memoryTypes[0].heapIndex = 0;
  properties.memoryTypes[0].propertyFlags =
      vk::MemoryPropertyFlagBits::eDeviceLocal;
  properties.memoryHeaps[0].size = 1024 * 1024 * 1024;
  properties.memoryHeaps[0].flags = vk::MemoryHeapFlagBits::eDeviceLocal;
 
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(1, properties), 0);
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(2, properties), -1);
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(3, properties), 0);
}

References impeller::AllocatorVK::FindMemoryTypeIndex().

◆ TEST() [20/689]

impeller::testing::TEST	(	AllocatorVKTest	,
		MemoryTypeSelectionTwoHeap
	)

Definition at line 56 of file allocator_vk_unittests.cc.

                                                  {
  vk::PhysicalDeviceMemoryProperties properties;
  properties.memoryTypeCount = 2;
  properties.memoryHeapCount = 2;
  properties.memoryTypes[0].heapIndex = 0;
  properties.memoryTypes[0].propertyFlags =
      vk::MemoryPropertyFlagBits::eHostVisible;
  properties.memoryHeaps[0].size = 1024 * 1024 * 1024;
  properties.memoryHeaps[0].flags = vk::MemoryHeapFlagBits::eDeviceLocal;
 
  properties.memoryTypes[1].heapIndex = 1;
  properties.memoryTypes[1].propertyFlags =
      vk::MemoryPropertyFlagBits::eDeviceLocal;
  properties.memoryHeaps[1].size = 1024 * 1024 * 1024;
  properties.memoryHeaps[1].flags = vk::MemoryHeapFlagBits::eDeviceLocal;
 
  // First fails because this only looks for eDeviceLocal.
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(1, properties), -1);
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(2, properties), 1);
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(3, properties), 1);
  EXPECT_EQ(AllocatorVK::FindMemoryTypeIndex(4, properties), -1);
}

References impeller::AllocatorVK::FindMemoryTypeIndex().

◆ TEST() [21/689]

impeller::testing::TEST	(	AllocatorVKTest	,
		RetriesUncompressedOnCompressionExhausted
	)

Definition at line 98 of file allocator_vk_unittests.cc.

                                                                 {
  // Advertise fixed-rate compression support, then force the first (compressed)
  // vkCreateImage to fail with VK_ERROR_COMPRESSION_EXHAUSTED_EXT, as the
  // PowerVR driver does when its fixed-rate-compression resources are depleted.
  auto const context =
      MockVulkanContextBuilder()
          .SetDeviceExtensions(
              {"VK_KHR_swapchain", "VK_EXT_image_compression_control"})
          .SetCompressionExhaustedCreateImageFailures(1)
          .Build();
  ASSERT_TRUE(context);
  auto allocator = context->GetResourceAllocator();
  ASSERT_TRUE(allocator);
 
  // A lossy (fixed-rate-compressed) render target. The first compressed
  // allocation fails with COMPRESSION_EXHAUSTED; the allocator must retry
  // without compression and still produce a valid texture instead of returning
  // null (a null render target previously crashed the raster thread).
  auto texture = allocator->CreateTexture(TextureDescriptor{
      .storage_mode = StorageMode::kDevicePrivate,
      .format = PixelFormat::kR8G8B8A8UNormInt,
      .size = {64, 64},
      .usage = TextureUsage::kRenderTarget | TextureUsage::kShaderRead,
      .compression_type = CompressionType::kLossy,
  });
 
  ASSERT_TRUE(texture);
  EXPECT_TRUE(texture->IsValid());
 
  // vkCreateImage was called twice: the compressed attempt (which failed with
  // COMPRESSION_EXHAUSTED) and the uncompressed retry (which succeeded).
  auto const called = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateImage"), 2);
}

References allocator, impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), impeller::kDevicePrivate, impeller::kLossy, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::testing::MockVulkanContextBuilder::SetDeviceExtensions(), impeller::TextureDescriptor::storage_mode, and texture.

◆ TEST() [22/689]

impeller::testing::TEST	(	AllocatorVKTest	,
		ToVKImageUsageFlags
	)

Definition at line 22 of file allocator_vk_unittests.cc.

                                           {
  EXPECT_EQ(AllocatorVK::ToVKImageUsageFlags(
                PixelFormat::kR8G8B8A8UNormInt,
                static_cast<TextureUsageMask>(TextureUsage::kRenderTarget),
                StorageMode::kDeviceTransient,
                /*supports_memoryless_textures=*/true),
            vk::ImageUsageFlagBits::eInputAttachment |
                vk::ImageUsageFlagBits::eColorAttachment |
                vk::ImageUsageFlagBits::eTransientAttachment);
 
  EXPECT_EQ(AllocatorVK::ToVKImageUsageFlags(
                PixelFormat::kD24UnormS8Uint,
                static_cast<TextureUsageMask>(TextureUsage::kRenderTarget),
                StorageMode::kDeviceTransient,
                /*supports_memoryless_textures=*/true),
            vk::ImageUsageFlagBits::eDepthStencilAttachment |
                vk::ImageUsageFlagBits::eTransientAttachment);
}

References impeller::kD24UnormS8Uint, impeller::kDeviceTransient, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, and impeller::AllocatorVK::ToVKImageUsageFlags().

◆ TEST() [23/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsAllQuadrantsFromFirst
	)

Definition at line 262 of file arc_unittests.cc.

                                                  {
  CheckFiveQuadrants(Degrees(90 * 0 + 60), Degrees(330));
}

◆ TEST() [24/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsAllQuadrantsFromFourth
	)

Definition at line 274 of file arc_unittests.cc.

                                                   {
  CheckFiveQuadrants(Degrees(90 * 3 + 60), Degrees(330));
}

◆ TEST() [25/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsAllQuadrantsFromSecond
	)

Definition at line 266 of file arc_unittests.cc.

                                                   {
  CheckFiveQuadrants(Degrees(90 * 1 + 60), Degrees(330));
}

◆ TEST() [26/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsAllQuadrantsFromThird
	)

Definition at line 270 of file arc_unittests.cc.

                                                  {
  CheckFiveQuadrants(Degrees(90 * 2 + 60), Degrees(330));
}

◆ TEST() [27/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsFullCircle
	)

Definition at line 125 of file arc_unittests.cc.

                                       {
  // Anything with a sweep <=-360 or >=360 is a full circle regardless of
  // starting angle
  for (int start = -720; start < 720; start += 30) {
    for (int sweep = 360; sweep < 1080; sweep += 45) {
      TestFullCircleArc(Degrees(start), Degrees(sweep));
      TestFullCircleArc(Degrees(start), Degrees(-sweep));
    }
  }
}

References start.

◆ TEST() [28/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsOnlyFirstQuadrant
	)

Definition at line 210 of file arc_unittests.cc.

                                              {
  CheckOneQuadrant(Degrees(90 * 0 + 30), Degrees(30));
}

◆ TEST() [29/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsOnlyFourthQuadrant
	)

Definition at line 222 of file arc_unittests.cc.

                                               {
  CheckOneQuadrant(Degrees(90 * 3 + 30), Degrees(30));
}

◆ TEST() [30/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsOnlySecondQuadrant
	)

Definition at line 214 of file arc_unittests.cc.

                                               {
  CheckOneQuadrant(Degrees(90 * 1 + 30), Degrees(30));
}

◆ TEST() [31/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsOnlyThirdQuadrant
	)

Definition at line 218 of file arc_unittests.cc.

                                              {
  CheckOneQuadrant(Degrees(90 * 2 + 30), Degrees(30));
}

◆ TEST() [32/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsVariousEndAnglesNearQuadrantAxis
	)

Definition at line 172 of file arc_unittests.cc.

                                                             {
  Tessellator tessellator;
  const auto trigs = tessellator.GetTrigsForDeviceRadius(100);
 
  for (int sweep_i = 5; sweep_i < 20000; sweep_i += 5) {
    const Degrees sweep(sweep_i * 0.01f);
    for (int quadrant = -360; quadrant <= 360; quadrant += 90) {
      const Degrees start(quadrant + 80);
      Arc arc(Rect::MakeLTRB(10, 10, 20, 20), start, sweep, false);
      const auto& arc_iteration = arc.ComputeIterations(trigs.GetSteps());
 
      TestArcIterator(arc_iteration, trigs, start, sweep,
                      "Various angles(" + std::to_string(start.degrees) +
                          " += " + std::to_string(sweep.degrees));
    }
  }
}

References impeller::Arc::ComputeIterations(), impeller::Degrees::degrees, impeller::Tessellator::Trigs::GetSteps(), impeller::Tessellator::GetTrigsForDeviceRadius(), impeller::TRect< Scalar >::MakeLTRB(), and start.

◆ TEST() [33/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsVariousStartAnglesNearQuadrantAxis
	)

Definition at line 153 of file arc_unittests.cc.

                                                               {
  Tessellator tessellator;
  const auto trigs = tessellator.GetTrigsForDeviceRadius(100);
  const Degrees sweep(45);
 
  for (int start_i = -1000; start_i < 1000; start_i += 5) {
    Scalar start_degrees = start_i * 0.01f;
    for (int quadrant = -360; quadrant <= 360; quadrant += 90) {
      const Degrees start(quadrant + start_degrees);
      Arc arc(Rect::MakeLTRB(10, 10, 20, 20), start, sweep, false);
      const auto& arc_iteration = arc.ComputeIterations(trigs.GetSteps());
 
      TestArcIterator(arc_iteration, trigs, start, sweep,
                      "Various angles(" + std::to_string(start.degrees) +
                          " += " + std::to_string(sweep.degrees));
    }
  }
}

References impeller::Arc::ComputeIterations(), impeller::Degrees::degrees, impeller::Tessellator::Trigs::GetSteps(), impeller::Tessellator::GetTrigsForDeviceRadius(), impeller::TRect< Scalar >::MakeLTRB(), and start.

◆ TEST() [34/689]

impeller::testing::TEST	(	ArcTest	,
		ArcIterationsVariousTinyArcsNearQuadrantAxis
	)

Definition at line 190 of file arc_unittests.cc.

                                                            {
  Tessellator tessellator;
  const auto trigs = tessellator.GetTrigsForDeviceRadius(100);
  const Degrees sweep(0.1f);
 
  for (int start_i = -1000; start_i < 1000; start_i += 5) {
    Scalar start_degrees = start_i * 0.01f;
    for (int quadrant = -360; quadrant <= 360; quadrant += 90) {
      const Degrees start(quadrant + start_degrees);
      Arc arc(Rect::MakeLTRB(10, 10, 20, 20), start, sweep, false);
      const auto& arc_iteration = arc.ComputeIterations(trigs.GetSteps());
      ASSERT_EQ(arc_iteration.quadrant_count, 0u);
 
      TestArcIterator(arc_iteration, trigs, start, sweep,
                      "Various angles(" + std::to_string(start.degrees) +
                          " += " + std::to_string(sweep.degrees));
    }
  }
}

References impeller::Arc::ComputeIterations(), impeller::Degrees::degrees, impeller::Tessellator::Trigs::GetSteps(), impeller::Tessellator::GetTrigsForDeviceRadius(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Arc::Iteration::quadrant_count, and start.

◆ TEST() [35/689]

impeller::testing::TEST	(	BaseTest	,
		CanUseTypedMasks
	)

Definition at line 259 of file base_unittests.cc.

                                 {
  {
    MyMask mask;
    ASSERT_EQ(static_cast<uint32_t>(mask), 0u);
    ASSERT_FALSE(mask);
  }
 
  {
    MyMask mask(MyMaskBits::kBar);
    ASSERT_EQ(static_cast<uint32_t>(mask), 1u);
    ASSERT_TRUE(mask);
  }
 
  {
    MyMask mask2(MyMaskBits::kBar);
    MyMask mask(mask2);
    ASSERT_EQ(static_cast<uint32_t>(mask), 1u);
    ASSERT_TRUE(mask);
  }
 
  {
    MyMask mask2(MyMaskBits::kBar);
    MyMask mask(std::move(mask2));  // NOLINT
    ASSERT_EQ(static_cast<uint32_t>(mask), 1u);
    ASSERT_TRUE(mask);
  }
 
  ASSERT_LT(MyMaskBits::kBar, MyMaskBits::kBaz);
  ASSERT_LE(MyMaskBits::kBar, MyMaskBits::kBaz);
  ASSERT_GT(MyMaskBits::kBaz, MyMaskBits::kBar);
  ASSERT_GE(MyMaskBits::kBaz, MyMaskBits::kBar);
  ASSERT_EQ(MyMaskBits::kBaz, MyMaskBits::kBaz);
  ASSERT_NE(MyMaskBits::kBaz, MyMaskBits::kBang);
 
  {
    MyMask m1(MyMaskBits::kBar);
    MyMask m2(MyMaskBits::kBaz);
    ASSERT_EQ(static_cast<uint32_t>(m1 & m2), 0u);
    ASSERT_FALSE(m1 & m2);
  }
 
  {
    MyMask m1(MyMaskBits::kBar);
    MyMask m2(MyMaskBits::kBaz);
    ASSERT_EQ(static_cast<uint32_t>(m1 | m2), ((1u << 0u) | (1u << 1u)));
    ASSERT_TRUE(m1 | m2);
  }
 
  {
    MyMask m1(MyMaskBits::kBar);
    MyMask m2(MyMaskBits::kBaz);
    ASSERT_EQ(static_cast<uint32_t>(m1 ^ m2), ((1u << 0u) ^ (1u << 1u)));
    ASSERT_TRUE(m1 ^ m2);
  }
 
  {
    MyMask m1(MyMaskBits::kBar);
    ASSERT_EQ(static_cast<uint32_t>(~m1), (~(1u << 0u)));
    ASSERT_TRUE(m1);
  }
 
  {
    MyMask m1 = MyMaskBits::kBar;
    MyMask m2 = MyMaskBits::kBaz;
    m2 = m1;
    ASSERT_EQ(m2, MyMaskBits::kBar);
  }
 
  {
    MyMask m = MyMaskBits::kBar | MyMaskBits::kBaz;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask m = MyMaskBits::kBar & MyMaskBits::kBaz;
    ASSERT_FALSE(m);
  }
 
  {
    MyMask m = MyMaskBits::kBar ^ MyMaskBits::kBaz;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask m = ~MyMaskBits::kBar;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask m1 = MyMaskBits::kBar;
    MyMask m2 = MyMaskBits::kBaz;
    m2 |= m1;
    ASSERT_EQ(m1, MyMaskBits::kBar);
    MyMask pred = MyMaskBits::kBar | MyMaskBits::kBaz;
    ASSERT_EQ(m2, pred);
  }
 
  {
    MyMask m1 = MyMaskBits::kBar;
    MyMask m2 = MyMaskBits::kBaz;
    m2 &= m1;
    ASSERT_EQ(m1, MyMaskBits::kBar);
    MyMask pred = MyMaskBits::kBar & MyMaskBits::kBaz;
    ASSERT_EQ(m2, pred);
  }
 
  {
    MyMask m1 = MyMaskBits::kBar;
    MyMask m2 = MyMaskBits::kBaz;
    m2 ^= m1;
    ASSERT_EQ(m1, MyMaskBits::kBar);
    MyMask pred = MyMaskBits::kBar ^ MyMaskBits::kBaz;
    ASSERT_EQ(m2, pred);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = x | MyMaskBits::kBaz;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz | x;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = x & MyMaskBits::kBaz;
    ASSERT_FALSE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz & x;
    ASSERT_FALSE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = x ^ MyMaskBits::kBaz;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz ^ x;
    ASSERT_TRUE(m);
  }
 
  {
    MyMask x = MyMaskBits::kBar;
    MyMask m = ~x;
    ASSERT_TRUE(m);
  }
 
  {
    MyMaskBits x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz;
    ASSERT_TRUE(x < m);
    ASSERT_TRUE(x <= m);
  }
 
  {
    MyMaskBits x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz;
    ASSERT_FALSE(x == m);
  }
 
  {
    MyMaskBits x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz;
    ASSERT_TRUE(x != m);
  }
 
  {
    MyMaskBits x = MyMaskBits::kBar;
    MyMask m = MyMaskBits::kBaz;
    ASSERT_FALSE(x > m);
    ASSERT_FALSE(x >= m);
  }
}

References impeller::kBang, impeller::kBar, impeller::kBaz, and x.

◆ TEST() [36/689]

impeller::testing::TEST	(	BaseTest	,
		NoExceptionPromiseEmpty
	)

Definition at line 250 of file base_unittests.cc.

                                        {
  auto wrapper = std::make_shared<NoExceptionPromise<int>>();
  std::future future = wrapper->get_future();
 
  // Destroy the empty promise with the future still pending. Verify that the
  // process does not abort while destructing the promise.
  wrapper.reset();
}

◆ TEST() [37/689]

impeller::testing::TEST	(	BaseTest	,
		NoExceptionPromiseValue
	)

Definition at line 243 of file base_unittests.cc.

                                        {
  NoExceptionPromise<int> wrapper;
  std::future future = wrapper.get_future();
  wrapper.set_value(123);
  ASSERT_EQ(future.get(), 123);
}

References impeller::NoExceptionPromise< T >::get_future(), and impeller::NoExceptionPromise< T >::set_value().

◆ TEST() [38/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandAllocatesEachMipLevelOnFirstWrite
	)

Definition at line 389 of file blit_command_gles_unittests.cc.

                                                                      {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  auto dest = CreateMipTexture(reactor, PixelFormat::kR8G8B8A8UNormInt,
                               ISize{8, 8}, /*mip_count=*/3);
 
  // Each level needs its own correctly-sized source buffer.
  auto source0 = CreateMipBuffer(reactor, 8 * 8 * 4);
  auto source1 = CreateMipBuffer(reactor, 4 * 4 * 4);
  auto source2 = CreateMipBuffer(reactor, 2 * 2 * 4);
 
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 0, _, 8, 8, _, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 1, _, 4, 4, _, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 2, _, 2, 2, _, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 0, _, _, 8, 8, _, _, _))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 1, _, _, 4, 4, _, _, _))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 2, _, _, 2, 2, _, _, _))
      .Times(1);
 
  for (const auto& [level, w, source] : std::initializer_list<
           std::tuple<uint32_t, int32_t, std::shared_ptr<DeviceBufferGLES>>>{
           {0, 8, source0}, {1, 4, source1}, {2, 2, source2}}) {
    BlitCopyBufferToTextureCommandGLES command;
    command.source = DeviceBuffer::AsBufferView(source);
    command.destination = dest;
    command.destination_region = IRect::MakeXYWH(0, 0, w, w);
    command.mip_level = level;
    command.slice = 0;
    command.label = "TestBlit";
    EXPECT_TRUE(command.Encode(*reactor));
  }
}

References impeller::DeviceBuffer::AsBufferView(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::BlitCommand::label, impeller::TRect< T >::MakeXYWH(), impeller::BlitCopyBufferToTextureCommand::mip_level, mock_gl, reactor, impeller::BlitCopyBufferToTextureCommand::slice, and impeller::BlitCopyBufferToTextureCommand::source.

◆ TEST() [39/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandAllocatesNonZeroMipLevelOnFirstUpload
	)

Definition at line 346 of file blit_command_gles_unittests.cc.

                                                                          {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  auto dest = CreateMipTexture(reactor, PixelFormat::kR8G8B8A8UNormInt,
                               ISize{8, 8}, /*mip_count=*/3);
  auto source = CreateMipBuffer(reactor, 4 * 4 * 4);
 
  BlitCopyBufferToTextureCommandGLES command;
  command.source = DeviceBuffer::AsBufferView(source);
  command.destination = dest;
  command.destination_region = IRect::MakeXYWH(0, 0, 4, 4);
  command.mip_level = 1;
  command.slice = 0;
  command.label = "TestBlit";
 
  // Only level 1 is allocated, and at the halved 4x4 size.
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 1, _, 4, 4, _, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 0, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 2, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 1, _, _, 4, 4, _, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::DeviceBuffer::AsBufferView(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::BlitCommand::label, impeller::TRect< T >::MakeXYWH(), impeller::BlitCopyBufferToTextureCommand::mip_level, mock_gl, reactor, impeller::BlitCopyBufferToTextureCommand::slice, and impeller::BlitCopyBufferToTextureCommand::source.

◆ TEST() [40/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandAllocatesOnlyTheRequestedBaseMip
	)

Definition at line 303 of file blit_command_gles_unittests.cc.

                                                                     {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  auto dest = CreateMipTexture(reactor, PixelFormat::kR8G8B8A8UNormInt,
                               ISize{8, 8}, /*mip_count=*/3);
  auto source = CreateMipBuffer(reactor, 8 * 8 * 4);
 
  BlitCopyBufferToTextureCommandGLES command;
  command.source = DeviceBuffer::AsBufferView(source);
  command.destination = dest;
  command.destination_region = IRect::MakeSize(ISize{8, 8});
  command.mip_level = 0;
  command.slice = 0;
  command.label = "TestBlit";
 
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 0, _, 8, 8, _, _, _, nullptr))
      .Times(1);
  // Higher mip levels must NOT be allocated by a level-0 upload.
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 1, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 2, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 0, _, _, 8, 8, _, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::DeviceBuffer::AsBufferView(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::BlitCommand::label, impeller::TRect< T >::MakeSize(), impeller::BlitCopyBufferToTextureCommand::mip_level, mock_gl, reactor, impeller::BlitCopyBufferToTextureCommand::slice, and impeller::BlitCopyBufferToTextureCommand::source.

◆ TEST() [41/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandDoesNotReallocateOnSubsequentUpload
	)

Definition at line 441 of file blit_command_gles_unittests.cc.

                                                                        {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  auto dest = CreateMipTexture(reactor, PixelFormat::kR8G8B8A8UNormInt,
                               ISize{4, 4}, /*mip_count=*/2);
  auto source = CreateMipBuffer(reactor, 4 * 4 * 4);
 
  BlitCopyBufferToTextureCommandGLES command;
  command.source = DeviceBuffer::AsBufferView(source);
  command.destination = dest;
  command.destination_region = IRect::MakeSize(ISize{4, 4});
  command.mip_level = 0;
  command.slice = 0;
  command.label = "TestBlit";
 
  // Across both encodes, only the first allocates level 0.
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 0, _, 4, 4, _, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 1, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 0, _, _, _, _, _, _, _))
      .Times(2);
 
  EXPECT_TRUE(command.Encode(*reactor));
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::DeviceBuffer::AsBufferView(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::BlitCommand::label, impeller::TRect< T >::MakeSize(), impeller::BlitCopyBufferToTextureCommand::mip_level, mock_gl, reactor, impeller::BlitCopyBufferToTextureCommand::slice, and impeller::BlitCopyBufferToTextureCommand::source.

◆ TEST() [42/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandGLESBGRA
	)

Definition at line 117 of file blit_command_gles_unittests.cc.

                                                                  {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  // Mock gl to support BGRA.
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(
      std::move(mock_gles_impl),
      std::vector<const char*>{"GL_EXT_texture_format_BGRA8888"});
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  // Dest texture with BGRA format.
  std::shared_ptr<TextureGLES> dest_texture =
      CreateTexture(reactor, PixelFormat::kB8G8R8A8UNormInt);
  std::shared_ptr<DeviceBufferGLES> source_buffer = CreateBuffer(reactor);
  BlitCopyBufferToTextureCommandGLES command =
      CreateCopyBufferToTextureCommand(source_buffer, dest_texture);
 
  // Expect gl TexSubImage2D with GL_BGRA_EXT.
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, _, _, _, _, _, GL_BGRA_EXT, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::CreateTexture(), impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kB8G8R8A8UNormInt, mock_gl, and reactor.

◆ TEST() [43/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandGLESRGBA
	)

Definition at line 93 of file blit_command_gles_unittests.cc.

                                                                  {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  // Dest texture with RGBA format.
  std::shared_ptr<TextureGLES> dest_texture =
      CreateTexture(reactor, PixelFormat::kR8G8B8A8UNormInt);
  std::shared_ptr<DeviceBufferGLES> source_buffer = CreateBuffer(reactor);
  BlitCopyBufferToTextureCommandGLES command =
      CreateCopyBufferToTextureCommand(source_buffer, dest_texture);
 
  // Expect gl TexSubImage2D with GL_RGBA.
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, _, _, _, _, _, GL_RGBA, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::CreateTexture(), impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, mock_gl, and reactor.

◆ TEST() [44/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyBufferToTextureCommandUsesCubemapFaceTargetForCubemap
	)

Definition at line 481 of file blit_command_gles_unittests.cc.

                                                                    {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  auto dest =
      CreateMipTexture(reactor, PixelFormat::kR8G8B8A8UNormInt, ISize{4, 4},
                       /*mip_count=*/2, TextureType::kTextureCube);
  auto source = CreateMipBuffer(reactor, 4 * 4 * 4);
 
  BlitCopyBufferToTextureCommandGLES command;
  command.source = DeviceBuffer::AsBufferView(source);
  command.destination = dest;
  command.destination_region = IRect::MakeSize(ISize{4, 4});
  command.mip_level = 0;
  command.slice = 2;  // GL_TEXTURE_CUBE_MAP_POSITIVE_Z
  command.label = "TestBlit";
 
  const GLenum face_target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + 2;
 
  // The bind target is the cubemap parent, even though allocation/upload
  // calls use the per-face target.
  EXPECT_CALL(mock_gles_impl_ref, BindTexture(GL_TEXTURE_CUBE_MAP, _)).Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(face_target, 0, _, 4, 4, _, _, _, nullptr))
      .Times(1);
  // Higher mips for this face are not allocated by a level-0 upload.
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(face_target, 1, _, _, _, _, _, _, nullptr))
      .Times(0);
  // No other face is touched.
  EXPECT_CALL(mock_gles_impl_ref, TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, _,
                                             _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, _, _, _, _, _, _, _, nullptr))
      .Times(0);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(face_target, 0, _, _, 4, 4, _, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::DeviceBuffer::AsBufferView(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BlitCopyBufferToTextureCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::kTextureCube, impeller::BlitCommand::label, impeller::TRect< T >::MakeSize(), impeller::BlitCopyBufferToTextureCommand::mip_level, mock_gl, reactor, impeller::BlitCopyBufferToTextureCommand::slice, and impeller::BlitCopyBufferToTextureCommand::source.

◆ TEST() [45/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyTextureToBufferCommandGLESBGRA
	)

Definition at line 207 of file blit_command_gles_unittests.cc.

                                                                  {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  // Mock gl to support BGRA.
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(
      std::move(mock_gles_impl),
      std::vector<const char*>{"GL_EXT_texture_format_BGRA8888"});
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  // Source texture with BGRA format.
  std::shared_ptr<TextureGLES> source_texture =
      CreateTexture(reactor, PixelFormat::kB8G8R8A8UNormInt);
  std::shared_ptr<DeviceBufferGLES> dest_buffer = CreateBuffer(reactor);
  BlitCopyTextureToBufferCommandGLES command =
      CreateCopyTextureToBufferCommand(source_texture, dest_buffer);
 
  EXPECT_CALL(mock_gles_impl_ref, CheckFramebufferStatus(_))
      .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE));
  // Expect gl ReadPixels with GL_BGRA_EXT.
  EXPECT_CALL(mock_gles_impl_ref, ReadPixels(_, _, _, _, GL_BGRA_EXT, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::CreateTexture(), impeller::BlitCopyTextureToBufferCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kB8G8R8A8UNormInt, mock_gl, and reactor.

◆ TEST() [46/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyTextureToBufferCommandGLESBindsFramebuffer
	)

Definition at line 146 of file blit_command_gles_unittests.cc.

                                                                              {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  EXPECT_CALL(mock_gles_impl_ref, GenFramebuffers(1, _))
      .WillOnce(::testing::SetArgPointee<1>(3));
  EXPECT_CALL(mock_gles_impl_ref, GenTextures(1, _))
      .WillOnce(::testing::SetArgPointee<1>(1));
  EXPECT_CALL(mock_gles_impl_ref, BindFramebuffer(GL_FRAMEBUFFER, 3)).Times(1);
  EXPECT_CALL(mock_gles_impl_ref, CheckFramebufferStatus(GL_FRAMEBUFFER))
      .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE));
  EXPECT_CALL(mock_gles_impl_ref, ReadPixels(_, _, _, _, _, _, _)).Times(1);
  EXPECT_CALL(mock_gles_impl_ref, BindFramebuffer(GL_FRAMEBUFFER, 0)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  std::shared_ptr<TextureGLES> source_texture =
      CreateTexture(reactor, PixelFormat::kR8G8B8A8UNormInt);
  std::shared_ptr<DeviceBufferGLES> dest_buffer = CreateBuffer(reactor);
 
  ASSERT_TRUE(reactor->React());
 
  BlitCopyTextureToBufferCommandGLES command =
      CreateCopyTextureToBufferCommand(source_texture, dest_buffer);
 
  EXPECT_TRUE(command.Encode(*reactor));
 
  source_texture.reset();
  dest_buffer.reset();
 
  ASSERT_TRUE(reactor->React());
}

References impeller::CreateTexture(), impeller::BlitCopyTextureToBufferCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, mock_gl, and reactor.

◆ TEST() [47/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyTextureToBufferCommandGLESRGBA
	)

Definition at line 182 of file blit_command_gles_unittests.cc.

                                                                  {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  // Source texture with RGBA format.
  std::shared_ptr<TextureGLES> source_texture =
      CreateTexture(reactor, PixelFormat::kR8G8B8A8UNormInt);
  std::shared_ptr<DeviceBufferGLES> dest_buffer = CreateBuffer(reactor);
  BlitCopyTextureToBufferCommandGLES command =
      CreateCopyTextureToBufferCommand(source_texture, dest_buffer);
 
  EXPECT_CALL(mock_gles_impl_ref, CheckFramebufferStatus(_))
      .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE));
  // Expect gl ReadPixels with GL_RGBA.
  EXPECT_CALL(mock_gles_impl_ref, ReadPixels(_, _, _, _, GL_RGBA, _, _))
      .Times(1);
 
  EXPECT_TRUE(command.Encode(*reactor));
}

References impeller::CreateTexture(), impeller::BlitCopyTextureToBufferCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, mock_gl, and reactor.

◆ TEST() [48/689]

impeller::testing::TEST	(	BlitCommandGLESTest	,
		BlitCopyTextureToBufferCommandGLESUnsupportedPixelFormats
	)

Definition at line 235 of file blit_command_gles_unittests.cc.

                                                                {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  auto reactor = std::make_shared<TestReactorGLES>();
  auto worker = std::make_shared<MockWorker>();
  reactor->AddWorker(worker);
 
  std::shared_ptr<DeviceBufferGLES> dest_buffer = CreateBuffer(reactor);
 
  std::shared_ptr<TextureGLES> source_texture_D32FloatS8Uint =
      CreateTexture(reactor, PixelFormat::kD32FloatS8UInt);
  BlitCopyTextureToBufferCommandGLES command_for_D32FloatS8Uint =
      CreateCopyTextureToBufferCommand(source_texture_D32FloatS8Uint,
                                       dest_buffer);
 
  std::shared_ptr<TextureGLES> source_texture_R8G8UNormInt =
      CreateTexture(reactor, PixelFormat::kR8G8UNormInt);
  BlitCopyTextureToBufferCommandGLES command_for_R8G8UNormInt =
      CreateCopyTextureToBufferCommand(source_texture_R8G8UNormInt,
                                       dest_buffer);
 
  EXPECT_CALL(mock_gles_impl_ref, CheckFramebufferStatus(_)).Times(0);
 
  // GL does not support texture with an unsupported pixel format.
  EXPECT_FALSE(command_for_D32FloatS8Uint.Encode(*reactor));
 
  // GL does not support texture with another unsupported pixel format.
  EXPECT_FALSE(command_for_R8G8UNormInt.Encode(*reactor));
}

References impeller::CreateTexture(), impeller::BlitCopyTextureToBufferCommandGLES::Encode(), impeller::testing::MockGLES::Init(), impeller::kD32FloatS8UInt, impeller::kR8G8UNormInt, mock_gl, and reactor.

◆ TEST() [49/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		BindArrayData
	)

Definition at line 78 of file buffer_bindings_gles_unittests.cc.

                                            {
  BufferBindingsGLES bindings;
  absl::flat_hash_map<std::string, GLint> uniform_bindings;
  uniform_bindings["SHADERMETADATA.FOOBAR[0]"] = 1;
  bindings.SetUniformBindings(std::move(uniform_bindings));
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, Uniform1fv(_, _, _)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  std::vector<BufferResource> bound_buffers;
  std::vector<TextureAndSampler> bound_textures;
 
  ShaderMetadata shader_metadata = {
      .name = "shader_metadata",
      .members = {
          ShaderStructMemberMetadata{.type = ShaderType::kFloat,
                                     .name = "foobar",
                                     .offset = 0,
                                     .size = sizeof(float),
                                     .byte_length = sizeof(float) * 4,
                                     .array_elements = 4,
                                     .float_type = ShaderFloatType::kFloat}}};
  std::shared_ptr<ReactorGLES> reactor;
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{sizeof(float) * 4}));
  DeviceBufferGLES device_buffer(
      DeviceBufferDescriptor{.size = sizeof(float) * 4}, reactor,
      std::move(backing_store));
  BufferView buffer_view(&device_buffer, Range(0, sizeof(float)));
  bound_buffers.push_back(BufferResource(&shader_metadata, buffer_view));
 
  EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
                                       bound_buffers, Range{0, 0},
                                       Range{0, 1}));
}

References impeller::BufferBindingsGLES::BindUniformData(), impeller::testing::MockGLES::Init(), impeller::kFloat, mock_gl, impeller::ShaderMetadata::name, reactor, impeller::DeviceBufferDescriptor::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [50/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		BindUniformData
	)

Definition at line 42 of file buffer_bindings_gles_unittests.cc.

                                              {
  BufferBindingsGLES bindings;
  absl::flat_hash_map<std::string, GLint> uniform_bindings;
  uniform_bindings["SHADERMETADATA.FOOBAR"] = 1;
  bindings.SetUniformBindings(std::move(uniform_bindings));
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, Uniform1fv(_, _, _)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  std::vector<BufferResource> bound_buffers;
  std::vector<TextureAndSampler> bound_textures;
 
  ShaderMetadata shader_metadata = {
      .name = "shader_metadata",
      .members = {
          ShaderStructMemberMetadata{.type = ShaderType::kFloat,
                                     .name = "foobar",
                                     .offset = 0,
                                     .size = sizeof(float),
                                     .byte_length = sizeof(float),
                                     .array_elements = std::nullopt,
                                     .float_type = ShaderFloatType::kFloat}}};
  std::shared_ptr<ReactorGLES> reactor;
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{sizeof(float)}));
  DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = sizeof(float)},
                                 reactor, std::move(backing_store));
  BufferView buffer_view(&device_buffer, Range(0, sizeof(float)));
  bound_buffers.push_back(BufferResource(&shader_metadata, buffer_view));
 
  EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
                                       bound_buffers, Range{0, 0},
                                       Range{0, 1}));
}

References impeller::BufferBindingsGLES::BindUniformData(), impeller::testing::MockGLES::Init(), impeller::kFloat, mock_gl, impeller::ShaderMetadata::name, reactor, impeller::DeviceBufferDescriptor::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [51/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		BindUniformDataVerticesAndMatrices
	)

Definition at line 115 of file buffer_bindings_gles_unittests.cc.

                                                                 {
  BufferBindingsGLES bindings;
  absl::flat_hash_map<std::string, GLint> uniform_bindings;
  uniform_bindings["SHADERMETADATA.VEC2"] = 1;
  uniform_bindings["SHADERMETADATA.VEC3"] = 2;
  uniform_bindings["SHADERMETADATA.VEC4"] = 3;
  uniform_bindings["SHADERMETADATA.MAT2"] = 4;
  uniform_bindings["SHADERMETADATA.MAT3"] = 5;
  uniform_bindings["SHADERMETADATA.MAT4"] = 6;
  bindings.SetUniformBindings(std::move(uniform_bindings));
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, Uniform2fv(1, 1, _)).Times(1);
  EXPECT_CALL(*mock_gles_impl, Uniform3fv(2, 1, _)).Times(1);
  EXPECT_CALL(*mock_gles_impl, Uniform4fv(3, 1, _)).Times(1);
  EXPECT_CALL(*mock_gles_impl, UniformMatrix2fv(4, 1, GL_FALSE, _)).Times(1);
  EXPECT_CALL(*mock_gles_impl, UniformMatrix3fv(5, 1, GL_FALSE, _)).Times(1);
  EXPECT_CALL(*mock_gles_impl, UniformMatrix4fv(6, 1, GL_FALSE, _)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  std::vector<BufferResource> bound_buffers;
  std::vector<TextureAndSampler> bound_textures;
 
  auto make_metadata = [](ShaderFloatType float_type, const char* name,
                          size_t size) {
    return ShaderStructMemberMetadata{.type = ShaderType::kFloat,
                                      .name = name,
                                      .offset = 0,
                                      .size = size,
                                      .byte_length = size,
                                      .array_elements = std::nullopt,
                                      .float_type = float_type};
  };
 
  ShaderMetadata shader_metadata = {
      .name = "shader_metadata",
      .members = {
          make_metadata(ShaderFloatType::kVec2, "vec2", sizeof(Vector2)),
          make_metadata(ShaderFloatType::kVec3, "vec3", sizeof(Vector3)),
          make_metadata(ShaderFloatType::kVec4, "vec4", sizeof(Vector4)),
          make_metadata(ShaderFloatType::kMat2, "mat2", sizeof(float) * 4),
          make_metadata(ShaderFloatType::kMat3, "mat3", sizeof(float) * 9),
          make_metadata(ShaderFloatType::kMat4, "mat4", sizeof(Matrix)),
      }};
 
  std::shared_ptr<ReactorGLES> reactor;
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{1024}));  // Plenty of space
  DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = 1024}, reactor,
                                 std::move(backing_store));
  BufferView buffer_view(&device_buffer, Range(0, 1024));
  bound_buffers.push_back(BufferResource(&shader_metadata, buffer_view));
 
  EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
                                       bound_buffers, Range{0, 0},
                                       Range{0, 1}));
}

References impeller::BufferBindingsGLES::BindUniformData(), impeller::testing::MockGLES::Init(), impeller::kFloat, impeller::kMat2, impeller::kMat3, impeller::kMat4, impeller::kVec2, impeller::kVec3, impeller::kVec4, mock_gl, impeller::ShaderMetadata::name, flutter::name, reactor, impeller::DeviceBufferDescriptor::size, flutter::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [52/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		BindUniformFailsWithoutFloatType
	)

Definition at line 179 of file buffer_bindings_gles_unittests.cc.

                                                               {
  BufferBindingsGLES bindings;
  absl::flat_hash_map<std::string, GLint> uniform_bindings;
  uniform_bindings["SHADERMETADATA.FOOBAR"] = 1;
  bindings.SetUniformBindings(std::move(uniform_bindings));
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
  std::vector<BufferResource> bound_buffers;
  std::vector<TextureAndSampler> bound_textures;
 
  ShaderMetadata shader_metadata = {
      .name = "shader_metadata",
      .members = {ShaderStructMemberMetadata{.type = ShaderType::kFloat,
                                             .name = "foobar",
                                             .offset = 0,
                                             .size = sizeof(float),
                                             .byte_length = sizeof(float),
                                             .array_elements = std::nullopt,
                                             .float_type = std::nullopt}}};
  std::shared_ptr<ReactorGLES> reactor;
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{sizeof(float)}));
  DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = sizeof(float)},
                                 reactor, std::move(backing_store));
  BufferView buffer_view(&device_buffer, Range(0, sizeof(float)));
  bound_buffers.push_back(BufferResource(&shader_metadata, buffer_view));
 
  EXPECT_FALSE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
                                        bound_buffers, Range{0, 0},
                                        Range{0, 1}));
}

References impeller::BufferBindingsGLES::BindUniformData(), impeller::testing::MockGLES::Init(), impeller::kFloat, mock_gl, impeller::ShaderMetadata::name, reactor, impeller::DeviceBufferDescriptor::size, and impeller::ShaderStructMemberMetadata::type.

◆ TEST() [53/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		BindVertexAttributesSetsInstanceRateDivisor
	)

Definition at line 215 of file buffer_bindings_gles_unittests.cc.

                                                                          {
  auto mock_gles_impl = std::make_unique<::testing::NiceMock<MockGLESImpl>>();
  EXPECT_CALL(*mock_gles_impl, VertexAttribDivisor(0, 0)).Times(1);
  EXPECT_CALL(*mock_gles_impl, VertexAttribDivisor(1, 1)).Times(1);
  std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gles_impl));
 
  BufferBindingsGLES bindings;
 
  ShaderStageIOSlot per_vertex_input = {
      .name = "position",
      .location = 0,
      .set = 0,
      .binding = 0,
      .type = ShaderType::kFloat,
      .bit_width = sizeof(float) * 8,
      .vec_size = 2,
      .columns = 1,
      .offset = 0,
  };
  ShaderStageIOSlot per_instance_input = {
      .name = "instance_offset",
      .location = 1,
      .set = 0,
      .binding = 1,
      .type = ShaderType::kFloat,
      .bit_width = sizeof(float) * 8,
      .vec_size = 2,
      .columns = 1,
      .offset = 0,
  };
  std::vector<ShaderStageIOSlot> inputs = {per_vertex_input,
                                           per_instance_input};
  std::vector<ShaderStageBufferLayout> layouts = {
      ShaderStageBufferLayout{.stride = sizeof(float) * 2,
                              .binding = 0,
                              .input_rate = VertexInputRate::kVertex},
      ShaderStageBufferLayout{.stride = sizeof(float) * 2,
                              .binding = 1,
                              .input_rate = VertexInputRate::kInstance},
  };
 
  ASSERT_TRUE(bindings.RegisterVertexStageInput(mock_gl->GetProcTable(), inputs,
                                                layouts));
  // Binding 0 is per-vertex (divisor 0); binding 1 is per-instance
  // (divisor 1).
  EXPECT_TRUE(bindings.BindVertexAttributes(mock_gl->GetProcTable(),
                                            /*binding=*/0, /*vertex_offset=*/0,
                                            /*instance=*/0));
  EXPECT_TRUE(bindings.BindVertexAttributes(mock_gl->GetProcTable(),
                                            /*binding=*/1, /*vertex_offset=*/0,
                                            /*instance=*/0));
}

References impeller::BufferBindingsGLES::BindVertexAttributes(), columns, impeller::testing::MockGLES::Init(), impeller::kFloat, impeller::kInstance, impeller::kVertex, mock_gl, impeller::ShaderStageIOSlot::name, impeller::BufferBindingsGLES::RegisterVertexStageInput(), impeller::ShaderStageBufferLayout::stride, and vec_size.

◆ TEST() [54/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		ToVertexAttribTypeRejectsUnsupportedFormats
	)

Definition at line 32 of file buffer_bindings_gles_unittests.cc.

                                                                          {
  // Half-float and 32-bit integer vertex attributes are not available on the
  // GLES 2.0 floor.
  EXPECT_FALSE(ToVertexAttribType(VertexAttributeFormat::kFloat16).has_value());
  EXPECT_FALSE(ToVertexAttribType(VertexAttributeFormat::kSInt32).has_value());
  EXPECT_FALSE(
      ToVertexAttribType(VertexAttributeFormat::kUInt32x4).has_value());
  EXPECT_FALSE(ToVertexAttribType(VertexAttributeFormat::kInvalid).has_value());
}

References impeller::kFloat16, impeller::kInvalid, impeller::kSInt32, impeller::kUInt32x4, and impeller::ToVertexAttribType().

◆ TEST() [55/689]

impeller::testing::TEST	(	BufferBindingsGLESTest	,
		ToVertexAttribTypeSupportedFormats
	)

Definition at line 19 of file buffer_bindings_gles_unittests.cc.

                                                                 {
  EXPECT_EQ(ToVertexAttribType(VertexAttributeFormat::kFloat32x3),
            std::optional<GLenum>(GL_FLOAT));
  EXPECT_EQ(ToVertexAttribType(VertexAttributeFormat::kSInt8x4),
            std::optional<GLenum>(GL_BYTE));
  EXPECT_EQ(ToVertexAttribType(VertexAttributeFormat::kUInt8),
            std::optional<GLenum>(GL_UNSIGNED_BYTE));
  EXPECT_EQ(ToVertexAttribType(VertexAttributeFormat::kSInt16x2),
            std::optional<GLenum>(GL_SHORT));
  EXPECT_EQ(ToVertexAttribType(VertexAttributeFormat::kUInt16),
            std::optional<GLenum>(GL_UNSIGNED_SHORT));
}

References impeller::kFloat32x3, impeller::kSInt16x2, impeller::kSInt8x4, impeller::kUInt16, impeller::kUInt8, and impeller::ToVertexAttribType().

◆ TEST() [56/689]

impeller::testing::TEST	(	BufferViewTest	,
		Empty
	)

Definition at line 11 of file buffer_view_unittests.cc.

                            {
  BufferView buffer_view;
  EXPECT_FALSE(buffer_view);
}

◆ TEST() [57/689]

impeller::testing::TEST	(	BufferViewTest	,
		TakeRaw
	)

Definition at line 16 of file buffer_view_unittests.cc.

                              {
  DeviceBuffer* buffer = reinterpret_cast<DeviceBuffer*>(0xcafebabe);
  BufferView buffer_view(buffer, {0, 123});
  EXPECT_TRUE(buffer_view);
  std::shared_ptr<const DeviceBuffer> taken = buffer_view.TakeBuffer();
  EXPECT_FALSE(taken);
  EXPECT_EQ(buffer_view.GetBuffer(), buffer);
}

References flutter::buffer.

◆ TEST() [58/689]

impeller::testing::TEST	(	CanvasTest	,
		AntialiasedPaintCompatibleWithSDFRendering
	)

Definition at line 555 of file canvas_unittests.cc.

                                                             {
  Paint paint;
  EXPECT_TRUE(Canvas::IsCompatibleWithSDFRendering(paint));
}

References impeller::Canvas::IsCompatibleWithSDFRendering().

◆ TEST() [59/689]

impeller::testing::TEST	(	CanvasTest	,
		NonAntialiasedPaintIncompatibleWithSDFRendering
	)

Definition at line 549 of file canvas_unittests.cc.

                                                                  {
  Paint paint;
  paint.anti_alias = false;
  EXPECT_FALSE(Canvas::IsCompatibleWithSDFRendering(paint));
}

References impeller::Paint::anti_alias, and impeller::Canvas::IsCompatibleWithSDFRendering().

◆ TEST() [60/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		CanInitializeWithDefaults
	)

Definition at line 13 of file capabilities_unittests.cc.

                                                  {
  auto mock_gles = MockGLES::Init();
 
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
 
  EXPECT_FALSE(capabilities->SupportsOffscreenMSAA());
  EXPECT_FALSE(capabilities->SupportsSSBO());
  EXPECT_TRUE(capabilities->SupportsTextureToTextureBlits());
  EXPECT_FALSE(capabilities->SupportsFramebufferFetch());
  EXPECT_FALSE(capabilities->SupportsCompute());
  EXPECT_FALSE(capabilities->SupportsComputeSubgroups());
  EXPECT_FALSE(capabilities->SupportsReadFromResolve());
  EXPECT_FALSE(capabilities->SupportsDecalSamplerAddressMode());
  EXPECT_FALSE(capabilities->SupportsDeviceTransientTextures());
 
  EXPECT_EQ(capabilities->GetDefaultColorFormat(),
            PixelFormat::kR8G8B8A8UNormInt);
  EXPECT_EQ(capabilities->GetDefaultStencilFormat(), PixelFormat::kS8UInt);
  EXPECT_EQ(capabilities->GetDefaultDepthStencilFormat(),
            PixelFormat::kD24UnormS8Uint);
}

References impeller::testing::MockGLES::Init(), impeller::kD24UnormS8Uint, impeller::kR8G8B8A8UNormInt, and impeller::kS8UInt.

◆ TEST() [61/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		MaxSamplerAnisotropyUnsupportedByDefault
	)

Definition at line 75 of file capabilities_unittests.cc.

                                                                 {
  auto mock_gles = MockGLES::Init();
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  EXPECT_EQ(capabilities->GetMaxSamplerAnisotropy(), 1u);
}

References impeller::testing::MockGLES::Init().

◆ TEST() [62/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		MaxSamplerAnisotropyWithExtension
	)

Definition at line 81 of file capabilities_unittests.cc.

                                                          {
  auto const extensions = std::vector<const char*>{
      "GL_KHR_debug",                       //
      "GL_EXT_texture_filter_anisotropic",  //
  };
  auto mock_gles = MockGLES::Init(extensions);
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  // The extension guarantees a maximum anisotropy of at least 2.
  EXPECT_GE(capabilities->GetMaxSamplerAnisotropy(), 2u);
}

References impeller::testing::MockGLES::Init().

◆ TEST() [63/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		SupportsDecalSamplerAddressMode
	)

Definition at line 35 of file capabilities_unittests.cc.

                                                        {
  auto const extensions = std::vector<const char*>{
      "GL_KHR_debug",                 //
      "GL_EXT_texture_border_clamp",  //
  };
  auto mock_gles = MockGLES::Init(extensions);
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  EXPECT_TRUE(capabilities->SupportsDecalSamplerAddressMode());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [64/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		SupportsDecalSamplerAddressModeNotOES
	)

Definition at line 45 of file capabilities_unittests.cc.

                                                              {
  auto const extensions = std::vector<const char*>{
      "GL_KHR_debug",                 //
      "GL_OES_texture_border_clamp",  //
  };
  auto mock_gles = MockGLES::Init(extensions);
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  EXPECT_FALSE(capabilities->SupportsDecalSamplerAddressMode());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [65/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		SupportsFramebufferFetch
	)

Definition at line 55 of file capabilities_unittests.cc.

                                                 {
  auto const extensions = std::vector<const char*>{
      "GL_KHR_debug",                     //
      "GL_EXT_shader_framebuffer_fetch",  //
  };
  auto mock_gles = MockGLES::Init(extensions);
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  EXPECT_TRUE(capabilities->SupportsFramebufferFetch());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [66/689]

impeller::testing::TEST	(	CapabilitiesGLES	,
		SupportsMSAA
	)

Definition at line 65 of file capabilities_unittests.cc.

                                     {
  auto const extensions = std::vector<const char*>{
      "GL_EXT_multisampled_render_to_texture",
  };
  auto mock_gles = MockGLES::Init(extensions);
  auto capabilities = mock_gles->GetProcTable().GetCapabilities();
  EXPECT_TRUE(capabilities->SupportsImplicitResolvingMSAA());
  EXPECT_FALSE(capabilities->SupportsOffscreenMSAA());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [67/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		DefaultColorFormat
	)

Definition at line 34 of file capabilities_unittests.cc.

                                           {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetDefaultColorFormat(), PixelFormat::kUnknown);
  auto mutated = CapabilitiesBuilder()
                     .SetDefaultColorFormat(PixelFormat::kB10G10R10A10XR)
                     .Build();
  EXPECT_EQ(mutated->GetDefaultColorFormat(), PixelFormat::kB10G10R10A10XR);
}

References impeller::CapabilitiesBuilder::Build(), impeller::kB10G10R10A10XR, impeller::kUnknown, and impeller::CapabilitiesBuilder::SetDefaultColorFormat().

◆ TEST() [68/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		DefaultDepthStencilFormat
	)

Definition at line 52 of file capabilities_unittests.cc.

                                                  {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetDefaultDepthStencilFormat(), PixelFormat::kUnknown);
  auto mutated = CapabilitiesBuilder()
                     .SetDefaultDepthStencilFormat(PixelFormat::kD32FloatS8UInt)
                     .Build();
  EXPECT_EQ(mutated->GetDefaultDepthStencilFormat(),
            PixelFormat::kD32FloatS8UInt);
}

References impeller::CapabilitiesBuilder::Build(), impeller::kD32FloatS8UInt, impeller::kUnknown, and impeller::CapabilitiesBuilder::SetDefaultDepthStencilFormat().

◆ TEST() [69/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		DefaultGlyphAtlasFormat
	)

Definition at line 62 of file capabilities_unittests.cc.

                                                {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetDefaultGlyphAtlasFormat(), PixelFormat::kUnknown);
  auto mutated = CapabilitiesBuilder()
                     .SetDefaultGlyphAtlasFormat(PixelFormat::kA8UNormInt)
                     .Build();
  EXPECT_EQ(mutated->GetDefaultGlyphAtlasFormat(), PixelFormat::kA8UNormInt);
}

References impeller::CapabilitiesBuilder::Build(), impeller::kA8UNormInt, impeller::kUnknown, and impeller::CapabilitiesBuilder::SetDefaultGlyphAtlasFormat().

◆ TEST() [70/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		DefaultStencilFormat
	)

Definition at line 43 of file capabilities_unittests.cc.

                                             {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetDefaultStencilFormat(), PixelFormat::kUnknown);
  auto mutated = CapabilitiesBuilder()
                     .SetDefaultStencilFormat(PixelFormat::kS8UInt)
                     .Build();
  EXPECT_EQ(mutated->GetDefaultStencilFormat(), PixelFormat::kS8UInt);
}

References impeller::CapabilitiesBuilder::Build(), impeller::kS8UInt, impeller::kUnknown, and impeller::CapabilitiesBuilder::SetDefaultStencilFormat().

◆ TEST() [71/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		MaxRenderPassAttachmentSize
	)

Definition at line 71 of file capabilities_unittests.cc.

                                                    {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetMaximumRenderPassAttachmentSize(), ISize(1, 1));
  auto mutated = CapabilitiesBuilder()
                     .SetMaximumRenderPassAttachmentSize({100, 100})
                     .Build();
  EXPECT_EQ(mutated->GetMaximumRenderPassAttachmentSize(), ISize(100, 100));
}

References impeller::CapabilitiesBuilder::Build(), and impeller::CapabilitiesBuilder::SetMaximumRenderPassAttachmentSize().

◆ TEST() [72/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		MaxSamplerAnisotropy
	)

Definition at line 123 of file capabilities_unittests.cc.

                                             {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetMaxSamplerAnisotropy(), 1u);
  auto mutated = CapabilitiesBuilder().SetMaxSamplerAnisotropy(16).Build();
  EXPECT_EQ(mutated->GetMaxSamplerAnisotropy(), 16u);
}

References impeller::CapabilitiesBuilder::Build(), and impeller::CapabilitiesBuilder::SetMaxSamplerAnisotropy().

◆ TEST() [73/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		MinUniformAlignment
	)

Definition at line 116 of file capabilities_unittests.cc.

                                            {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_EQ(defaults->GetMinimumUniformAlignment(), 256u);
  auto mutated = CapabilitiesBuilder().SetMinimumUniformAlignment(16).Build();
  EXPECT_EQ(mutated->GetMinimumUniformAlignment(), 16u);
}

References impeller::CapabilitiesBuilder::Build(), and impeller::CapabilitiesBuilder::SetMinimumUniformAlignment().

◆ TEST() [74/689]

impeller::testing::TEST	(	CapabilitiesTest	,
		SupportsTextureCompression
	)

Definition at line 80 of file capabilities_unittests.cc.

                                                   {
  auto defaults = CapabilitiesBuilder().Build();
  EXPECT_FALSE(
      defaults->SupportsTextureCompression(CompressedTextureFamily::kBC));
  EXPECT_FALSE(
      defaults->SupportsTextureCompression(CompressedTextureFamily::kETC2));
  EXPECT_FALSE(
      defaults->SupportsTextureCompression(CompressedTextureFamily::kASTC));
  EXPECT_FALSE(
      defaults->SupportsTextureCompression(CompressedTextureFamily::kASTCHDR));
 
  // Each family is gated independently.
  auto mutated =
      CapabilitiesBuilder()
          .SetSupportsTextureCompression(CompressedTextureFamily::kETC2, true)
          .Build();
  EXPECT_FALSE(
      mutated->SupportsTextureCompression(CompressedTextureFamily::kBC));
  EXPECT_TRUE(
      mutated->SupportsTextureCompression(CompressedTextureFamily::kETC2));
  EXPECT_FALSE(
      mutated->SupportsTextureCompression(CompressedTextureFamily::kASTC));
  EXPECT_FALSE(
      mutated->SupportsTextureCompression(CompressedTextureFamily::kASTCHDR));
 
  // ASTC LDR and HDR are distinct families.
  auto astc_hdr = CapabilitiesBuilder()
                      .SetSupportsTextureCompression(
                          CompressedTextureFamily::kASTCHDR, true)
                      .Build();
  EXPECT_FALSE(
      astc_hdr->SupportsTextureCompression(CompressedTextureFamily::kASTC));
  EXPECT_TRUE(
      astc_hdr->SupportsTextureCompression(CompressedTextureFamily::kASTCHDR));
}

References impeller::CapabilitiesBuilder::Build(), impeller::kASTC, impeller::kASTCHDR, impeller::kBC, impeller::kETC2, and impeller::CapabilitiesBuilder::SetSupportsTextureCompression().

◆ TEST() [75/689]

impeller::testing::TEST	(	CapabilitiesVKTest	,
		ContextFailsInitializationForNoCombinedDepthStencilFormat
	)

Definition at line 215 of file context_vk_unittests.cc.

                                                                {
  ScopedValidationDisable disable_validation;
  const std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalDeviceFormatPropertiesCallback(
              [](VkPhysicalDevice physicalDevice, VkFormat format,
                 VkFormatProperties* pFormatProperties) {
                if (format == VK_FORMAT_R8G8B8A8_UNORM) {
                  pFormatProperties->optimalTilingFeatures =
                      static_cast<VkFormatFeatureFlags>(
                          vk::FormatFeatureFlagBits::eColorAttachment);
                }
                // Ignore combined depth-stencil formats.
              })
          .Build();
  ASSERT_EQ(context, nullptr);
}

References context, format, and impeller::testing::MockVulkanContextBuilder::SetPhysicalDeviceFormatPropertiesCallback().

◆ TEST() [76/689]

impeller::testing::TEST	(	CapabilitiesVKTest	,
		ContextInitializesWithNoStencilFormat
	)

Definition at line 184 of file context_vk_unittests.cc.

                                                                {
  const std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalDeviceFormatPropertiesCallback(
              [](VkPhysicalDevice physicalDevice, VkFormat format,
                 VkFormatProperties* pFormatProperties) {
                if (format == VK_FORMAT_R8G8B8A8_UNORM) {
                  pFormatProperties->optimalTilingFeatures =
                      static_cast<VkFormatFeatureFlags>(
                          vk::FormatFeatureFlagBits::eColorAttachment);
                } else if (format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
                  pFormatProperties->optimalTilingFeatures =
                      static_cast<VkFormatFeatureFlags>(
                          vk::FormatFeatureFlagBits::eDepthStencilAttachment);
                }
                // Ignore just the stencil format.
              })
          .Build();
  ASSERT_NE(context, nullptr);
  const CapabilitiesVK* capabilites_vk =
      reinterpret_cast<const CapabilitiesVK*>(context->GetCapabilities().get());
  ASSERT_EQ(capabilites_vk->GetDefaultDepthStencilFormat(),
            PixelFormat::kD32FloatS8UInt);
  ASSERT_EQ(capabilites_vk->GetDefaultStencilFormat(),
            PixelFormat::kD32FloatS8UInt);
}

References context, format, impeller::CapabilitiesVK::GetDefaultDepthStencilFormat(), impeller::CapabilitiesVK::GetDefaultStencilFormat(), impeller::kD32FloatS8UInt, and impeller::testing::MockVulkanContextBuilder::SetPhysicalDeviceFormatPropertiesCallback().

◆ TEST() [77/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		BufferToTextureBlitCanBeSubmittedBeforeContextCurrent
	)

Definition at line 176 of file command_buffer_gles_unittests.cc.

                                                                               {
  auto mock_gles_impl = std::make_unique<NiceMock<MockGLESImpl>>();
  auto& mock_gles_impl_ref = *mock_gles_impl;
  auto mock_gles = MockGLES::Init(std::move(mock_gles_impl));
  auto context = CreateFakeGLESContext();
  auto context_base = std::static_pointer_cast<Context>(context);
  auto worker = std::make_shared<ToggleWorker>(false);
  context->AddReactorWorker(worker);
 
  constexpr GLuint kTextureHandle = 1234;
  bool texture_generated = false;
  bool texture_uploaded = false;
  EXPECT_CALL(mock_gles_impl_ref, GenTextures(1, _))
      .WillOnce([&](GLsizei size, GLuint* textures) {
        texture_generated = true;
        textures[0] = kTextureHandle;
      });
  EXPECT_CALL(mock_gles_impl_ref, BindTexture(GL_TEXTURE_2D, kTextureHandle))
      .Times(::testing::AtLeast(1));
  EXPECT_CALL(mock_gles_impl_ref,
              TexImage2D(GL_TEXTURE_2D, 0, _, 2, 2, 0, _, _, nullptr))
      .Times(1);
  EXPECT_CALL(mock_gles_impl_ref,
              TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 2, _, _, _))
      .WillOnce([&](GLenum target, GLint level, GLint xoffset, GLint yoffset,
                    GLsizei width, GLsizei height, GLenum format, GLenum type,
                    const void* pixels) { texture_uploaded = true; });
 
  TextureDescriptor texture_descriptor;
  texture_descriptor.size = {2, 2};
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  auto texture = context_base->GetResourceAllocator()->CreateTexture(
      texture_descriptor, /*threadsafe=*/true);
  ASSERT_TRUE(texture);
 
  const uint8_t pixels[16] = {};
  auto buffer =
      context_base->GetResourceAllocator()->CreateBufferWithCopy(pixels, 16);
  ASSERT_TRUE(buffer);
 
  auto command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(command_buffer);
  auto blit_pass = command_buffer->CreateBlitPass();
  ASSERT_TRUE(blit_pass);
 
  EXPECT_TRUE(blit_pass->AddCopy(BufferView(buffer, Range(0, 16)), texture,
                                 IRect::MakeXYWH(0, 0, 2, 2),
                                 "Deferred texture overwrite"));
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(context_base->GetCommandQueue()->Submit({command_buffer}).ok());
  EXPECT_FALSE(texture_generated);
  EXPECT_FALSE(texture_uploaded);
 
  worker->SetAllowed(true);
  EXPECT_TRUE(context->GetReactor()->React());
  EXPECT_TRUE(texture_generated);
  EXPECT_TRUE(texture_uploaded);
}

References flutter::buffer, command_buffer, context, impeller::TextureDescriptor::format, format, height, impeller::testing::MockGLES::Init(), impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeXYWH(), impeller::TextureDescriptor::size, flutter::size, target, texture, type, and width.

◆ TEST() [78/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		DeferredSubmitCallbackErrorsIfReactorIsDestroyed
	)

Definition at line 94 of file command_buffer_gles_unittests.cc.

                                                                          {
  bool callback_called = false;
  CommandBuffer::Status callback_status = CommandBuffer::Status::kCompleted;
 
  {
    auto mock_gles = MockGLES::Init();
    auto context = CreateFakeGLESContext();
    auto context_base = std::static_pointer_cast<Context>(context);
    auto worker = std::make_shared<ToggleWorker>(false);
    context->AddReactorWorker(worker);
 
    auto command_buffer = context_base->CreateCommandBuffer();
    ASSERT_TRUE(command_buffer);
    auto status = context_base->GetCommandQueue()->Submit(
        {command_buffer}, [&](CommandBuffer::Status status) {
          callback_called = true;
          callback_status = status;
        });
 
    EXPECT_TRUE(status.ok());
    EXPECT_FALSE(callback_called);
  }
 
  EXPECT_TRUE(callback_called);
  EXPECT_EQ(callback_status, CommandBuffer::Status::kError);
}

References command_buffer, context, impeller::testing::MockGLES::Init(), impeller::CommandBuffer::kCompleted, and impeller::CommandBuffer::kError.

◆ TEST() [79/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		DeferredSubmitCompletesAfterPreviouslyQueuedWork
	)

Definition at line 121 of file command_buffer_gles_unittests.cc.

                                                                          {
  auto mock_gles = MockGLES::Init();
  auto context = CreateFakeGLESContext();
  auto context_base = std::static_pointer_cast<Context>(context);
  auto worker = std::make_shared<ToggleWorker>(false);
  context->AddReactorWorker(worker);
 
  std::vector<int> order;
  ASSERT_TRUE(context->GetReactor()->AddOperation(
      [&](const ReactorGLES& reactor) { order.push_back(1); },
      /*defer=*/true));
 
  auto command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(command_buffer);
  auto status = context_base->GetCommandQueue()->Submit(
      {command_buffer},
      [&](CommandBuffer::Status status) { order.push_back(2); });
 
  EXPECT_TRUE(status.ok());
  EXPECT_TRUE(order.empty());
 
  worker->SetAllowed(true);
  EXPECT_TRUE(context->GetReactor()->React());
  EXPECT_THAT(order, ::testing::ElementsAre(1, 2));
}

References command_buffer, context, impeller::testing::MockGLES::Init(), and reactor.

◆ TEST() [80/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		LaterCurrentSubmitDrainsPreviouslyDeferredWork
	)

Definition at line 147 of file command_buffer_gles_unittests.cc.

                                                                        {
  auto mock_gles = MockGLES::Init();
  auto context = CreateFakeGLESContext();
  auto context_base = std::static_pointer_cast<Context>(context);
  auto worker = std::make_shared<ToggleWorker>(false);
  context->AddReactorWorker(worker);
 
  std::vector<int> order;
  ASSERT_TRUE(context->GetReactor()->AddOperation(
      [&](const ReactorGLES& reactor) { order.push_back(1); },
      /*defer=*/true));
 
  auto deferred_command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(deferred_command_buffer);
  EXPECT_TRUE(
      context_base->GetCommandQueue()->Submit({deferred_command_buffer}).ok());
  EXPECT_TRUE(order.empty());
 
  worker->SetAllowed(true);
  auto current_command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(current_command_buffer);
  EXPECT_TRUE(
      context_base->GetCommandQueue()
          ->Submit({current_command_buffer},
                   [&](CommandBuffer::Status status) { order.push_back(2); })
          .ok());
  EXPECT_THAT(order, ::testing::ElementsAre(1, 2));
}

References context, impeller::testing::MockGLES::Init(), and reactor.

◆ TEST() [81/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		SubmitWithoutCallbackIsAcceptedWithoutCurrentContext
	)

Definition at line 81 of file command_buffer_gles_unittests.cc.

                                                                              {
  auto mock_gles = MockGLES::Init();
  auto context = CreateFakeGLESContext();
  auto context_base = std::static_pointer_cast<Context>(context);
  auto worker = std::make_shared<ToggleWorker>(false);
  context->AddReactorWorker(worker);
 
  auto command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(command_buffer);
 
  EXPECT_TRUE(context_base->GetCommandQueue()->Submit({command_buffer}).ok());
}

References command_buffer, context, and impeller::testing::MockGLES::Init().

◆ TEST() [82/689]

impeller::testing::TEST	(	CommandBufferGLES	,
		SubmitWithoutCurrentContextIsAcceptedAndCompletesAfterReaction
	)

Definition at line 53 of file command_buffer_gles_unittests.cc.

                                                                     {
  auto mock_gles = MockGLES::Init();
  auto context = CreateFakeGLESContext();
  auto context_base = std::static_pointer_cast<Context>(context);
  auto worker = std::make_shared<ToggleWorker>(false);
  context->AddReactorWorker(worker);
 
  auto command_buffer = context_base->CreateCommandBuffer();
  ASSERT_TRUE(command_buffer);
 
  bool callback_called = false;
  CommandBuffer::Status callback_status = CommandBuffer::Status::kError;
  auto status = context_base->GetCommandQueue()->Submit(
      {command_buffer}, [&](CommandBuffer::Status status) {
        callback_called = true;
        callback_status = status;
      });
 
  EXPECT_TRUE(status.ok());
  EXPECT_FALSE(callback_called);
 
  worker->SetAllowed(true);
  EXPECT_TRUE(context->GetReactor()->React());
  EXPECT_TRUE(callback_called);
  EXPECT_EQ(callback_status, CommandBuffer::Status::kCompleted);
}

References command_buffer, context, impeller::testing::MockGLES::Init(), impeller::CommandBuffer::kCompleted, and impeller::CommandBuffer::kError.

◆ TEST() [83/689]

impeller::testing::TEST	(	CommandEncoderVKTest	,
		CleanupAfterSubmit
	)

Definition at line 37 of file command_encoder_vk_unittests.cc.

                                               {
  // This tests deleting the TrackedObjects where the thread is killed before
  // the fence waiter has disposed of them, making sure the command buffer and
  // its pools are deleted in that order.
  std::shared_ptr<std::vector<std::string>> called_functions;
  {
    fml::AutoResetWaitableEvent wait_for_submit;
    fml::AutoResetWaitableEvent wait_for_thread_join;
    auto context = MockVulkanContextBuilder().Build();
    std::thread thread([&] {
      auto buffer = context->CreateCommandBuffer();
      context->GetCommandQueue()->Submit(
          {buffer}, [&](CommandBuffer::Status status) {
            ASSERT_EQ(status, CommandBuffer::Status::kCompleted);
            wait_for_thread_join.Wait();
            wait_for_submit.Signal();
          });
    });
    thread.join();
    wait_for_thread_join.Signal();
    wait_for_submit.Wait();
    called_functions = GetMockVulkanFunctions(context->GetDevice());
    context->Shutdown();
  }
 
  auto destroy_pool =
      std::find(called_functions->begin(), called_functions->end(),
                "vkDestroyCommandPool");
  auto free_buffers =
      std::find(called_functions->begin(), called_functions->end(),
                "vkFreeCommandBuffers");
  EXPECT_TRUE(destroy_pool != called_functions->end());
  EXPECT_TRUE(free_buffers != called_functions->end());
  EXPECT_TRUE(free_buffers < destroy_pool);
}

References flutter::buffer, impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), impeller::CommandBuffer::kCompleted, fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

◆ TEST() [84/689]

impeller::testing::TEST	(	CommandEncoderVKTest	,
		DeleteEncoderAfterThreadDies
	)

Definition at line 15 of file command_encoder_vk_unittests.cc.

                                                         {
  // Tests that when a CommandEncoderVK is deleted that it will clean up its
  // command buffers before it cleans up its command pool.
  std::shared_ptr<std::vector<std::string>> called_functions;
  {
    auto context = MockVulkanContextBuilder().Build();
    called_functions = GetMockVulkanFunctions(context->GetDevice());
    std::thread thread([&] { context->CreateCommandBuffer(); });
    thread.join();
    context->Shutdown();
  }
  auto destroy_pool =
      std::find(called_functions->begin(), called_functions->end(),
                "vkDestroyCommandPool");
  auto free_buffers =
      std::find(called_functions->begin(), called_functions->end(),
                "vkFreeCommandBuffers");
  EXPECT_TRUE(destroy_pool != called_functions->end());
  EXPECT_TRUE(free_buffers != called_functions->end());
  EXPECT_TRUE(free_buffers < destroy_pool);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, and GetMockVulkanFunctions().

◆ TEST() [85/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		CommandBuffersAreRecycled
	)

Definition at line 138 of file command_pool_vk_unittests.cc.

                                                           {
  auto const context = MockVulkanContextBuilder().Build();
 
  {
    // Fetch a pool (which will be created).
    auto const recycler = context->GetCommandPoolRecycler();
    auto pool = recycler->Get();
 
    auto buffer = pool->CreateCommandBuffer();
    pool->CollectCommandBuffer(std::move(buffer));
 
    // This normally is called at the end of a frame.
    recycler->Dispose();
  }
 
  WaitForReclaim(context);
 
  {
    // Create a second pool and command buffer, which should reused the existing
    // pool and cmd buffer.
    auto const recycler = context->GetCommandPoolRecycler();
    auto pool = recycler->Get();
 
    auto buffer = pool->CreateCommandBuffer();
    pool->CollectCommandBuffer(std::move(buffer));
 
    // This normally is called at the end of a frame.
    recycler->Dispose();
  }
 
  // Now check that we only ever created one pool and one command buffer.
  auto const called = ReclaimAndGetMockVulkanFunctions(context);
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateCommandPool"),
            1u);
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkAllocateCommandBuffers"),
      1u);
 
  context->Shutdown();
}

References flutter::buffer, impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [86/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		ExtraCommandBufferAllocationsTriggerTrim
	)

Definition at line 179 of file command_pool_vk_unittests.cc.

                                                                          {
  auto const context = MockVulkanContextBuilder().Build();
 
  {
    // Fetch a pool (which will be created).
    auto const recycler = context->GetCommandPoolRecycler();
    auto pool = recycler->Get();
 
    // Allocate a large number of command buffers
    for (auto i = 0; i < 64; i++) {
      auto buffer = pool->CreateCommandBuffer();
      pool->CollectCommandBuffer(std::move(buffer));
    }
 
    // This normally is called at the end of a frame.
    recycler->Dispose();
  }
 
  // Command pool is reset but does not release resources.
  auto called = ReclaimAndGetMockVulkanFunctions(context);
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkResetCommandPool"),
            1u);
 
  // Create the pool a second time, but dont use any command buffers.
  {
    // Fetch a pool (which will be created).
    auto const recycler = context->GetCommandPoolRecycler();
    auto pool = recycler->Get();
 
    // This normally is called at the end of a frame.
    recycler->Dispose();
  }
 
  // Verify that the cmd pool was trimmed.
 
  // Now check that we only ever created one pool and one command buffer.
  called = ReclaimAndGetMockVulkanFunctions(context);
  EXPECT_EQ(std::count(called->begin(), called->end(),
                       "vkResetCommandPoolReleaseResources"),
            1u);
 
  context->Shutdown();
}

References flutter::buffer, impeller::testing::MockVulkanContextBuilder::Build(), context, and i.

◆ TEST() [87/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		GetsACommandPoolPerThread
	)

Definition at line 15 of file command_pool_vk_unittests.cc.

                                                           {
  auto const context = MockVulkanContextBuilder().Build();
 
  {
    // Record the memory location of each pointer to a command pool.
    //
    // These pools have to be held at this context, otherwise they will be
    // dropped and recycled and potentially reused by another thread, causing
    // flaky tests.
    std::shared_ptr<CommandPoolVK> pool1;
    std::shared_ptr<CommandPoolVK> pool2;
 
    // Create a command pool in two threads and record the memory location.
    std::thread thread1(
        [&]() { pool1 = context->GetCommandPoolRecycler()->Get(); });
 
    std::thread thread2(
        [&]() { pool2 = context->GetCommandPoolRecycler()->Get(); });
 
    thread1.join();
    thread2.join();
 
    // The two command pools should be different.
    EXPECT_NE(pool1, pool2);
  }
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [88/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		GetsTheSameCommandPoolOnSameThread
	)

Definition at line 44 of file command_pool_vk_unittests.cc.

                                                                    {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto const pool1 = context->GetCommandPoolRecycler()->Get();
  auto const pool2 = context->GetCommandPoolRecycler()->Get();
 
  // The two command pools should be the same.
  EXPECT_EQ(pool1.get(), pool2.get());
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [89/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		ReclaimMakesCommandPoolAvailable
	)

Definition at line 108 of file command_pool_vk_unittests.cc.

                                                                  {
  auto const context = MockVulkanContextBuilder().Build();
 
  {
    // Fetch a pool (which will be created).
    auto const recycler = context->GetCommandPoolRecycler();
    auto const pool = recycler->Get();
 
    // This normally is called at the end of a frame.
    recycler->Dispose();
  }
 
  WaitForReclaim(context);
 
  // On another thread explicitly, request a new pool.
  std::thread thread([&]() {
    auto const pool = context->GetCommandPoolRecycler()->Get();
    EXPECT_NE(pool.get(), nullptr);
  });
 
  thread.join();
 
  // Now check that we only ever created one pool.
  auto const called = ReclaimAndGetMockVulkanFunctions(context);
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateCommandPool"),
            1u);
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [90/689]

impeller::testing::TEST	(	CommandPoolRecyclerVKTest	,
		RecyclerGlobalPoolMapSize
	)

Definition at line 223 of file command_pool_vk_unittests.cc.

                                                           {
  auto context = MockVulkanContextBuilder().Build();
  auto const recycler = context->GetCommandPoolRecycler();
 
  // The global pool list for this context should initially be empty.
  EXPECT_EQ(CommandPoolRecyclerVK::GetGlobalPoolCount(*context), 0);
 
  // Creating a pool for this thread should insert the pool into the global map.
  auto pool = recycler->Get();
  EXPECT_EQ(CommandPoolRecyclerVK::GetGlobalPoolCount(*context), 1);
 
  // Disposing this thread's pool should remove it from the global map.
  pool.reset();
  recycler->Dispose();
  EXPECT_EQ(CommandPoolRecyclerVK::GetGlobalPoolCount(*context), 0);
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, and impeller::CommandPoolRecyclerVK::GetGlobalPoolCount().

◆ TEST() [91/689]

impeller::testing::TEST	(	CommandPoolVKTest	,
		DestroysCleanlyIfDeviceIsDestroyed
	)

Definition at line 255 of file command_pool_vk_unittests.cc.

                                                            {
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create a vk::UniqueCommandPool
  vk::CommandPoolCreateInfo info;
  info.setQueueFamilyIndex(context->GetGraphicsQueue()->GetIndex().family);
  info.setFlags(vk::CommandPoolCreateFlagBits::eTransient);
 
  auto device = context->GetDevice();
  auto [result, pool] = device.createCommandPoolUnique(info);
  ASSERT_EQ(result, vk::Result::eSuccess);
 
  auto device_holder = std::make_shared<MockDeviceHolder>(device);
  std::weak_ptr<DeviceHolderVK> weak_device_holder = device_holder;
 
  auto command_pool = std::make_unique<CommandPoolVK>(
      std::move(pool), std::vector<vk::UniqueCommandBuffer>{}, context,
      weak_device_holder);
 
  // Now, destroy the device holder.
  device_holder.reset();
 
  // Now, destroy the command pool. Since the device holder is dead, this should
  // NOT call vkDestroyCommandPool.
  command_pool.reset();
 
  auto const called = ReclaimAndGetMockVulkanFunctions(context);
  EXPECT_EQ(std::count(called->begin(), called->end(), "vkDestroyCommandPool"),
            0u);
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, and device.

◆ TEST() [92/689]

impeller::testing::TEST	(	CommandQueueVKTest	,
		QueueSubmit
	)

Definition at line 16 of file command_queue_vk_unittests.cc.

                                      {
  const auto context = MockVulkanContextBuilder().Build();
  auto buffer = context->CreateCommandBuffer();
  auto status = context->GetCommandQueue()->Submit({buffer});
  EXPECT_TRUE(status.ok());
 
  const auto called = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_NE(std::find(called->begin(), called->end(), "vkQueueSubmit"),
            called->end());
}

References flutter::buffer, impeller::testing::MockVulkanContextBuilder::Build(), context, and GetMockVulkanFunctions().

◆ TEST() [93/689]

impeller::testing::TEST	(	CommandQueueVKTest	,
		SubmitAfterFenceWaiterTerminated
	)

Definition at line 27 of file command_queue_vk_unittests.cc.

                                                           {
  const auto context = MockVulkanContextBuilder().Build();
  auto buffer = context->CreateCommandBuffer();
  context->GetFenceWaiter()->Terminate();
  auto status = context->GetCommandQueue()->Submit({buffer});
  EXPECT_EQ(status.code(), fml::StatusCode::kCancelled);
 
  // The command buffer should not be submitted to the Vulkan queue if the
  // fence waiter has been terminated.
  const auto called = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::find(called->begin(), called->end(), "vkQueueSubmit"),
            called->end());
}

References flutter::buffer, impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), and fml::kCancelled.

◆ TEST() [94/689]

impeller::testing::TEST	(	ConditionVariableTest	,
		TestsCriticalSectionAfterWait
	)

Definition at line 197 of file base_unittests.cc.

                                                           {
  std::vector<std::thread> threads;
  const auto kThreadCount = 10u;
 
  Mutex mtx;
  ConditionVariable cv;
  size_t sum = 0u;
 
  std::condition_variable start_cv;
  std::mutex start_mtx;
  bool start = false;
  auto start_predicate = [&start]() { return start; };
  auto thread_main = [&]() {
    {
      std::unique_lock start_lock(start_mtx);
      start_cv.wait(start_lock, start_predicate);
    }
 
    mtx.Lock();
    cv.Wait(mtx, []() { return true; });
    auto old_val = sum;
    std::this_thread::sleep_for(std::chrono::milliseconds{100u});
    sum = old_val + 1u;
    mtx.Unlock();
  };
  // Launch all threads. They will wait for the start CV to be signaled.
  threads.reserve(kThreadCount);
  for (size_t i = 0; i < kThreadCount; i++) {
    threads.emplace_back(thread_main);
  }
  // Notify all threads that the test may start.
  {
    {
      std::scoped_lock start_lock(start_mtx);
      start = true;
    }
    start_cv.notify_all();
  }
  // Join all threads.
  ASSERT_EQ(threads.size(), kThreadCount);
  for (size_t i = 0; i < kThreadCount; i++) {
    threads[i].join();
  }
  ASSERT_EQ(sum, kThreadCount);
}

References i, kThreadCount, start, and impeller::ConditionVariable::Wait().

◆ TEST() [95/689]

impeller::testing::TEST	(	ConditionVariableTest	,
		TestsCriticalSectionAfterWaitForUntil
	)

Definition at line 151 of file base_unittests.cc.

                                                                   {
  std::vector<std::thread> threads;
  const auto kThreadCount = 10u;
 
  Mutex mtx;
  ConditionVariable cv;
  size_t sum = 0u;
 
  std::condition_variable start_cv;
  std::mutex start_mtx;
  bool start = false;
  auto start_predicate = [&start]() { return start; };
  auto thread_main = [&]() {
    {
      std::unique_lock start_lock(start_mtx);
      start_cv.wait(start_lock, start_predicate);
    }
 
    mtx.Lock();
    cv.WaitFor(mtx, std::chrono::milliseconds{0u}, []() { return true; });
    auto old_val = sum;
    std::this_thread::sleep_for(std::chrono::milliseconds{100u});
    sum = old_val + 1u;
    mtx.Unlock();
  };
  // Launch all threads. They will wait for the start CV to be signaled.
  threads.reserve(kThreadCount);
  for (size_t i = 0; i < kThreadCount; i++) {
    threads.emplace_back(thread_main);
  }
  // Notify all threads that the test may start.
  {
    {
      std::scoped_lock start_lock(start_mtx);
      start = true;
    }
    start_cv.notify_all();
  }
  // Join all threads.
  ASSERT_EQ(threads.size(), kThreadCount);
  for (size_t i = 0; i < kThreadCount; i++) {
    threads[i].join();
  }
  ASSERT_EQ(sum, kThreadCount);
}

References i, kThreadCount, start, and impeller::ConditionVariable::WaitFor().

◆ TEST() [96/689]

impeller::testing::TEST	(	ConditionVariableTest	,
		WaitFor
	)

Definition at line 113 of file base_unittests.cc.

                                     {
  CVTest test;
  // test.rando_ivar = 12; // <--- Static analysis error
  for (size_t i = 0; i < 2; ++i) {
    test.mutex.Lock();  // <--- Static analysis error without this.
    auto result = test.cv.WaitFor(
        test.mutex, std::chrono::milliseconds{10},
        [&]() IPLR_REQUIRES(test.mutex) {
          test.rando_ivar = 12;  // <-- Static analysics error without the
                                 // IPLR_REQUIRES on the pred.
          return false;
        });
    test.mutex.Unlock();
    ASSERT_FALSE(result);
  }
  Lock lock(test.mutex);  // <--- Static analysis error without this.
  // The predicate never returns true. So return has to be due to a non-spurious
  // wake.
  ASSERT_EQ(test.rando_ivar, 12u);
}

References impeller::testing::CVTest::cv, i, IPLR_REQUIRES, impeller::testing::CVTest::mutex, and impeller::ConditionVariable::WaitFor().

◆ TEST() [97/689]

impeller::testing::TEST	(	ConditionVariableTest	,
		WaitForever
	)

Definition at line 134 of file base_unittests.cc.

                                         {
  CVTest test;
  // test.rando_ivar = 12; // <--- Static analysis error
  for (size_t i = 0; i < 2; ++i) {
    test.mutex.Lock();  // <--- Static analysis error without this.
    test.cv.Wait(test.mutex, [&]() IPLR_REQUIRES(test.mutex) {
      test.rando_ivar = 12;  // <-- Static analysics error without
                             // the IPLR_REQUIRES on the pred.
      return true;
    });
    test.mutex.Unlock();
  }
  Lock lock(test.mutex);  // <--- Static analysis error without this.
  // The wake only happens when the predicate returns true.
  ASSERT_EQ(test.rando_ivar, 12u);
}

References impeller::testing::CVTest::cv, i, IPLR_REQUIRES, impeller::testing::CVTest::mutex, and impeller::ConditionVariable::Wait().

◆ TEST() [98/689]

impeller::testing::TEST	(	ConditionVariableTest	,
		WaitUntil
	)

Definition at line 90 of file base_unittests.cc.

                                       {
  CVTest test;
  // test.rando_ivar = 12; // <--- Static analysis error
  for (size_t i = 0; i < 2; ++i) {
    test.mutex.Lock();  // <--- Static analysis error without this.
    auto result = test.cv.WaitUntil(
        test.mutex,
        std::chrono::high_resolution_clock::now() +
            std::chrono::milliseconds{10},
        [&]() IPLR_REQUIRES(test.mutex) {
          test.rando_ivar = 12;  // <-- Static analysics error without the
                                 // IPLR_REQUIRES on the pred.
          return false;
        });
    test.mutex.Unlock();
    ASSERT_FALSE(result);
  }
  Lock lock(test.mutex);  // <--- Static analysis error without this.
  // The predicate never returns true. So return has to be due to a non-spurious
  // wake.
  ASSERT_EQ(test.rando_ivar, 12u);
}

References impeller::testing::CVTest::cv, i, IPLR_REQUIRES, impeller::testing::CVTest::mutex, and impeller::ConditionVariable::WaitUntil().

◆ TEST() [99/689]

impeller::testing::TEST	(	ContextVKTest	,
		AHBSwapchainCapabilitiesCanBeMissing
	)

Definition at line 357 of file context_vk_unittests.cc.

                                                          {
  {
    std::shared_ptr<ContextVK> context =
        MockVulkanContextBuilder()
            .SetSettingsCallback([](ContextVK::Settings& settings) {
              settings.enable_surface_control = true;
            })
            .Build();
 
    EXPECT_FALSE(context->GetShouldEnableSurfaceControlSwapchain());
  }
 
  ContextVK::EmbedderData data;
  auto other_context = MockVulkanContextBuilder().Build();
 
  data.instance = other_context->GetInstance();
  data.device = other_context->GetDevice();
  data.physical_device = other_context->GetPhysicalDevice();
  data.queue = VkQueue{};
  data.queue_family_index = 0;
  data.instance_extensions = {"VK_KHR_surface", "VK_KHR_android_surface"};
  data.device_extensions = {"VK_KHR_swapchain",
                            VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME,
                            VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME,
                            VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME,
                            VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME};
 
  auto context = MockVulkanContextBuilder()
                     .SetSettingsCallback([](ContextVK::Settings& settings) {
                       settings.enable_surface_control = true;
                     })
                     .SetEmbedderData(data)
                     .Build();
 
  EXPECT_TRUE(context->GetShouldEnableSurfaceControlSwapchain());
 
}  // namespace impeller

References impeller::testing::MockVulkanContextBuilder::Build(), context, flutter::data, impeller::ContextVK::Settings::enable_surface_control, and impeller::testing::MockVulkanContextBuilder::SetSettingsCallback().

◆ TEST() [100/689]

impeller::testing::TEST	(	ContextVKTest	,
		BatchSubmitCommandBuffersOnArm
	)

Definition at line 306 of file context_vk_unittests.cc.

                                                    {
  std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x13B5;  // ARM
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
 
  EXPECT_TRUE(context->EnqueueCommandBuffer(context->CreateCommandBuffer()));
  EXPECT_TRUE(context->EnqueueCommandBuffer(context->CreateCommandBuffer()));
 
  // If command buffers are batch submitted, we should have created them but not
  // created the fence to track them after enqueing.
  auto functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkAllocateCommandBuffers") != functions->end());
  EXPECT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkCreateFence") == functions->end());
 
  context->FlushCommandBuffers();
 
  // After flushing, the fence should be created.
  functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkCreateFence") != functions->end());
}

References context, device, GetMockVulkanFunctions(), and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [101/689]

impeller::testing::TEST	(	ContextVKTest	,
		BatchSubmitCommandBuffersOnNonArm
	)

Definition at line 335 of file context_vk_unittests.cc.

                                                       {
  std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x8686;  // Made up ID
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
 
  EXPECT_TRUE(context->EnqueueCommandBuffer(context->CreateCommandBuffer()));
  EXPECT_TRUE(context->EnqueueCommandBuffer(context->CreateCommandBuffer()));
 
  // If command buffers are batched and not submitted, we should have created
  // them and a corresponding fence immediately.
  auto functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkAllocateCommandBuffers") != functions->end());
  EXPECT_FALSE(std::find(functions->begin(), functions->end(),
                         "vkCreateFence") != functions->end());
}

References context, device, GetMockVulkanFunctions(), and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [102/689]

impeller::testing::TEST	(	ContextVKTest	,
		CanCreateContextInAbsenceOfValidationLayers
	)

Definition at line 152 of file context_vk_unittests.cc.

                                                                 {
  // The mocked methods don't report the presence of a validation layer but we
  // explicitly ask for validation. Context creation should continue anyway.
  auto context = MockVulkanContextBuilder()
                     .SetSettingsCallback([](auto& settings) {
                       settings.enable_validation = true;
                     })
                     .Build();
  ASSERT_NE(context, nullptr);
  const CapabilitiesVK* capabilites_vk =
      reinterpret_cast<const CapabilitiesVK*>(context->GetCapabilities().get());
  ASSERT_FALSE(capabilites_vk->AreValidationsEnabled());
}

References impeller::CapabilitiesVK::AreValidationsEnabled(), context, and impeller::testing::MockVulkanContextBuilder::SetSettingsCallback().

◆ TEST() [103/689]

impeller::testing::TEST	(	ContextVKTest	,
		CanCreateContextWithValidationLayers
	)

Definition at line 166 of file context_vk_unittests.cc.

                                                          {
  auto context =
      MockVulkanContextBuilder()
          .SetSettingsCallback(
              [](auto& settings) { settings.enable_validation = true; })
          .SetInstanceExtensions(
              {"VK_KHR_surface", "VK_MVK_macos_surface", "VK_EXT_debug_utils"})
          .SetInstanceLayers({"VK_LAYER_KHRONOS_validation"})
          .Build();
  ASSERT_NE(context, nullptr);
  const CapabilitiesVK* capabilites_vk =
      reinterpret_cast<const CapabilitiesVK*>(context->GetCapabilities().get());
  ASSERT_TRUE(capabilites_vk->AreValidationsEnabled());
}

References impeller::CapabilitiesVK::AreValidationsEnabled(), context, and impeller::testing::MockVulkanContextBuilder::SetSettingsCallback().

◆ TEST() [104/689]

impeller::testing::TEST	(	ContextVKTest	,
		CommonHardwareConcurrencyConfigurations
	)

Definition at line 17 of file context_vk_unittests.cc.

                                                             {
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(100u), 4u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(9u), 4u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(8u), 4u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(7u), 3u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(6u), 3u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(5u), 2u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(4u), 2u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(3u), 1u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(2u), 1u);
  EXPECT_EQ(ContextVK::ChooseThreadCountForWorkers(1u), 1u);
}

References impeller::ContextVK::ChooseThreadCountForWorkers().

◆ TEST() [105/689]

impeller::testing::TEST	(	ContextVKTest	,
		DeletePipelineAfterContext
	)

Definition at line 95 of file context_vk_unittests.cc.

                                                {
  std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline;
  std::shared_ptr<std::vector<std::string>> functions;
  {
    std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
    PipelineDescriptor pipeline_desc;
    pipeline_desc.SetVertexDescriptor(std::make_shared<VertexDescriptor>());
    PipelineFuture<PipelineDescriptor> pipeline_future =
        context->GetPipelineLibrary()->GetPipeline(pipeline_desc);
    pipeline = pipeline_future.Get();
    ASSERT_TRUE(pipeline);
    functions = GetMockVulkanFunctions(context->GetDevice());
    ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                          "vkCreateGraphicsPipelines") != functions->end());
  }
  ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkDestroyDevice") != functions->end());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::PipelineFuture< T >::Get(), GetMockVulkanFunctions(), pipeline, and impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [106/689]

impeller::testing::TEST	(	ContextVKTest	,
		DeletePipelineLibraryAfterContext
	)

Definition at line 136 of file context_vk_unittests.cc.

                                                       {
  std::shared_ptr<PipelineLibrary> pipeline_library;
  std::shared_ptr<std::vector<std::string>> functions;
  {
    std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
    PipelineDescriptor pipeline_desc;
    pipeline_desc.SetVertexDescriptor(std::make_shared<VertexDescriptor>());
    pipeline_library = context->GetPipelineLibrary();
    functions = GetMockVulkanFunctions(context->GetDevice());
    ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                          "vkCreatePipelineCache") != functions->end());
  }
  ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkDestroyDevice") != functions->end());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), and impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [107/689]

impeller::testing::TEST	(	ContextVKTest	,
		DeletesCommandPools
	)

Definition at line 30 of file context_vk_unittests.cc.

                                         {
  std::weak_ptr<ContextVK> weak_context;
  std::weak_ptr<CommandPoolVK> weak_pool;
  {
    std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
    auto const pool = context->GetCommandPoolRecycler()->Get();
    weak_pool = pool;
    weak_context = context;
    ASSERT_TRUE(weak_pool.lock());
    ASSERT_TRUE(weak_context.lock());
  }
  ASSERT_FALSE(weak_pool.lock());
  ASSERT_FALSE(weak_context.lock());
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [108/689]

impeller::testing::TEST	(	ContextVKTest	,
		DeletesCommandPoolsOnAllThreads
	)

Definition at line 45 of file context_vk_unittests.cc.

                                                     {
  std::weak_ptr<ContextVK> weak_context;
  std::weak_ptr<CommandPoolVK> weak_pool_main;
 
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
  weak_pool_main = context->GetCommandPoolRecycler()->Get();
  weak_context = context;
  ASSERT_TRUE(weak_pool_main.lock());
  ASSERT_TRUE(weak_context.lock());
 
  // Start a second thread that obtains a command pool.
  fml::AutoResetWaitableEvent latch1, latch2;
  std::weak_ptr<CommandPoolVK> weak_pool_thread;
  std::thread thread([&]() {
    weak_pool_thread = context->GetCommandPoolRecycler()->Get();
    latch1.Signal();
    latch2.Wait();
  });
 
  // Delete the ContextVK on the main thread.
  latch1.Wait();
  context.reset();
  ASSERT_FALSE(weak_pool_main.lock());
  ASSERT_FALSE(weak_context.lock());
 
  // Stop the second thread and check that its command pool has been deleted.
  latch2.Signal();
  thread.join();
  ASSERT_FALSE(weak_pool_thread.lock());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

◆ TEST() [109/689]

impeller::testing::TEST	(	ContextVKTest	,
		DeleteShaderFunctionAfterContext
	)

Definition at line 114 of file context_vk_unittests.cc.

                                                      {
  std::shared_ptr<const ShaderFunction> shader_function;
  std::shared_ptr<std::vector<std::string>> functions;
  {
    std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
    PipelineDescriptor pipeline_desc;
    pipeline_desc.SetVertexDescriptor(std::make_shared<VertexDescriptor>());
    std::vector<uint8_t> data = {0x03, 0x02, 0x23, 0x07};
    context->GetShaderLibrary()->RegisterFunction(
        "foobar_fragment_main", ShaderStage::kFragment,
        std::make_shared<fml::DataMapping>(data), [](bool) {});
    shader_function = context->GetShaderLibrary()->GetFunction(
        "foobar_fragment_main", ShaderStage::kFragment);
    ASSERT_TRUE(shader_function);
    functions = GetMockVulkanFunctions(context->GetDevice());
    ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                          "vkCreateShaderModule") != functions->end());
  }
  ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkDestroyDevice") != functions->end());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, flutter::data, GetMockVulkanFunctions(), impeller::kFragment, and impeller::PipelineDescriptor::SetVertexDescriptor().

◆ TEST() [110/689]

impeller::testing::TEST	(	ContextVKTest	,
		EmbedderOverrides
	)

Definition at line 283 of file context_vk_unittests.cc.

                                       {
  ContextVK::EmbedderData data;
  auto other_context = MockVulkanContextBuilder().Build();
 
  data.instance = other_context->GetInstance();
  data.device = other_context->GetDevice();
  data.physical_device = other_context->GetPhysicalDevice();
  data.queue = VkQueue{};
  data.queue_family_index = 0;
  data.instance_extensions = {"VK_KHR_surface",
                              "VK_KHR_portability_enumeration"};
  data.device_extensions = {"VK_KHR_swapchain"};
 
  auto context = MockVulkanContextBuilder().SetEmbedderData(data).Build();
 
  EXPECT_TRUE(context->IsValid());
  EXPECT_EQ(context->GetInstance(), other_context->GetInstance());
  EXPECT_EQ(context->GetDevice(), other_context->GetDevice());
  EXPECT_EQ(context->GetPhysicalDevice(), other_context->GetPhysicalDevice());
  EXPECT_EQ(context->GetGraphicsQueue()->GetIndex().index, 0u);
  EXPECT_EQ(context->GetGraphicsQueue()->GetIndex().family, 0u);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, flutter::data, and impeller::testing::MockVulkanContextBuilder::SetEmbedderData().

◆ TEST() [111/689]

impeller::testing::TEST	(	ContextVKTest	,
		EmbedderOverridesUsesInstanceExtensions
	)

Definition at line 264 of file context_vk_unittests.cc.

                                                             {
  ContextVK::EmbedderData data;
  auto other_context = MockVulkanContextBuilder().Build();
 
  data.instance = other_context->GetInstance();
  data.device = other_context->GetDevice();
  data.physical_device = other_context->GetPhysicalDevice();
  data.queue = VkQueue{};
  data.queue_family_index = 0;
  // Missing surface extension.
  data.instance_extensions = {};
  data.device_extensions = {"VK_KHR_swapchain"};
 
  ScopedValidationDisable scoped;
  auto context = MockVulkanContextBuilder().SetEmbedderData(data).Build();
 
  EXPECT_EQ(context, nullptr);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, flutter::data, and impeller::testing::MockVulkanContextBuilder::SetEmbedderData().

◆ TEST() [112/689]

impeller::testing::TEST	(	ContextVKTest	,
		FatalMissingValidations
	)

Definition at line 245 of file context_vk_unittests.cc.

                                             {
  EXPECT_DEATH(const std::shared_ptr<ContextVK> context =
                   MockVulkanContextBuilder()
                       .SetSettingsCallback([](ContextVK::Settings& settings) {
                         settings.enable_validation = true;
                         settings.fatal_missing_validations = true;
                       })
                       .Build(),
               "");
}

References context, impeller::ContextVK::Settings::enable_validation, and impeller::ContextVK::Settings::fatal_missing_validations.

◆ TEST() [113/689]

impeller::testing::TEST	(	ContextVKTest	,
		HasDefaultColorFormat
	)

Definition at line 256 of file context_vk_unittests.cc.

                                           {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  const CapabilitiesVK* capabilites_vk =
      reinterpret_cast<const CapabilitiesVK*>(context->GetCapabilities().get());
  ASSERT_NE(capabilites_vk->GetDefaultColorFormat(), PixelFormat::kUnknown);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::CapabilitiesVK::GetDefaultColorFormat(), and impeller::kUnknown.

◆ TEST() [114/689]

impeller::testing::TEST	(	ContextVKTest	,
		HashIsUniqueAcrossThreads
	)

Definition at line 395 of file context_vk_unittests.cc.

                                               {
  uint64_t hash1, hash2;
  std::thread thread1([&]() {
    auto context = MockVulkanContextBuilder().Build();
    hash1 = context->GetHash();
  });
  std::thread thread2([&]() {
    auto context = MockVulkanContextBuilder().Build();
    hash2 = context->GetHash();
  });
  thread1.join();
  thread2.join();
 
  EXPECT_NE(hash1, hash2);
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [115/689]

impeller::testing::TEST	(	ContextVKTest	,
		ThreadLocalCleanupDeletesCommandPool
	)

Definition at line 76 of file context_vk_unittests.cc.

                                                          {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  fml::AutoResetWaitableEvent latch1, latch2;
  std::weak_ptr<CommandPoolVK> weak_pool;
  std::thread thread([&]() {
    weak_pool = context->GetCommandPoolRecycler()->Get();
    context->DisposeThreadLocalCachedResources();
    latch1.Signal();
    latch2.Wait();
  });
 
  latch1.Wait();
  ASSERT_FALSE(weak_pool.lock());
 
  latch2.Signal();
  thread.join();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, fml::AutoResetWaitableEvent::Signal(), and fml::AutoResetWaitableEvent::Wait().

◆ TEST() [116/689]

impeller::testing::TEST	(	ContextVKTest	,
		WarmUpFunctionCreatesRenderPass
	)

Definition at line 234 of file context_vk_unittests.cc.

                                                     {
  const std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  context->SetOffscreenFormat(PixelFormat::kR8G8B8A8UNormInt);
  context->InitializeCommonlyUsedShadersIfNeeded();
 
  auto functions = GetMockVulkanFunctions(context->GetDevice());
  ASSERT_TRUE(std::find(functions->begin(), functions->end(),
                        "vkCreateRenderPass") != functions->end());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), and impeller::kR8G8B8A8UNormInt.

◆ TEST() [117/689]

impeller::testing::TEST	(	DescriptorPoolRecyclerVKTest	,
		DescriptorsAreRecycled
	)

Definition at line 110 of file descriptor_pool_vk_unittests.cc.

                                                           {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  {
    DescriptorPoolVK pool = DescriptorPoolVK(context);
    pool.AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
  }
 
  // Should reuse the same descriptor set allocated above.
  std::shared_ptr<DescriptorPoolVK> pool =
      context->GetDescriptorPoolRecycler()->GetDescriptorPool();
  pool->AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
 
  std::shared_ptr<std::vector<std::string>> called =
      GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkAllocateDescriptorSets"),
      1);
 
  // Should allocate a new descriptor set.
  pool->AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkAllocateDescriptorSets"),
      2);
}

References impeller::DescriptorPoolVK::AllocateDescriptorSets(), impeller::testing::MockVulkanContextBuilder::Build(), context, and GetMockVulkanFunctions().

◆ TEST() [118/689]

impeller::testing::TEST	(	DescriptorPoolRecyclerVKTest	,
		GetDescriptorPoolRecyclerCreatesNewPools
	)

Definition at line 13 of file descriptor_pool_vk_unittests.cc.

                                                                             {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  vk::UniqueDescriptorPool pool1 = context->GetDescriptorPoolRecycler()->Get();
  vk::UniqueDescriptorPool pool2 = context->GetDescriptorPoolRecycler()->Get();
 
  // The two descriptor pools should be different.
  EXPECT_NE(pool1.get(), pool2.get());
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [119/689]

impeller::testing::TEST	(	DescriptorPoolRecyclerVKTest	,
		MultipleCommandBuffersShareDescriptorPool
	)

Definition at line 88 of file descriptor_pool_vk_unittests.cc.

                                                                              {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  std::shared_ptr<CommandBuffer> cmd_buffer_1 = context->CreateCommandBuffer();
  std::shared_ptr<CommandBuffer> cmd_buffer_2 = context->CreateCommandBuffer();
 
  CommandBufferVK& vk_1 = CommandBufferVK::Cast(*cmd_buffer_1);
  CommandBufferVK& vk_2 = CommandBufferVK::Cast(*cmd_buffer_2);
 
  EXPECT_EQ(&vk_1.GetDescriptorPool(), &vk_2.GetDescriptorPool());
 
  // Resetting resources creates a new pool.
  context->DisposeThreadLocalCachedResources();
 
  std::shared_ptr<CommandBuffer> cmd_buffer_3 = context->CreateCommandBuffer();
  CommandBufferVK& vk_3 = CommandBufferVK::Cast(*cmd_buffer_3);
 
  EXPECT_NE(&vk_1.GetDescriptorPool(), &vk_3.GetDescriptorPool());
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::BackendCast< CommandBufferVK, CommandBuffer >::Cast(), context, and impeller::CommandBufferVK::GetDescriptorPool().

◆ TEST() [120/689]

impeller::testing::TEST	(	DescriptorPoolRecyclerVKTest	,
		ReclaimDropsDescriptorPoolIfSizeIsExceeded
	)

Definition at line 46 of file descriptor_pool_vk_unittests.cc.

                                                                               {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  // Create 33 pools
  {
    std::vector<std::unique_ptr<DescriptorPoolVK>> pools;
    for (size_t i = 0u; i < 33; i++) {
      std::unique_ptr<DescriptorPoolVK> pool =
          std::make_unique<DescriptorPoolVK>(context);
      pool->AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
      pools.push_back(std::move(pool));
    }
  }
 
  std::shared_ptr<std::vector<std::string>> called =
      GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkCreateDescriptorPool"),
      33u);
 
  // Now create 33 more descriptor pools and observe that only one more is
  // allocated.
  {
    std::vector<std::shared_ptr<DescriptorPoolVK>> pools;
    for (size_t i = 0u; i < 33; i++) {
      std::shared_ptr<DescriptorPoolVK> pool =
          context->GetDescriptorPoolRecycler()->GetDescriptorPool();
      pool->AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
      pools.push_back(std::move(pool));
    }
  }
 
  std::shared_ptr<std::vector<std::string>> called_twice =
      GetMockVulkanFunctions(context->GetDevice());
  // 32 of the descriptor pools were recycled, so only one more is created.
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkCreateDescriptorPool"),
      34u);
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), and i.

◆ TEST() [121/689]

impeller::testing::TEST	(	DescriptorPoolRecyclerVKTest	,
		ReclaimMakesDescriptorPoolAvailable
	)

Definition at line 25 of file descriptor_pool_vk_unittests.cc.

                                                                        {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  {
    // Fetch a pool (which will be created).
    DescriptorPoolVK pool = DescriptorPoolVK(context);
    pool.AllocateDescriptorSets({}, /*pipeline_key=*/0, *context);
  }
 
  std::shared_ptr<DescriptorPoolVK> pool =
      context->GetDescriptorPoolRecycler()->GetDescriptorPool();
 
  // Now check that we only ever created one pool.
  std::shared_ptr<std::vector<std::string>> called =
      GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(
      std::count(called->begin(), called->end(), "vkCreateDescriptorPool"), 1u);
 
  context->Shutdown();
}

References impeller::DescriptorPoolVK::AllocateDescriptorSets(), impeller::testing::MockVulkanContextBuilder::Build(), context, and GetMockVulkanFunctions().

◆ TEST() [122/689]

impeller::testing::TEST	(	DeviceBufferGLESTest	,
		BindUniformData
	)

Definition at line 68 of file device_buffer_gles_unittests.cc.

                                            {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, GenBuffers(1, _)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gled =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{sizeof(float)}));
  DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = sizeof(float)},
                                 reactor, std::move(backing_store));
  EXPECT_FALSE(device_buffer.GetHandle().has_value());
  EXPECT_TRUE(device_buffer.BindAndUploadDataIfNecessary(
      DeviceBufferGLES::BindingType::kUniformBuffer));
  EXPECT_TRUE(device_buffer.GetHandle().has_value());
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, impeller::DeviceBufferGLES::kUniformBuffer, reactor, and impeller::DeviceBufferDescriptor::size.

◆ TEST() [123/689]

impeller::testing::TEST	(	DeviceBufferGLESTest	,
		FlushDuringUploadIsNotDiscarded
	)

Definition at line 28 of file device_buffer_gles_unittests.cc.

                                                            {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  DeviceBufferGLES* device_buffer_ptr = nullptr;
  int upload_count = 0;
  EXPECT_CALL(*mock_gles_impl, BufferSubData(_, _, _, _))
      .Times(2)
      .WillRepeatedly([&](GLenum target, GLintptr offset, GLsizeiptr size,
                          const void* data) {
        ++upload_count;
        if (upload_count == 1) {
          // Simulates a writer thread flushing new data during the upload.
          device_buffer_ptr->Flush(Range{0, 4});
        }
      });
 
  std::shared_ptr<MockGLES> mock_gles =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  auto backing_store = std::make_unique<Allocation>();
  ASSERT_TRUE(backing_store->Truncate(Bytes{16}));
  DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = 16}, reactor,
                                 std::move(backing_store));
  device_buffer_ptr = &device_buffer;
 
  device_buffer.Flush(Range{0, 4});
  // First bind uploads the flushed range; the mock flushes again mid-upload.
  EXPECT_TRUE(device_buffer.BindAndUploadDataIfNecessary(
      DeviceBufferGLES::BindingType::kArrayBuffer));
  // Second bind must see the mid-upload flush and upload again.
  EXPECT_TRUE(device_buffer.BindAndUploadDataIfNecessary(
      DeviceBufferGLES::BindingType::kArrayBuffer));
  EXPECT_EQ(upload_count, 2);
}

References flutter::data, impeller::DeviceBufferGLES::Flush(), impeller::testing::MockGLES::Init(), impeller::DeviceBufferGLES::kArrayBuffer, kMockResolverGLES, reactor, impeller::DeviceBufferDescriptor::size, flutter::size, and target.

◆ TEST() [124/689]

impeller::testing::TEST	(	DrawOrderResolverTest	,
		GetSortedDrawsRespectsSkipCounts
	)

Definition at line 89 of file draw_order_resolver_unittests.cc.

                                                              {
  DrawOrderResolver resolver;
 
  // These items will be skipped.
  resolver.AddElement(0, false);
  resolver.AddElement(1, true);
  resolver.AddElement(2, false);
  // These ones will be included in the final draw list.
  resolver.AddElement(3, false);
  resolver.AddElement(4, true);
  resolver.AddElement(5, true);
 
  // Form the draw list, skipping elements 0, 1, and 2.
  // This emulates what happens when entitypass applies the clear color
  // optimization.
  auto sorted_elements = resolver.GetSortedDraws(1, 2);
 
  EXPECT_EQ(sorted_elements.size(), 3u);
  // First, opaque items are drawn in reverse order.
  EXPECT_EQ(sorted_elements[0], 5u);
  EXPECT_EQ(sorted_elements[1], 4u);
  // Then, translucent items are drawn.
  EXPECT_EQ(sorted_elements[2], 3u);
}

References impeller::DrawOrderResolver::AddElement(), and impeller::DrawOrderResolver::GetSortedDraws().

◆ TEST() [125/689]

impeller::testing::TEST	(	DrawOrderResolverTest	,
		GetSortedDrawsReturnsCorrectOrderWithClips
	)

Definition at line 33 of file draw_order_resolver_unittests.cc.

                                                                        {
  DrawOrderResolver resolver;
 
  // Items before clip.
  resolver.AddElement(0, false);
  resolver.AddElement(1, true);
  resolver.AddElement(2, false);
  resolver.AddElement(3, true);
 
  // Clip.
  resolver.PushClip(4);
  {
    // Clipped items.
    resolver.AddElement(5, false);
    resolver.AddElement(6, false);
    // Clipped translucent items.
    resolver.AddElement(7, true);
    resolver.AddElement(8, true);
  }
  resolver.PopClip();
 
  // Items after clip.
  resolver.AddElement(9, true);
  resolver.AddElement(10, false);
  resolver.AddElement(11, true);
  resolver.AddElement(12, false);
 
  auto sorted_elements = resolver.GetSortedDraws(0, 0);
 
  EXPECT_EQ(sorted_elements.size(), 13u);
  // First, all the non-clipped opaque items are drawn in reverse order.
  EXPECT_EQ(sorted_elements[0], 11u);
  EXPECT_EQ(sorted_elements[1], 9u);
  EXPECT_EQ(sorted_elements[2], 3u);
  EXPECT_EQ(sorted_elements[3], 1u);
  // Then, non-clipped translucent items that came before the clip are drawn in
  // their original order.
  EXPECT_EQ(sorted_elements[4], 0u);
  EXPECT_EQ(sorted_elements[5], 2u);
 
  // Then, the clip and its sorted child items are drawn.
  EXPECT_EQ(sorted_elements[6], 4u);
  {
    // Opaque clipped items are drawn in reverse order.
    EXPECT_EQ(sorted_elements[7], 8u);
    EXPECT_EQ(sorted_elements[8], 7u);
    // Translucent clipped items are drawn.
    EXPECT_EQ(sorted_elements[9], 5u);
    EXPECT_EQ(sorted_elements[10], 6u);
  }
  // Finally, the non-clipped translucent items which came after the clip are
  // drawn in their original order.
  EXPECT_EQ(sorted_elements[11], 10u);
  EXPECT_EQ(sorted_elements[12], 12u);
}

References impeller::DrawOrderResolver::AddElement(), impeller::DrawOrderResolver::GetSortedDraws(), impeller::DrawOrderResolver::PopClip(), and impeller::DrawOrderResolver::PushClip().

◆ TEST() [126/689]

impeller::testing::TEST	(	DrawOrderResolverTest	,
		GetSortedDrawsReturnsCorrectOrderWithFlush
	)

Definition at line 114 of file draw_order_resolver_unittests.cc.

                                                                        {
  DrawOrderResolver resolver;
 
  resolver.AddElement(0, false);
  resolver.AddElement(1, true);
  resolver.AddElement(2, false);
  resolver.AddElement(3, true);
 
  resolver.Flush();
 
  resolver.AddElement(4, false);
  resolver.AddElement(5, true);
  resolver.AddElement(6, false);
  resolver.AddElement(7, true);
 
  resolver.Flush();
 
  resolver.AddElement(8, false);
  resolver.AddElement(9, true);
  resolver.AddElement(10, false);
  resolver.AddElement(11, true);
 
  auto sorted_elements = resolver.GetSortedDraws(1, 1);
 
  EXPECT_EQ(sorted_elements.size(), 10u);
 
  // Skipped draws apply to the first flush.
  EXPECT_EQ(sorted_elements[0], 3u);
  EXPECT_EQ(sorted_elements[1], 2u);
 
  EXPECT_EQ(sorted_elements[2], 7u);
  EXPECT_EQ(sorted_elements[3], 5u);
  EXPECT_EQ(sorted_elements[4], 4u);
  EXPECT_EQ(sorted_elements[5], 6u);
 
  EXPECT_EQ(sorted_elements[6], 11u);
  EXPECT_EQ(sorted_elements[7], 9u);
  EXPECT_EQ(sorted_elements[8], 8u);
  EXPECT_EQ(sorted_elements[9], 10u);
}

References impeller::DrawOrderResolver::AddElement(), impeller::DrawOrderResolver::Flush(), and impeller::DrawOrderResolver::GetSortedDraws().

◆ TEST() [127/689]

impeller::testing::TEST	(	DrawOrderResolverTest	,
		GetSortedDrawsReturnsCorrectOrderWithNoClips
	)

Definition at line 12 of file draw_order_resolver_unittests.cc.

                                                                          {
  DrawOrderResolver resolver;
 
  // Opaque items.
  resolver.AddElement(0, true);
  resolver.AddElement(1, true);
  // Translucent items.
  resolver.AddElement(2, false);
  resolver.AddElement(3, false);
 
  auto sorted_elements = resolver.GetSortedDraws(0, 0);
 
  EXPECT_EQ(sorted_elements.size(), 4u);
  // First, the opaque items are drawn in reverse order.
  EXPECT_EQ(sorted_elements[0], 1u);
  EXPECT_EQ(sorted_elements[1], 0u);
  // Then the translucent items are drawn.
  EXPECT_EQ(sorted_elements[2], 2u);
  EXPECT_EQ(sorted_elements[3], 3u);
}

References impeller::DrawOrderResolver::AddElement(), and impeller::DrawOrderResolver::GetSortedDraws().

◆ TEST() [128/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		CanBatchSubmitCommandBuffers
	)

Definition at line 90 of file driver_info_vk_unittests.cc.

                                                     {
  // Old Adreno no batch submit!
  EXPECT_FALSE(CanBatchSubmitTest("Adreno (TM) 540", true));
 
  EXPECT_TRUE(CanBatchSubmitTest("Mali-G51", false));
  EXPECT_TRUE(CanBatchSubmitTest("Adreno (TM) 750", true));
}

References CanBatchSubmitTest().

◆ TEST() [129/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		CanGenerateMipMaps
	)

Definition at line 146 of file driver_info_vk_unittests.cc.

                                           {
  // Adreno no mips
  EXPECT_FALSE(CanUseMipgeneration("Adreno (TM) 540", true));
  EXPECT_FALSE(CanUseMipgeneration("Adreno (TM) 750", true));
 
  // Mali A-OK
  EXPECT_TRUE(CanUseMipgeneration("Mali-G51", false));
}

References CanUseMipgeneration().

◆ TEST() [130/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		CanIdentifyBadMaleoonDriver
	)

Definition at line 40 of file driver_info_vk_unittests.cc.

                                                    {
  auto const context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x19E5;  // Huawei
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
              })
          .Build();
 
  EXPECT_TRUE(context->GetDriverInfo()->IsKnownBadDriver());
}

References context, device, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [131/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		CanUseFramebufferFetch
	)

Definition at line 216 of file driver_info_vk_unittests.cc.

                                               {
  // Adreno no primitive restart on models as or older than 630.
  EXPECT_FALSE(CanUseFramebufferFetch("Adreno (TM) 540", true));
  EXPECT_FALSE(CanUseFramebufferFetch("Adreno (TM) 630", true));
 
  EXPECT_TRUE(CanUseFramebufferFetch("Adreno (TM) 640", true));
  EXPECT_TRUE(CanUseFramebufferFetch("Adreno (TM) 750", true));
  EXPECT_TRUE(CanUseFramebufferFetch("Mali-G51", false));
}

References CanUseFramebufferFetch().

◆ TEST() [132/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		CanUsePrimitiveRestart
	)

Definition at line 118 of file driver_info_vk_unittests.cc.

                                               {
  // Adreno no primitive restart
  EXPECT_FALSE(CanUsePrimitiveRestartSubmitTest("Adreno (TM) 540", true));
  EXPECT_FALSE(CanUsePrimitiveRestartSubmitTest("Adreno (TM) 750", true));
 
  // Mali A-OK
  EXPECT_TRUE(CanUsePrimitiveRestartSubmitTest("Mali-G51", false));
}

References CanUsePrimitiveRestartSubmitTest().

◆ TEST() [133/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		DisabledDevices
	)

Definition at line 166 of file driver_info_vk_unittests.cc.

                                        {
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 504"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 505"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 506"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 508"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 509"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 512"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 530"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 610"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 620"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 630"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 640"));
  EXPECT_TRUE(IsBadVersionTest("Adreno (TM) 650"));
}

References IsBadVersionTest().

◆ TEST() [134/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		DisableOldXclipseDriver
	)

Definition at line 226 of file driver_info_vk_unittests.cc.

                                                {
  auto context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x144D;  // Samsung
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
                // Version 1.1.0
                prop->apiVersion = (1 << 22) | (1 << 12);
              })
          .Build();
 
  EXPECT_TRUE(context->GetDriverInfo()->IsKnownBadDriver());
 
  context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x144D;  // Samsung
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
                // Version 1.3.0
                prop->apiVersion = (1 << 22) | (3 << 12);
              })
          .Build();
 
  EXPECT_FALSE(context->GetDriverInfo()->IsKnownBadDriver());
}

References context, device, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [135/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		DriverParsingAdreno
	)

Definition at line 161 of file driver_info_vk_unittests.cc.

                                            {
  EXPECT_EQ(GetAdrenoVersion("Adreno (TM) 540"), AdrenoGPU::kAdreno540);
  EXPECT_EQ(GetAdrenoVersion("Foo Bar"), AdrenoGPU::kUnknown);
}

References impeller::GetAdrenoVersion(), impeller::kAdreno540, and impeller::kUnknown.

◆ TEST() [136/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		DriverParsingMali
	)

Definition at line 155 of file driver_info_vk_unittests.cc.

                                          {
  EXPECT_EQ(GetMaliVersion("Mali-G51-MORE STUFF"), MaliGPU::kG51);
  EXPECT_EQ(GetMaliVersion("Mali-G51"), MaliGPU::kG51);
  EXPECT_EQ(GetMaliVersion("Mali-111111"), MaliGPU::kUnknown);
}

References impeller::GetMaliVersion(), impeller::kG51, and impeller::kUnknown.

◆ TEST() [137/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		EnabledDevicesAdreno
	)

Definition at line 186 of file driver_info_vk_unittests.cc.

                                             {
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 702"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 710"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 720"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 725"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 730"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 732"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 740"));
  EXPECT_FALSE(IsBadVersionTest("Adreno (TM) 750"));
}

References IsBadVersionTest().

◆ TEST() [138/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		EnabledDevicesMali
	)

Definition at line 181 of file driver_info_vk_unittests.cc.

                                           {
  EXPECT_FALSE(IsBadVersionTest("Mali-G52", /*qc=*/false));
  EXPECT_FALSE(IsBadVersionTest("Mali-G54-MORE STUFF", /*qc=*/false));
}

References IsBadVersionTest().

◆ TEST() [139/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		NewPowerVREnabled
	)

Definition at line 271 of file driver_info_vk_unittests.cc.

                                          {
  std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x1010;
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
                std::string name = "PowerVR DXT 123";
                name.copy(prop->deviceName, name.size());
              })
          .Build();
 
  EXPECT_FALSE(context->GetDriverInfo()->IsKnownBadDriver());
  EXPECT_EQ(context->GetDriverInfo()->GetPowerVRGPUInfo(),
            std::optional<PowerVRGPU>(PowerVRGPU::kDXT));
  EXPECT_TRUE(GetWorkaroundsFromDriverInfo(*context->GetDriverInfo())
                  .input_attachment_self_dependency_broken);
}

References context, device, impeller::GetWorkaroundsFromDriverInfo(), impeller::WorkaroundsVK::input_attachment_self_dependency_broken, impeller::kDXT, flutter::name, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [140/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		OldPowerVRDisabled
	)

Definition at line 254 of file driver_info_vk_unittests.cc.

                                           {
  std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x1010;
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
                std::string name = "PowerVR Rogue GE8320";
                name.copy(prop->deviceName, name.size());
              })
          .Build();
 
  EXPECT_TRUE(context->GetDriverInfo()->IsKnownBadDriver());
  EXPECT_EQ(context->GetDriverInfo()->GetPowerVRGPUInfo(),
            std::optional<PowerVRGPU>(PowerVRGPU::kUnknown));
}

References context, device, impeller::kUnknown, flutter::name, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [141/689]

impeller::testing::TEST	(	DriverInfoVKTest	,
		PowerVRBSeries
	)

Definition at line 290 of file driver_info_vk_unittests.cc.

                                       {
  std::shared_ptr<ContextVK> context =
      MockVulkanContextBuilder()
          .SetPhysicalPropertiesCallback(
              [](VkPhysicalDevice device, VkPhysicalDeviceProperties* prop) {
                prop->vendorID = 0x1010;
                prop->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
                std::string name = "PowerVR BXM-8-256";
                name.copy(prop->deviceName, name.size());
              })
          .Build();
 
  EXPECT_FALSE(context->GetDriverInfo()->IsKnownBadDriver());
  EXPECT_EQ(context->GetDriverInfo()->GetPowerVRGPUInfo(),
            std::optional<PowerVRGPU>(PowerVRGPU::kBXM));
}

References context, device, impeller::kBXM, flutter::name, and impeller::testing::MockVulkanContextBuilder::SetPhysicalPropertiesCallback().

◆ TEST() [142/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		AlphaCoverageStrokePaths
	)

Definition at line 584 of file geometry_unittests.cc.

                                                   {
  auto matrix = Matrix::MakeScale(Vector2{3.0, 3.0});
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 0.5f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.1f})
                  ->ComputeAlphaCoverage(matrix),
              0.6, 0.05);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.05})
                  ->ComputeAlphaCoverage(matrix),
              0.3, 0.05);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.01})
                  ->ComputeAlphaCoverage(matrix),
              0.1, 0.1);
  EXPECT_NEAR(Geometry::MakeStrokePath({}, {.width = 0.0000005f})
                  ->ComputeAlphaCoverage(matrix),
              1e-05, 0.001);
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 0.0f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
  EXPECT_EQ(Geometry::MakeStrokePath({}, {.width = 40.0f})
                ->ComputeAlphaCoverage(matrix),
            1.0f);
}

References impeller::Matrix::MakeScale(), and impeller::Geometry::MakeStrokePath().

◆ TEST() [143/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		FillArcGeometryCoverage
	)

Definition at line 145 of file geometry_unittests.cc.

                                                  {
  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
  Matrix transform45 = Matrix::MakeTranslation(oval_bounds.GetCenter()) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-oval_bounds.GetCenter());
 
  {  // Sweeps <=-360 or >=360
    for (int start = -720; start <= 720; start += 10) {
      for (int sweep = 360; sweep <= 720; sweep += 30) {
        std::string label =
            "start: " + std::to_string(start) + " + " + std::to_string(sweep);
        auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                                Degrees(sweep), false);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << sweep;
        geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                           Degrees(-sweep), false);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << -sweep;
        geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                           Degrees(-sweep), true);
        EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
            << "start: " << start << ", sweep: " << -sweep << ", with center";
      }
    }
  }
  {  // Sweep from late in one quadrant to earlier in same quadrant
    for (int start = 60; start < 360; start += 90) {
      auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                              Degrees(330), false);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                         Degrees(330), true);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep from early in one quadrant backwards to later in same quadrant
    for (int start = 30; start < 360; start += 90) {
      auto geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                              Degrees(-330), false);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeFilledArc(oval_bounds, Degrees(start),
                                         Degrees(-330), true);
      EXPECT_EQ(geometry->GetCoverage({}), oval_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep past each quadrant axis individually, no center
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start - 45), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2,  //
                                              200,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 45), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2,  //
                                              200);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 135), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(100,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2,  //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 225), Degrees(90), false);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              100,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              150 - 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // Sweep past each quadrant axis individually, including the center
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start - 45), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              200,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 45), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              150,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              200);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 135), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(100,                     //
                                              150 - 50 * kSqrt2Over2,  //
                                              150,                     //
                                              150 + 50 * kSqrt2Over2);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeFilledArc(
            oval_bounds, Degrees(start + 225), Degrees(90), true);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2,  //
                                              100,                     //
                                              150 + 50 * kSqrt2Over2,  //
                                              150);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // 45 degree tilted full circle
    auto geometry =
        Geometry::MakeFilledArc(oval_bounds, Degrees(0), Degrees(360), false);
    ASSERT_TRUE(oval_bounds.TransformBounds(transform45).Contains(oval_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(oval_bounds));
  }
  {  // 45 degree tilted mostly full circle
    auto geometry =
        Geometry::MakeFilledArc(oval_bounds, Degrees(3), Degrees(359), false);
    ASSERT_TRUE(oval_bounds.TransformBounds(transform45).Contains(oval_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(oval_bounds));
  }
}

References EXPECT_RECT_NEAR, impeller::kSqrt2Over2, impeller::Geometry::MakeFilledArc(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), and start.

◆ TEST() [144/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		FillPathGeometryCoversArea
	)

Definition at line 122 of file geometry_unittests.cc.

                                                     {
  auto path = flutter::DlPathBuilder{}
                  .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                  .TakePath();
  auto geometry = Geometry::MakeFillPath(
      path, /* inner rect */ Rect::MakeLTRB(0, 0, 100, 100));
  ASSERT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, IRect()));
}

References flutter::DlPathBuilder::AddRect(), impeller::Geometry::MakeFillPath(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [145/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		FillPathGeometryCoversAreaNoInnerRect
	)

Definition at line 134 of file geometry_unittests.cc.

                                                                {
  auto path = flutter::DlPathBuilder{}
                  .AddRect(Rect::MakeLTRB(0, 0, 100, 100))
                  .TakePath();
  auto geometry = Geometry::MakeFillPath(path);
  ASSERT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, IRect()));
}

References flutter::DlPathBuilder::AddRect(), impeller::Geometry::MakeFillPath(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [146/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		FillRoundRectGeometryCoversArea
	)

Definition at line 512 of file geometry_unittests.cc.

                                                          {
  Rect bounds = Rect::MakeLTRB(100, 100, 200, 200);
  RoundRect round_rect =
      RoundRect::MakeRectRadii(bounds, RoundingRadii{
                                           .top_left = Size(1, 11),
                                           .top_right = Size(2, 12),
                                           .bottom_left = Size(3, 13),
                                           .bottom_right = Size(4, 14),
                                       });
  FillRoundRectGeometry geom(round_rect);
 
  // Tall middle rect should barely be covered.
  EXPECT_TRUE(geom.CoversArea({}, IRect::MakeLTRB(103, 100, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(102, 100, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(103, 99, 196, 200)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(103, 100, 197, 200)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(103, 100, 196, 201)));
 
  // Wide middle rect should barely be covered.
  EXPECT_TRUE(geom.CoversArea({}, IRect::MakeLTRB(100, 112, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(99, 112, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(100, 111, 200, 186)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(100, 112, 201, 186)));
  EXPECT_FALSE(geom.CoversArea({}, IRect::MakeLTRB(100, 112, 200, 187)));
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::RoundingRadii::top_left.

◆ TEST() [147/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		GeometryResultHasReasonableDefaults
	)

Definition at line 577 of file geometry_unittests.cc.

                                                              {
  GeometryResult result;
  EXPECT_EQ(result.type, PrimitiveType::kTriangleStrip);
  EXPECT_EQ(result.transform, Matrix());
  EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal);
}

References impeller::GeometryResult::kNormal, impeller::kTriangleStrip, impeller::GeometryResult::mode, impeller::GeometryResult::transform, and impeller::GeometryResult::type.

◆ TEST() [148/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		LineGeometryCoverage
	)

Definition at line 538 of file geometry_unittests.cc.

                                               {
  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {20, 10}, {.width = 2, .cap = Cap::kButt});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(10, 9, 20, 11));
    EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(10, 9, 20, 11)));
  }
 
  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {20, 10}, {.width = 2, .cap = Cap::kSquare});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 9, 21, 11));
    EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(9, 9, 21, 11)));
  }
 
  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {10, 20}, {.width = 2, .cap = Cap::kButt});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 10, 11, 20));
    EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(9, 10, 11, 20)));
  }
 
  {
    auto geometry = Geometry::MakeLine(  //
        {10, 10}, {10, 20}, {.width = 2, .cap = Cap::kSquare});
    EXPECT_EQ(geometry->GetCoverage({}), Rect::MakeLTRB(9, 9, 11, 21));
    EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(9, 9, 11, 21)));
  }
}

References impeller::kButt, impeller::kSquare, impeller::Geometry::MakeLine(), impeller::TRect< T >::MakeLTRB(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [149/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		RectGeometryCoversArea
	)

Definition at line 76 of file geometry_unittests.cc.

                                                 {
  auto geometry = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 100, 100));
  ASSERT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(0, 0, 100, 100)));
  ASSERT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(-1, 0, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(1, 1, 100, 100)));
  ASSERT_TRUE(geometry->CoversArea({}, IRect()));
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::Geometry::MakeRect().

◆ TEST() [150/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		RotatedFilledCircleGeometryCoverage
	)

Definition at line 1403 of file geometry_unittests.cc.

                                                              {
  Point center = Point(50, 50);
  auto geometry = Geometry::MakeCircle(center, 50);
  Rect circle_bounds = Rect::MakeLTRB(0, 0, 100, 100);
  ASSERT_EQ(geometry->GetCoverage({}).value_or(Rect()), circle_bounds);
 
  Matrix transform45 = Matrix::MakeTranslation(center) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-center);
 
  EXPECT_TRUE(geometry->GetCoverage(transform45).has_value());
  Rect bounds = geometry->GetCoverage(transform45).value_or(Rect());
  EXPECT_TRUE(bounds.Contains(circle_bounds))
      << "geometry bounds: " << bounds << std::endl
      << "  circle bounds: " << circle_bounds;
}

References impeller::Geometry::MakeCircle(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeTranslation().

◆ TEST() [151/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		RotatedStrokedCircleGeometryCoverage
	)

Definition at line 1420 of file geometry_unittests.cc.

                                                               {
  Point center = Point(50, 50);
  auto geometry = Geometry::MakeStrokedCircle(center, 50, 10);
  Rect circle_bounds = Rect::MakeLTRB(0, 0, 100, 100).Expand(5);
  ASSERT_EQ(geometry->GetCoverage({}).value_or(Rect()), circle_bounds);
 
  Matrix transform45 = Matrix::MakeTranslation(center) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-center);
 
  EXPECT_TRUE(geometry->GetCoverage(transform45).has_value());
  Rect bounds = geometry->GetCoverage(transform45).value_or(Rect());
  EXPECT_TRUE(bounds.Contains(circle_bounds))
      << "geometry bounds: " << bounds << std::endl
      << "  circle bounds: " << circle_bounds;
}

References impeller::TRect< T >::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), impeller::Geometry::MakeStrokedCircle(), and impeller::Matrix::MakeTranslation().

◆ TEST() [152/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		RoundRectGeometryCoversArea
	)

Definition at line 568 of file geometry_unittests.cc.

                                                      {
  auto geometry =
      Geometry::MakeRoundRect(Rect::MakeLTRB(0, 0, 100, 100), Size(20, 20));
  EXPECT_FALSE(geometry->CoversArea({}, IRect::MakeLTRB(15, 15, 85, 85)));
  EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(20, 20, 80, 80)));
  EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(30, 1, 70, 99)));
  EXPECT_TRUE(geometry->CoversArea({}, IRect::MakeLTRB(1, 30, 99, 70)));
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::Geometry::MakeRoundRect().

◆ TEST() [153/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		SimpleTwoLineStrokeVerticesButtCap
	)

Definition at line 609 of file geometry_unittests.cc.

                                                             {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // The glue points that allow us to "pick up the pen" between segments
      Point(30, 20),
      Point(30, 20),
      Point(120, 20),
      Point(120, 20),
 
      // The points for the second segment (120, 20) -> (130, 20)
      Point(120, 25),
      Point(120, 15),
      Point(130, 25),
      Point(130, 15),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [154/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		SimpleTwoLineStrokeVerticesRoundCap
	)

Definition at line 650 of file geometry_unittests.cc.

                                                              {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kRound,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  size_t count = points.size();
  ASSERT_TRUE((count & 0x1) == 0x0);  // Should always be even
 
  // For a scale factor of 1.0 and a stroke width of 10.0 we currently
  // generate 40 total points for the 2 line segments based on the number
  // of quadrant circle divisions for a radius of 5.0
  //
  // If the number of points changes because of a change in the way we
  // compute circle divisions, we need to recompute the circular offsets
  ASSERT_EQ(points.size(), 40u);
 
  // Compute the indicated circular end cap offset based on the current
  // step out of 4 divisions [1, 2, 3] (not 0 or 4) based on whether this
  // is the left or right side of the path and whether this is a backwards
  // (starting) cap or a forwards (ending) cap.
  auto offset = [](int step, bool left, bool backwards) -> Point {
    Radians angle(kPiOver2 * (step / 4.0f));
    Point along = Point(5.0f, 0.0f) * std::cos(angle.radians);
    Point across = Point(0.0f, 5.0f) * std::sin(angle.radians);
    Point center = backwards ? -along : along;
    return left ? center + across : center - across;
  };
 
  // The points for the first segment (20, 20) -> (30, 20)
  EXPECT_EQ(points[0], Point(15, 20));
  EXPECT_EQ(points[1], Point(20, 20) + offset(1, true, true));
  EXPECT_EQ(points[2], Point(20, 20) + offset(1, false, true));
  EXPECT_EQ(points[3], Point(20, 20) + offset(2, true, true));
  EXPECT_EQ(points[4], Point(20, 20) + offset(2, false, true));
  EXPECT_EQ(points[5], Point(20, 20) + offset(3, true, true));
  EXPECT_EQ(points[6], Point(20, 20) + offset(3, false, true));
  EXPECT_EQ(points[7], Point(20, 25));
  EXPECT_EQ(points[8], Point(20, 15));
  EXPECT_EQ(points[9], Point(30, 25));
  EXPECT_EQ(points[10], Point(30, 15));
  EXPECT_EQ(points[11], Point(30, 20) + offset(3, true, false));
  EXPECT_EQ(points[12], Point(30, 20) + offset(3, false, false));
  EXPECT_EQ(points[13], Point(30, 20) + offset(2, true, false));
  EXPECT_EQ(points[14], Point(30, 20) + offset(2, false, false));
  EXPECT_EQ(points[15], Point(30, 20) + offset(1, true, false));
  EXPECT_EQ(points[16], Point(30, 20) + offset(1, false, false));
  EXPECT_EQ(points[17], Point(35, 20));
 
  // The glue points that allow us to "pick up the pen" between segments
  EXPECT_EQ(points[18], Point(30, 20));
  EXPECT_EQ(points[19], Point(30, 20));
  EXPECT_EQ(points[20], Point(120, 20));
  EXPECT_EQ(points[21], Point(120, 20));
 
  // The points for the second segment (120, 20) -> (130, 20)
  EXPECT_EQ(points[22], Point(115, 20));
  EXPECT_EQ(points[23], Point(120, 20) + offset(1, true, true));
  EXPECT_EQ(points[24], Point(120, 20) + offset(1, false, true));
  EXPECT_EQ(points[25], Point(120, 20) + offset(2, true, true));
  EXPECT_EQ(points[26], Point(120, 20) + offset(2, false, true));
  EXPECT_EQ(points[27], Point(120, 20) + offset(3, true, true));
  EXPECT_EQ(points[28], Point(120, 20) + offset(3, false, true));
  EXPECT_EQ(points[29], Point(120, 25));
  EXPECT_EQ(points[30], Point(120, 15));
  EXPECT_EQ(points[31], Point(130, 25));
  EXPECT_EQ(points[32], Point(130, 15));
  EXPECT_EQ(points[33], Point(130, 20) + offset(3, true, false));
  EXPECT_EQ(points[34], Point(130, 20) + offset(3, false, false));
  EXPECT_EQ(points[35], Point(130, 20) + offset(2, true, false));
  EXPECT_EQ(points[36], Point(130, 20) + offset(2, false, false));
  EXPECT_EQ(points[37], Point(130, 20) + offset(1, true, false));
  EXPECT_EQ(points[38], Point(130, 20) + offset(1, false, false));
  EXPECT_EQ(points[39], Point(135, 20));
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kPiOver2, impeller::kRound, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, impeller::Radians::radians, and flutter::DlPathBuilder::TakePath().

◆ TEST() [155/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		SimpleTwoLineStrokeVerticesSquareCap
	)

Definition at line 738 of file geometry_unittests.cc.

                                                               {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.MoveTo({120, 20});
  path_builder.LineTo({130, 20});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  // clang-format off
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(15, 25),
      Point(15, 15),
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
      Point(35, 25),
      Point(35, 15),
 
      // The glue points that allow us to "pick up the pen" between segments
      Point(30, 20),
      Point(30, 20),
      Point(120, 20),
      Point(120, 20),
 
      // The points for the second segment (120, 20) -> (130, 20)
      Point(115, 25),
      Point(115, 15),
      Point(120, 25),
      Point(120, 15),
      Point(130, 25),
      Point(130, 15),
      Point(135, 25),
      Point(135, 15),
  };
  // clang-format on
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [156/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		StrokeArcGeometryCoverage
	)

Definition at line 311 of file geometry_unittests.cc.

                                                    {
  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
  Rect expanded_bounds = Rect::MakeLTRB(95, 95, 205, 205);
  Rect squared_bounds = Rect::MakeLTRB(100 - 5 * kSqrt2, 100 - 5 * kSqrt2,
                                       200 + 5 * kSqrt2, 200 + 5 * kSqrt2);
  Matrix transform45 = Matrix::MakeTranslation(oval_bounds.GetCenter()) *
                       Matrix::MakeRotationZ(Degrees(45)) *
                       Matrix::MakeTranslation(-oval_bounds.GetCenter());
 
  StrokeParameters butt_params = {
      .width = 10.0f,
      .cap = Cap::kButt,
  };
  StrokeParameters square_params = {
      .width = 10.0f,
      .cap = Cap::kSquare,
  };
 
  {  // Sweeps <=-360 or >=360
    for (int start = -720; start <= 720; start += 10) {
      for (int sweep = 360; sweep <= 720; sweep += 30) {
        std::string label =
            "start: " + std::to_string(start) + " + " + std::to_string(sweep);
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), butt_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << sweep;
        geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                            Degrees(-sweep), butt_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << -sweep;
        geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                            Degrees(-sweep), square_params);
        EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
            << "start: " << start << ", sweep: " << -sweep << ", square caps";
      }
    }
  }
  {  // Sweep from late in one quadrant to earlier in same quadrant
    for (int start = 60; start < 360; start += 90) {
      auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                               Degrees(330), butt_params);
      EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
          << "start: " << start << ", butt caps";
      geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                          Degrees(330), square_params);
      EXPECT_EQ(geometry->GetCoverage({}), squared_bounds)
          << "start: " << start << ", square caps";
    }
  }
  {  // Sweep from early in one quadrant backwards to later in same quadrant
    for (int start = 30; start < 360; start += 90) {
      auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                               Degrees(-330), butt_params);
      EXPECT_EQ(geometry->GetCoverage({}), expanded_bounds)
          << "start: " << start << " without center";
      geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                          Degrees(-330), square_params);
      EXPECT_EQ(geometry->GetCoverage({}), squared_bounds)
          << "start: " << start << " with center";
    }
  }
  {  // Sweep past each quadrant axis individually with butt caps
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start - 45), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2 - 5,  //
                                              150 - 50 * kSqrt2Over2 - 5,  //
                                              205,                         //
                                              150 + 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 45), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - 5,  //
                                              150 + 50 * kSqrt2Over2 - 5,  //
                                              150 + 50 * kSqrt2Over2 + 5,  //
                                              205);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 135), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(95,                          //
                                              150 - 50 * kSqrt2Over2 - 5,  //
                                              150 - 50 * kSqrt2Over2 + 5,  //
                                              150 + 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 225), Degrees(90), butt_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - 5,  //
                                              95,                          //
                                              150 + 50 * kSqrt2Over2 + 5,  //
                                              150 - 50 * kSqrt2Over2 + 5);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // Sweep past each quadrant axis individually with square caps
    Scalar pad = 5 * kSqrt2;
    for (int start = -360; start <= 720; start += 360) {
      {  // Quadrant 0
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start - 45), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 + 50 * kSqrt2Over2 - pad,  //
                                              150 - 50 * kSqrt2Over2 - pad,  //
                                              200 + pad,                     //
                                              150 + 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start - 45;
      }
      {  // Quadrant 1
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 45), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - pad,  //
                                              150 + 50 * kSqrt2Over2 - pad,  //
                                              150 + 50 * kSqrt2Over2 + pad,  //
                                              200 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 45;
      }
      {  // Quadrant 2
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 135), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(100 - pad,                     //
                                              150 - 50 * kSqrt2Over2 - pad,  //
                                              150 - 50 * kSqrt2Over2 + pad,  //
                                              150 + 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 135;
      }
      {  // Quadrant 3
        auto geometry = Geometry::MakeStrokedArc(
            oval_bounds, Degrees(start + 225), Degrees(90), square_params);
        Rect expected_bounds = Rect::MakeLTRB(150 - 50 * kSqrt2Over2 - pad,  //
                                              100 - pad,                     //
                                              150 + 50 * kSqrt2Over2 + pad,  //
                                              150 - 50 * kSqrt2Over2 + pad);
        EXPECT_RECT_NEAR(geometry->GetCoverage({}).value_or(Rect()),
                         expected_bounds)
            << "start: " << start + 225;
      }
    }
  }
  {  // 45 degree tilted full circle, butt caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(0), Degrees(360), butt_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(expanded_bounds));
  }
  {  // 45 degree tilted full circle, square caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(0), Degrees(360), square_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(squared_bounds));
  }
  {  // 45 degree tilted mostly full circle, butt caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(3), Degrees(359), butt_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(expanded_bounds));
  }
  {  // 45 degree tilted mostly full circle, square caps
    auto geometry = Geometry::MakeStrokedArc(  //
        oval_bounds, Degrees(3), Degrees(359), square_params);
    ASSERT_TRUE(
        oval_bounds.TransformBounds(transform45).Contains(expanded_bounds));
 
    EXPECT_TRUE(geometry->GetCoverage(transform45)
                    .value_or(Rect())
                    .Contains(squared_bounds));
  }
}

References EXPECT_RECT_NEAR, impeller::kButt, impeller::kSqrt2, impeller::kSqrt2Over2, impeller::kSquare, impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), impeller::Geometry::MakeStrokedArc(), impeller::Matrix::MakeTranslation(), start, and impeller::StrokeParameters::width.

◆ TEST() [157/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TightConic180DegreeJoins
	)

Definition at line 1268 of file geometry_unittests.cc.

                                                   {
  // First, create a mild conic that helps us verify how many points
  // should normally be on a quad with 2 legs of length 90.
  flutter::DlPathBuilder path_builder_refrence;
  path_builder_refrence.MoveTo(Point(10, 10));
  path_builder_refrence.ConicCurveTo(Point(100, 10), Point(100, 100), 0.9f);
  flutter::DlPath path_reference = path_builder_refrence.TakePath();
 
  auto points_bevel_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_bevel_reference.size(), 78u);
 
  // Now create a path that doubles back on itself with a conic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.QuadraticCurveTo(Point(100, 10), Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();
 
  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_bevel_reference.size());
 
  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_bevel_reference.size());
 
  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_bevel_reference.size());
}

References flutter::DlPathBuilder::ConicCurveTo(), impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [158/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TightCubic180DegreeJoins
	)

Definition at line 1335 of file geometry_unittests.cc.

                                                   {
  // First, create a mild cubic that helps us verify how many points
  // should normally be on a quad with 3 legs of length ~50.
  flutter::DlPathBuilder path_builder_reference;
  path_builder_reference.MoveTo(Point(10, 10));
  path_builder_reference.CubicCurveTo(Point(60, 10), Point(100, 40),
                                      Point(100, 90));
  flutter::DlPath path_reference = path_builder_reference.TakePath();
 
  auto points_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_reference.size(), 76u);
 
  // Now create a path that doubles back on itself with a cubic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.CubicCurveTo(Point(60, 10), Point(100, 40), Point(60, 10));
  flutter::DlPath path = path_builder.TakePath();
 
  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_reference.size());
 
  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_reference.size());
 
  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_reference.size());
}

References flutter::DlPathBuilder::CubicCurveTo(), impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [159/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TightQuadratic180DegreeJoins
	)

Definition at line 1201 of file geometry_unittests.cc.

                                                       {
  // First, create a mild quadratic that helps us verify how many points
  // should normally be on a quad with 2 legs of length 90.
  flutter::DlPathBuilder path_builder_refrence;
  path_builder_refrence.MoveTo(Point(10, 10));
  path_builder_refrence.QuadraticCurveTo(Point(100, 10), Point(100, 100));
  flutter::DlPath path_reference = path_builder_refrence.TakePath();
 
  auto points_bevel_reference =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path_reference,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no joins because the curve is smooth
  EXPECT_EQ(points_bevel_reference.size(), 74u);
 
  // Now create a path that doubles back on itself with a quadratic.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.QuadraticCurveTo(Point(100, 10), Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();
 
  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_bevel.size(), points_bevel_reference.size());
 
  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_miter.size(), points_bevel_reference.size());
 
  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates round join because it is in the middle of a curved segment
  EXPECT_GT(points_round.size(), points_bevel_reference.size());
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [160/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TinyConicGeneratesCaps
	)

Definition at line 1015 of file geometry_unittests.cc.

                                                 {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.ConicCurveTo({20.125, 20}, {20.250, 20}, 0.6);
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),
 
      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),
 
      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),
 
      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };
 
  EXPECT_EQ(points, expected);
}

References flutter::DlPathBuilder::ConicCurveTo(), impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [161/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TinyCubicGeneratesCaps
	)

Definition at line 1052 of file geometry_unittests.cc.

                                                 {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.CubicCurveTo({20.0625, 20}, {20.125, 20}, {20.250, 20});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),
 
      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),
 
      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),
 
      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };
 
  EXPECT_EQ(points, expected);
}

References flutter::DlPathBuilder::CubicCurveTo(), impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [162/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TinyQuadGeneratesCaps
	)

Definition at line 978 of file geometry_unittests.cc.

                                                {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.QuadraticCurveTo({20.125, 20}, {20.250, 20});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 4.0f,
          .cap = Cap::kSquare,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the opening square cap
      Point(18, 22),
      Point(18, 18),
 
      // The points for the start of the curve
      Point(20, 22),
      Point(20, 18),
 
      // The points for the end of the curve
      Point(20.25, 22),
      Point(20.25, 18),
 
      // The points for the closing square cap
      Point(22.25, 22),
      Point(22.25, 18),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kSquare, flutter::DlPathBuilder::MoveTo(), flutter::path, points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [163/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegments180DegreeJoins
	)

Definition at line 1153 of file geometry_unittests.cc.

                                                        {
  // First, create a path that doubles back on itself.
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(Point(10, 10));
  path_builder.LineTo(Point(100, 10));
  path_builder.LineTo(Point(10, 10));
  flutter::DlPath path = path_builder.TakePath();
 
  auto points_bevel =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kBevel,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates no join - because it is a bevel join
  EXPECT_EQ(points_bevel.size(), 8u);
 
  auto points_miter =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kMiter,
              .miter_limit = 400.0f,
          },
          1.0f);
  // Generates no join - even with a very large miter limit
  EXPECT_EQ(points_miter.size(), 8u);
 
  auto points_round =
      ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
          path,
          {
              .width = 20.0f,
              .cap = Cap::kButt,
              .join = Join::kRound,
              .miter_limit = 4.0f,
          },
          1.0f);
  // Generates lots of join points - to round off the 180 degree bend
  EXPECT_EQ(points_round.size(), 19u);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [164/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsInDifferentContoursAreNotJoined
	)

Definition at line 857 of file geometry_unittests.cc.

                                                                         {
  flutter::DlPathBuilder path_builder;
  // First contour with a single line.
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  // Starts a new contour with a MoveTo command. The start of the new contour is
  // specified to be the same as the end of the previous contour.
  path_builder.MoveTo({30, 20});
  // Add a line in the second contour.
  path_builder.LineTo({30, 30});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // The glue points that allow us to "pick up the pen" between segments.
      // This prevents segments in different contours from being unintentionally
      // joined with a bevel.
      Point(30, 20),
      Point(30, 20),
      Point(30, 20),
      Point(30, 20),
 
      // The points for the second segment (30, 20) -> (30, 30)
      Point(25, 20),
      Point(35, 20),
      Point(25, 30),
      Point(35, 30),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [165/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsLeftTurnStrokeVerticesBevelJoin
	)

Definition at line 823 of file geometry_unittests.cc.

                                                                         {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 10});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // The points for the second segment (30, 20) -> (30, 10)
      Point(35, 20),
      Point(25, 20),
      Point(35, 10),
      Point(25, 10),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [166/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsLeftTurnStrokeVerticesMiterJoin
	)

Definition at line 941 of file geometry_unittests.cc.

                                                                         {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 10});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kMiter,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // And one point makes a Miter
      Point(35, 25),
 
      // The points for the second segment (120, 20) -> (130, 20)
      Point(35, 20),
      Point(25, 20),
      Point(35, 10),
      Point(25, 10),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kButt, impeller::kMiter, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [167/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsMiterLimit
	)

Definition at line 1089 of file geometry_unittests.cc.

                                                    {
  // degrees is the angle that the line deviates from "straight ahead"
  for (int degrees = 10; degrees < 180; degrees += 10) {
    // Start with a width of 2 since line widths of 1 usually decide
    // that they don't need join geometry at a scale of 1.0
    for (int width = 2; width <= 10; width++) {
      Degrees d(degrees);
      Radians r(d);
      Point pixel_delta = Point(std::cos(r.radians), std::sin(r.radians));
 
      if (pixel_delta.GetDistance(Point(1, 0)) * width < 1.0f) {
        // Some combinations of angle and width result in a join that is
        // less than a pixel in size. We don't care about compliance on
        // such a small join delta (and, in fact, the implementation may
        // decide to elide those small joins).
        continue;
      }
 
      // Miter limits are based on angle between the vectors/segments
      Degrees between(180 - degrees);
      Radians r_between(between);
      Scalar limit = 1.0f / std::sin(r_between.radians / 2.0f);
 
      flutter::DlPathBuilder path_builder;
      path_builder.MoveTo(Point(20, 20));
      path_builder.LineTo(Point(30, 20));
      path_builder.LineTo(Point(30, 20) + pixel_delta * 10.0f);
      flutter::DlPath path = path_builder.TakePath();
 
      // Miter limit too small (99% of required) to allow a miter
      auto points1 =
          ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
              path,
              {
                  .width = static_cast<Scalar>(width),
                  .cap = Cap::kButt,
                  .join = Join::kMiter,
                  .miter_limit = limit * 0.99f,
              },
              1.0f);
      EXPECT_EQ(points1.size(), 8u)
          << "degrees: " << degrees << ", width: " << width << ", "
          << points1[4];
 
      // Miter limit large enough (101% of required) to allow a miter
      auto points2 =
          ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
              path,
              {
                  .width = static_cast<Scalar>(width),
                  .cap = Cap::kButt,
                  .join = Join::kMiter,
                  .miter_limit = limit * 1.01f,
              },
              1.0f);
      EXPECT_EQ(points2.size(), 9u)
          << "degrees: " << degrees << ", width: " << width;
      EXPECT_LE(points2[4].GetDistance({30, 20}), width * limit * 1.05f)
          << "degrees: " << degrees << ", width: " << width << ", "
          << points2[4];
    }
  }
}

References d, impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kButt, impeller::kMiter, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::Radians::radians, flutter::DlPathBuilder::TakePath(), and width.

◆ TEST() [168/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsRightTurnStrokeVerticesBevelJoin
	)

Definition at line 789 of file geometry_unittests.cc.

                                                                          {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 30});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kBevel,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // The points for the second segment (30, 20) -> (30, 30)
      Point(25, 20),
      Point(35, 20),
      Point(25, 30),
      Point(35, 30),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kBevel, impeller::kButt, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [169/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		TwoLineSegmentsRightTurnStrokeVerticesMiterJoin
	)

Definition at line 904 of file geometry_unittests.cc.

                                                                          {
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo({20, 20});
  path_builder.LineTo({30, 20});
  path_builder.LineTo({30, 30});
  flutter::DlPath path = path_builder.TakePath();
 
  auto points = ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(
      path,
      {
          .width = 10.0f,
          .cap = Cap::kButt,
          .join = Join::kMiter,
          .miter_limit = 4.0f,
      },
      1.0f);
 
  std::vector<Point> expected = {
      // The points for the first segment (20, 20) -> (30, 20)
      Point(20, 25),
      Point(20, 15),
      Point(30, 25),
      Point(30, 15),
 
      // And one point makes a Miter
      Point(35, 15),
 
      // The points for the second segment (120, 20) -> (130, 20)
      Point(25, 20),
      Point(35, 20),
      Point(25, 30),
      Point(35, 30),
  };
 
  EXPECT_EQ(points, expected);
}

References impeller::ImpellerEntityUnitTestAccessor::GenerateSolidStrokeVertices(), impeller::kButt, impeller::kMiter, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [170/689]

impeller::testing::TEST	(	EntityGeometryTest	,
		UberSDFGeometryPaddingIsAdjustedByInverseMaxBasis
	)

Definition at line 84 of file geometry_unittests.cc.

                                                                            {
  UberSDFGeometry geometry(UberSDFParameters::MakeRect(
      Color::Red(), Rect::MakeLTRB(0, 0, 100, 100), /*stroke=*/std::nullopt));
 
  // At scale 1, padding should be 1.
  {
    auto coverage = geometry.GetCoverage(Matrix());
    EXPECT_TRUE(coverage.has_value());
    if (coverage.has_value()) {
      EXPECT_EQ(coverage.value(), Rect::MakeLTRB(-1, -1, 101, 101));
    }
  }
 
  // At scale 2, padding should be 0.5 in local coordinates, which becomes 1.0
  // in screen coordinates.
  {
    auto matrix = Matrix::MakeScale({2.0, 2.0, 1.0});
    auto coverage = geometry.GetCoverage(matrix);
    EXPECT_TRUE(coverage.has_value());
    if (coverage.has_value()) {
      EXPECT_EQ(coverage.value(), Rect::MakeLTRB(-0.5, -0.5, 100.5, 100.5)
                                      .TransformAndClipBounds(matrix));
    }
  }
 
  // At scale 0.5, padding should be 2.0 in local coordinates, which becomes 1.0
  // in screen coordinates.
  {
    auto matrix = Matrix::MakeScale({0.5, 0.5, 1.0});
    auto coverage = geometry.GetCoverage(matrix);
    EXPECT_TRUE(coverage.has_value());
    if (coverage.has_value()) {
      EXPECT_EQ(coverage.value(), Rect::MakeLTRB(-2.0, -2.0, 102.0, 102.0)
                                      .TransformAndClipBounds(matrix));
    }
  }
}

References impeller::UberSDFGeometry::GetCoverage(), impeller::TRect< Scalar >::MakeLTRB(), impeller::UberSDFParameters::MakeRect(), impeller::Matrix::MakeScale(), impeller::Color::Red(), and impeller::TRect< T >::TransformAndClipBounds().

◆ TEST() [171/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendAndRestoreClipCoverage
	)

Definition at line 58 of file clip_stack_unittests.cc.

                                                            {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  EntityPassClipStack::ClipStateResult result =
      recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.5, 55.5),
                                       /*is_axis_aligned_rect=*/true),
                          Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
  EXPECT_TRUE(result.should_render);
  EXPECT_TRUE(result.clip_did_change);
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55.5, 55.5));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  // Restore the clip.
  recorder.RecordRestore({0, 0}, 0);
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeSize(Size::MakeWH(100, 100)));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 0u);
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), impeller::TSize< Scalar >::MakeWH(), impeller::EntityPassClipStack::RecordClip(), impeller::EntityPassClipStack::RecordRestore(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [172/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendAndRestoreClipCoverageNonAA
	)

Definition at line 88 of file clip_stack_unittests.cc.

                                                                 {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  EntityPassClipStack::ClipStateResult result =
      recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.4, 55.4),
                                       /*is_axis_aligned_rect=*/true),
                          Matrix(), {0, 0}, 0, 100, /*is_aa=*/false);
  EXPECT_FALSE(result.should_render);
  EXPECT_TRUE(result.clip_did_change);
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55, 55));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  // Restore the clip.
  recorder.RecordRestore({0, 0}, 0);
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeSize(Size::MakeWH(100, 100)));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 0u);
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), impeller::TSize< Scalar >::MakeWH(), impeller::EntityPassClipStack::RecordClip(), impeller::EntityPassClipStack::RecordRestore(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [173/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendDecreasingSizeClipCoverage
	)

Definition at line 171 of file clip_stack_unittests.cc.

                                                                {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push Clips that shrink in size. All should be applied.
  Entity entity;
 
  for (auto i = 1; i < 20; i++) {
    EntityPassClipStack::ClipStateResult result = recorder.RecordClip(
        ClipContents(Rect::MakeLTRB(i, i, 99.6 - i, 99.6 - i),
                     /*is_axis_aligned_rect=*/true),
        Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
    EXPECT_TRUE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
    EXPECT_EQ(recorder.CurrentClipCoverage(),
              Rect::MakeLTRB(i, i, 99.6 - i, 99.6 - i));
  }
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::CurrentClipCoverage(), impeller::EntityPassClipStack::GetClipCoverageLayers(), i, impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [174/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendIncreasingSizeClipCoverage
	)

Definition at line 193 of file clip_stack_unittests.cc.

                                                                {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push Clips that grow in size. All should be skipped.
 
  for (auto i = 1; i < 20; i++) {
    EntityPassClipStack::ClipStateResult result = recorder.RecordClip(
        ClipContents(Rect::MakeLTRB(0 - i, 0 - i, 100 + i, 100 + i),
                     /*is_axis_aligned_rect=*/true),
        Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
    EXPECT_FALSE(result.should_render);
    EXPECT_FALSE(result.clip_did_change);
    EXPECT_EQ(recorder.CurrentClipCoverage(), Rect::MakeLTRB(0, 0, 100, 100));
  }
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::CurrentClipCoverage(), impeller::EntityPassClipStack::GetClipCoverageLayers(), i, impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [175/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendLargerClipCoverage
	)

Definition at line 120 of file clip_stack_unittests.cc.

                                                        {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  EntityPassClipStack::ClipStateResult result =
      recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.5, 55.5),
                                       /*is_axis_aligned_rect=*/true),
                          Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
  EXPECT_TRUE(result.should_render);
  EXPECT_TRUE(result.clip_did_change);
 
  // Push a clip with larger coverage than the previous state.
  result = recorder.RecordClip(ClipContents(Rect::MakeLTRB(0, 0, 100.5, 100.5),
                                            /*is_axis_aligned_rect=*/true),
                               Matrix(), {0, 0}, 1, 100, /*is_aa=*/true);
 
  EXPECT_FALSE(result.should_render);
  EXPECT_FALSE(result.clip_did_change);
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [176/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		AppendLargerClipCoverageWithDifferenceOrNonSquare
	)

Definition at line 146 of file clip_stack_unittests.cc.

                                                        {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  EntityPassClipStack::ClipStateResult result =
      recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55, 55),
                                       /*is_axis_aligned_rect=*/true),
                          Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
  EXPECT_FALSE(result.should_render);
  EXPECT_TRUE(result.clip_did_change);
 
  // Push a clip with larger coverage than the previous state.
  result = recorder.RecordClip(ClipContents(Rect::MakeLTRB(0, 0, 100, 100),
                                            /*is_axis_aligned_rect=*/false),
                               Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
  EXPECT_TRUE(result.should_render);
  EXPECT_TRUE(result.clip_did_change);
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [177/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		CanPopEntitiesSafely
	)

Definition at line 48 of file clip_stack_unittests.cc.

                                                    {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
 
  recorder.RecordRestore({0, 0}, 0);
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
}

References impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::EntityPassClipStack::RecordRestore().

◆ TEST() [178/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		CanPushAndPopEntities
	)

Definition at line 14 of file clip_stack_unittests.cc.

                                                     {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
 
  recorder.RecordClip(ClipContents(Rect::MakeLTRB(0, 0, 100, 100),
                                   /*is_axis_aligned_rect=*/false),
                      Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  recorder.RecordClip(ClipContents(Rect::MakeLTRB(0, 0, 50.5, 50.5),
                                   /*is_axis_aligned_rect=*/true),
                      Matrix(), {0, 0}, 2, 100, /*is_aa=*/true);
 
  EXPECT_EQ(recorder.GetReplayEntities().size(), 2u);
  ASSERT_TRUE(recorder.GetReplayEntities()[0].clip_coverage.has_value());
  ASSERT_TRUE(recorder.GetReplayEntities()[1].clip_coverage.has_value());
 
  // NOLINTBEGIN(bugprone-unchecked-optional-access)
  EXPECT_EQ(recorder.GetReplayEntities()[0].clip_coverage.value(),
            Rect::MakeLTRB(0, 0, 100, 100));
  EXPECT_EQ(recorder.GetReplayEntities()[1].clip_coverage.value(),
            Rect::MakeLTRB(0, 0, 50.5, 50.5));
  // NOLINTEND(bugprone-unchecked-optional-access)
 
  recorder.RecordRestore({0, 0}, 1);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  recorder.RecordRestore({0, 0}, 0);
  EXPECT_TRUE(recorder.GetReplayEntities().empty());
}

References impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::RecordRestore().

◆ TEST() [179/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		ClipAndRestoreWithSubpasses
	)

Definition at line 232 of file clip_stack_unittests.cc.

                                                           {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  {
    EntityPassClipStack::ClipStateResult result =
        recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.5, 55.5),
                                         /*is_axis_aligned_rect=*/true),
                            Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
    EXPECT_TRUE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
  }
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55.5, 55.5));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  // Begin a subpass.
  recorder.PushSubpass(Rect::MakeLTRB(50, 50, 55, 55), 1);
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeLTRB(50, 50, 55, 55));
 
  {
    EntityPassClipStack::ClipStateResult result =
        recorder.RecordClip(ClipContents(Rect::MakeLTRB(54, 54, 54.5, 54.5),
                                         /*is_axis_aligned_rect=*/true),
                            Matrix(), {0, 0}, 0, 100, /*is_aa=*/true);
 
    EXPECT_TRUE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
  }
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(54, 54, 54.5, 54.5));
 
  // End subpass.
  recorder.PopSubpass();
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55.5, 55.5));
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::PopSubpass(), impeller::EntityPassClipStack::PushSubpass(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [180/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		ClipAndRestoreWithSubpassesNonAA
	)

Definition at line 281 of file clip_stack_unittests.cc.

                                                                {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Push a clip.
  {
    EntityPassClipStack::ClipStateResult result =
        recorder.RecordClip(ClipContents(Rect::MakeLTRB(50, 50, 55.4, 55.4),
                                         /*is_axis_aligned_rect=*/true),
                            Matrix(), {0, 0}, 0, 100, /*is_aa=*/false);
 
    EXPECT_FALSE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
  }
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 2u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55.0, 55.0));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].clip_height, 1u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 1u);
 
  // Begin a subpass.
  recorder.PushSubpass(Rect::MakeLTRB(50, 50, 55, 55), 1);
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeLTRB(50, 50, 55, 55));
 
  {
    EntityPassClipStack::ClipStateResult result =
        recorder.RecordClip(ClipContents(Rect::MakeLTRB(54, 54, 55.4, 55.4),
                                         /*is_axis_aligned_rect=*/true),
                            Matrix(), {0, 0}, 0, 100, /*is_aa=*/false);
 
    EXPECT_FALSE(result.should_render);
    EXPECT_TRUE(result.clip_did_change);
  }
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(54, 54, 55.0, 55.0));
 
  // End subpass.
  recorder.PopSubpass();
 
  EXPECT_EQ(recorder.GetClipCoverageLayers()[1].coverage,
            Rect::MakeLTRB(50, 50, 55, 55));
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::EntityPassClipStack::PopSubpass(), impeller::EntityPassClipStack::PushSubpass(), impeller::EntityPassClipStack::RecordClip(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [181/689]

impeller::testing::TEST	(	EntityPassClipStackTest	,
		UnbalancedRestore
	)

Definition at line 213 of file clip_stack_unittests.cc.

                                                 {
  EntityPassClipStack recorder =
      EntityPassClipStack(Rect::MakeLTRB(0, 0, 100, 100));
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
 
  // Restore the clip.
  EntityPassClipStack::ClipStateResult result =
      recorder.RecordRestore(Point(0, 0), 0);
  EXPECT_FALSE(result.should_render);
  EXPECT_FALSE(result.clip_did_change);
 
  ASSERT_EQ(recorder.GetClipCoverageLayers().size(), 1u);
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].coverage,
            Rect::MakeSize(Size::MakeWH(100, 100)));
  EXPECT_EQ(recorder.GetClipCoverageLayers()[0].clip_height, 0u);
  EXPECT_EQ(recorder.GetReplayEntities().size(), 0u);
}

References impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::EntityPassClipStack::GetClipCoverageLayers(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), impeller::TSize< Scalar >::MakeWH(), impeller::EntityPassClipStack::RecordRestore(), and impeller::EntityPassClipStack::ClipStateResult::should_render.

◆ TEST() [182/689]

impeller::testing::TEST	(	EntityTest	,
		UberSDFContentsCoverageFillCircle
	)

Definition at line 1272 of file entity_unittests.cc.

                                                    {
  auto params =
      UberSDFParameters::MakeCircle(Color::Red(), /*center=*/{50, 50},
                                    /*radius=*/10.0f, /*stroke=*/std::nullopt);
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  auto coverage = contents->GetCoverage(entity);
  ASSERT_TRUE(coverage.has_value());
  ASSERT_RECT_NEAR(
      coverage.value(),
      Rect::MakeXYWH(40, 40, 20, 20).Expand(1.0f));  // expanded by AA
}

References ASSERT_RECT_NEAR, impeller::TRect< T >::Expand(), impeller::Entity::GetCoverage(), impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeCircle(), impeller::TRect< Scalar >::MakeXYWH(), params, and impeller::Color::Red().

◆ TEST() [183/689]

impeller::testing::TEST	(	EntityTest	,
		UberSDFContentsCoverageFillRect
	)

Definition at line 1242 of file entity_unittests.cc.

                                                  {
  auto rect = Rect::MakeXYWH(100, 100, 200, 200);
  auto params =
      UberSDFParameters::MakeRect(Color::Red(), rect, /*stroke=*/std::nullopt);
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  auto coverage = contents->GetCoverage(entity);
  ASSERT_TRUE(coverage.has_value());
  ASSERT_RECT_NEAR(
      coverage.value(),
      Rect::MakeXYWH(100, 100, 200, 200).Expand(1.0f));  // expanded by AA
}

References ASSERT_RECT_NEAR, impeller::TRect< T >::Expand(), impeller::Entity::GetCoverage(), impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, and impeller::Color::Red().

◆ TEST() [184/689]

impeller::testing::TEST	(	EntityTest	,
		UberSDFContentsCoverageStrokeCircle
	)

Definition at line 1287 of file entity_unittests.cc.

                                                      {
  auto params = UberSDFParameters::MakeCircle(Color::Red(), /*center=*/{50, 50},
                                              /*radius=*/10.0f,
                                              StrokeParameters{.width = 4.0f});
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  auto coverage = contents->GetCoverage(entity);
  ASSERT_TRUE(coverage.has_value());
  ASSERT_RECT_NEAR(coverage.value(),
                   Rect::MakeXYWH(40, 40, 20, 20)
                       .Expand(3.0f));  // expanded by half stroke width + AA
}

References ASSERT_RECT_NEAR, impeller::TRect< T >::Expand(), impeller::Entity::GetCoverage(), impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeCircle(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::StrokeParameters::width.

◆ TEST() [185/689]

impeller::testing::TEST	(	EntityTest	,
		UberSDFContentsCoverageStrokeRect
	)

Definition at line 1257 of file entity_unittests.cc.

                                                    {
  auto rect = Rect::MakeXYWH(100, 100, 200, 200);
  auto params = UberSDFParameters::MakeRect(Color::Red(), rect,
                                            StrokeParameters{.width = 4.0f});
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  auto coverage = contents->GetCoverage(entity);
  ASSERT_TRUE(coverage.has_value());
  ASSERT_RECT_NEAR(coverage.value(),
                   Rect::MakeXYWH(100, 100, 200, 200)
                       .Expand(3.0f));  // expanded by half stroke width + AA
}

References ASSERT_RECT_NEAR, impeller::TRect< T >::Expand(), impeller::Entity::GetCoverage(), impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::StrokeParameters::width.

◆ TEST() [186/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		AddFenceDoesNothingIfTerminating
	)

Definition at line 121 of file fence_waiter_vk_unittests.cc.

                                                          {
  auto signal = fml::ManualResetWaitableEvent();
 
  {
    auto const context = MockVulkanContextBuilder().Build();
    auto const device = context->GetDevice();
    auto const waiter = context->GetFenceWaiter();
    waiter->Terminate();
 
    auto fence = device.createFenceUnique({}).value;
    waiter->AddFence(std::move(fence), default_submit_callback,
                     [&signal]() { signal.Signal(); });
  }
 
  // Ensure the fence did _not_ signal.
  EXPECT_TRUE(signal.WaitWithTimeout(fml::TimeDelta::FromMilliseconds(100)));
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, fml::TimeDelta::FromMilliseconds(), and value.

◆ TEST() [187/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesFenceCallback
	)

Definition at line 51 of file fence_waiter_vk_unittests.cc.

                                               {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  bool submit_called = false;
  auto submit_callback = [&](vk::Fence) {
    submit_called = true;
    return fml::Status();
  };
 
  auto signal = fml::ManualResetWaitableEvent();
  auto fence = device.createFenceUnique({}).value;
  waiter->AddFence(std::move(fence), submit_callback,
                   [&signal]() { signal.Signal(); });
  EXPECT_TRUE(submit_called);
 
  signal.Wait();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, and value.

◆ TEST() [188/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesFenceCallbackX2
	)

Definition at line 71 of file fence_waiter_vk_unittests.cc.

                                                 {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  auto signal = fml::ManualResetWaitableEvent();
  auto fence = device.createFenceUnique({}).value;
  waiter->AddFence(std::move(fence), default_submit_callback,
                   [&signal]() { signal.Signal(); });
 
  auto signal2 = fml::ManualResetWaitableEvent();
  auto fence2 = device.createFenceUnique({}).value;
  waiter->AddFence(std::move(fence2), default_submit_callback,
                   [&signal2]() { signal2.Signal(); });
 
  signal.Wait();
  signal2.Wait();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, and value.

◆ TEST() [189/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ExecutesNewFenceThenOldFence
	)

Definition at line 90 of file fence_waiter_vk_unittests.cc.

                                                      {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  auto signal = fml::ManualResetWaitableEvent();
  auto fence = device.createFenceUnique({}).value;
  MockFence::SetStatus(fence, vk::Result::eNotReady);
  auto raw_fence = MockFence::GetRawPointer(fence);
  waiter->AddFence(std::move(fence), default_submit_callback,
                   [&signal]() { signal.Signal(); });
 
  // The easiest way to verify that the callback was _not_ called is to wait
  // for a timeout, but that could introduce flakiness. Instead, we'll add a
  // second fence that will signal immediately, and wait for that one instead.
  {
    auto signal2 = fml::ManualResetWaitableEvent();
    auto fence2 = device.createFenceUnique({}).value;
    MockFence::SetStatus(fence2, vk::Result::eSuccess);
    waiter->AddFence(std::move(fence2), default_submit_callback,
                     [&signal2]() { signal2.Signal(); });
    signal2.Wait();
  }
 
  // Now, we'll signal the first fence, and wait for the callback to be called.
  raw_fence->SetStatus(vk::Result::eSuccess);
 
  // Now, we'll signal the first fence, and wait for the callback to be called.
  signal.Wait();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, impeller::testing::MockFence::GetRawPointer(), impeller::testing::MockFence::SetStatus(), and value.

◆ TEST() [190/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		IgnoresNullCallback
	)

Definition at line 25 of file fence_waiter_vk_unittests.cc.

                                             {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  auto fence = device.createFenceUnique({}).value;
  const auto add_status =
      waiter->AddFence(std::move(fence), default_submit_callback, nullptr);
  EXPECT_EQ(add_status.code(), fml::StatusCode::kInvalidArgument);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, fml::kInvalidArgument, and value.

◆ TEST() [191/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		IgnoresNullFence
	)

Definition at line 17 of file fence_waiter_vk_unittests.cc.

                                          {
  auto const context = MockVulkanContextBuilder().Build();
  auto const waiter = context->GetFenceWaiter();
  const auto add_status =
      waiter->AddFence(vk::UniqueFence(), default_submit_callback, []() {});
  EXPECT_EQ(add_status.code(), fml::StatusCode::kInvalidArgument);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, and fml::kInvalidArgument.

◆ TEST() [192/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		InProgressFencesStillWaitIfTerminated
	)

Definition at line 139 of file fence_waiter_vk_unittests.cc.

                                                               {
  MockFence* raw_fence = nullptr;
  auto signal = fml::ManualResetWaitableEvent();
 
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  // Add a fence that isn't signalled yet.
  auto fence = device.createFenceUnique({}).value;
 
  // Even if the fence is eSuccess, it's not guaranteed to be called in time.
  MockFence::SetStatus(fence, vk::Result::eNotReady);
  raw_fence = MockFence::GetRawPointer(fence);
  waiter->AddFence(std::move(fence), default_submit_callback,
                   [&signal]() { signal.Signal(); });
 
  // Signal the fence after a delay.
  std::thread thread([&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds{100u});
    raw_fence->SetStatus(vk::Result::eSuccess);
  });
 
  // Terminate the waiter.  This will block until all pending fences are
  // signalled.
  waiter->Terminate();
 
  // This will hang if the fence was not signalled.
  signal.Wait();
 
  thread.join();
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, impeller::testing::MockFence::GetRawPointer(), impeller::testing::MockFence::SetStatus(), and value.

◆ TEST() [193/689]

impeller::testing::TEST	(	FenceWaiterVKTest	,
		ReturnsSubmitError
	)

Definition at line 36 of file fence_waiter_vk_unittests.cc.

                                            {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
  auto const waiter = context->GetFenceWaiter();
 
  auto submit_callback = [&](vk::Fence) {
    return fml::Status(fml::StatusCode::kCancelled, "Submit failed");
  };
 
  auto fence = device.createFenceUnique({}).value;
  const auto add_status =
      waiter->AddFence(std::move(fence), submit_callback, []() {});
  EXPECT_EQ(add_status.code(), fml::StatusCode::kCancelled);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, fml::kCancelled, and value.

◆ TEST() [194/689]

impeller::testing::TEST	(	FilterInputTest	,
		CanSetLocalTransformForTexture
	)

Definition at line 15 of file filter_input_unittests.cc.

                                                      {
  std::shared_ptr<Texture> texture = nullptr;
  auto input =
      FilterInput::Make(texture, Matrix::MakeTranslation({1.0, 0.0, 0.0}));
  Entity e;
  e.SetTransform(Matrix::MakeTranslation({0.0, 2.0, 0.0}));
 
  ASSERT_MATRIX_NEAR(input->GetLocalTransform(e),
                     Matrix::MakeTranslation({1.0, 0.0, 0.0}));
  ASSERT_MATRIX_NEAR(input->GetTransform(e),
                     Matrix::MakeTranslation({1.0, 2.0, 0.0}));
}

References ASSERT_MATRIX_NEAR, input(), impeller::FilterInput::Make(), impeller::Matrix::MakeTranslation(), impeller::Entity::SetTransform(), and texture.

◆ TEST() [195/689]

impeller::testing::TEST	(	FormatsGLES	,
		CanFormatFramebufferErrorMessage
	)

Definition at line 12 of file formats_gles_unittests.cc.

                                                    {
  ASSERT_EQ(DebugToFramebufferError(GL_FRAMEBUFFER_UNDEFINED),
            "GL_FRAMEBUFFER_UNDEFINED");
  ASSERT_EQ(DebugToFramebufferError(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT),
            "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT");
  ASSERT_EQ(
      DebugToFramebufferError(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT),
      "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
  ASSERT_EQ(DebugToFramebufferError(GL_FRAMEBUFFER_UNSUPPORTED),
            "GL_FRAMEBUFFER_UNSUPPORTED");
  ASSERT_EQ(DebugToFramebufferError(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE),
            "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE");
  ASSERT_EQ(DebugToFramebufferError(0), "Unknown error code: 0");
}

References impeller::DebugToFramebufferError().

◆ TEST() [196/689]

impeller::testing::TEST	(	FormatsVKTest	,
		DescriptorMapping
	)

Definition at line 11 of file formats_vk_unittests.cc.

                                       {
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kSampledImage),
            vk::DescriptorType::eCombinedImageSampler);
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kUniformBuffer),
            vk::DescriptorType::eUniformBuffer);
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kStorageBuffer),
            vk::DescriptorType::eStorageBuffer);
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kImage),
            vk::DescriptorType::eSampledImage);
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kSampler),
            vk::DescriptorType::eSampler);
  EXPECT_EQ(ToVKDescriptorType(DescriptorType::kInputAttachment),
            vk::DescriptorType::eInputAttachment);
}

References impeller::kImage, impeller::kInputAttachment, impeller::kSampledImage, impeller::kSampler, impeller::kStorageBuffer, impeller::kUniformBuffer, and impeller::ToVKDescriptorType().

◆ TEST() [197/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CalculateSigmaForBlurRadius
	)

Definition at line 490 of file gaussian_blur_filter_contents_unittests.cc.

                                                                  {
  Scalar sigma = 1.0;
  Scalar radius = GaussianBlurFilterContents::CalculateBlurRadius(
      GaussianBlurFilterContents::ScaleSigma(sigma));
  fml::StatusOr<Scalar> derived_sigma =
      CalculateSigmaForBlurRadius(radius, Matrix());
  ASSERT_TRUE(derived_sigma.ok());
  EXPECT_NEAR(sigma, derived_sigma.value(), 0.01f);
}

References impeller::GaussianBlurFilterContents::CalculateBlurRadius(), fml::StatusOr< T >::ok(), impeller::GaussianBlurFilterContents::ScaleSigma(), and fml::StatusOr< T >::value().

◆ TEST() [198/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CalculateSigmaValues
	)

Definition at line 252 of file gaussian_blur_filter_contents_unittests.cc.

                                                           {
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(1.0f), 1);
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(2.0f), 1);
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(3.0f), 1);
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(4.0f), 1);
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(16.0f), 0.25);
  // Hang on to 1/8 as long as possible.
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(95.0f), 0.125);
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(96.0f), 0.0625);
  // Downsample clamped to 1/16th.
  EXPECT_EQ(GaussianBlurFilterContents::CalculateScale(1024.0f), 0.0625);
}

References impeller::GaussianBlurFilterContents::CalculateScale().

◆ TEST() [199/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		ChopHugeBlurs
	)

Definition at line 658 of file gaussian_blur_filter_contents_unittests.cc.

                                                    {
  Scalar sigma = 30.5f;
  int32_t blur_radius = static_cast<int32_t>(
      std::ceil(GaussianBlurFilterContents::CalculateBlurRadius(sigma)));
  BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                               .blur_sigma = sigma,
                               .blur_radius = blur_radius,
                               .step_size = 1};
  KernelSamples kernel_samples = GenerateBlurInfo(parameters);
  LerpHackResult frag_kernel_samples = LerpHackKernelSamples(kernel_samples);
  EXPECT_TRUE(frag_kernel_samples.sample_count <= kGaussianBlurMaxKernelSize);
}

References blur_radius, impeller::BlurParameters::blur_uv_offset, impeller::GaussianBlurFilterContents::CalculateBlurRadius(), impeller::GenerateBlurInfo(), impeller::kGaussianBlurMaxKernelSize, impeller::LerpHackKernelSamples(), and impeller::LerpHackResult::sample_count.

◆ TEST() [200/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		Coefficients
	)

Definition at line 500 of file gaussian_blur_filter_contents_unittests.cc.

                                                   {
  BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                               .blur_sigma = 1,
                               .blur_radius = 5,
                               .step_size = 1};
  KernelSamples samples = GenerateBlurInfo(parameters);
  EXPECT_EQ(samples.sample_count, 11);
 
  // Coefficients should add up to 1.
  Scalar tally = 0;
  for (int i = 0; i < samples.sample_count; ++i) {
    tally += samples.samples[i].coefficient;
  }
  EXPECT_FLOAT_EQ(tally, 1.0f);
 
  // Verify the shape of the curve.
  for (int i = 0; i < 4; ++i) {
    EXPECT_FLOAT_EQ(samples.samples[i].coefficient,
                    samples.samples[10 - i].coefficient);
    EXPECT_TRUE(samples.samples[i + 1].coefficient >
                samples.samples[i].coefficient);
  }
}

References impeller::BlurParameters::blur_uv_offset, impeller::KernelSample::coefficient, impeller::GenerateBlurInfo(), i, impeller::KernelSamples::sample_count, and impeller::KernelSamples::samples.

◆ TEST() [201/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageEmpty
	)

Definition at line 122 of file gaussian_blur_filter_contents_unittests.cc.

                                                    {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  FilterInput::Vector inputs = {};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
  ASSERT_FALSE(coverage.has_value());
}

References impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, and impeller::FilterContents::kNormal.

◆ TEST() [202/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageSimple
	)

Definition at line 134 of file gaussian_blur_filter_contents_unittests.cc.

                                                     {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  FilterInput::Vector inputs = {
      FilterInput::Make(Rect::MakeLTRB(10, 10, 110, 110))};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
 
  ASSERT_EQ(coverage, Rect::MakeLTRB(10, 10, 110, 110));
}

References impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [203/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		CoverageWithSigma
	)

Definition at line 148 of file gaussian_blur_filter_contents_unittests.cc.

                                                        {
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  GaussianBlurFilterContents contents(
      /*sigma_x=*/sigma_radius_1.value(),
      /*sigma_y=*/sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  FilterInput::Vector inputs = {
      FilterInput::Make(Rect::MakeLTRB(100, 100, 200, 200))};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
 
  EXPECT_TRUE(coverage.has_value());
  if (coverage.has_value()) {
    EXPECT_RECT_NEAR(coverage.value(), Rect::MakeLTRB(99, 99, 201, 201));
  }
}

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), fml::StatusOr< T >::ok(), and fml::StatusOr< T >::value().

◆ TEST() [204/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		Create
	)

Definition at line 113 of file gaussian_blur_filter_contents_unittests.cc.

                                             {
  GaussianBlurFilterContents contents(
      /*sigma_x=*/0.0, /*sigma_y=*/0.0, Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  EXPECT_EQ(contents.GetSigmaX(), 0.0);
  EXPECT_EQ(contents.GetSigmaY(), 0.0);
}

References impeller::GaussianBlurFilterContents::GetSigmaX(), impeller::GaussianBlurFilterContents::GetSigmaY(), impeller::Entity::kDecal, and impeller::FilterContents::kNormal.

◆ TEST() [205/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		FilterSourceCoverage
	)

Definition at line 214 of file gaussian_blur_filter_contents_unittests.cc.

                                                           {
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  std::optional<Rect> coverage = contents->GetFilterSourceCoverage(
      /*effect_transform=*/Matrix::MakeScale({2.0, 2.0, 1.0}),
      /*output_limit=*/Rect::MakeLTRB(100, 100, 200, 200));
  EXPECT_TRUE(coverage.has_value());
  if (coverage.has_value()) {
    EXPECT_RECT_NEAR(coverage.value(),
                     Rect::MakeLTRB(100 - 2, 100 - 2, 200 + 2, 200 + 2));
  }
}

References EXPECT_RECT_NEAR, impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), fml::StatusOr< T >::ok(), and fml::StatusOr< T >::value().

◆ TEST() [206/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		FilterSourceCoverageNegativeScale
	)

Definition at line 232 of file gaussian_blur_filter_contents_unittests.cc.

                                                                        {
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
 
  // Negative scale should still result in an expanded coverage rect.
  std::optional<Rect> coverage = contents->GetFilterSourceCoverage(
      /*effect_transform=*/Matrix::MakeScale({-2.0, 2.0, 1.0}),
      /*output_limit=*/Rect::MakeLTRB(100, 100, 200, 200));
  ASSERT_TRUE(coverage.has_value());
  if (coverage.has_value()) {
    EXPECT_RECT_NEAR(coverage.value(),
                     Rect::MakeLTRB(100 - 2, 100 - 2, 200 + 2, 200 + 2));
  }
}

References EXPECT_RECT_NEAR, impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), fml::StatusOr< T >::ok(), and fml::StatusOr< T >::value().

◆ TEST() [207/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		LerpHackKernelSamplesComplex
	)

Definition at line 604 of file gaussian_blur_filter_contents_unittests.cc.

                                                                   {
  Scalar sigma = 10.0f;
  int32_t blur_radius = static_cast<int32_t>(
      std::ceil(GaussianBlurFilterContents::CalculateBlurRadius(sigma)));
  BlurParameters parameters = {.blur_uv_offset = Point(1, 0),
                               .blur_sigma = sigma,
                               .blur_radius = blur_radius,
                               .step_size = 1};
  KernelSamples kernel_samples = GenerateBlurInfo(parameters);
  EXPECT_EQ(kernel_samples.sample_count, 33);
  LerpHackResult fast_kernel_samples = LerpHackKernelSamples(kernel_samples);
  EXPECT_EQ(fast_kernel_samples.sample_count, 17);
  float data[33];
  srand(0);
  for (int i = 0; i < 33; i++) {
    data[i] = 255.0 * static_cast<double>(IMPELLER_RAND()) / RAND_MAX;
  }
 
  auto sampler = [data](Point point) -> Scalar {
    FML_CHECK(point.y == 0.0f);
    FML_CHECK(point.x >= -16);
    FML_CHECK(point.x <= 16);
    Scalar fint_part;
    Scalar fract = fabsf(modf(point.x, &fint_part));
    if (fract == 0) {
      int32_t int_part = static_cast<int32_t>(fint_part) + 16;
      return data[int_part];
    } else {
      int32_t left = static_cast<int32_t>(floor(point.x)) + 16;
      int32_t right = static_cast<int32_t>(ceil(point.x)) + 16;
      if (point.x < 0) {
        return fract * data[left] + (1.0 - fract) * data[right];
      } else {
        return (1.0 - fract) * data[left] + fract * data[right];
      }
    }
  };
 
  Scalar output = 0.0;
  for (int i = 0; i < kernel_samples.sample_count; ++i) {
    auto sample = kernel_samples.samples[i];
    output += sample.coefficient * sampler(sample.uv_offset);
  }
 
  Scalar fast_output = 0.0;
  for (int i = 0; i < fast_kernel_samples.sample_count; i++) {
    fast_output +=
        GetCoefficient(fast_kernel_samples.kernel_samples.sample_data[i]) *
        sampler(GetUVOffset(fast_kernel_samples.kernel_samples.sample_data[i]));
  }
 
  EXPECT_NEAR(output, fast_output, 0.1);
}

References blur_radius, impeller::BlurParameters::blur_uv_offset, impeller::GaussianBlurFilterContents::CalculateBlurRadius(), impeller::KernelSample::coefficient, flutter::data, FML_CHECK, impeller::GenerateBlurInfo(), i, IMPELLER_RAND, impeller::LerpHackResult::kernel_samples, impeller::LerpHackKernelSamples(), impeller::KernelSamples::sample_count, impeller::LerpHackResult::sample_count, and impeller::KernelSamples::samples.

◆ TEST() [208/689]

impeller::testing::TEST	(	GaussianBlurFilterContentsTest	,
		LerpHackKernelSamplesSimple
	)

Definition at line 524 of file gaussian_blur_filter_contents_unittests.cc.

                                                                  {
  KernelSamples kernel_samples = {
      .sample_count = 5,
      .samples =
          {
              {
                  .uv_offset = Vector2(-2, 0),
                  .coefficient = 0.1f,
              },
              {
                  .uv_offset = Vector2(-1, 0),
                  .coefficient = 0.2f,
              },
              {
                  .uv_offset = Vector2(0, 0),
                  .coefficient = 0.4f,
              },
              {
                  .uv_offset = Vector2(1, 0),
                  .coefficient = 0.2f,
              },
              {
                  .uv_offset = Vector2(2, 0),
                  .coefficient = 0.1f,
              },
          },
  };
 
  LerpHackResult blur_info = LerpHackKernelSamples(kernel_samples);
  EXPECT_EQ(blur_info.sample_count, 3);
 
  KernelSample* samples = kernel_samples.samples;
 
  //////////////////////////////////////////////////////////////////////////////
  // Check output kernel.
 
  EXPECT_POINT_NEAR(GetUVOffset(blur_info.kernel_samples.sample_data[0]),
                    Point(-1.3333333, 0));
  EXPECT_FLOAT_EQ(GetCoefficient(blur_info.kernel_samples.sample_data[0]), 0.3);
 
  EXPECT_POINT_NEAR(GetUVOffset(blur_info.kernel_samples.sample_data[1]),
                    Point(0, 0));
  EXPECT_FLOAT_EQ(GetCoefficient(blur_info.kernel_samples.sample_data[1]), 0.4);
 
  EXPECT_POINT_NEAR(GetUVOffset(blur_info.kernel_samples.sample_data[2]),
                    Point(1.333333, 0));
  EXPECT_FLOAT_EQ(GetCoefficient(blur_info.kernel_samples.sample_data[2]), 0.3);
 
  //////////////////////////////////////////////////////////////////////////////
  // Check output of fast kernel versus original kernel.
 
  Scalar data[5] = {0.25, 0.5, 0.5, 1.0, 0.2};
  Scalar original_output =
      samples[0].coefficient * data[0] + samples[1].coefficient * data[1] +
      samples[2].coefficient * data[2] + samples[3].coefficient * data[3] +
      samples[4].coefficient * data[4];
 
  auto lerp = [](const Point& point, Scalar left, Scalar right) {
    Scalar int_part;
    Scalar fract = fabsf(modf(point.x, &int_part));
    if (point.x < 0) {
      return left * fract + right * (1.0 - fract);
    } else {
      return left * (1.0 - fract) + right * fract;
    }
  };
  Scalar fast_output =
      /*1st*/ lerp(GetUVOffset(blur_info.kernel_samples.sample_data[0]),
                   data[0], data[1]) *
          GetCoefficient(blur_info.kernel_samples.sample_data[0]) +
      /*2nd*/ data[2] *
          GetCoefficient(blur_info.kernel_samples.sample_data[1]) +
      /*3rd*/
      lerp(GetUVOffset(blur_info.kernel_samples.sample_data[2]), data[3],
           data[4]) *
          GetCoefficient(blur_info.kernel_samples.sample_data[2]);
 
  EXPECT_NEAR(original_output, fast_output, 0.01);
}

References impeller::KernelSample::coefficient, flutter::data, EXPECT_POINT_NEAR, impeller::LerpHackResult::kernel_samples, impeller::LerpHackKernelSamples(), impeller::KernelSamples::sample_count, impeller::LerpHackResult::sample_count, impeller::KernelSamples::samples, and flutter::Point::x().

◆ TEST() [209/689]

impeller::testing::TEST	(	GeometryTest	,
		BlendModeToString
	)

Definition at line 1709 of file geometry_unittests.cc.

                                      {
  using BlendT = std::underlying_type_t<BlendMode>;
  for (BlendT i = 0; i <= static_cast<BlendT>(BlendMode::kLastMode); i++) {
    auto mode = static_cast<BlendMode>(i);
    auto result = BlendModeToString(mode);
    switch (mode) { IMPELLER_FOR_EACH_BLEND_MODE(_BLEND_MODE_NAME_CHECK) }
  }
}

References _BLEND_MODE_NAME_CHECK, impeller::BlendModeToString(), i, IMPELLER_FOR_EACH_BLEND_MODE, impeller::kLastMode, and flutter::mode.

◆ TEST() [210/689]

impeller::testing::TEST	(	GeometryTest	,
		CanConvertBetweenDegressAndRadians
	)

Definition at line 1718 of file geometry_unittests.cc.

                                                       {
  {
    auto deg = Degrees{90.0};
    Radians rad = deg;
    ASSERT_FLOAT_EQ(rad.radians, kPiOver2);
  }
}

References impeller::kPiOver2, and impeller::Radians::radians.

◆ TEST() [211/689]

impeller::testing::TEST	(	GeometryTest	,
		CanConvertTTypesExplicitly
	)

Definition at line 593 of file geometry_unittests.cc.

                                               {
  {
    Point p1(1.0, 2.0);
    IPoint p2 = static_cast<IPoint>(p1);
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 2u);
  }
 
  {
    Size s1(1.0, 2.0);
    ISize s2 = static_cast<ISize>(s1);
    ASSERT_EQ(s2.width, 1u);
    ASSERT_EQ(s2.height, 2u);
  }
 
  {
    Size s1(1.0, 2.0);
    Point p1 = static_cast<Point>(s1);
    ASSERT_EQ(p1.x, 1u);
    ASSERT_EQ(p1.y, 2u);
  }
}

References impeller::TSize< T >::height, p1, p2, impeller::TSize< T >::width, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [212/689]

impeller::testing::TEST	(	GeometryTest	,
		CanGenerateMipCounts
	)

Definition at line 580 of file geometry_unittests.cc.

                                         {
  EXPECT_EQ((Size{128, 128}.MipCount()), 7u);
  EXPECT_EQ((Size{128, 256}.MipCount()), 7u);
  EXPECT_EQ((Size{128, 130}.MipCount()), 7u);
  EXPECT_EQ((Size{128, 257}.MipCount()), 7u);
  EXPECT_EQ((Size{257, 128}.MipCount()), 7u);
  EXPECT_EQ((Size{128, 0}.MipCount()), 1u);
  EXPECT_EQ((Size{128, -25}.MipCount()), 1u);
  EXPECT_EQ((Size{-128, 25}.MipCount()), 1u);
  EXPECT_EQ((Size{1, 1}.MipCount()), 1u);
  EXPECT_EQ((Size{0, 0}.MipCount()), 1u);
}

◆ TEST() [213/689]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicPointOps
	)

Definition at line 616 of file geometry_unittests.cc.

                                                {
  {
    IPoint p1(1, 2);
    IPoint p2 = p1 + IPoint(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(3, 6);
    IPoint p2 = p1 - IPoint(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(1, 2);
    IPoint p2 = p1 * IPoint(2, 3);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 6u);
  }
 
  {
    IPoint p1(2, 6);
    IPoint p2 = p1 / IPoint(2, 3);
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 2u);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [214/689]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicPointOpsWithArithmeticTypes
	)

Definition at line 646 of file geometry_unittests.cc.

                                                                   {
  // LHS
  {
    IPoint p1(1, 2);
    IPoint p2 = p1 * 2.0f;
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(2, 6);
    IPoint p2 = p1 / 2.0f;
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 3u);
  }
 
  // RHS
  {
    IPoint p1(1, 2);
    IPoint p2 = 2.0f * p1;
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(2, 6);
    IPoint p2 = 12.0f / p1;
    ASSERT_EQ(p2.x, 6u);
    ASSERT_EQ(p2.y, 2u);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [215/689]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicVector3Ops
	)

Definition at line 1276 of file geometry_unittests.cc.

                                                  {
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = p1 + Vector3(1, 2, 3);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
    ASSERT_EQ(p2.z, 6u);
  }
 
  {
    Vector3 p1(3, 6, 9);
    Vector3 p2 = p1 - Vector3(1, 2, 3);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
    ASSERT_EQ(p2.z, 6u);
  }
 
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = p1 * Vector3(2, 3, 4);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 6u);
    ASSERT_EQ(p2.z, 12u);
  }
 
  {
    Vector3 p1(2, 6, 12);
    Vector3 p2 = p1 / Vector3(2, 3, 4);
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 2u);
    ASSERT_EQ(p2.z, 3u);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [216/689]

impeller::testing::TEST	(	GeometryTest	,
		CanPerformAlgebraicVector3OpsWithArithmeticTypes
	)

Definition at line 1310 of file geometry_unittests.cc.

                                                                     {
  // LHS
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = p1 + 2.0f;
    ASSERT_EQ(p2.x, 3);
    ASSERT_EQ(p2.y, 4);
    ASSERT_EQ(p2.z, 5);
  }
 
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = p1 - 2.0f;
    ASSERT_EQ(p2.x, -1);
    ASSERT_EQ(p2.y, 0);
    ASSERT_EQ(p2.z, 1);
  }
 
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = p1 * 2.0f;
    ASSERT_EQ(p2.x, 2);
    ASSERT_EQ(p2.y, 4);
    ASSERT_EQ(p2.z, 6);
  }
 
  {
    Vector3 p1(2, 6, 12);
    Vector3 p2 = p1 / 2.0f;
    ASSERT_EQ(p2.x, 1);
    ASSERT_EQ(p2.y, 3);
    ASSERT_EQ(p2.z, 6);
  }
 
  // RHS
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = 2.0f + p1;
    ASSERT_EQ(p2.x, 3);
    ASSERT_EQ(p2.y, 4);
    ASSERT_EQ(p2.z, 5);
  }
 
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = 2.0f - p1;
    ASSERT_EQ(p2.x, 1);
    ASSERT_EQ(p2.y, 0);
    ASSERT_EQ(p2.z, -1);
  }
 
  {
    Vector3 p1(1, 2, 3);
    Vector3 p2 = 2.0f * p1;
    ASSERT_EQ(p2.x, 2);
    ASSERT_EQ(p2.y, 4);
    ASSERT_EQ(p2.z, 6);
  }
 
  {
    Vector3 p1(2, 6, 12);
    Vector3 p2 = 12.0f / p1;
    ASSERT_EQ(p2.x, 6);
    ASSERT_EQ(p2.y, 2);
    ASSERT_EQ(p2.z, 1);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [217/689]

impeller::testing::TEST	(	GeometryTest	,
		CanUsePointAssignmentOperators
	)

Definition at line 798 of file geometry_unittests.cc.

                                                   {
  // Point on RHS
  {
    IPoint p(1, 2);
    p += IPoint(1, 2);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
  }
 
  {
    IPoint p(3, 6);
    p -= IPoint(1, 2);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
  }
 
  {
    IPoint p(1, 2);
    p *= IPoint(2, 3);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 6u);
  }
 
  {
    IPoint p(2, 6);
    p /= IPoint(2, 3);
    ASSERT_EQ(p.x, 1u);
    ASSERT_EQ(p.y, 2u);
  }
 
  // Size on RHS
  {
    IPoint p(1, 2);
    p += ISize(1, 2);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
  }
 
  {
    IPoint p(3, 6);
    p -= ISize(1, 2);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
  }
 
  {
    IPoint p(1, 2);
    p *= ISize(2, 3);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 6u);
  }
 
  {
    IPoint p(2, 6);
    p /= ISize(2, 3);
    ASSERT_EQ(p.x, 1u);
    ASSERT_EQ(p.y, 2u);
  }
 
  // Arithmetic type on RHS
  {
    IPoint p(1, 2);
    p *= 3;
    ASSERT_EQ(p.x, 3u);
    ASSERT_EQ(p.y, 6u);
  }
 
  {
    IPoint p(3, 6);
    p /= 3;
    ASSERT_EQ(p.x, 1u);
    ASSERT_EQ(p.y, 2u);
  }
}

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST() [218/689]

impeller::testing::TEST	(	GeometryTest	,
		CanUseVector3AssignmentOperators
	)

Definition at line 1226 of file geometry_unittests.cc.

                                                     {
  {
    Vector3 p(1, 2, 4);
    p += Vector3(1, 2, 4);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
    ASSERT_EQ(p.z, 8u);
  }
 
  {
    Vector3 p(3, 6, 8);
    p -= Vector3(1, 2, 3);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
    ASSERT_EQ(p.z, 5u);
  }
 
  {
    Vector3 p(1, 2, 3);
    p *= Vector3(2, 3, 4);
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 6u);
    ASSERT_EQ(p.z, 12u);
  }
 
  {
    Vector3 p(1, 2, 3);
    p *= 2;
    ASSERT_EQ(p.x, 2u);
    ASSERT_EQ(p.y, 4u);
    ASSERT_EQ(p.z, 6u);
  }
 
  {
    Vector3 p(2, 6, 12);
    p /= Vector3(2, 3, 4);
    ASSERT_EQ(p.x, 1u);
    ASSERT_EQ(p.y, 2u);
    ASSERT_EQ(p.z, 3u);
  }
 
  {
    Vector3 p(2, 6, 12);
    p /= 2;
    ASSERT_EQ(p.x, 1u);
    ASSERT_EQ(p.y, 3u);
    ASSERT_EQ(p.z, 6u);
  }
}

References impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ TEST() [219/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorApplyColorMatrix
	)

Definition at line 1483 of file geometry_unittests.cc.

                                          {
  {
    ColorMatrix color_matrix = {
        1, 1, 1, 1, 1,  //
        1, 1, 1, 1, 1,  //
        1, 1, 1, 1, 1,  //
        1, 1, 1, 1, 1,  //
    };
    auto result = Color::White().ApplyColorMatrix(color_matrix);
    auto expected = Color(1, 1, 1, 1);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    ColorMatrix color_matrix = {
        0.1, 0,   0,   0,   0.01,  //
        0,   0.2, 0,   0,   0.02,  //
        0,   0,   0.3, 0,   0.03,  //
        0,   0,   0,   0.4, 0.04,  //
    };
    auto result = Color::White().ApplyColorMatrix(color_matrix);
    auto expected = Color(0.11, 0.22, 0.33, 0.44);
    ASSERT_COLOR_NEAR(result, expected);
  }
}

References impeller::Color::ApplyColorMatrix(), ASSERT_COLOR_NEAR, and impeller::Color::White().

◆ TEST() [220/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorBlendReturnsExpectedResults
	)

Definition at line 1692 of file geometry_unittests.cc.

                                                     {
  Color dst = ColorBlendTestData::kDestinationColor;
  for (size_t source_i = 0;
       source_i < sizeof(ColorBlendTestData::kSourceColors) / sizeof(Color);
       source_i++) {
    Color src = ColorBlendTestData::kSourceColors[source_i];
 
    Color expected;
    IMPELLER_FOR_EACH_BLEND_MODE(_BLEND_MODE_RESULT_CHECK)
  }
}

References _BLEND_MODE_RESULT_CHECK, IMPELLER_FOR_EACH_BLEND_MODE, impeller::testing::ColorBlendTestData::kDestinationColor, and impeller::testing::ColorBlendTestData::kSourceColors.

◆ TEST() [221/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorClamp01
	)

Definition at line 1443 of file geometry_unittests.cc.

                                 {
  {
    Color result = Color(0.5, 0.5, 0.5, 0.5).Clamp01();
    Color expected = Color(0.5, 0.5, 0.5, 0.5);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    Color result = Color(-1, -1, -1, -1).Clamp01();
    Color expected = Color(0, 0, 0, 0);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    Color result = Color(2, 2, 2, 2).Clamp01();
    Color expected = Color(1, 1, 1, 1);
    ASSERT_COLOR_NEAR(result, expected);
  }
}

References ASSERT_COLOR_NEAR, and impeller::Color::Clamp01().

◆ TEST() [222/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorLerp
	)

Definition at line 1421 of file geometry_unittests.cc.

                              {
  {
    Color a(0.0, 0.0, 0.0, 0.0);
    Color b(1.0, 1.0, 1.0, 1.0);
 
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.5), Color(0.5, 0.5, 0.5, 0.5));
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.0), a);
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 1.0), b);
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.2), Color(0.2, 0.2, 0.2, 0.2));
  }
 
  {
    Color a(0.2, 0.4, 1.0, 0.5);
    Color b(0.4, 1.0, 0.2, 0.3);
 
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.5), Color(0.3, 0.7, 0.6, 0.4));
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.0), a);
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 1.0), b);
    ASSERT_COLOR_NEAR(Color::Lerp(a, b, 0.2), Color(0.24, 0.52, 0.84, 0.46));
  }
}

References ASSERT_COLOR_NEAR, and impeller::Color::Lerp().

◆ TEST() [223/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorLinearToSRGB
	)

Definition at line 1509 of file geometry_unittests.cc.

                                      {
  {
    auto result = Color::White().LinearToSRGB();
    auto expected = Color(1, 1, 1, 1);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    auto result = Color::BlackTransparent().LinearToSRGB();
    auto expected = Color(0, 0, 0, 0);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    auto result = Color(0.2, 0.4, 0.6, 0.8).LinearToSRGB();
    auto expected = Color(0.484529, 0.665185, 0.797738, 0.8);
    ASSERT_COLOR_NEAR(result, expected);
  }
}

References ASSERT_COLOR_NEAR, impeller::Color::BlackTransparent(), impeller::Color::LinearToSRGB(), and impeller::Color::White().

◆ TEST() [224/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorMakeRGBA8
	)

Definition at line 1463 of file geometry_unittests.cc.

                                   {
  {
    Color a = Color::MakeRGBA8(0, 0, 0, 0);
    Color b = Color::BlackTransparent();
    ASSERT_COLOR_NEAR(a, b);
  }
 
  {
    Color a = Color::MakeRGBA8(255, 255, 255, 255);
    Color b = Color::White();
    ASSERT_COLOR_NEAR(a, b);
  }
 
  {
    Color a = Color::MakeRGBA8(63, 127, 191, 127);
    Color b(0.247059, 0.498039, 0.74902, 0.498039);
    ASSERT_COLOR_NEAR(a, b);
  }
}

References ASSERT_COLOR_NEAR, impeller::Color::BlackTransparent(), impeller::Color::MakeRGBA8(), and impeller::Color::White().

◆ TEST() [225/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorPremultiply
	)

Definition at line 1378 of file geometry_unittests.cc.

                                     {
  {
    Color a(1.0, 0.5, 0.2, 0.5);
    Color premultiplied = a.Premultiply();
    Color expected = Color(0.5, 0.25, 0.1, 0.5);
    ASSERT_COLOR_NEAR(premultiplied, expected);
  }
 
  {
    Color a(0.5, 0.25, 0.1, 0.5);
    Color unpremultiplied = a.Unpremultiply();
    Color expected = Color(1.0, 0.5, 0.2, 0.5);
    ASSERT_COLOR_NEAR(unpremultiplied, expected);
  }
 
  {
    Color a(0.5, 0.25, 0.1, 0.0);
    Color unpremultiplied = a.Unpremultiply();
    Color expected = Color(0.0, 0.0, 0.0, 0.0);
    ASSERT_COLOR_NEAR(unpremultiplied, expected);
  }
}

References ASSERT_COLOR_NEAR, impeller::Color::Premultiply(), and impeller::Color::Unpremultiply().

◆ TEST() [226/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorPrinting
	)

Definition at line 1801 of file geometry_unittests.cc.

                                  {
  {
    std::stringstream stream;
    Color m;
    stream << m;
    ASSERT_EQ(stream.str(), "(0, 0, 0, 0)");
  }
 
  {
    std::stringstream stream;
    Color m(1, 2, 3, 4);
    stream << m;
    ASSERT_EQ(stream.str(), "(1, 2, 3, 4)");
  }
}

◆ TEST() [227/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorR8G8B8A8
	)

Definition at line 1401 of file geometry_unittests.cc.

                                  {
  {
    Color a(1.0, 0.5, 0.2, 0.5);
    std::array<uint8_t, 4> expected = {255, 128, 51, 128};
    ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
  }
 
  {
    Color a(0.0, 0.0, 0.0, 0.0);
    std::array<uint8_t, 4> expected = {0, 0, 0, 0};
    ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
  }
 
  {
    Color a(1.0, 1.0, 1.0, 1.0);
    std::array<uint8_t, 4> expected = {255, 255, 255, 255};
    ASSERT_ARRAY_4_NEAR(a.ToR8G8B8A8(), expected);
  }
}

References ASSERT_ARRAY_4_NEAR, and impeller::Color::ToR8G8B8A8().

◆ TEST() [228/689]

impeller::testing::TEST	(	GeometryTest	,
		ColorSRGBToLinear
	)

Definition at line 1529 of file geometry_unittests.cc.

                                      {
  {
    auto result = Color::White().SRGBToLinear();
    auto expected = Color(1, 1, 1, 1);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    auto result = Color::BlackTransparent().SRGBToLinear();
    auto expected = Color(0, 0, 0, 0);
    ASSERT_COLOR_NEAR(result, expected);
  }
 
  {
    auto result = Color(0.2, 0.4, 0.6, 0.8).SRGBToLinear();
    auto expected = Color(0.0331048, 0.132868, 0.318547, 0.8);
    ASSERT_COLOR_NEAR(result, expected);
  }
}

References ASSERT_COLOR_NEAR, impeller::Color::BlackTransparent(), impeller::Color::SRGBToLinear(), and impeller::Color::White().

◆ TEST() [229/689]

impeller::testing::TEST	(	GeometryTest	,
		DeterminantTest
	)

Definition at line 121 of file geometry_unittests.cc.

                                    {
  auto matrix = Matrix{3, 4, 14, 155, 2, 1, 3, 4, 2, 3, 2, 1, 1, 2, 4, 2};
  ASSERT_EQ(matrix.GetDeterminant(), -1889);
}

◆ TEST() [230/689]

impeller::testing::TEST	(	GeometryTest	,
		Gradient
	)

Definition at line 1823 of file geometry_unittests.cc.

                             {
  {
    // Simple 2 color gradient produces color buffer containing exactly those
    // values.
    std::vector<Color> colors = {Color::Red(), Color::Blue()};
    std::vector<Scalar> stops = {0.0, 1.0};
 
    auto gradient = CreateGradientBuffer(colors, stops);
 
    ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, colors);
    ASSERT_EQ(gradient.texture_size, 2u);
  }
 
  {
    // Gradient with duplicate stops does not create an empty texture.
    std::vector<Color> colors = {Color::Red(), Color::Yellow(), Color::Black(),
                                 Color::Blue()};
    std::vector<Scalar> stops = {0.0, 0.25, 0.25, 1.0};
 
    auto gradient = CreateGradientBuffer(colors, stops);
    ASSERT_EQ(gradient.texture_size, 5u);
  }
 
  {
    // Simple N color gradient produces color buffer containing exactly those
    // values.
    std::vector<Color> colors = {Color::Red(), Color::Blue(), Color::Green(),
                                 Color::White()};
    std::vector<Scalar> stops = {0.0, 0.33, 0.66, 1.0};
 
    auto gradient = CreateGradientBuffer(colors, stops);
 
    ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, colors);
    ASSERT_EQ(gradient.texture_size, 4u);
  }
 
  {
    // Gradient with color stops will lerp and scale buffer.
    std::vector<Color> colors = {Color::Red(), Color::Blue(), Color::Green()};
    std::vector<Scalar> stops = {0.0, 0.25, 1.0};
 
    auto gradient = CreateGradientBuffer(colors, stops);
 
    std::vector<Color> lerped_colors = {
        Color::Red(),
        Color::Blue(),
        Color::Lerp(Color::Blue(), Color::Green(), 0.3333),
        Color::Lerp(Color::Blue(), Color::Green(), 0.6666),
        Color::Green(),
    };
    ASSERT_COLOR_BUFFER_NEAR(gradient.color_bytes, lerped_colors);
    ASSERT_EQ(gradient.texture_size, 5u);
  }
 
  {
    // Gradient size is capped at 1024.
    std::vector<Color> colors = {};
    std::vector<Scalar> stops = {};
    for (auto i = 0u; i < 1025; i++) {
      colors.push_back(Color::Blue());
      stops.push_back(i / 1025.0);
    }
 
    auto gradient = CreateGradientBuffer(colors, stops);
 
    ASSERT_EQ(gradient.texture_size, 1024u);
    ASSERT_EQ(gradient.color_bytes.size(), 1024u * 4);
  }
}

References ASSERT_COLOR_BUFFER_NEAR, impeller::Color::Black(), impeller::Color::Blue(), impeller::CreateGradientBuffer(), impeller::Color::Green(), i, impeller::Color::Lerp(), impeller::Color::Red(), impeller::Color::White(), and impeller::Color::Yellow().

◆ TEST() [231/689]

impeller::testing::TEST	(	GeometryTest	,
		HalfConversions
	)

Definition at line 1893 of file geometry_unittests.cc.

                                    {
#if defined(FML_OS_MACOSX) || defined(FML_OS_IOS) || \
    defined(FML_OS_IOS_SIMULATOR)
  ASSERT_EQ(ScalarToHalf(0.0), 0.0f16);
  ASSERT_EQ(ScalarToHalf(0.05), 0.05f16);
  ASSERT_EQ(ScalarToHalf(2.43), 2.43f16);
  ASSERT_EQ(ScalarToHalf(-1.45), -1.45f16);
 
  // 65504 is the largest possible half.
  ASSERT_EQ(ScalarToHalf(65504.0f), 65504.0f16);
  ASSERT_EQ(ScalarToHalf(65504.0f + 1), 65504.0f16);
 
  // Colors
  ASSERT_EQ(HalfVector4(Color::Red()),
            HalfVector4(1.0f16, 0.0f16, 0.0f16, 1.0f16));
  ASSERT_EQ(HalfVector4(Color::Green()),
            HalfVector4(0.0f16, 1.0f16, 0.0f16, 1.0f16));
  ASSERT_EQ(HalfVector4(Color::Blue()),
            HalfVector4(0.0f16, 0.0f16, 1.0f16, 1.0f16));
  ASSERT_EQ(HalfVector4(Color::Black().WithAlpha(0)),
            HalfVector4(0.0f16, 0.0f16, 0.0f16, 0.0f16));
 
  ASSERT_EQ(HalfVector3(Vector3(4.0, 6.0, -1.0)),
            HalfVector3(4.0f16, 6.0f16, -1.0f16));
  ASSERT_EQ(HalfVector2(Vector2(4.0, 6.0)), HalfVector2(4.0f16, 6.0f16));
 
  ASSERT_EQ(Half(0.5f), Half(0.5f16));
  ASSERT_EQ(Half(0.5), Half(0.5f16));
  ASSERT_EQ(Half(5), Half(5.0f16));
#else
  GTEST_SKIP() << "Half-precision floats (IEEE 754) are not portable and "
                  "only used on Apple platforms.";
#endif  // FML_OS_MACOSX || FML_OS_IOS || FML_OS_IOS_SIMULATOR
}

References impeller::Color::Black(), impeller::Color::Blue(), impeller::Color::Green(), impeller::Color::Red(), and impeller::ScalarToHalf().

◆ TEST() [232/689]

impeller::testing::TEST	(	GeometryTest	,
		InvertMatrix
	)

Definition at line 126 of file geometry_unittests.cc.

                                 {
  auto inverted = Matrix{10,  -9,  -12, 8,   //
                         7,   -12, 11,  22,  //
                         -10, 10,  3,   6,   //
                         -2,  22,  2,   1}
                      .Invert();
 
  auto result = Matrix{
      438.0 / 85123.0,   1751.0 / 85123.0, -7783.0 / 85123.0, 4672.0 / 85123.0,
      393.0 / 85123.0,   -178.0 / 85123.0, -570.0 / 85123.0,  4192 / 85123.0,
      -5230.0 / 85123.0, 2802.0 / 85123.0, -3461.0 / 85123.0, 962.0 / 85123.0,
      2690.0 / 85123.0,  1814.0 / 85123.0, 3896.0 / 85123.0,  319.0 / 85123.0};
 
  ASSERT_MATRIX_NEAR(inverted, result);
}

References ASSERT_MATRIX_NEAR, and impeller::Matrix::Invert().

◆ TEST() [233/689]

impeller::testing::TEST	(	GeometryTest	,
		InvertMultMatrix
	)

Definition at line 79 of file geometry_unittests.cc.

                                     {
  {
    auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
    auto invert = rotation.Invert();
    // clang-format off
    auto expect = Matrix{k1OverSqrt2, -k1OverSqrt2, 0, 0,
                         k1OverSqrt2, k1OverSqrt2,  0, 0,
                         0,           0,            1, 0,
                         0,           0,            0, 1};
    // clang-format on
    ASSERT_MATRIX_NEAR(invert, expect);
  }
  {
    auto scale = Matrix::MakeScale(Vector2{2, 4});
    auto invert = scale.Invert();
    auto expect = Matrix{0.5, 0,    0, 0,  //
                         0,   0.25, 0, 0,  //
                         0,   0,    1, 0,  //
                         0,   0,    0, 1};
    ASSERT_MATRIX_NEAR(invert, expect);
  }
}

References ASSERT_MATRIX_NEAR, impeller::Matrix::Invert(), impeller::k1OverSqrt2, impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [234/689]

impeller::testing::TEST	(	GeometryTest	,
		MakeColumn
	)

Definition at line 40 of file geometry_unittests.cc.

                               {
  auto matrix = Matrix::MakeColumn(1, 2, 3, 4,     //
                                   5, 6, 7, 8,     //
                                   9, 10, 11, 12,  //
                                   13, 14, 15, 16);
 
  auto expect = Matrix{1,  2,  3,  4,   //
                       5,  6,  7,  8,   //
                       9,  10, 11, 12,  //
                       13, 14, 15, 16};
 
  ASSERT_TRUE(matrix == expect);
}

References impeller::Matrix::MakeColumn().

◆ TEST() [235/689]

impeller::testing::TEST	(	GeometryTest	,
		MakeRow
	)

Definition at line 54 of file geometry_unittests.cc.

                            {
  auto matrix = Matrix::MakeRow(1, 2, 3, 4,     //
                                5, 6, 7, 8,     //
                                9, 10, 11, 12,  //
                                13, 14, 15, 16);
 
  auto expect = Matrix{1, 5, 9,  13,  //
                       2, 6, 10, 14,  //
                       3, 7, 11, 15,  //
                       4, 8, 12, 16};
 
  ASSERT_TRUE(matrix == expect);
}

References impeller::Matrix::MakeRow().

◆ TEST() [236/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixBasis
	)

Definition at line 102 of file geometry_unittests.cc.

                                {
  auto matrix = Matrix{1,  2,  3,  4,   //
                       5,  6,  7,  8,   //
                       9,  10, 11, 12,  //
                       13, 14, 15, 16};
  auto basis = matrix.Basis();
  auto expect = Matrix{1, 2,  3,  0,  //
                       5, 6,  7,  0,  //
                       9, 10, 11, 0,  //
                       0, 0,  0,  1};
  ASSERT_MATRIX_NEAR(basis, expect);
}

References ASSERT_MATRIX_NEAR, and impeller::Matrix::Basis().

◆ TEST() [237/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetBasisVectors
	)

Definition at line 408 of file geometry_unittests.cc.

                                          {
  {
    auto m = Matrix();
    Vector3 x = m.GetBasisX();
    Vector3 y = m.GetBasisY();
    Vector3 z = m.GetBasisZ();
    ASSERT_VECTOR3_NEAR(x, Vector3(1, 0, 0));
    ASSERT_VECTOR3_NEAR(y, Vector3(0, 1, 0));
    ASSERT_VECTOR3_NEAR(z, Vector3(0, 0, 1));
  }
 
  {
    auto m = Matrix::MakeRotationZ(Radians{kPiOver2}) *
             Matrix::MakeRotationX(Radians{kPiOver2}) *
             Matrix::MakeScale(Vector3(2, 3, 4));
    Vector3 x = m.GetBasisX();
    Vector3 y = m.GetBasisY();
    Vector3 z = m.GetBasisZ();
    ASSERT_VECTOR3_NEAR(x, Vector3(0, 2, 0));
    ASSERT_VECTOR3_NEAR(y, Vector3(0, 0, 3));
    ASSERT_VECTOR3_NEAR(z, Vector3(4, 0, 0));
  }
}

References ASSERT_VECTOR3_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), x, and y.

◆ TEST() [238/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetDirectionScale
	)

Definition at line 432 of file geometry_unittests.cc.

                                            {
  {
    auto m = Matrix();
    Scalar result = m.GetDirectionScale(Vector3{1, 0, 0});
    ASSERT_FLOAT_EQ(result, 1);
  }
 
  {
    auto m = Matrix::MakeRotationX(Degrees{10}) *
             Matrix::MakeRotationY(Degrees{83}) *
             Matrix::MakeRotationZ(Degrees{172});
    Scalar result = m.GetDirectionScale(Vector3{0, 1, 0});
    ASSERT_FLOAT_EQ(result, 1);
  }
 
  {
    auto m = Matrix::MakeRotationZ(Radians{kPiOver2}) *
             Matrix::MakeScale(Vector3(3, 4, 5));
    Scalar result = m.GetDirectionScale(Vector3{2, 0, 0});
    ASSERT_FLOAT_EQ(result, 8);
  }
}

References impeller::Matrix::GetDirectionScale(), impeller::kPiOver2, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [239/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixGetMaxBasisLengthXY
	)

Definition at line 333 of file geometry_unittests.cc.

                                              {
  {
    auto m = Matrix::MakeScale({3, 1, 1});
    ASSERT_EQ(m.GetMaxBasisLengthXY(), 3);
 
    m = m * Matrix::MakeSkew(0, 4);
    ASSERT_EQ(m.GetMaxBasisLengthXY(), 5);
  }
 
  {
    auto m = Matrix::MakeScale({-3, 4, 7});
    ASSERT_EQ(m.GetMaxBasisLengthXY(), 4);
  }
 
  {
    // clang-format off
    auto m = Matrix::MakeColumn(
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        4.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
    );
    // clang-format on
    ASSERT_EQ(m.GetMaxBasisLengthXY(), 1.0f);
  }
}

References impeller::Matrix::MakeColumn(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeSkew().

◆ TEST() [240/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixLookAt
	)

Definition at line 481 of file geometry_unittests.cc.

                                 {
  {
    auto m = Matrix::MakeLookAt(Vector3(0, 0, -1), Vector3(0, 0, 1),
                                Vector3(0, 1, 0));
    auto expected = Matrix{
        1, 0, 0, 0,  //
        0, 1, 0, 0,  //
        0, 0, 1, 0,  //
        0, 0, 1, 1,  //
    };
    ASSERT_MATRIX_NEAR(m, expected);
  }
 
  // Sideways tilt.
  {
    auto m = Matrix::MakeLookAt(Vector3(0, 0, -1), Vector3(0, 0, 1),
                                Vector3(1, 1, 0).Normalize());
 
    // clang-format off
    auto expected = Matrix{
        k1OverSqrt2, k1OverSqrt2, 0, 0,
       -k1OverSqrt2, k1OverSqrt2, 0, 0,
        0,           0,           1, 0,
        0,           0,           1, 1,
    };
    // clang-format on
    ASSERT_MATRIX_NEAR(m, expected);
  }
 
  // Half way between +x and -y, yaw 90
  {
    auto m =
        Matrix::MakeLookAt(Vector3(), Vector3(10, -10, 0), Vector3(0, 0, -1));
 
    // clang-format off
    auto expected = Matrix{
       -k1OverSqrt2,  0,  k1OverSqrt2, 0,
       -k1OverSqrt2,  0, -k1OverSqrt2, 0,
        0,           -1,  0,           0,
        0,            0,  0,           1,
    };
    // clang-format on
    ASSERT_MATRIX_NEAR(m, expected);
  }
}

References ASSERT_MATRIX_NEAR, impeller::k1OverSqrt2, and impeller::Matrix::MakeLookAt().

◆ TEST() [241/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixMakeOrthographic
	)

Definition at line 360 of file geometry_unittests.cc.

                                           {
  {
    auto m = Matrix::MakeOrthographic(Size(100, 200));
    auto expect = Matrix{
        0.02, 0,     0,   0,  //
        0,    -0.01, 0,   0,  //
        0,    0,     0,   0,  //
        -1,   1,     0.5, 1,  //
    };
    ASSERT_MATRIX_NEAR(m, expect);
  }
 
  {
    auto m = Matrix::MakeOrthographic(Size(400, 100));
    auto expect = Matrix{
        0.005, 0,     0,   0,  //
        0,     -0.02, 0,   0,  //
        0,     0,     0,   0,  //
        -1,    1,     0.5, 1,  //
    };
    ASSERT_MATRIX_NEAR(m, expect);
  }
}

References ASSERT_MATRIX_NEAR, and impeller::Matrix::MakeOrthographic().

◆ TEST() [242/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixMakePerspective
	)

Definition at line 384 of file geometry_unittests.cc.

                                          {
  {
    auto m = Matrix::MakePerspective(Degrees(60), Size(100, 200), 1, 10);
    auto expect = Matrix{
        3.4641, 0,       0,        0,  //
        0,      1.73205, 0,        0,  //
        0,      0,       1.11111,  1,  //
        0,      0,       -1.11111, 0,  //
    };
    ASSERT_MATRIX_NEAR(m, expect);
  }
 
  {
    auto m = Matrix::MakePerspective(Radians(1), 2, 10, 20);
    auto expect = Matrix{
        0.915244, 0,       0,   0,  //
        0,        1.83049, 0,   0,  //
        0,        0,       2,   1,  //
        0,        0,       -20, 0,  //
    };
    ASSERT_MATRIX_NEAR(m, expect);
  }
}

References ASSERT_MATRIX_NEAR, and impeller::Matrix::MakePerspective().

◆ TEST() [243/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixMakeRotationFromQuaternion
	)

Definition at line 278 of file geometry_unittests.cc.

                                                     {
  {
    auto matrix = Matrix::MakeRotation(Quaternion({1, 0, 0}, kPiOver2));
    auto expected = Matrix::MakeRotationX(Radians(kPiOver2));
    ASSERT_MATRIX_NEAR(matrix, expected);
  }
 
  {
    auto matrix = Matrix::MakeRotation(Quaternion({0, 1, 0}, kPiOver2));
    auto expected = Matrix::MakeRotationY(Radians(kPiOver2));
    ASSERT_MATRIX_NEAR(matrix, expected);
  }
 
  {
    auto matrix = Matrix::MakeRotation(Quaternion({0, 0, 1}, kPiOver2));
    auto expected = Matrix::MakeRotationZ(Radians(kPiOver2));
    ASSERT_MATRIX_NEAR(matrix, expected);
  }
}

References ASSERT_MATRIX_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotation(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), and impeller::Matrix::MakeRotationZ().

◆ TEST() [244/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixPrinting
	)

Definition at line 1726 of file geometry_unittests.cc.

                                   {
  {
    std::stringstream stream;
    Matrix m;
    stream << m;
    ASSERT_EQ(stream.str(), R"((
       1.000000,       0.000000,       0.000000,       0.000000,
       0.000000,       1.000000,       0.000000,       0.000000,
       0.000000,       0.000000,       1.000000,       0.000000,
       0.000000,       0.000000,       0.000000,       1.000000,
))");
  }
 
  {
    std::stringstream stream;
    Matrix m = Matrix::MakeTranslation(Vector3(10, 20, 30));
    stream << m;
 
    ASSERT_EQ(stream.str(), R"((
       1.000000,       0.000000,       0.000000,      10.000000,
       0.000000,       1.000000,       0.000000,      20.000000,
       0.000000,       0.000000,       1.000000,      30.000000,
       0.000000,       0.000000,       0.000000,       1.000000,
))");
  }
}

References impeller::Matrix::MakeTranslation().

◆ TEST() [245/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixTransformDirection
	)

Definition at line 298 of file geometry_unittests.cc.

                                             {
  {
    auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Vector4(10, 20, 30, 2);
 
    Vector4 result = matrix.TransformDirection(vector);
    auto expected = Vector4(-40, 20, 60, 2);
    ASSERT_VECTOR4_NEAR(result, expected);
  }
 
  {
    auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Vector3(10, 20, 30);
 
    Vector3 result = matrix.TransformDirection(vector);
    auto expected = Vector3(-40, 20, 60);
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    auto matrix = Matrix::MakeTranslation({0, -0.4, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Point(10, 20);
 
    Point result = matrix.TransformDirection(vector);
    auto expected = Point(-40, 20);
    ASSERT_POINT_NEAR(result, expected);
  }
}

References ASSERT_POINT_NEAR, ASSERT_VECTOR3_NEAR, ASSERT_VECTOR4_NEAR, impeller::kPiOver2, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [246/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixTranslationScaleOnly
	)

Definition at line 455 of file geometry_unittests.cc.

                                               {
  {
    auto m = Matrix();
    bool result = m.IsTranslationScaleOnly();
    ASSERT_TRUE(result);
  }
 
  {
    auto m = Matrix::MakeScale(Vector3(2, 3, 4));
    bool result = m.IsTranslationScaleOnly();
    ASSERT_TRUE(result);
  }
 
  {
    auto m = Matrix::MakeTranslation(Vector3(2, 3, 4));
    bool result = m.IsTranslationScaleOnly();
    ASSERT_TRUE(result);
  }
 
  {
    auto m = Matrix::MakeRotationZ(Degrees(10));
    bool result = m.IsTranslationScaleOnly();
    ASSERT_FALSE(result);
  }
}

References impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [247/689]

impeller::testing::TEST	(	GeometryTest	,
		MatrixVectorMultiplication
	)

Definition at line 213 of file geometry_unittests.cc.

                                               {
  {
    auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Vector4(10, 20, 30, 2);
 
    Vector4 result = matrix * vector;
    auto expected = Vector4(160, 220, 260, 2);
    ASSERT_VECTOR4_NEAR(result, expected);
  }
 
  {
    auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Vector3(10, 20, 30);
 
    Vector3 result = matrix * vector;
    auto expected = Vector3(60, 120, 160);
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                  Matrix::MakeRotationZ(Radians{kPiOver2}) *
                  Matrix::MakeScale({2.0, 2.0, 2.0});
    auto vector = Point(10, 20);
 
    Point result = matrix * vector;
    auto expected = Point(60, 120);
    ASSERT_POINT_NEAR(result, expected);
  }
 
  // Matrix Vector ops should respect perspective transforms.
  {
    auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100);
    auto vector = Vector3(3, 3, -3);
 
    Vector3 result = matrix * vector;
    auto expected = Vector3(-1, -1, 1.3468);
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100) *
                  Matrix::MakeTranslation(Vector3(0, 0, -3));
    auto point = Point(3, 3);
 
    Point result = matrix * point;
    auto expected = Point(-1, -1);
    ASSERT_POINT_NEAR(result, expected);
  }
 
  // Resolves to 0 on perspective singularity.
  {
    auto matrix = Matrix::MakePerspective(Radians(kPiOver2), 1, 1, 100);
    auto point = Point(3, 3);
 
    Point result = matrix * point;
    auto expected = Point(0, 0);
    ASSERT_POINT_NEAR(result, expected);
  }
}

References ASSERT_POINT_NEAR, ASSERT_VECTOR3_NEAR, ASSERT_VECTOR4_NEAR, impeller::kPiOver2, impeller::Matrix::MakePerspective(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [248/689]

impeller::testing::TEST	(	GeometryTest	,
		MutliplicationMatrix
	)

Definition at line 115 of file geometry_unittests.cc.

                                         {
  auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
  auto invert = rotation.Invert();
  ASSERT_MATRIX_NEAR(rotation * invert, Matrix{});
}

References ASSERT_MATRIX_NEAR, impeller::Matrix::Invert(), impeller::kPiOver4, and impeller::Matrix::MakeRotationZ().

◆ TEST() [249/689]

impeller::testing::TEST	(	GeometryTest	,
		PointAbs
	)

Definition at line 938 of file geometry_unittests.cc.

                             {
  Point a(-1, -2);
  auto a_abs = a.Abs();
  auto expected = Point(1, 2);
  ASSERT_POINT_NEAR(a_abs, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [250/689]

impeller::testing::TEST	(	GeometryTest	,
		PointAngleTo
	)

Definition at line 975 of file geometry_unittests.cc.

                                 {
  // Negative result in the CCW (with up = -Y) direction.
  {
    Point a(1, 1);
    Point b(1, -1);
    Radians actual = a.AngleTo(b);
    Radians expected = Radians{-kPi / 2};
    ASSERT_FLOAT_EQ(actual.radians, expected.radians);
  }
 
  // Check the other direction to ensure the result is signed correctly.
  {
    Point a(1, -1);
    Point b(1, 1);
    Radians actual = a.AngleTo(b);
    Radians expected = Radians{kPi / 2};
    ASSERT_FLOAT_EQ(actual.radians, expected.radians);
  }
 
  // Differences in magnitude should have no impact on the result.
  {
    Point a(100, -100);
    Point b(0.01, 0.01);
    Radians actual = a.AngleTo(b);
    Radians expected = Radians{kPi / 2};
    ASSERT_FLOAT_EQ(actual.radians, expected.radians);
  }
}

References flutter::kPi, and impeller::Radians::radians.

◆ TEST() [251/689]

impeller::testing::TEST	(	GeometryTest	,
		PointCeil
	)

Definition at line 1113 of file geometry_unittests.cc.

                              {
  Point p(1.5, 2.3);
  Point result = p.Ceil();
  Point expected(2, 3);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [252/689]

impeller::testing::TEST	(	GeometryTest	,
		PointCrossProduct
	)

Definition at line 893 of file geometry_unittests.cc.

                                      {
  {
    Point p(1, 0);
    Scalar s = p.Cross(Point(-1, 0));
    ASSERT_FLOAT_EQ(s, 0);
  }
 
  {
    Point p(0, -1);
    Scalar s = p.Cross(Point(-1, 0));
    ASSERT_FLOAT_EQ(s, -1);
  }
 
  {
    Point p(1, 2);
    Scalar s = p.Cross(Point(3, -4));
    ASSERT_FLOAT_EQ(s, -10);
  }
}

◆ TEST() [253/689]

impeller::testing::TEST	(	GeometryTest	,
		PointDotProduct
	)

Definition at line 873 of file geometry_unittests.cc.

                                    {
  {
    Point p(1, 0);
    Scalar s = p.Dot(Point(-1, 0));
    ASSERT_FLOAT_EQ(s, -1);
  }
 
  {
    Point p(0, -1);
    Scalar s = p.Dot(Point(-1, 0));
    ASSERT_FLOAT_EQ(s, 0);
  }
 
  {
    Point p(1, 2);
    Scalar s = p.Dot(Point(3, -4));
    ASSERT_FLOAT_EQ(s, -5);
  }
}

◆ TEST() [254/689]

impeller::testing::TEST	(	GeometryTest	,
		PointFloor
	)

Definition at line 1092 of file geometry_unittests.cc.

                               {
  Point p(1.5, 2.3);
  Point result = p.Floor();
  Point expected(1, 2);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [255/689]

impeller::testing::TEST	(	GeometryTest	,
		PointIntegerCoercesToFloat
	)

Definition at line 678 of file geometry_unittests.cc.

                                               {
  // Integer on LHS, float on RHS
  {
    IPoint p1(1, 2);
    Point p2 = p1 + Point(1, 2);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(3, 6);
    Point p2 = p1 - Point(1, 2);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(1, 2);
    Point p2 = p1 * Point(2, 3);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 6u);
  }
 
  {
    IPoint p1(2, 6);
    Point p2 = p1 / Point(2, 3);
    ASSERT_FLOAT_EQ(p2.x, 1u);
    ASSERT_FLOAT_EQ(p2.y, 2u);
  }
 
  // Float on LHS, integer on RHS
  {
    Point p1(1, 2);
    Point p2 = p1 + IPoint(1, 2);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 4u);
  }
 
  {
    Point p1(3, 6);
    Point p2 = p1 - IPoint(1, 2);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 4u);
  }
 
  {
    Point p1(1, 2);
    Point p2 = p1 * IPoint(2, 3);
    ASSERT_FLOAT_EQ(p2.x, 2u);
    ASSERT_FLOAT_EQ(p2.y, 6u);
  }
 
  {
    Point p1(2, 6);
    Point p2 = p1 / IPoint(2, 3);
    ASSERT_FLOAT_EQ(p2.x, 1u);
    ASSERT_FLOAT_EQ(p2.y, 2u);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [256/689]

impeller::testing::TEST	(	GeometryTest	,
		PointLerp
	)

Definition at line 1155 of file geometry_unittests.cc.

                              {
  Point p(1, 2);
  Point result = p.Lerp({5, 10}, 0.75);
  Point expected(4, 8);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [257/689]

impeller::testing::TEST	(	GeometryTest	,
		PointMax
	)

Definition at line 1071 of file geometry_unittests.cc.

                             {
  Point p(1, 2);
  Point result = p.Max({0, 10});
  Point expected(1, 10);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [258/689]

impeller::testing::TEST	(	GeometryTest	,
		PointMin
	)

Definition at line 1004 of file geometry_unittests.cc.

                             {
  Point p(1, 2);
  Point result = p.Min({0, 10});
  Point expected(0, 2);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [259/689]

impeller::testing::TEST	(	GeometryTest	,
		PointPrinting
	)

Definition at line 1753 of file geometry_unittests.cc.

                                  {
  {
    std::stringstream stream;
    Point m;
    stream << m;
    ASSERT_EQ(stream.str(), "(0, 0)");
  }
 
  {
    std::stringstream stream;
    Point m(13, 37);
    stream << m;
    ASSERT_EQ(stream.str(), "(13, 37)");
  }
}

◆ TEST() [260/689]

impeller::testing::TEST	(	GeometryTest	,
		PointReflect
	)

Definition at line 913 of file geometry_unittests.cc.

                                 {
  {
    Point axis = Point(0, 1);
    Point a(2, 3);
    auto reflected = a.Reflect(axis);
    auto expected = Point(2, -3);
    ASSERT_POINT_NEAR(reflected, expected);
  }
 
  {
    Point axis = Point(1, 1).Normalize();
    Point a(1, 0);
    auto reflected = a.Reflect(axis);
    auto expected = Point(0, -1);
    ASSERT_POINT_NEAR(reflected, expected);
  }
 
  {
    Point axis = Point(1, 1).Normalize();
    Point a(-1, -1);
    auto reflected = a.Reflect(axis);
    ASSERT_POINT_NEAR(reflected, -a);
  }
}

References ASSERT_POINT_NEAR.

◆ TEST() [261/689]

impeller::testing::TEST	(	GeometryTest	,
		PointRotate
	)

Definition at line 945 of file geometry_unittests.cc.

                                {
  {
    Point a(1, 0);
    auto rotated = a.Rotate(Radians{kPiOver2});
    auto expected = Point(0, 1);
    ASSERT_POINT_NEAR(rotated, expected);
  }
 
  {
    Point a(1, 0);
    auto rotated = a.Rotate(Radians{-kPiOver2});
    auto expected = Point(0, -1);
    ASSERT_POINT_NEAR(rotated, expected);
  }
 
  {
    Point a(1, 0);
    auto rotated = a.Rotate(Radians{kPi});
    auto expected = Point(-1, 0);
    ASSERT_POINT_NEAR(rotated, expected);
  }
 
  {
    Point a(1, 0);
    auto rotated = a.Rotate(Radians{kPi * 1.5});
    auto expected = Point(0, -1);
    ASSERT_POINT_NEAR(rotated, expected);
  }
}

References ASSERT_POINT_NEAR, flutter::kPi, and impeller::kPiOver2.

◆ TEST() [262/689]

impeller::testing::TEST	(	GeometryTest	,
		PointRound
	)

Definition at line 1134 of file geometry_unittests.cc.

                               {
  Point p(1.5, 2.3);
  Point result = p.Round();
  Point expected(2, 2);
  ASSERT_POINT_NEAR(result, expected);
}

References ASSERT_POINT_NEAR.

◆ TEST() [263/689]

impeller::testing::TEST	(	GeometryTest	,
		QuaternionLerp
	)

Definition at line 527 of file geometry_unittests.cc.

                                   {
  auto q1 = Quaternion{{0.0, 0.0, 1.0}, 0.0};
  auto q2 = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
 
  auto q3 = q1.Slerp(q2, 0.5);
 
  auto expected = Quaternion{{0.0, 0.0, 1.0}, kPiOver4 / 2.0};
 
  ASSERT_QUATERNION_NEAR(q3, expected);
}

References ASSERT_QUATERNION_NEAR, impeller::kPiOver4, and impeller::Quaternion::Slerp().

◆ TEST() [264/689]

impeller::testing::TEST	(	GeometryTest	,
		QuaternionVectorMultiply
	)

Definition at line 538 of file geometry_unittests.cc.

                                             {
  {
    Quaternion q({0, 0, 1}, 0);
    Vector3 v(0, 1, 0);
 
    Vector3 result = q * v;
    Vector3 expected(0, 1, 0);
 
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    Quaternion q({0, 0, 1}, k2Pi);
    Vector3 v(1, 0, 0);
 
    Vector3 result = q * v;
    Vector3 expected(1, 0, 0);
 
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    Quaternion q({0, 0, 1}, kPiOver4);
    Vector3 v(0, 1, 0);
 
    Vector3 result = q * v;
    Vector3 expected(-k1OverSqrt2, k1OverSqrt2, 0);
 
    ASSERT_VECTOR3_NEAR(result, expected);
  }
 
  {
    Quaternion q(Vector3(1, 0, 1).Normalize(), kPi);
    Vector3 v(0, 0, -1);
 
    Vector3 result = q * v;
    Vector3 expected(-1, 0, 0);
 
    ASSERT_VECTOR3_NEAR(result, expected);
  }
}

References ASSERT_VECTOR3_NEAR, impeller::k1OverSqrt2, impeller::k2Pi, flutter::kPi, and impeller::kPiOver4.

◆ TEST() [265/689]

impeller::testing::TEST	(	GeometryTest	,
		RotationMatrix
	)

Definition at line 68 of file geometry_unittests.cc.

                                   {
  auto rotation = Matrix::MakeRotationZ(Radians{kPiOver4});
  // clang-format off
  auto expect = Matrix{k1OverSqrt2,  k1OverSqrt2, 0, 0,
                       -k1OverSqrt2, k1OverSqrt2, 0, 0,
                       0,            0,           1, 0,
                       0,            0,           0, 1};
  // clang-format on
  ASSERT_MATRIX_NEAR(rotation, expect);
}

References ASSERT_MATRIX_NEAR, impeller::k1OverSqrt2, impeller::kPiOver4, and impeller::Matrix::MakeRotationZ().

◆ TEST() [266/689]

impeller::testing::TEST	(	GeometryTest	,
		ScalarNearlyEqual
	)

Definition at line 31 of file geometry_unittests.cc.

                                      {
  ASSERT_FALSE(ScalarNearlyEqual(0.0021f, 0.001f));
  ASSERT_TRUE(ScalarNearlyEqual(0.0019f, 0.001f));
  ASSERT_TRUE(ScalarNearlyEqual(0.002f, 0.001f, 0.0011f));
  ASSERT_FALSE(ScalarNearlyEqual(0.002f, 0.001f, 0.0009f));
  ASSERT_TRUE(ScalarNearlyEqual(
      1.0f, 1.0f + std::numeric_limits<float>::epsilon() * 4));
}

References impeller::ScalarNearlyEqual().

◆ TEST() [267/689]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2AngleTo
	)

Definition at line 1210 of file geometry_unittests.cc.

                                            {
  {
    SeparatedVector2 v(Vector2(10, 0));
    Radians actual = v.AngleTo(SeparatedVector2(Vector2(5, 0)));
    Radians expected = Radians{0};
    ASSERT_NEAR(actual.radians, expected.radians, kEhCloseEnough);
  }
 
  {
    SeparatedVector2 v(Vector2(10, 0));
    Radians actual = v.AngleTo(SeparatedVector2(Vector2(0, -5)));
    Radians expected = Radians{-kPi / 2};
    ASSERT_NEAR(actual.radians, expected.radians, kEhCloseEnough);
  }
}

References impeller::SeparatedVector2::AngleTo(), flutter::kEhCloseEnough, flutter::kPi, and impeller::Radians::radians.

◆ TEST() [268/689]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2GetAlignment
	)

Definition at line 1187 of file geometry_unittests.cc.

                                                 {
  // Parallel
  {
    SeparatedVector2 v(Vector2(10, 0));
    Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(5, 0)));
    ASSERT_NEAR(actual, 1, kEhCloseEnough);
  }
 
  // Perpendicular
  {
    SeparatedVector2 v(Vector2(10, 0));
    Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(0, 5)));
    ASSERT_NEAR(actual, 0, kEhCloseEnough);
  }
 
  // Opposite parallel
  {
    SeparatedVector2 v(Vector2(0, 10));
    Scalar actual = v.GetAlignment(SeparatedVector2(Vector2(0, -5)));
    ASSERT_NEAR(actual, -1, kEhCloseEnough);
  }
}

References impeller::SeparatedVector2::GetAlignment(), and flutter::kEhCloseEnough.

◆ TEST() [269/689]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2GetVector
	)

Definition at line 1182 of file geometry_unittests.cc.

                                              {
  SeparatedVector2 v(Vector2(10, 0));
  ASSERT_POINT_NEAR(v.GetVector(), Vector2(10, 0));
}

References ASSERT_POINT_NEAR, and impeller::SeparatedVector2::GetVector().

◆ TEST() [270/689]

impeller::testing::TEST	(	GeometryTest	,
		SeparatedVector2NormalizesWithConstructor
	)

Definition at line 1176 of file geometry_unittests.cc.

                                                              {
  SeparatedVector2 v(Vector2(10, 0));
  ASSERT_POINT_NEAR(v.direction, Vector2(1, 0));
  ASSERT_NEAR(v.magnitude, 10, kEhCloseEnough);
}

References ASSERT_POINT_NEAR, impeller::SeparatedVector2::direction, flutter::kEhCloseEnough, and impeller::SeparatedVector2::magnitude.

◆ TEST() [271/689]

impeller::testing::TEST	(	GeometryTest	,
		SizeCoercesToPoint
	)

Definition at line 738 of file geometry_unittests.cc.

                                       {
  // Point on LHS, Size on RHS
  {
    IPoint p1(1, 2);
    IPoint p2 = p1 + ISize(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(3, 6);
    IPoint p2 = p1 - ISize(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    IPoint p1(1, 2);
    IPoint p2 = p1 * ISize(2, 3);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 6u);
  }
 
  {
    IPoint p1(2, 6);
    IPoint p2 = p1 / ISize(2, 3);
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 2u);
  }
 
  // Size on LHS, Point on RHS
  {
    ISize p1(1, 2);
    IPoint p2 = p1 + IPoint(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    ISize p1(3, 6);
    IPoint p2 = p1 - IPoint(1, 2);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 4u);
  }
 
  {
    ISize p1(1, 2);
    IPoint p2 = p1 * IPoint(2, 3);
    ASSERT_EQ(p2.x, 2u);
    ASSERT_EQ(p2.y, 6u);
  }
 
  {
    ISize p1(2, 6);
    IPoint p2 = p1 / IPoint(2, 3);
    ASSERT_EQ(p2.x, 1u);
    ASSERT_EQ(p2.y, 2u);
  }
}

References p1, p2, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [272/689]

impeller::testing::TEST	(	GeometryTest	,
		TestDecomposition
	)

Definition at line 142 of file geometry_unittests.cc.

                                      {
  auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
 
  auto result = rotated.Decompose();
 
  ASSERT_TRUE(result.has_value());
 
  MatrixDecomposition res = result.value();
 
  auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
  ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
}

References ASSERT_QUATERNION_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::MatrixDecomposition::rotation.

◆ TEST() [273/689]

impeller::testing::TEST	(	GeometryTest	,
		TestDecomposition2
	)

Definition at line 155 of file geometry_unittests.cc.

                                       {
  auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
  auto scaled = Matrix::MakeScale({2.0, 3.0, 1.0});
  auto translated = Matrix::MakeTranslation({-200, 750, 20});
 
  auto result = (translated * rotated * scaled).Decompose();
 
  ASSERT_TRUE(result.has_value());
 
  MatrixDecomposition res = result.value();
 
  auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
 
  ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
 
  ASSERT_FLOAT_EQ(res.translation.x, -200);
  ASSERT_FLOAT_EQ(res.translation.y, 750);
  ASSERT_FLOAT_EQ(res.translation.z, 20);
 
  ASSERT_FLOAT_EQ(res.scale.x, 2);
  ASSERT_FLOAT_EQ(res.scale.y, 3);
  ASSERT_FLOAT_EQ(res.scale.z, 1);
}

References ASSERT_QUATERNION_NEAR, impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::MatrixDecomposition::rotation, impeller::MatrixDecomposition::scale, impeller::MatrixDecomposition::translation, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ TEST() [274/689]

impeller::testing::TEST	(	GeometryTest	,
		TestRecomposition
	)

Definition at line 179 of file geometry_unittests.cc.

                                      {
  /*
   *  Decomposition.
   */
  auto rotated = Matrix::MakeRotationZ(Radians{kPiOver4});
 
  auto result = rotated.Decompose();
 
  ASSERT_TRUE(result.has_value());
 
  MatrixDecomposition res = result.value();
 
  auto quaternion = Quaternion{{0.0, 0.0, 1.0}, kPiOver4};
 
  ASSERT_QUATERNION_NEAR(res.rotation, quaternion);
 
  /*
   *  Recomposition.
   */
  ASSERT_MATRIX_NEAR(rotated, Matrix{res});
}

References ASSERT_MATRIX_NEAR, ASSERT_QUATERNION_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), and impeller::MatrixDecomposition::rotation.

◆ TEST() [275/689]

impeller::testing::TEST	(	GeometryTest	,
		TestRecomposition2
	)

Definition at line 201 of file geometry_unittests.cc.

                                       {
  auto matrix = Matrix::MakeTranslation({100, 100, 100}) *
                Matrix::MakeRotationZ(Radians{kPiOver4}) *
                Matrix::MakeScale({2.0, 2.0, 2.0});
 
  auto result = matrix.Decompose();
 
  ASSERT_TRUE(result.has_value());
 
  ASSERT_MATRIX_NEAR(matrix, Matrix{result.value()});
}

References ASSERT_MATRIX_NEAR, impeller::Matrix::Decompose(), impeller::kPiOver4, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [276/689]

impeller::testing::TEST	(	GeometryTest	,
		ToIColor
	)

Definition at line 1817 of file geometry_unittests.cc.

                             {
  ASSERT_EQ(Color::ToIColor(Color(0, 0, 0, 0)), 0u);
  ASSERT_EQ(Color::ToIColor(Color(1.0, 1.0, 1.0, 1.0)), 0xFFFFFFFF);
  ASSERT_EQ(Color::ToIColor(Color(0.5, 0.5, 1.0, 1.0)), 0xFF8080FF);
}

References impeller::Color::ToIColor().

◆ TEST() [277/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Ceil
	)

Definition at line 1120 of file geometry_unittests.cc.

                                {
  Vector3 p(1.5, 2.3, 3.9);
  Vector3 result = p.Ceil();
  Vector3 expected(2, 3, 4);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Ceil().

◆ TEST() [278/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Floor
	)

Definition at line 1099 of file geometry_unittests.cc.

                                 {
  Vector3 p(1.5, 2.3, 3.9);
  Vector3 result = p.Floor();
  Vector3 expected(1, 2, 3);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Floor().

◆ TEST() [279/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Lerp
	)

Definition at line 1162 of file geometry_unittests.cc.

                                {
  Vector3 p(1, 2, 3);
  Vector3 result = p.Lerp({5, 10, 15}, 0.75);
  Vector3 expected(4, 8, 12);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Lerp().

◆ TEST() [280/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Max
	)

Definition at line 1078 of file geometry_unittests.cc.

                               {
  Vector3 p(1, 2, 3);
  Vector3 result = p.Max({0, 10, 2});
  Vector3 expected(1, 10, 3);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Max().

◆ TEST() [281/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Min
	)

Definition at line 1057 of file geometry_unittests.cc.

                               {
  Vector3 p(1, 2, 3);
  Vector3 result = p.Min({0, 10, 2});
  Vector3 expected(0, 2, 2);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Min().

◆ TEST() [282/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Printing
	)

Definition at line 1769 of file geometry_unittests.cc.

                                    {
  {
    std::stringstream stream;
    Vector3 m;
    stream << m;
    ASSERT_EQ(stream.str(), "(0, 0, 0)");
  }
 
  {
    std::stringstream stream;
    Vector3 m(1, 2, 3);
    stream << m;
    ASSERT_EQ(stream.str(), "(1, 2, 3)");
  }
}

◆ TEST() [283/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector3Round
	)

Definition at line 1141 of file geometry_unittests.cc.

                                 {
  Vector3 p(1.5, 2.3, 3.9);
  Vector3 result = p.Round();
  Vector3 expected(2, 2, 4);
  ASSERT_VECTOR3_NEAR(result, expected);
}

References ASSERT_VECTOR3_NEAR, and impeller::Vector3::Round().

◆ TEST() [284/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Ceil
	)

Definition at line 1127 of file geometry_unittests.cc.

                                {
  Vector4 p(1.5, 2.3, 3.9, 4.0);
  Vector4 result = p.Ceil();
  Vector4 expected(2, 3, 4, 4);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Ceil().

◆ TEST() [285/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Floor
	)

Definition at line 1106 of file geometry_unittests.cc.

                                 {
  Vector4 p(1.5, 2.3, 3.9, 4.0);
  Vector4 result = p.Floor();
  Vector4 expected(1, 2, 3, 4);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Floor().

◆ TEST() [286/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4IsFinite
	)

Definition at line 1011 of file geometry_unittests.cc.

                                    {
  {
    Vector4 v;
    ASSERT_TRUE(v.IsFinite());
    v.x = std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.x = -std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.x = -std::numeric_limits<Scalar>::quiet_NaN();
    ASSERT_FALSE(v.IsFinite());
  }
 
  {
    Vector4 v;
    ASSERT_TRUE(v.IsFinite());
    v.y = std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.y = -std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.y = -std::numeric_limits<Scalar>::quiet_NaN();
    ASSERT_FALSE(v.IsFinite());
  }
 
  {
    Vector4 v;
    ASSERT_TRUE(v.IsFinite());
    v.z = std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.z = -std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.z = -std::numeric_limits<Scalar>::quiet_NaN();
    ASSERT_FALSE(v.IsFinite());
  }
 
  {
    Vector4 v;
    ASSERT_TRUE(v.IsFinite());
    v.w = std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.w = -std::numeric_limits<Scalar>::infinity();
    ASSERT_FALSE(v.IsFinite());
    v.w = -std::numeric_limits<Scalar>::quiet_NaN();
    ASSERT_FALSE(v.IsFinite());
  }
}

References impeller::Vector4::IsFinite(), impeller::Vector4::w, impeller::Vector4::x, impeller::Vector4::y, and impeller::Vector4::z.

◆ TEST() [287/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Lerp
	)

Definition at line 1169 of file geometry_unittests.cc.

                                {
  Vector4 p(1, 2, 3, 4);
  Vector4 result = p.Lerp({5, 10, 15, 20}, 0.75);
  Vector4 expected(4, 8, 12, 16);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Lerp().

◆ TEST() [288/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Max
	)

Definition at line 1085 of file geometry_unittests.cc.

                               {
  Vector4 p(1, 2, 3, 4);
  Vector4 result = p.Max({0, 10, 2, 1});
  Vector4 expected(1, 10, 3, 4);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Max().

◆ TEST() [289/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Min
	)

Definition at line 1064 of file geometry_unittests.cc.

                               {
  Vector4 p(1, 2, 3, 4);
  Vector4 result = p.Min({0, 10, 2, 1});
  Vector4 expected(0, 2, 2, 1);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Min().

◆ TEST() [290/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Printing
	)

Definition at line 1785 of file geometry_unittests.cc.

                                    {
  {
    std::stringstream stream;
    Vector4 m;
    stream << m;
    ASSERT_EQ(stream.str(), "(0, 0, 0, 1)");
  }
 
  {
    std::stringstream stream;
    Vector4 m(1, 2, 3, 4);
    stream << m;
    ASSERT_EQ(stream.str(), "(1, 2, 3, 4)");
  }
}

◆ TEST() [291/689]

impeller::testing::TEST	(	GeometryTest	,
		Vector4Round
	)

Definition at line 1148 of file geometry_unittests.cc.

                                 {
  Vector4 p(1.5, 2.3, 3.9, 4.0);
  Vector4 result = p.Round();
  Vector4 expected(2, 2, 4, 4);
  ASSERT_VECTOR4_NEAR(result, expected);
}

References ASSERT_VECTOR4_NEAR, and impeller::Vector4::Round().

◆ TEST() [292/689]

impeller::testing::TEST	(	GLErrorToString	,
		ReturnsCorrectStringForKnownErrors
	)

Definition at line 62 of file proc_table_gles_unittests.cc.

                                                          {
  EXPECT_EQ(GLErrorToString(GL_NO_ERROR), "GL_NO_ERROR");
  EXPECT_EQ(GLErrorToString(GL_INVALID_ENUM), "GL_INVALID_ENUM");
  EXPECT_EQ(GLErrorToString(GL_INVALID_VALUE), "GL_INVALID_VALUE");
  EXPECT_EQ(GLErrorToString(GL_INVALID_OPERATION), "GL_INVALID_OPERATION");
  EXPECT_EQ(GLErrorToString(GL_INVALID_FRAMEBUFFER_OPERATION),
            "GL_INVALID_FRAMEBUFFER_OPERATION");
  EXPECT_EQ(GLErrorToString(GL_FRAMEBUFFER_COMPLETE),
            "GL_FRAMEBUFFER_COMPLETE");
  EXPECT_EQ(GLErrorToString(GL_OUT_OF_MEMORY), "GL_OUT_OF_MEMORY");
}

References impeller::GLErrorToString().

◆ TEST() [293/689]

impeller::testing::TEST	(	GLErrorToString	,
		ReturnsUnknownForInvalidError
	)

Definition at line 74 of file proc_table_gles_unittests.cc.

                                                     {
  // Test with an invalid error code
  GLenum invalid_error = 0x9999;
  EXPECT_EQ(GLErrorToString(invalid_error), "Unknown.");
}

References impeller::GLErrorToString().

◆ TEST() [294/689]

impeller::testing::TEST	(	GLErrorToString	,
		ReturnValueIsValidStringView
	)

Definition at line 80 of file proc_table_gles_unittests.cc.

                                                    {
  // Test that the returned string_view is valid and non-empty
  auto result = GLErrorToString(GL_NO_ERROR);
  EXPECT_FALSE(result.empty());
  EXPECT_NE(result.data(), nullptr);
 
  // Test that we can compare with string literals
  EXPECT_TRUE(result == "GL_NO_ERROR");
}

References impeller::GLErrorToString().

◆ TEST() [295/689]

impeller::testing::TEST	(	GLProc	,
		NameFieldWorksWithStringView
	)

Definition at line 90 of file proc_table_gles_unittests.cc.

                                           {
  GLProc<void()> proc;
 
  // Test setting name with string literal
  const char* literal = "glTestFunction";
  proc.name = literal;
 
  EXPECT_EQ(proc.name, "glTestFunction");
  EXPECT_FALSE(proc.name.empty());
 
  // Test that the string_view properly references the original data
  EXPECT_EQ(proc.name.data(), literal);
}

References impeller::GLProc< T >::name.

◆ TEST() [296/689]

impeller::testing::TEST	(	GpuSubmissionTrackerTest	,
		WatermarkHandlesOutOfOrderCompletion
	)

Definition at line 222 of file host_buffer_unittests.cc.

                                                                     {
  GpuSubmissionTracker tracker;
  EXPECT_EQ(tracker.CompletedThrough(), 0u);
  uint64_t a = tracker.RecordSubmission();
  uint64_t b = tracker.RecordSubmission();
  uint64_t c = tracker.RecordSubmission();
  EXPECT_EQ(tracker.LatestSubmission(), c);
 
  tracker.RecordCompletion(b);
  EXPECT_EQ(tracker.CompletedThrough(), 0u);
  tracker.RecordCompletion(a);
  EXPECT_EQ(tracker.CompletedThrough(), b);
  tracker.RecordCompletion(c);
  EXPECT_EQ(tracker.CompletedThrough(), c);
}

References c, impeller::GpuSubmissionTracker::CompletedThrough(), impeller::GpuSubmissionTracker::LatestSubmission(), impeller::GpuSubmissionTracker::RecordCompletion(), and impeller::GpuSubmissionTracker::RecordSubmission().

◆ TEST() [297/689]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		Coverage2x
	)

Definition at line 65 of file matrix_filter_contents_unittests.cc.

                                           {
  MatrixFilterContents contents;
  contents.SetMatrix(Matrix::MakeScale({2.0, 2.0, 1.0}));
  FilterInput::Vector inputs = {
      FilterInput::Make(Rect::MakeXYWH(10, 10, 100, 100))};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
 
  ASSERT_EQ(coverage, Rect::MakeXYWH(20, 20, 200, 200));
}

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::MatrixFilterContents::SetMatrix().

◆ TEST() [298/689]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		Coverage2xEffect
	)

Definition at line 77 of file matrix_filter_contents_unittests.cc.

                                                 {
  MatrixFilterContents contents;
  FilterInput::Vector inputs = {
      FilterInput::Make(Rect::MakeXYWH(10, 10, 100, 100))};
  Entity entity;
  std::optional<Rect> coverage = contents.GetFilterCoverage(
      inputs, entity, /*effect_transform=*/Matrix::MakeScale({2.0, 2.0, 1.0}));
 
  ASSERT_EQ(coverage, Rect::MakeXYWH(10, 10, 100, 100));
}

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [299/689]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		CoverageEmpty
	)

Definition at line 45 of file matrix_filter_contents_unittests.cc.

                                              {
  MatrixFilterContents contents;
  FilterInput::Vector inputs = {};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
  ASSERT_FALSE(coverage.has_value());
}

References impeller::MatrixFilterContents::GetFilterCoverage().

◆ TEST() [300/689]

impeller::testing::TEST	(	MatrixFilterContentsTest	,
		CoverageSimple
	)

Definition at line 54 of file matrix_filter_contents_unittests.cc.

                                               {
  MatrixFilterContents contents;
  FilterInput::Vector inputs = {
      FilterInput::Make(Rect::MakeLTRB(10, 10, 110, 110))};
  Entity entity;
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
 
  ASSERT_EQ(coverage, Rect::MakeLTRB(10, 10, 110, 110));
}

References impeller::MatrixFilterContents::GetFilterCoverage(), impeller::FilterInput::Make(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [301/689]

impeller::testing::TEST	(	MatrixTest	,
		Equals
	)

Definition at line 28 of file matrix_unittests.cc.

                         {
  Matrix x;
  Matrix y = x;
  EXPECT_TRUE(x.Equals(y));
}

References x, and y.

◆ TEST() [302/689]

impeller::testing::TEST	(	MatrixTest	,
		GetBasisXYScale2D
	)

Definition at line 289 of file matrix_unittests.cc.

                                    {
  Matrix m = Matrix::MakeScale({5.0f, 3.0f, 1.0f});
  EXPECT_POINT_NEAR(m.GetBasisX2D(), Vector2(5.0f, 0.0f));
  EXPECT_POINT_NEAR(m.GetBasisY2D(), Vector2(0.0f, 3.0f));
  EXPECT_POINT_NEAR(m.GetBasisScaleXY(), Vector2(5.0f, 3.0f));
 
  Matrix m2 = Matrix::MakeColumn(
      // clang-format off
      2.0f, 3.0f, 0.0f, 0.0f,
      5.0f, 7.0f, 0.0f, 0.0f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 1.0f
      // clang-format on
  );
  EXPECT_POINT_NEAR(m2.GetBasisX2D(), Vector2(2.0f, 3.0f));
  EXPECT_POINT_NEAR(m2.GetBasisY2D(), Vector2(5.0f, 7.0f));
  EXPECT_POINT_NEAR(m2.GetBasisScaleXY(), Vector2(sqrt(13.0f), sqrt(74.0f)));
 
  Matrix m3 = Matrix::MakeColumn(
      // clang-format off
      2.0f, 3.0f, 4.0f, 11.0f,
      5.0f, 7.0f, 6.0f, 13.0f,
      1.0f, 8.0f, 9.0f, 15.0f,
      1.0f, 1.0f, 1.0f, 17.0f
      // clang-format on
  );
  EXPECT_POINT_NEAR(m3.GetBasisX2D(), Vector2(2.0f, 3.0f));
  EXPECT_POINT_NEAR(m3.GetBasisY2D(), Vector2(5.0f, 7.0f));
  EXPECT_POINT_NEAR(m2.GetBasisScaleXY(), Vector2(sqrt(13.0f), sqrt(74.0f)));
}

References EXPECT_POINT_NEAR, impeller::Matrix::GetBasisScaleXY(), impeller::Matrix::GetBasisX2D(), impeller::Matrix::GetBasisY2D(), impeller::Matrix::MakeColumn(), and impeller::Matrix::MakeScale().

◆ TEST() [303/689]

impeller::testing::TEST	(	MatrixTest	,
		GetMaxBasisXYNegativeScale
	)

Definition at line 263 of file matrix_unittests.cc.

                                             {
  Matrix m = Matrix::MakeScale({-2, 1, 1});
 
  EXPECT_EQ(m.GetMaxBasisLengthXY(), 2);
 
  m = Matrix::MakeScale({1, -3, 1});
 
  EXPECT_EQ(m.GetMaxBasisLengthXY(), 3);
}

References impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [304/689]

impeller::testing::TEST	(	MatrixTest	,
		GetMaxBasisXYWithLargeAndSmallScalingFactor
	)

Definition at line 274 of file matrix_unittests.cc.

                                                              {
  Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
  EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e+20, 1e+20);
 
  m = Matrix::MakeScale({2.625e-20, 2.625e-20, 1});
  EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e-20, 1e-20);
}

References impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [305/689]

impeller::testing::TEST	(	MatrixTest	,
		GetMaxBasisXYWithLargeAndSmallScalingFactorNonScaleTranslate
	)

Definition at line 282 of file matrix_unittests.cc.

                                                                               {
  Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
  m.e[0][1] = 2;
 
  EXPECT_TRUE(std::isinf(m.GetMaxBasisLengthXY()));
}

References impeller::Matrix::e, impeller::Matrix::GetMaxBasisLengthXY(), and impeller::Matrix::MakeScale().

◆ TEST() [306/689]

impeller::testing::TEST	(	MatrixTest	,
		HasPerspective
	)

Definition at line 58 of file matrix_unittests.cc.

                                 {
  EXPECT_FALSE(Matrix().HasPerspective());
 
  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_FALSE(matrix.HasPerspective());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.HasPerspective(), expect) << "index: " << index;
  };
 
  // clang-format off
  test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
  test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
  test( 8, false);  test( 9, false);  test(10, false);  test(11, true);
  test(12, false);  test(13, false);  test(14, false);  test(15, true);
  // clang-format on
}

References impeller::Matrix::HasPerspective(), and impeller::Matrix::m.

◆ TEST() [307/689]

impeller::testing::TEST	(	MatrixTest	,
		HasPerspective2D
	)

Definition at line 40 of file matrix_unittests.cc.

                                   {
  EXPECT_FALSE(Matrix().HasPerspective2D());
 
  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_FALSE(matrix.HasPerspective2D());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.HasPerspective2D(), expect) << "index: " << index;
  };
 
  // clang-format off
  test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
  test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
  test( 8, false);  test( 9, false);  test(10, false);  test(11, false);
  test(12, false);  test(13, false);  test(14, false);  test(15, true);
  // clang-format on
}

References impeller::Matrix::HasPerspective2D(), and impeller::Matrix::m.

◆ TEST() [308/689]

impeller::testing::TEST	(	MatrixTest	,
		HasTranslation
	)

Definition at line 76 of file matrix_unittests.cc.

                                 {
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).HasTranslation());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).HasTranslation());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).HasTranslation());
  EXPECT_FALSE(Matrix().HasTranslation());
}

References impeller::Matrix::MakeTranslation().

◆ TEST() [309/689]

impeller::testing::TEST	(	MatrixTest	,
		IsAligned
	)

Definition at line 203 of file matrix_unittests.cc.

                            {
  EXPECT_TRUE(Matrix().IsAligned());
  EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned());
 
  // Begin Legacy tests transferred over from geometry_unittests.cc
  {
    auto m = Matrix::MakeTranslation({1, 2, 3});
    bool result = m.IsAligned();
    ASSERT_TRUE(result);
  }
 
  {
    auto m = Matrix::MakeRotationZ(Degrees{123});
    bool result = m.IsAligned();
    ASSERT_FALSE(result);
  }
  // End Legacy tests transferred over from geometry_unittests.cc
 
  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_TRUE(matrix.IsAligned());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.IsAligned(), expect) << "index: " << index;
  };
 
  // clang-format off
  test( 0, true);   test( 1, false);  test( 2, false);  test( 3, false);
  test( 4, false);  test( 5, true);   test( 6, false);  test( 7, false);
  test( 8, false);  test( 9, false);  test(10, true);   test(11, false);
  test(12, true);   test(13, true);   test(14, true);   test(15, false);
  // clang-format on
 
  // True for quadrant rotations from -250 to +250 full circles
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i * 90);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_TRUE(matrix.IsAligned()) << "degrees: " << d.degrees;
  }
 
  // False for half degree rotations from -999.5 to +1000.5 degrees
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i + 0.5f);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_FALSE(matrix.IsAligned()) << "degrees: " << d.degrees;
  }
}

References d, i, impeller::Matrix::IsAligned(), impeller::Matrix::m, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [310/689]

impeller::testing::TEST	(	MatrixTest	,
		IsAligned2D
	)

Definition at line 170 of file matrix_unittests.cc.

                              {
  EXPECT_TRUE(Matrix().IsAligned2D());
  EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned2D());
 
  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_TRUE(matrix.IsAligned2D());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.IsAligned2D(), expect) << "index: " << index;
  };
 
  // clang-format off
  test( 0, true);   test( 1, false);  test( 2, true);   test( 3, false);
  test( 4, false);  test( 5, true);   test( 6, true);   test( 7, false);
  test( 8, true);   test( 9, true);   test(10, true);   test(11, true);
  test(12, true);   test(13, true);   test(14, true);   test(15, false);
  // clang-format on
 
  // True for quadrant rotations from -250 to +250 full circles
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i * 90);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_TRUE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
  }
 
  // False for half degree rotations from -999.5 to +1000.5 degrees
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i + 0.5f);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_FALSE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
  }
}

References d, i, impeller::Matrix::IsAligned2D(), impeller::Matrix::m, impeller::Matrix::MakeRotationZ(), and impeller::Matrix::MakeScale().

◆ TEST() [311/689]

impeller::testing::TEST	(	MatrixTest	,
		IsFinite
	)

Definition at line 132 of file matrix_unittests.cc.

                           {
  EXPECT_TRUE(Matrix().IsFinite());
 
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsFinite());
 
  EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsFinite());
  EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsFinite());
  EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsFinite());
 
  EXPECT_TRUE(Matrix::MakeScale({0, 1, 1}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({1, 0, 1}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({1, 1, 0}).IsFinite());
 
  for (int i = 0; i < 16; i++) {
    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = std::numeric_limits<Scalar>::infinity();
      ASSERT_FALSE(matrix.IsFinite());
    }
 
    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = -std::numeric_limits<Scalar>::infinity();
      ASSERT_FALSE(matrix.IsFinite());
    }
 
    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = -std::numeric_limits<Scalar>::quiet_NaN();
      ASSERT_FALSE(matrix.IsFinite());
    }
  }
}

References i, impeller::Matrix::IsFinite(), impeller::Matrix::m, impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [312/689]

impeller::testing::TEST	(	MatrixTest	,
		IsInvertibleGetDeterminant
	)

Definition at line 105 of file matrix_unittests.cc.

                                             {
  EXPECT_TRUE(Matrix().IsInvertible());
  EXPECT_NE(Matrix().GetDeterminant(), 0.0f);
 
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsInvertible());
  EXPECT_NE(Matrix::MakeTranslation({100, 100, 0}).GetDeterminant(), 0.0f);
 
  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsInvertible());
  EXPECT_NE(Matrix::MakeScale({100, 100, 1}).GetDeterminant(), 0.0f);
 
  EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationX(Degrees(30)).GetDeterminant(), 0.0f);
 
  EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationY(Degrees(30)).GetDeterminant(), 0.0f);
 
  EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationZ(Degrees(30)).GetDeterminant(), 0.0f);
 
  EXPECT_FALSE(Matrix::MakeScale({0, 1, 1}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({0, 1, 1}).GetDeterminant(), 0.0f);
  EXPECT_FALSE(Matrix::MakeScale({1, 0, 1}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({1, 0, 1}).GetDeterminant(), 0.0f);
  EXPECT_FALSE(Matrix::MakeScale({1, 1, 0}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({1, 1, 0}).GetDeterminant(), 0.0f);
}

References impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), and impeller::Matrix::MakeTranslation().

◆ TEST() [313/689]

impeller::testing::TEST	(	MatrixTest	,
		IsTranslationOnly
	)

Definition at line 83 of file matrix_unittests.cc.

                                    {
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix().IsTranslationOnly());
  EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
}

References impeller::Matrix::MakeTranslation().

◆ TEST() [314/689]

impeller::testing::TEST	(	MatrixTest	,
		IsTranslationScaleOnly
	)

Definition at line 94 of file matrix_unittests.cc.

                                         {
  EXPECT_FALSE(Matrix::MakeScale({100, 100, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsTranslationScaleOnly());
  EXPECT_FALSE(Matrix::MakeScale({1, 100, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({1, 100, 1}).IsTranslationScaleOnly());
  EXPECT_FALSE(Matrix::MakeScale({100, 1, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({100, 1, 1}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix().IsTranslationOnly());
  EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
}

References impeller::Matrix::MakeScale().

◆ TEST() [315/689]

impeller::testing::TEST	(	MatrixTest	,
		MakeScaleTranslate
	)

Definition at line 332 of file matrix_unittests.cc.

                                     {
  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({1, 1, 1.0 / 1024}, {10, 10, 1.0 / 1024}),
      Matrix::MakeTranslation({10, 10, 1.0 / 1024}) *
          Matrix::MakeScale({1, 1, 1.0 / 1024})));
 
  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({2, 2, 2}, {10, 10, 0}),
      Matrix::MakeTranslation({10, 10, 0}) * Matrix::MakeScale({2, 2, 2})));
 
  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({0, 0, 0}, {0, 0, 0}),
      Matrix::MakeTranslation({0, 0, 0}) * Matrix::MakeScale({0, 0, 0})));
}

References impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslateScale(), impeller::Matrix::MakeTranslation(), and MatrixNear().

◆ TEST() [316/689]

impeller::testing::TEST	(	MatrixTest	,
		MinMaxScales2D
	)

Definition at line 356 of file matrix_unittests.cc.

                                 {
  // The GetScales2D() method is allowed to return the scales in any
  // order so we need to take special care in verifying the return
  // value to test them in either order.
  auto check_pair = [](const Matrix& matrix, Scalar scale1, Scalar scale2) {
    auto pair = matrix.GetScales2D();
    EXPECT_TRUE(pair.has_value())
        << "Scales: " << scale1 << ", " << scale2 << ", " << matrix;
    if (ScalarNearlyEqual(pair->first, scale1)) {
      EXPECT_FLOAT_EQ(pair->first, scale1) << matrix;
      EXPECT_FLOAT_EQ(pair->second, scale2) << matrix;
    } else {
      EXPECT_FLOAT_EQ(pair->first, scale2) << matrix;
      EXPECT_FLOAT_EQ(pair->second, scale1) << matrix;
    }
  };
 
  for (int i = 1; i < 10; i++) {
    Scalar xScale = static_cast<Scalar>(i);
    for (int j = 1; j < 10; j++) {
      Scalar yScale = static_cast<Scalar>(j);
      Scalar minScale = std::min(xScale, yScale);
      Scalar maxScale = std::max(xScale, yScale);
 
      {
        // Simple scale
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }
 
      {
        // Simple scale with Z scale
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 5.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }
 
      {
        // Simple scale + translate
        Matrix matrix = Matrix::MakeTranslateScale({xScale, yScale, 1.0f},
                                                   {10.0f, 15.0f, 2.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }
 
      for (int d = 45; d < 360; d += 45) {
        {
          // Rotation * Scale
          Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f}) *
                          Matrix::MakeRotationZ(Degrees(d));
          EXPECT_TRUE(matrix.GetMinScale2D().has_value());
          EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
          EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
          EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
          check_pair(matrix, xScale, yScale);
        }
 
        {
          // Scale * Rotation
          Matrix matrix = Matrix::MakeRotationZ(Degrees(d)) *
                          Matrix::MakeScale({xScale, yScale, 1.0f});
          EXPECT_TRUE(matrix.GetMinScale2D().has_value());
          EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
          EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
          EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
          check_pair(matrix, xScale, yScale);
        }
      }
 
      {
        // Scale + PerspectiveX (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[3] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }
 
      {
        // Scale + PerspectiveY (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[7] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }
 
      {
        // Scale + PerspectiveZ (Z ignored; returns actual scales)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[11] = 0.1;
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }
 
      {
        // Scale + PerspectiveW (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[15] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }
    }
  }
}

References d, impeller::Matrix::GetMaxScale2D(), impeller::Matrix::GetMinScale2D(), impeller::Matrix::GetScales2D(), i, impeller::Matrix::m, impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslateScale(), and impeller::ScalarNearlyEqual().

◆ TEST() [317/689]

impeller::testing::TEST	(	MatrixTest	,
		Multiply
	)

Definition at line 15 of file matrix_unittests.cc.

                           {
  Matrix x(0.0, 0.0, 0.0, 1.0,  //
           1.0, 0.0, 0.0, 1.0,  //
           0.0, 1.0, 0.0, 1.0,  //
           1.0, 1.0, 0.0, 1.0);
  Matrix translate = Matrix::MakeTranslation({10, 20, 0});
  Matrix result = translate * x;
  EXPECT_TRUE(MatrixNear(result, Matrix(10.0, 20.0, 0.0, 1.0,  //
                                        11.0, 20.0, 0.0, 1.0,  //
                                        10.0, 21.0, 0.0, 1.0,  //
                                        11.0, 21.0, 0.0, 1.0)));
}

References impeller::Matrix::MakeTranslation(), MatrixNear(), and x.

◆ TEST() [318/689]

impeller::testing::TEST	(	MatrixTest	,
		NotEquals
	)

Definition at line 34 of file matrix_unittests.cc.

                            {
  Matrix x;
  Matrix y = x.Translate({1, 0, 0});
  EXPECT_FALSE(x.Equals(y));
}

References impeller::Matrix::Translate(), x, and y.

◆ TEST() [319/689]

impeller::testing::TEST	(	MatrixTest	,
		To3x3
	)

Definition at line 347 of file matrix_unittests.cc.

                        {
  Matrix x(1.0, 0.0, 4.0, 0.0,    //
           0.0, 1.0, 4.0, 0.0,    //
           6.0, 5.0, 111.0, 7.0,  //
           0.0, 0.0, 9.0, 1.0);
 
  EXPECT_TRUE(MatrixNear(x.To3x3(), Matrix()));
}

References MatrixNear(), and x.

◆ TEST() [320/689]

impeller::testing::TEST	(	MatrixTest	,
		TransformHomogenous
	)

Definition at line 250 of file matrix_unittests.cc.

                                      {
  Matrix matrix = Matrix::MakeColumn(
      // clang-format off
       2.0f,  3.0f,  5.0f,  7.0f,
      11.0f, 13.0f, 17.0f, 19.0f,
      23.0f, 29.0f, 31.0f, 37.0f,
      41.0f, 43.0f, 47.0f, 53.0f
      // clang-format on
  );
  EXPECT_EQ(matrix.TransformHomogenous({1.0f, -1.0f}),
            Vector3(32.0f, 33.0f, 41.0f));
}

References impeller::Matrix::MakeColumn(), and impeller::Matrix::TransformHomogenous().

◆ TEST() [321/689]

impeller::testing::TEST	(	MatrixTest	,
		TranslateWithPerspective
	)

Definition at line 320 of file matrix_unittests.cc.

                                           {
  Matrix m = Matrix::MakeRow(1.0, 0.0, 0.0, 10.0,  //
                             0.0, 1.0, 0.0, 20.0,  //
                             0.0, 0.0, 1.0, 0.0,   //
                             0.0, 2.0, 0.0, 30.0);
  Matrix result = m.Translate({100, 200});
  EXPECT_TRUE(MatrixNear(result, Matrix::MakeRow(1.0, 0.0, 0.0, 110.0,  //
                                                 0.0, 1.0, 0.0, 220.0,  //
                                                 0.0, 0.0, 1.0, 0.0,    //
                                                 0.0, 2.0, 0.0, 430.0)));
}

References impeller::Matrix::MakeRow(), MatrixNear(), and impeller::Matrix::Translate().

◆ TEST() [322/689]

impeller::testing::TEST	(	MockGLES	,
		CanCallUnmockedFunction
	)

Definition at line 25 of file mock_gles_unittests.cc.

                                        {
  auto mock_gles = MockGLES::Init();
 
  auto& gl = mock_gles->GetProcTable();
  gl.DeleteFramebuffers(1, nullptr);
 
  // Test should still complete.
  // If we end up mocking DeleteFramebuffers, delete this test.
}

References impeller::testing::MockGLES::Init().

◆ TEST() [323/689]

impeller::testing::TEST	(	MockGLES	,
		CanInitialize
	)

Definition at line 16 of file mock_gles_unittests.cc.

                              {
  auto mock_gles = MockGLES::Init();
 
  std::string_view vendor(reinterpret_cast<const char*>(
      mock_gles->GetProcTable().GetString(GL_VENDOR)));
  EXPECT_EQ(vendor, "MockGLES");
}

References impeller::testing::MockGLES::Init().

◆ TEST() [324/689]

impeller::testing::TEST	(	MockPipelineLibrary	,
		LogAndGetPipelineUsageMultiplePipelines
	)

Definition at line 28 of file pipeline_library_unittests.cc.

                                                                   {
  MockPipelineLibrary pipeline_library;
 
  PipelineDescriptor pipeline_a;
  pipeline_a.SetLabel("pipeline_a");
 
  PipelineDescriptor pipeline_b;
  pipeline_b.SetLabel("pipeline_b");
 
  pipeline_library.LogPipelineUsage(pipeline_a);
  pipeline_library.LogPipelineUsage(pipeline_a);
  pipeline_library.LogPipelineUsage(pipeline_b);
 
  auto usage_counts = pipeline_library.GetPipelineUseCounts();
 
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG || \
    FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_PROFILE
  EXPECT_EQ(usage_counts[pipeline_a], 2);
  EXPECT_EQ(usage_counts[pipeline_b], 1);
#else
  EXPECT_EQ(usage_counts[pipeline_a], 0);
  EXPECT_EQ(usage_counts[pipeline_b], 0);
#endif
}

References impeller::PipelineLibrary::GetPipelineUseCounts(), impeller::PipelineLibrary::LogPipelineUsage(), and impeller::PipelineDescriptor::SetLabel().

◆ TEST() [325/689]

impeller::testing::TEST	(	MockPipelineLibrary	,
		LogAndGetPipelineUsageSinglePipeline
	)

Definition at line 10 of file pipeline_library_unittests.cc.

                                                                {
  MockPipelineLibrary pipeline_library;
 
  PipelineDescriptor pipeline_desc;
  pipeline_desc.SetLabel("pipeline");
 
  pipeline_library.LogPipelineUsage(pipeline_desc);
  pipeline_library.LogPipelineUsage(pipeline_desc);
 
  auto usage_counts = pipeline_library.GetPipelineUseCounts();
#if FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_DEBUG || \
    FLUTTER_RUNTIME_MODE == FLUTTER_RUNTIME_MODE_PROFILE
  EXPECT_EQ(usage_counts[pipeline_desc], 2);
#else
  EXPECT_EQ(usage_counts[pipeline_desc], 0);
#endif
}

References impeller::PipelineLibrary::GetPipelineUseCounts(), impeller::PipelineLibrary::LogPipelineUsage(), and impeller::PipelineDescriptor::SetLabel().

◆ TEST() [326/689]

impeller::testing::TEST	(	MockVulkanContextTest	,
		DefaultFenceAlwaysReportsSuccess
	)

Definition at line 37 of file mock_vulkan_unittests.cc.

                                                              {
  auto const context = MockVulkanContextBuilder().Build();
  auto const device = context->GetDevice();
 
  auto fence = device.createFenceUnique({}).value;
  EXPECT_EQ(vk::Result::eSuccess, device.getFenceStatus(*fence));
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, and value.

◆ TEST() [327/689]

impeller::testing::TEST	(	MockVulkanContextTest	,
		IsThreadSafe
	)

Definition at line 14 of file mock_vulkan_unittests.cc.

                                          {
  // In a typical app, there is a single ContextVK per app, shared b/w threads.
  //
  // This test ensures that the (mock) ContextVK is thread-safe.
  auto const context = MockVulkanContextBuilder().Build();
 
  // Spawn two threads, and have them create a CommandPoolVK each.
  std::thread thread1([&context]() {
    auto const pool = context->GetCommandPoolRecycler()->Get();
    EXPECT_TRUE(pool);
  });
 
  std::thread thread2([&context]() {
    auto const pool = context->GetCommandPoolRecycler()->Get();
    EXPECT_TRUE(pool);
  });
 
  thread1.join();
  thread2.join();
 
  context->Shutdown();
}

References impeller::testing::MockVulkanContextBuilder::Build(), and context.

◆ TEST() [328/689]

impeller::testing::TEST	(	MockVulkanContextTest	,
		MockedFenceReportsStatus
	)

Definition at line 45 of file mock_vulkan_unittests.cc.

                                                      {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto const device = context->GetDevice();
  auto fence = device.createFenceUnique({}).value;
  MockFence::SetStatus(fence, vk::Result::eNotReady);
 
  EXPECT_EQ(vk::Result::eNotReady, device.getFenceStatus(fence.get()));
 
  MockFence::SetStatus(fence, vk::Result::eSuccess);
  EXPECT_EQ(vk::Result::eSuccess, device.getFenceStatus(*fence));
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, device, impeller::testing::MockFence::SetStatus(), and value.

◆ TEST() [329/689]

impeller::testing::TEST	(	PaintTest	,
		GradientConversionNonMonotonic
	)

Definition at line 156 of file paint_unittests.cc.

                                                {
  std::vector<flutter::DlColor> colors = {
      flutter::DlColor::kBlue(), flutter::DlColor::kGreen(),
      flutter::DlColor::kGreen(), flutter::DlColor::kRed()};
  std::vector<float> stops = {0.0, 0.5, 0.4, 1.0};
  const auto gradient =
      flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                         flutter::DlPoint(1.0, 1.0),   //
                                         4,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                      converted_stops);
 
  // Value is clamped to 0.5
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 0.5f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[3], 1.0f));
}

References impeller::Paint::ConvertStops(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and impeller::ScalarNearlyEqual().

◆ TEST() [330/689]

impeller::testing::TEST	(	PaintTest	,
		GradientMissing0
	)

Definition at line 78 of file paint_unittests.cc.

                                  {
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  std::vector<float> stops = {0.5, 1.0};
  const auto gradient =
      flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                         flutter::DlPoint(1.0, 1.0),   //
                                         2,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                      converted_stops);
 
  // First color is inserted as blue.
  ASSERT_TRUE(ScalarNearlyEqual(converted_colors[0].blue, 1.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
}

References impeller::Paint::ConvertStops(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and impeller::ScalarNearlyEqual().

◆ TEST() [331/689]

impeller::testing::TEST	(	PaintTest	,
		GradientMissingLastValue
	)

Definition at line 104 of file paint_unittests.cc.

                                          {
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  std::vector<float> stops = {0.0, .5};
  const auto gradient =
      flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                         flutter::DlPoint(1.0, 1.0),   //
                                         2,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                      converted_stops);
 
  // Last color is inserted as red.
  ASSERT_TRUE(ScalarNearlyEqual(converted_colors[2].red, 1.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
}

References impeller::Paint::ConvertStops(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and impeller::ScalarNearlyEqual().

◆ TEST() [332/689]

impeller::testing::TEST	(	PaintTest	,
		GradientStopConversion
	)

Definition at line 52 of file paint_unittests.cc.

                                        {
  // Typical gradient.
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed(),
                                          flutter::DlColor::kGreen()};
  std::vector<float> stops = {0.0, 0.5, 1.0};
  const auto gradient =
      flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                         flutter::DlPoint(1.0, 1.0),   //
                                         3,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                      converted_stops);
 
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 0.5f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
}

References impeller::Paint::ConvertStops(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and impeller::ScalarNearlyEqual().

◆ TEST() [333/689]

impeller::testing::TEST	(	PaintTest	,
		GradientStopGreaterThan1
	)

Definition at line 130 of file paint_unittests.cc.

                                          {
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kGreen(),
                                          flutter::DlColor::kRed()};
  std::vector<float> stops = {0.0, 100, 1.0};
  const auto gradient =
      flutter::DlColorSource::MakeLinear(flutter::DlPoint(0, 0),       //
                                         flutter::DlPoint(1.0, 1.0),   //
                                         3,                            //
                                         colors.data(),                //
                                         stops.data(),                 //
                                         flutter::DlTileMode::kClamp,  //
                                         nullptr                       //
      );
 
  std::vector<Color> converted_colors;
  std::vector<Scalar> converted_stops;
  Paint::ConvertStops(gradient->asLinearGradient(), converted_colors,
                      converted_stops);
 
  // Value is clamped to 1.0
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[0], 0.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[1], 1.0f));
  ASSERT_TRUE(ScalarNearlyEqual(converted_stops[2], 1.0f));
}

References impeller::Paint::ConvertStops(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and impeller::ScalarNearlyEqual().

◆ TEST() [334/689]

impeller::testing::TEST	(	PaintTest	,
		OptionalStrokeWithFill
	)

Definition at line 17 of file paint_unittests.cc.

                                        {
  Paint paint;
  paint.style = Paint::Style::kFill;
  paint.stroke.cap = Cap::kRound;
  paint.stroke.join = Join::kRound;
  paint.stroke.width = 20.0f;
  paint.stroke.miter_limit = 100.0f;
 
  EXPECT_FALSE(paint.GetStroke().has_value());
  // Even though optional stroke wasn't returned, the underlying values
  // are still in the Paint.
  EXPECT_EQ(paint.stroke.cap, Cap::kRound);
  EXPECT_EQ(paint.stroke.join, Join::kRound);
  EXPECT_EQ(paint.stroke.width, 20.0f);
  EXPECT_EQ(paint.stroke.miter_limit, 100.0f);
}

References impeller::StrokeParameters::cap, impeller::Paint::GetStroke(), impeller::StrokeParameters::join, impeller::Paint::kFill, impeller::kRound, impeller::StrokeParameters::miter_limit, impeller::Paint::stroke, impeller::Paint::style, and impeller::StrokeParameters::width.

◆ TEST() [335/689]

impeller::testing::TEST	(	PaintTest	,
		OptionalStrokeWithStroke
	)

Definition at line 34 of file paint_unittests.cc.

                                          {
  Paint paint;
  paint.style = Paint::Style::kStroke;
  paint.stroke.cap = Cap::kRound;
  paint.stroke.join = Join::kRound;
  paint.stroke.width = 20.0f;
  paint.stroke.miter_limit = 100.0f;
 
  std::optional<StrokeParameters> optional_stroke = paint.GetStroke();
  EXPECT_TRUE(optional_stroke.has_value());
  if (optional_stroke.has_value()) {  // Test to keep clang-tidy happy.
    EXPECT_EQ(optional_stroke->cap, Cap::kRound);
    EXPECT_EQ(optional_stroke->join, Join::kRound);
    EXPECT_EQ(optional_stroke->width, 20.0f);
    EXPECT_EQ(optional_stroke->miter_limit, 100.0f);
  }
}

References impeller::StrokeParameters::cap, impeller::Paint::GetStroke(), impeller::StrokeParameters::join, impeller::kRound, impeller::Paint::kStroke, impeller::StrokeParameters::miter_limit, impeller::Paint::stroke, impeller::Paint::style, and impeller::StrokeParameters::width.

◆ TEST() [336/689]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSource
	)

Definition at line 158 of file path_source_unittests.cc.

                                           {
  DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, 5);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(15, 10)));
    EXPECT_CALL(receiver, MoveTo(Point(20, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(25, 10)));
  }
 
  source.Dispatch(receiver);
}

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [337/689]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceInvalidOffGaps
	)

Definition at line 217 of file path_source_unittests.cc.

                                                         {
  DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, -1);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(30, 10)));
  }
 
  source.Dispatch(receiver);
}

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [338/689]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceInvalidOnRegion
	)

Definition at line 236 of file path_source_unittests.cc.

                                                          {
  DashedLinePathSource source(Point(10, 10), Point(30, 10), -1, 5);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(30, 10)));
  }
 
  source.Dispatch(receiver);
}

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [339/689]

impeller::testing::TEST	(	PathSourceTest	,
		DashedLinePathSourceZeroOffGaps
	)

Definition at line 198 of file path_source_unittests.cc.

                                                      {
  DashedLinePathSource source(Point(10, 10), Point(30, 10), 5, 0);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 30, 10));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(30, 10)));
  }
 
  source.Dispatch(receiver);
}

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [340/689]

impeller::testing::TEST	(	PathSourceTest	,
		DiffRoundRectSourceTest
	)

Definition at line 105 of file path_source_unittests.cc.

                                              {
  Rect outer_rect = Rect::MakeLTRB(10, 15, 200, 300);
  Rect inner_rect = Rect::MakeLTRB(50, 60, 100, 200);
  ASSERT_TRUE(outer_rect.Contains(inner_rect));
  RoundingRadii radii = {
      .top_left = Size(1, 11),
      .top_right = Size(2, 12),
      .bottom_left = Size(4, 14),
      .bottom_right = Size(3, 13),
  };
  RoundRect outer_rrect = RoundRect::MakeRectRadii(outer_rect, radii);
  RoundRect inner_rrect = RoundRect::MakeRectRadii(inner_rect, radii);
  DiffRoundRectPathSource source(outer_rrect, inner_rrect);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kOdd);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 200, 300));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(11, 15), true));
    EXPECT_CALL(receiver, LineTo(Point(198, 15)));
    EXPECT_CALL(receiver, ConicTo(Point(200, 15), Point(200, 27), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(200, 287)));
    EXPECT_CALL(receiver,
                ConicTo(Point(200, 300), Point(197, 300), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(14, 300)));
    EXPECT_CALL(receiver, ConicTo(Point(10, 300), Point(10, 286), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(10, 26)));
    EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(11, 15), kSqrt2Over2));
    // RetiresOnSaturation keeps identical calls from matching each other
    EXPECT_CALL(receiver, Close()).RetiresOnSaturation();
 
    EXPECT_CALL(receiver, MoveTo(Point(51, 60), true));
    EXPECT_CALL(receiver, LineTo(Point(98, 60)));
    EXPECT_CALL(receiver, ConicTo(Point(100, 60), Point(100, 72), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(100, 187)));
    EXPECT_CALL(receiver,
                ConicTo(Point(100, 200), Point(97, 200), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(54, 200)));
    EXPECT_CALL(receiver, ConicTo(Point(50, 200), Point(50, 186), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(50, 71)));
    EXPECT_CALL(receiver, ConicTo(Point(50, 60), Point(51, 60), kSqrt2Over2));
    // RetiresOnSaturation keeps identical calls from matching each other
    EXPECT_CALL(receiver, Close()).RetiresOnSaturation();
  }
 
  source.Dispatch(receiver);
}

References impeller::Close(), impeller::DiffRoundRectPathSource::Dispatch(), impeller::DiffRoundRectPathSource::GetBounds(), impeller::DiffRoundRectPathSource::GetFillType(), impeller::DiffRoundRectPathSource::IsConvex(), impeller::kOdd, impeller::kSqrt2Over2, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::MoveTo(), and impeller::RoundingRadii::top_left.

◆ TEST() [341/689]

impeller::testing::TEST	(	PathSourceTest	,
		EllipseSourceTest
	)

Definition at line 46 of file path_source_unittests.cc.

                                        {
  Rect rect = Rect::MakeLTRB(10, 15, 20, 30);
  EllipsePathSource source(rect);
 
  EXPECT_TRUE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 20, 30));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 22.5), true));
    EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(15, 15), kSqrt2Over2));
    EXPECT_CALL(receiver, ConicTo(Point(20, 15), Point(20, 22.5), kSqrt2Over2));
    EXPECT_CALL(receiver, ConicTo(Point(20, 30), Point(15, 30), kSqrt2Over2));
    EXPECT_CALL(receiver, ConicTo(Point(10, 30), Point(10, 22.5), kSqrt2Over2));
    EXPECT_CALL(receiver, Close());
  }
 
  source.Dispatch(receiver);
}

References impeller::Close(), impeller::EllipsePathSource::Dispatch(), impeller::EllipsePathSource::GetBounds(), impeller::EllipsePathSource::GetFillType(), impeller::EllipsePathSource::IsConvex(), impeller::kNonZero, impeller::kSqrt2Over2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [342/689]

impeller::testing::TEST	(	PathSourceTest	,
		EmptyDashedLinePathSource
	)

Definition at line 179 of file path_source_unittests.cc.

                                                {
  DashedLinePathSource source(Point(10, 10), Point(10, 10), 5, 5);
 
  EXPECT_FALSE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 10, 10, 10));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 10), false));
    EXPECT_CALL(receiver, LineTo(Point(10, 10)));
  }
 
  source.Dispatch(receiver);
}

References impeller::DashedLinePathSource::Dispatch(), impeller::DashedLinePathSource::GetBounds(), impeller::DashedLinePathSource::GetFillType(), impeller::DashedLinePathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [343/689]

impeller::testing::TEST	(	PathSourceTest	,
		PathTransformerAllSegmentsTest
	)

Definition at line 282 of file path_source_unittests.cc.

                                                     {
  Matrix matrix =
      Matrix::MakeTranslateScale({2.0f, 3.0f, 1.0f}, {1.5f, 4.25f, 0.0f});
 
  ::testing::StrictMock<DlPathReceiverMock> mock_receiver;
  PathTransformer receiver = PathTransformer(mock_receiver, matrix);
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(mock_receiver, MoveTo(Point(21.5f, 49.25f), false));
    EXPECT_CALL(mock_receiver, LineTo(Point(41.5f, 49.25f)));
 
    EXPECT_CALL(mock_receiver, MoveTo(Point(221.5f, 349.25f), true));
    EXPECT_CALL(mock_receiver,
                QuadTo(Point(241.5f, 349.25f), Point(241.5f, 394.25f)));
    EXPECT_CALL(mock_receiver,
                ConicTo(Point(237.5f, 409.25f), Point(231.5f, 409.25f), 5))
        .WillOnce(Return(true));
    EXPECT_CALL(mock_receiver,
                ConicTo(Point(225.5f, 409.25f), Point(221.5f, 394.25f), 6))
        .WillOnce(Return(false));
    EXPECT_CALL(mock_receiver,
                CubicTo(Point(211.5f, 379.25f), Point(211.5f, 364.25f),
                        Point(221.5f, 349.25f)));
    EXPECT_CALL(mock_receiver, Close());
  }
 
  receiver.MoveTo(Point(10, 15), false);
  receiver.LineTo(Point(20, 15));
 
  receiver.MoveTo(Point(110, 115), true);
  receiver.QuadTo(Point(120, 115), Point(120, 130));
  EXPECT_TRUE(receiver.ConicTo(Point(118, 135), Point(115, 135), 5));
  EXPECT_FALSE(receiver.ConicTo(Point(112, 135), Point(110, 130), 6));
  receiver.CubicTo(Point(105, 125), Point(105, 120), Point(110, 115));
  receiver.Close();
}

References impeller::PathTransformer::Close(), impeller::Close(), impeller::PathTransformer::ConicTo(), impeller::PathTransformer::CubicTo(), impeller::CubicTo(), impeller::PathTransformer::LineTo(), impeller::LineTo(), impeller::Matrix::MakeTranslateScale(), impeller::PathTransformer::MoveTo(), impeller::MoveTo(), and impeller::PathTransformer::QuadTo().

◆ TEST() [344/689]

impeller::testing::TEST	(	PathSourceTest	,
		PathTransformerRectSourceTest
	)

Definition at line 255 of file path_source_unittests.cc.

                                                    {
  Matrix matrix =
      Matrix::MakeTranslateScale({2.0f, 3.0f, 1.0f}, {1.5f, 4.25f, 0.0f});
  Rect rect = Rect::MakeLTRB(10, 15, 20, 30);
  RectPathSource source(rect);
 
  EXPECT_TRUE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 20, 30));
 
  ::testing::StrictMock<DlPathReceiverMock> mock_receiver;
  PathTransformer receiver = PathTransformer(mock_receiver, matrix);
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(mock_receiver, MoveTo(Point(21.5f, 49.25f), true));
    EXPECT_CALL(mock_receiver, LineTo(Point(41.5f, 49.25f)));
    EXPECT_CALL(mock_receiver, LineTo(Point(41.5f, 94.25f)));
    EXPECT_CALL(mock_receiver, LineTo(Point(21.5f, 94.25f)));
    EXPECT_CALL(mock_receiver, LineTo(Point(21.5f, 49.25f)));
    EXPECT_CALL(mock_receiver, Close());
  }
 
  source.Dispatch(receiver);
}

References impeller::Close(), impeller::RectPathSource::Dispatch(), impeller::RectPathSource::GetBounds(), impeller::RectPathSource::GetFillType(), impeller::RectPathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslateScale(), and impeller::MoveTo().

◆ TEST() [345/689]

impeller::testing::TEST	(	PathSourceTest	,
		RectSourceTest
	)

Definition at line 22 of file path_source_unittests.cc.

                                     {
  Rect rect = Rect::MakeLTRB(10, 15, 20, 30);
  RectPathSource source(rect);
 
  EXPECT_TRUE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 20, 30));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(10, 15), true));
    EXPECT_CALL(receiver, LineTo(Point(20, 15)));
    EXPECT_CALL(receiver, LineTo(Point(20, 30)));
    EXPECT_CALL(receiver, LineTo(Point(10, 30)));
    EXPECT_CALL(receiver, LineTo(Point(10, 15)));
    EXPECT_CALL(receiver, Close());
  }
 
  source.Dispatch(receiver);
}

References impeller::Close(), impeller::RectPathSource::Dispatch(), impeller::RectPathSource::GetBounds(), impeller::RectPathSource::GetFillType(), impeller::RectPathSource::IsConvex(), impeller::kNonZero, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::MoveTo().

◆ TEST() [346/689]

impeller::testing::TEST	(	PathSourceTest	,
		RoundRectSourceTest
	)

Definition at line 70 of file path_source_unittests.cc.

                                          {
  Rect rect = Rect::MakeLTRB(10, 15, 40, 60);
  RoundingRadii radii = {
      .top_left = Size(1, 11),
      .top_right = Size(2, 12),
      .bottom_left = Size(4, 14),
      .bottom_right = Size(3, 13),
  };
  RoundRect round_rect = RoundRect::MakeRectRadii(rect, radii);
  RoundRectPathSource source(round_rect);
 
  EXPECT_TRUE(source.IsConvex());
  EXPECT_EQ(source.GetFillType(), FillType::kNonZero);
  EXPECT_EQ(source.GetBounds(), Rect::MakeLTRB(10, 15, 40, 60));
 
  ::testing::StrictMock<DlPathReceiverMock> receiver;
 
  {
    ::testing::Sequence sequence;
 
    EXPECT_CALL(receiver, MoveTo(Point(11, 15), true));
    EXPECT_CALL(receiver, LineTo(Point(38, 15)));
    EXPECT_CALL(receiver, ConicTo(Point(40, 15), Point(40, 27), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(40, 47)));
    EXPECT_CALL(receiver, ConicTo(Point(40, 60), Point(37, 60), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(14, 60)));
    EXPECT_CALL(receiver, ConicTo(Point(10, 60), Point(10, 46), kSqrt2Over2));
    EXPECT_CALL(receiver, LineTo(Point(10, 26)));
    EXPECT_CALL(receiver, ConicTo(Point(10, 15), Point(11, 15), kSqrt2Over2));
    EXPECT_CALL(receiver, Close());
  }
 
  source.Dispatch(receiver);
}

References impeller::Close(), impeller::RoundRectPathSource::Dispatch(), impeller::RoundRectPathSource::GetBounds(), impeller::RoundRectPathSource::GetFillType(), impeller::RoundRectPathSource::IsConvex(), impeller::kNonZero, impeller::kSqrt2Over2, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::MoveTo(), and impeller::RoundingRadii::top_left.

◆ TEST() [347/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		ComplexPath
	)

Definition at line 396 of file path_tessellator_unittests.cc.

                                       {
  PathTessellator::Quad quad{{10, 10}, {20, 20}, {20, 10}};
  PathTessellator::Conic conic{{20, 10}, {30, 20}, {30, 10}, 2.0f};
  PathTessellator::Cubic cubic{{30, 10}, {40, 20}, {40, 10}, {42, 15}};
 
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.QuadraticCurveTo(quad.cp, quad.p2);
  builder.ConicCurveTo(conic.cp, conic.p2, conic.weight);
  builder.CubicCurveTo(cubic.cp1, cubic.cp2, cubic.p2);
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
    EXPECT_CALL(mock_receiver,
                RecordConic(conic.p1, conic.cp, conic.p2, conic.weight));
    EXPECT_CALL(mock_receiver,
                RecordCubic(cubic.p1, cubic.cp1, cubic.cp2, cubic.p2));
    EXPECT_CALL(mock_receiver, RecordLine(cubic.p2, Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 25u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    {
      EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.p2));
    }
    {
      EXPECT_CALL(mock_writer, Write(conic.Solve(1 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(2 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(3 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(4 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(5 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(6 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(7 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.p2));
    }
    {
      EXPECT_CALL(mock_writer, Write(cubic.Solve(1 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(2 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(3 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(4 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(5 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(6 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(7 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(8 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.p2));
    }
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [348/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		ComplexPathTrailingMoveTo
	)

Definition at line 471 of file path_tessellator_unittests.cc.

                                                     {
  PathTessellator::Quad quad{{10, 10}, {20, 20}, {20, 10}};
  PathTessellator::Conic conic{{20, 10}, {30, 20}, {30, 10}, 2.0f};
  PathTessellator::Cubic cubic{{30, 10}, {40, 20}, {40, 10}, {42, 15}};
 
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.QuadraticCurveTo(quad.cp, quad.p2);
  builder.ConicCurveTo(conic.cp, conic.p2, conic.weight);
  builder.CubicCurveTo(cubic.cp1, cubic.cp2, cubic.p2);
  builder.Close();
  builder.MoveTo({500, 100});
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
    EXPECT_CALL(mock_receiver,
                RecordConic(conic.p1, conic.cp, conic.p2, conic.weight));
    EXPECT_CALL(mock_receiver,
                RecordCubic(cubic.p1, cubic.cp1, cubic.cp2, cubic.p2));
    EXPECT_CALL(mock_receiver, RecordLine(cubic.p2, Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 25u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    {
      EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.p2));
    }
    {
      EXPECT_CALL(mock_writer, Write(conic.Solve(1 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(2 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(3 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(4 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(5 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(6 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.Solve(7 / 8.0f)));
      EXPECT_CALL(mock_writer, Write(conic.p2));
    }
    {
      EXPECT_CALL(mock_writer, Write(cubic.Solve(1 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(2 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(3 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(4 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(5 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(6 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(7 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.Solve(8 / 9.0f)));
      EXPECT_CALL(mock_writer, Write(cubic.p2));
    }
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [349/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		ConicToLineToOptimization
	)

Definition at line 269 of file path_tessellator_unittests.cc.

                                                     {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  // CP == P1
  builder.ConicCurveTo({0, 0}, {10, 10}, 2.0f);
  // CP == P2
  builder.ConicCurveTo({20, 10}, {20, 10}, 2.0f);
  // weight == 0
  builder.ConicCurveTo({20, 0}, {10, 0}, 0.0f);
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(20, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(20, 10), Point(10, 0)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 0), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 5u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(20, 10)));
    EXPECT_CALL(mock_writer, Write(Point(10, 0)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [350/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		ConicToQuadToOptimization
	)

Definition at line 313 of file path_tessellator_unittests.cc.

                                                     {
  // The conic below will simplify to this quad
  PathTessellator::Quad quad{{0, 0}, {10, 0}, {0, 10}};
 
  flutter::DlPathBuilder builder;
  builder.MoveTo(quad.p1);
  // weight == 1
  builder.ConicCurveTo(quad.cp, quad.p2, 1.0f);
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver, BeginContour(quad.p1, /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordQuad(quad.p1, quad.cp, quad.p2));
    EXPECT_CALL(mock_receiver, RecordLine(quad.p2, quad.p1));
    EXPECT_CALL(mock_receiver, EndContour(quad.p1, /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 7u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(quad.p1));
    {
      EXPECT_CALL(mock_writer, Write(quad.Solve(1 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(2 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(3 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.Solve(4 / 5.0f)));
      EXPECT_CALL(mock_writer, Write(quad.p2));
    }
    EXPECT_CALL(mock_writer, Write(quad.p1));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [351/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		DegenerateSegmentsPath
	)

Definition at line 191 of file path_tessellator_unittests.cc.

                                                  {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({0, 0});
  builder.LineTo({0, 0});
  builder.QuadraticCurveTo({0, 0}, {0, 0});
  builder.QuadraticCurveTo({0, 0}, {0, 0});
  builder.ConicCurveTo({0, 0}, {0, 0}, 12.0f);
  builder.ConicCurveTo({0, 0}, {0, 0}, 12.0f);
  builder.CubicCurveTo({0, 0}, {0, 0}, {0, 0});
  builder.CubicCurveTo({0, 0}, {0, 0}, {0, 0});
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 1u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [352/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		EmptyPath
	)

Definition at line 42 of file path_tessellator_unittests.cc.

                                     {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 0u);
  EXPECT_EQ(contours, 0u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [353/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		EmptyPathMultipleMoveTo
	)

Definition at line 58 of file path_tessellator_unittests.cc.

                                                   {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.MoveTo({10, 10});
  builder.MoveTo({20, 20});
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 0u);
  EXPECT_EQ(contours, 0u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [354/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearConicToPointCount
	)

Definition at line 559 of file path_tessellator_unittests.cc.

                                                   {
  flutter::DlPathBuilder builder;
  builder.MoveTo({316.3, 121.5});
  builder.ConicCurveTo({316.4, 121.5}, {316.5, 121.5}, 2.0f);
  builder.Close();
  auto path = builder.TakePath();
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
  EXPECT_EQ(points, 3u);
  EXPECT_EQ(contours, 1u);
}

References flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [355/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearCubicToPointCount
	)

Definition at line 571 of file path_tessellator_unittests.cc.

                                                   {
  flutter::DlPathBuilder builder;
  builder.MoveTo({316.3, 121.5});
  builder.CubicCurveTo({316.4, 121.5}, {316.5, 121.5}, {316.6, 121.5});
  builder.Close();
  auto path = builder.TakePath();
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
  EXPECT_EQ(points, 3u);
  EXPECT_EQ(contours, 1u);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [356/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		LinearQuadToPointCount
	)

Definition at line 547 of file path_tessellator_unittests.cc.

                                                  {
  flutter::DlPathBuilder builder;
  builder.MoveTo({316.3, 121.5});
  builder.QuadraticCurveTo({316.4, 121.5}, {316.5, 121.5});
  builder.Close();
  auto path = builder.TakePath();
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 2.0f);
  EXPECT_EQ(points, 3u);
  EXPECT_EQ(contours, 1u);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [357/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		QuadToLineToOptimization
	)

Definition at line 229 of file path_tessellator_unittests.cc.

                                                    {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  // CP == P1
  builder.QuadraticCurveTo({0, 0}, {10, 10});
  // CP == P2
  builder.QuadraticCurveTo({20, 10}, {20, 10});
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(20, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(20, 10), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 4u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(20, 10)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, flutter::DlPathBuilder::QuadraticCurveTo(), and flutter::DlPathBuilder::TakePath().

◆ TEST() [358/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimpleClosedPath
	)

Definition at line 76 of file path_tessellator_unittests.cc.

                                            {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.LineTo({0, 20});
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 4u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(0, 20)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [359/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimplePathMultipleMoveTo
	)

Definition at line 357 of file path_tessellator_unittests.cc.

                                                    {
  flutter::DlPathBuilder builder;
  builder.MoveTo({500, 100});
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.LineTo({0, 20});
  builder.Close();
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 4u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(0, 20)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [360/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimplePathTrailingMoveTo
	)

Definition at line 152 of file path_tessellator_unittests.cc.

                                                    {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.LineTo({0, 20});
  builder.Close();
  builder.MoveTo({500, 100});
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/true));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/true));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 4u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(0, 20)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References flutter::DlPathBuilder::Close(), contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [361/689]

impeller::testing::TEST	(	PathTessellatorTest	,
		SimpleUnclosedPath
	)

Definition at line 114 of file path_tessellator_unittests.cc.

                                              {
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.LineTo({10, 10});
  builder.LineTo({0, 20});
  // Close not really needed for filled paths
  flutter::DlPath path = builder.TakePath();
 
  ::testing::StrictMock<MockSegmentReceiver> mock_receiver;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_receiver,
                BeginContour(Point(0, 0), /*will_be_closed=*/false));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 0), Point(10, 10)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(10, 10), Point(0, 20)));
    EXPECT_CALL(mock_receiver, RecordLine(Point(0, 20), Point(0, 0)));
    EXPECT_CALL(mock_receiver, EndContour(Point(0, 0), /*with_close=*/false));
  }
  PathTessellator::PathToFilledSegments(path, mock_receiver);
 
  auto [points, contours] = PathTessellator::CountFillStorage(path, 1.0f);
  EXPECT_EQ(points, 4u);
  EXPECT_EQ(contours, 1u);
 
  ::testing::StrictMock<MockPathVertexWriter> mock_writer;
  {
    ::testing::InSequence sequence;
 
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, Write(Point(10, 10)));
    EXPECT_CALL(mock_writer, Write(Point(0, 20)));
    EXPECT_CALL(mock_writer, Write(Point(0, 0)));
    EXPECT_CALL(mock_writer, EndContour());
  }
  PathTessellator::PathToFilledVertices(path, mock_writer, 1.0f);
}

References contours, impeller::PathTessellator::CountFillStorage(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::PathTessellator::PathToFilledSegments(), impeller::PathTessellator::PathToFilledVertices(), points, and flutter::DlPathBuilder::TakePath().

◆ TEST() [362/689]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		CanCreateFromDeviceProperties
	)

Definition at line 77 of file pipeline_cache_data_vk_unittests.cc.

                                                             {
  vk::PhysicalDeviceProperties props;
  std::array<uint8_t, 16> uuid{
      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  };
  props.pipelineCacheUUID = uuid;
  props.deviceID = 10;
  props.vendorID = 11;
  props.driverVersion = 12;
  PipelineCacheHeaderVK header(props, 99);
  EXPECT_EQ(uuid.size(), std::size(header.uuid));
  EXPECT_EQ(props.deviceID, header.device_id);
  EXPECT_EQ(props.vendorID, header.vendor_id);
  EXPECT_EQ(props.driverVersion, header.driver_version);
  for (size_t i = 0; i < uuid.size(); i++) {
    EXPECT_EQ(header.uuid[i], uuid.at(i));
  }
}

References impeller::PipelineCacheHeaderVK::device_id, impeller::PipelineCacheHeaderVK::driver_version, i, impeller::PipelineCacheHeaderVK::uuid, and impeller::PipelineCacheHeaderVK::vendor_id.

◆ TEST() [363/689]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		CanTestHeaderCompatibility
	)

Definition at line 17 of file pipeline_cache_data_vk_unittests.cc.

                                                          {
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    EXPECT_EQ(a.abi, sizeof(void*));
#ifdef FML_ARCH_CPU_64_BITS
    EXPECT_EQ(a.abi, 8u);
#elif FML_ARCH_CPU_32_BITS
    EXPECT_EQ(a.abi, 4u);
#endif
    EXPECT_TRUE(a.IsCompatibleWith(b));
  }
  // Different data sizes don't matter.
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    a.data_size = b.data_size + 100u;
    EXPECT_TRUE(a.IsCompatibleWith(b));
  }
  // Magic, Driver, vendor, ABI, and UUID matter.
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    b.magic = 100;
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    b.driver_version = 100;
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    b.vendor_id = 100;
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    b.device_id = 100;
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    b.abi = a.abi / 2u;
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
  {
    PipelineCacheHeaderVK a;
    PipelineCacheHeaderVK b;
    for (size_t i = 0; i < VK_UUID_SIZE; i++) {
      b.uuid[i] = a.uuid[i] + 1;
    }
    EXPECT_FALSE(a.IsCompatibleWith(b));
  }
}

References impeller::PipelineCacheHeaderVK::abi, impeller::PipelineCacheHeaderVK::data_size, i, impeller::PipelineCacheHeaderVK::IsCompatibleWith(), and impeller::PipelineCacheHeaderVK::uuid.

◆ TEST() [364/689]

impeller::testing::TEST	(	PipelineCacheDataVKTest	,
		WritesIncompleteCacheData
	)

Definition at line 96 of file pipeline_cache_data_vk_unittests.cc.

                                                         {
  fml::ScopedTemporaryDirectory temp_dir;
  auto context = MockVulkanContextBuilder().Build();
  auto cache = context->GetDevice().createPipelineCacheUnique({});
  const auto& caps = CapabilitiesVK::Cast(*context->GetCapabilities());
 
  ASSERT_TRUE(PipelineCacheDataPersist(
      temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
 
  std::unique_ptr<fml::FileMapping> mapping = fml::FileMapping::CreateReadOnly(
      temp_dir.fd(), "flutter.impeller.vkcache");
  ASSERT_TRUE(mapping);
  PipelineCacheHeaderVK header;
  ASSERT_GE(mapping->GetSize(), sizeof(header));
  std::memcpy(&header, mapping->GetMapping(), sizeof(header));
  ASSERT_EQ(mapping->GetSize(), sizeof(header) + header.data_size);
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), context, fml::FileMapping::CreateReadOnly(), impeller::PipelineCacheHeaderVK::data_size, fml::ScopedTemporaryDirectory::fd(), and impeller::PipelineCacheDataPersist().

◆ TEST() [365/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		CreateReturnsNullWithNullTaskRunner
	)

Definition at line 30 of file pipeline_compile_queue_gles_unittests.cc.

                                                                        {
  auto queue = PipelineCompileQueueGLES::Create(nullptr);
  EXPECT_EQ(queue, nullptr);
}

References impeller::PipelineCompileQueueGLES::Create(), and queue.

◆ TEST() [366/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		CreateSucceedsWithValidTaskRunner
	)

Definition at line 35 of file pipeline_compile_queue_gles_unittests.cc.

                                                                      {
  fml::Thread thread;
  auto queue = PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
  EXPECT_NE(queue, nullptr);
  thread.Join();
}

References impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), and queue.

◆ TEST() [367/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		DestroyQueueWithPendingTasks
	)

Definition at line 146 of file pipeline_compile_queue_gles_unittests.cc.

                                                                 {
  fml::Thread thread;
  std::atomic<int> completed_jobs{0};
  fml::CountDownLatch latch(3);
 
  {
    auto queue =
        PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
    ASSERT_NE(queue, nullptr);
 
    PipelineDescriptor desc1;
    desc1.SetSampleCount(SampleCount::kCount1);
    desc1.SetCullMode(CullMode::kNone);
 
    PipelineDescriptor desc2;
    desc2.SetSampleCount(SampleCount::kCount1);
    desc2.SetCullMode(CullMode::kFrontFace);
 
    PipelineDescriptor desc3;
    desc3.SetSampleCount(SampleCount::kCount1);
    desc3.SetCullMode(CullMode::kBackFace);
 
    queue->PostJobForDescriptor(desc1, [&]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      completed_jobs++;
      latch.CountDown();
    });
 
    queue->PostJobForDescriptor(desc2, [&]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      completed_jobs++;
      latch.CountDown();
    });
 
    queue->PostJobForDescriptor(desc3, [&]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      completed_jobs++;
      latch.CountDown();
    });
 
    // Queue will be destroyed here with pending jobs.
    // The destructor should ensure that the pending jobs are either executed
    // or posted to the queue's thread.
  }
 
  // Wait for completion of the jobs.
  latch.Wait();
  EXPECT_EQ(completed_jobs, 3);
 
  thread.Join();
}

References fml::CountDownLatch::CountDown(), impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), impeller::kBackFace, impeller::kCount1, impeller::kFrontFace, impeller::kNone, queue, impeller::PipelineDescriptor::SetCullMode(), impeller::PipelineDescriptor::SetSampleCount(), and fml::CountDownLatch::Wait().

◆ TEST() [368/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		IsProcessingResetsAfterAllJobsComplete
	)

Definition at line 124 of file pipeline_compile_queue_gles_unittests.cc.

                                                                           {
  fml::Thread thread;
  auto queue = PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
  ASSERT_NE(queue, nullptr);
 
  fml::CountDownLatch latch(1);
 
  queue->PostJobForDescriptor(PipelineDescriptor{},
                              [&]() { latch.CountDown(); });
 
  latch.Wait();
 
  fml::CountDownLatch latch2(1);
  queue->PostJobForDescriptor(PipelineDescriptor{},
                              [&]() { latch2.CountDown(); });
 
  latch2.Wait();
 
  SUCCEED();
  thread.Join();
}

References fml::CountDownLatch::CountDown(), impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), queue, and fml::CountDownLatch::Wait().

◆ TEST() [369/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		OnJobAddedProcessesJobsSequentially
	)

Definition at line 50 of file pipeline_compile_queue_gles_unittests.cc.

                                                                        {
  fml::Thread thread;
  auto queue = PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
  ASSERT_NE(queue, nullptr);
 
  std::atomic<int> completed_jobs{0};
  fml::CountDownLatch latch(3);
 
  PipelineDescriptor desc1;
  desc1.SetSampleCount(SampleCount::kCount1);
  desc1.SetCullMode(CullMode::kNone);
 
  PipelineDescriptor desc2;
  desc2.SetSampleCount(SampleCount::kCount1);
  desc2.SetCullMode(CullMode::kFrontFace);
 
  PipelineDescriptor desc3;
  desc3.SetSampleCount(SampleCount::kCount1);
  desc3.SetCullMode(CullMode::kBackFace);
 
  queue->PostJobForDescriptor(desc1, [&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds(80));
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc2, [&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds(80));
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc3, [&]() {
    std::this_thread::sleep_for(std::chrono::milliseconds(80));
    completed_jobs++;
    latch.CountDown();
  });
 
  latch.Wait();
 
  EXPECT_EQ(completed_jobs, 3);
 
  thread.Join();
}

References fml::CountDownLatch::CountDown(), impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), impeller::kBackFace, impeller::kCount1, impeller::kFrontFace, impeller::kNone, queue, impeller::PipelineDescriptor::SetCullMode(), impeller::PipelineDescriptor::SetSampleCount(), and fml::CountDownLatch::Wait().

◆ TEST() [370/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		PostJobDoesNothingWithNullClosure
	)

Definition at line 42 of file pipeline_compile_queue_gles_unittests.cc.

                                                                      {
  fml::Thread thread;
  auto queue = PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
  ASSERT_NE(queue, nullptr);
  queue->PostJob(nullptr);
  thread.Join();
}

References impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), and queue.

◆ TEST() [371/689]

impeller::testing::TEST	(	PipelineCompileQueueGLESTest	,
		PostJobForDescriptorWithDuplicateRunsEagerly
	)

Definition at line 95 of file pipeline_compile_queue_gles_unittests.cc.

                                                   {
  fml::Thread thread;
  auto queue = PipelineCompileQueueGLES::Create(CreateBasicTaskRunner(thread));
  ASSERT_NE(queue, nullptr);
 
  std::atomic<int> first_job_count{0};
  std::atomic<int> second_job_count{0};
  fml::CountDownLatch latch(2);
 
  PipelineDescriptor desc;
 
  queue->PostJobForDescriptor(desc, [&]() {
    first_job_count++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc, [&]() {
    second_job_count++;
    latch.CountDown();
  });
 
  latch.Wait();
 
  EXPECT_EQ(first_job_count, 1);
  EXPECT_EQ(second_job_count, 1);
  thread.Join();
}

References fml::CountDownLatch::CountDown(), impeller::PipelineCompileQueueGLES::Create(), fml::Thread::Join(), queue, and fml::CountDownLatch::Wait().

◆ TEST() [372/689]

impeller::testing::TEST	(	PipelineCompileQueueTest	,
		AddJobReturnsFalseForDuplicateDescriptor
	)

Definition at line 42 of file pipeline_compile_queue_unittests.cc.

                                                                         {
  TestPipelineCompileQueue queue;
  PipelineDescriptor desc;
  bool job1_executed = false;
  bool job2_executed = false;
  fml::closure job1 = [&job1_executed]() { job1_executed = true; };
  fml::closure job2 = [&job2_executed]() { job2_executed = true; };
 
  bool result1 = queue.AddJobForTest(desc, job1);
  bool result2 = queue.AddJobForTest(desc, job2);
 
  EXPECT_TRUE(result1);
  EXPECT_FALSE(result2);
}

References queue.

◆ TEST() [373/689]

impeller::testing::TEST	(	PipelineCompileQueueTest	,
		AddJobReturnsTrueForNewDescriptor
	)

Definition at line 32 of file pipeline_compile_queue_unittests.cc.

                                                                  {
  TestPipelineCompileQueue queue;
  PipelineDescriptor desc;
  bool job_executed = false;
  fml::closure job = [&job_executed]() { job_executed = true; };
 
  bool result = queue.AddJobForTest(desc, job);
  EXPECT_TRUE(result);
}

References queue.

◆ TEST() [374/689]

impeller::testing::TEST	(	PipelineCompileQueueTest	,
		FinishAllJobsDrainsQueue
	)

Definition at line 81 of file pipeline_compile_queue_unittests.cc.

                                                         {
  auto queue = std::make_shared<TestPipelineCompileQueue>();
  PipelineDescriptor desc;
  bool job_executed = false;
  fml::closure job = [&job_executed]() { job_executed = true; };
 
  queue->AddJobForTest(desc, job);
  EXPECT_TRUE(queue->HasPendingJobsForTest());
 
  queue.reset();
 
  EXPECT_TRUE(job_executed);
}

References queue.

◆ TEST() [375/689]

impeller::testing::TEST	(	PipelineCompileQueueTest	,
		HasPendingJobsReturnsCorrectState
	)

Definition at line 57 of file pipeline_compile_queue_unittests.cc.

                                                                  {
  TestPipelineCompileQueue queue;
  PipelineDescriptor desc;
  fml::closure job = []() {};
 
  EXPECT_FALSE(queue.HasPendingJobsForTest());
 
  queue.AddJobForTest(desc, job);
  EXPECT_TRUE(queue.HasPendingJobsForTest());
}

References queue.

◆ TEST() [376/689]

impeller::testing::TEST	(	PipelineCompileQueueTest	,
		PerformJobEagerlyExecutesJob
	)

Definition at line 68 of file pipeline_compile_queue_unittests.cc.

                                                             {
  TestPipelineCompileQueue queue;
  PipelineDescriptor desc;
  bool job_executed = false;
  fml::closure job = [&job_executed]() { job_executed = true; };
 
  queue.AddJobForTest(desc, job);
  queue.PerformJobEagerly(desc);
 
  EXPECT_TRUE(job_executed);
  EXPECT_FALSE(queue.HasPendingJobsForTest());
}

References queue.

◆ TEST() [377/689]

impeller::testing::TEST	(	PipelineCompileQueueVulkanTest	,
		CreateSucceedsWithValidTaskRunner
	)

Definition at line 20 of file pipeline_compile_queue_vulkan_unittests.cc.

                                                                        {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
  EXPECT_NE(queue, nullptr);
}

References fml::ConcurrentMessageLoop::Create(), impeller::PipelineCompileQueueVulkan::Create(), and queue.

◆ TEST() [378/689]

impeller::testing::TEST	(	PipelineCompileQueueVulkanTest	,
		MultipleJobsCompleteSuccessfully
	)

Definition at line 121 of file pipeline_compile_queue_vulkan_unittests.cc.

                                                                       {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
  ASSERT_NE(queue, nullptr);
 
  std::atomic<int> completed_jobs{0};
  fml::CountDownLatch latch(5);
 
  PipelineDescriptor desc1;
  desc1.SetSampleCount(SampleCount::kCount1);
  desc1.SetCullMode(CullMode::kNone);
 
  PipelineDescriptor desc2;
  desc2.SetSampleCount(SampleCount::kCount1);
  desc2.SetCullMode(CullMode::kFrontFace);
 
  PipelineDescriptor desc3;
  desc3.SetSampleCount(SampleCount::kCount1);
  desc3.SetCullMode(CullMode::kBackFace);
 
  PipelineDescriptor desc4;
  desc4.SetSampleCount(SampleCount::kCount4);
  desc4.SetCullMode(CullMode::kNone);
 
  PipelineDescriptor desc5;
  desc5.SetSampleCount(SampleCount::kCount4);
  desc5.SetCullMode(CullMode::kFrontFace);
 
  // Post 5 jobs with distinct descriptors
  queue->PostJobForDescriptor(desc1, [&]() {
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc2, [&]() {
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc3, [&]() {
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc4, [&]() {
    completed_jobs++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc5, [&]() {
    completed_jobs++;
    latch.CountDown();
  });
 
  latch.Wait();
 
  EXPECT_EQ(completed_jobs, 5);
}

References fml::CountDownLatch::CountDown(), fml::ConcurrentMessageLoop::Create(), impeller::PipelineCompileQueueVulkan::Create(), impeller::kBackFace, impeller::kCount1, impeller::kCount4, impeller::kFrontFace, impeller::kNone, queue, impeller::PipelineDescriptor::SetCullMode(), impeller::PipelineDescriptor::SetSampleCount(), and fml::CountDownLatch::Wait().

◆ TEST() [379/689]

impeller::testing::TEST	(	PipelineCompileQueueVulkanTest	,
		OnJobAddedProcessesJobsInParallel
	)

Definition at line 34 of file pipeline_compile_queue_vulkan_unittests.cc.

                                                                        {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
  ASSERT_NE(queue, nullptr);
 
  std::atomic<int> concurrent_jobs{0};
  std::atomic<int> max_concurrent{0};
  fml::CountDownLatch latch(3);
 
  PipelineDescriptor desc1;
  desc1.SetSampleCount(SampleCount::kCount1);
  desc1.SetCullMode(CullMode::kNone);
 
  PipelineDescriptor desc2;
  desc2.SetSampleCount(SampleCount::kCount1);
  desc2.SetCullMode(CullMode::kFrontFace);
 
  PipelineDescriptor desc3;
  desc3.SetSampleCount(SampleCount::kCount1);
  desc3.SetCullMode(CullMode::kBackFace);
 
  queue->PostJobForDescriptor(desc1, [&]() {
    int current = ++concurrent_jobs;
    int prev_max = max_concurrent.load();
    while (current > prev_max &&
           !max_concurrent.compare_exchange_weak(prev_max, current)) {
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    concurrent_jobs--;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc2, [&]() {
    int current = ++concurrent_jobs;
    int prev_max = max_concurrent.load();
    while (current > prev_max &&
           !max_concurrent.compare_exchange_weak(prev_max, current)) {
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    concurrent_jobs--;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc3, [&]() {
    int current = ++concurrent_jobs;
    int prev_max = max_concurrent.load();
    while (current > prev_max &&
           !max_concurrent.compare_exchange_weak(prev_max, current)) {
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    concurrent_jobs--;
    latch.CountDown();
  });
 
  latch.Wait();
 
  EXPECT_GE(max_concurrent.load(), 1);
}

References fml::CountDownLatch::CountDown(), fml::ConcurrentMessageLoop::Create(), impeller::PipelineCompileQueueVulkan::Create(), impeller::kBackFace, impeller::kCount1, impeller::kFrontFace, impeller::kNone, queue, impeller::PipelineDescriptor::SetCullMode(), impeller::PipelineDescriptor::SetSampleCount(), and fml::CountDownLatch::Wait().

◆ TEST() [380/689]

impeller::testing::TEST	(	PipelineCompileQueueVulkanTest	,
		PostJobDoesNothingWithNullClosure
	)

Definition at line 26 of file pipeline_compile_queue_vulkan_unittests.cc.

                                                                        {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
  ASSERT_NE(queue, nullptr);
 
  queue->PostJob(nullptr);
}

References fml::ConcurrentMessageLoop::Create(), impeller::PipelineCompileQueueVulkan::Create(), and queue.

◆ TEST() [381/689]

impeller::testing::TEST	(	PipelineCompileQueueVulkanTest	,
		PostJobForDescriptorWithDuplicateRunsEagerly
	)

Definition at line 93 of file pipeline_compile_queue_vulkan_unittests.cc.

                                                   {
  auto loop = fml::ConcurrentMessageLoop::Create();
  auto queue = PipelineCompileQueueVulkan::Create(loop->GetTaskRunner());
  ASSERT_NE(queue, nullptr);
 
  std::atomic<int> first_job_count{0};
  std::atomic<int> second_job_count{0};
  fml::CountDownLatch latch(2);
 
  PipelineDescriptor desc;
 
  queue->PostJobForDescriptor(desc, [&]() {
    first_job_count++;
    latch.CountDown();
  });
 
  queue->PostJobForDescriptor(desc, [&]() {
    second_job_count++;
    latch.CountDown();
  });
 
  latch.Wait();
 
  EXPECT_EQ(first_job_count, 1);
  EXPECT_EQ(second_job_count, 1);
}

References fml::CountDownLatch::CountDown(), fml::ConcurrentMessageLoop::Create(), impeller::PipelineCompileQueueVulkan::Create(), queue, and fml::CountDownLatch::Wait().

◆ TEST() [382/689]

impeller::testing::TEST	(	PipelineDescriptorTest	,
		PrimitiveTypeHashEquality
	)

Definition at line 13 of file pipeline_descriptor_unittests.cc.

                                                        {
  PipelineDescriptor descA;
  PipelineDescriptor descB;
 
  ASSERT_TRUE(descA.IsEqual(descB));
  ASSERT_EQ(descA.GetHash(), descB.GetHash());
 
  descA.SetPrimitiveType(PrimitiveType::kTriangleStrip);
 
  ASSERT_FALSE(descA.IsEqual(descB));
  ASSERT_NE(descA.GetHash(), descB.GetHash());
}

References impeller::PipelineDescriptor::GetHash(), impeller::PipelineDescriptor::IsEqual(), impeller::kTriangleStrip, and impeller::PipelineDescriptor::SetPrimitiveType().

◆ TEST() [383/689]

impeller::testing::TEST	(	PointTest	,
		CrossProductThreePoints
	)

Definition at line 357 of file point_unittests.cc.

                                         {
  // Colinear
  EXPECT_FLOAT_EQ(Point::Cross(Point(-1, 0), Point(0, 0), Point(1, 0)), 0);
  EXPECT_FLOAT_EQ(Point::Cross(Point(1, 0), Point(0, 0), Point(-1, 0)), 0);
 
  // Right turn
  EXPECT_FLOAT_EQ(Point::Cross(Point(-1, 0), Point(0, 0), Point(0, 1)), 1);
  EXPECT_FLOAT_EQ(Point::Cross(Point(-2, 0), Point(0, 0), Point(0, 2)), 4);
 
  // Left turn
  EXPECT_FLOAT_EQ(Point::Cross(Point(-1, 0), Point(0, 0), Point(0, -1)), -1);
  EXPECT_FLOAT_EQ(Point::Cross(Point(-2, 0), Point(0, 0), Point(0, -2)), -4);
 
  // Convenient values for a less obvious left turn.
  // p1 - p0 == (0, 0) - (3, -4) == (-3, 4)
  // p2 - p0 == (1, 2) - (3, -4) == (-2, 6)
  // product of the magnitude of the 2 legs and the sin of their angle
  // (||(-3, 4)||) * (||(-2, 6)||) * sin(angle)
  // 5 * sqrt(40) * sin(angle)
  // angle = arcsin(4 / 5) - arcsin(6 / sqrt(40)) ~= -18.4349
  // sin(angle) ~= -0.316227766
  // 5 * sqrt(40) * sin(angle) == -10
  // The math is cleaner with the cross product:
  // (-3 * 6) - (-2 * 4) == -18 - -8 == -10
  EXPECT_FLOAT_EQ(Point::Cross(Point(3, -4), Point(0, 0), Point(1, 2)), -10);
}

References impeller::TPoint< Scalar >::Cross().

◆ TEST() [384/689]

impeller::testing::TEST	(	PointTest	,
		Distance
	)

Definition at line 37 of file point_unittests.cc.

                          {
  for (int j = 0; j < 21; j++) {
    for (int i = 0; i < 21; i++) {
      {
        Scalar d = i - j;
 
        EXPECT_EQ(Point(i, 0).GetDistanceSquared(Point(j, 0)), d * d)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(0, i).GetDistanceSquared(Point(0, j)), d * d)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(j, 0).GetDistanceSquared(Point(i, 0)), d * d)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(0, j).GetDistanceSquared(Point(0, i)), d * d)
            << "i: " << i << ", j: " << j;
 
        EXPECT_EQ(Point(i, 0).GetDistance(Point(j, 0)), std::abs(d))
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(0, i).GetDistance(Point(0, j)), std::abs(d))
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(j, 0).GetDistance(Point(i, 0)), std::abs(d))
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(0, j).GetDistance(Point(0, i)), std::abs(d))
            << "i: " << i << ", j: " << j;
      }
 
      {
        Scalar d_squared = i * i + j * j;
 
        EXPECT_EQ(Point(i, 0).GetDistanceSquared(Point(0, j)), d_squared)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(-i, 0).GetDistanceSquared(Point(0, j)), d_squared)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(i, 0).GetDistanceSquared(Point(0, -j)), d_squared)
            << "i: " << i << ", j: " << j;
        EXPECT_EQ(Point(-i, 0).GetDistanceSquared(Point(0, -j)), d_squared)
            << "i: " << i << ", j: " << j;
 
        Scalar d = std::sqrt(d_squared);
 
        EXPECT_FLOAT_EQ(Point(i, 0).GetDistance(Point(0, j)), d)
            << "i: " << i << ", j: " << j;
        EXPECT_FLOAT_EQ(Point(-i, 0).GetDistance(Point(0, j)), d)
            << "i: " << i << ", j: " << j;
        EXPECT_FLOAT_EQ(Point(i, 0).GetDistance(Point(0, -j)), d)
            << "i: " << i << ", j: " << j;
        EXPECT_FLOAT_EQ(Point(-i, 0).GetDistance(Point(0, -j)), d)
            << "i: " << i << ", j: " << j;
      }
    }
  }
}

References d, and i.

◆ TEST() [385/689]

impeller::testing::TEST	(	PointTest	,
		Length
	)

Definition at line 13 of file point_unittests.cc.

                        {
  for (int i = 0; i < 21; i++) {
    EXPECT_EQ(Point(i, 0).GetLengthSquared(), i * i) << "i: " << i;
    EXPECT_EQ(Point(0, i).GetLengthSquared(), i * i) << "i: " << i;
    EXPECT_EQ(Point(-i, 0).GetLengthSquared(), i * i) << "i: " << i;
    EXPECT_EQ(Point(0, -i).GetLengthSquared(), i * i) << "i: " << i;
 
    EXPECT_EQ(Point(i, 0).GetLength(), i) << "i: " << i;
    EXPECT_EQ(Point(0, i).GetLength(), i) << "i: " << i;
    EXPECT_EQ(Point(-i, 0).GetLength(), i) << "i: " << i;
    EXPECT_EQ(Point(0, -i).GetLength(), i) << "i: " << i;
 
    EXPECT_EQ(Point(i, i).GetLengthSquared(), 2 * i * i) << "i: " << i;
    EXPECT_EQ(Point(-i, i).GetLengthSquared(), 2 * i * i) << "i: " << i;
    EXPECT_EQ(Point(i, -i).GetLengthSquared(), 2 * i * i) << "i: " << i;
    EXPECT_EQ(Point(-i, -i).GetLengthSquared(), 2 * i * i) << "i: " << i;
 
    EXPECT_FLOAT_EQ(Point(i, i).GetLength(), kSqrt2 * i) << "i: " << i;
    EXPECT_FLOAT_EQ(Point(-i, i).GetLength(), kSqrt2 * i) << "i: " << i;
    EXPECT_FLOAT_EQ(Point(i, -i).GetLength(), kSqrt2 * i) << "i: " << i;
    EXPECT_FLOAT_EQ(Point(-i, -i).GetLength(), kSqrt2 * i) << "i: " << i;
  }
}

References i, and impeller::kSqrt2.

◆ TEST() [386/689]

impeller::testing::TEST	(	PointTest	,
		PerpendicularLeft
	)

Definition at line 89 of file point_unittests.cc.

                                   {
  EXPECT_EQ(Point(1, 0).PerpendicularLeft(), Point(0, -1));
  EXPECT_EQ(Point(0, 1).PerpendicularLeft(), Point(1, 0));
  EXPECT_EQ(Point(-1, 0).PerpendicularLeft(), Point(0, 1));
  EXPECT_EQ(Point(0, -1).PerpendicularLeft(), Point(-1, 0));
 
  EXPECT_EQ(Point(1, 1).PerpendicularLeft(), Point(1, -1));
  EXPECT_EQ(Point(-1, 1).PerpendicularLeft(), Point(1, 1));
  EXPECT_EQ(Point(-1, -1).PerpendicularLeft(), Point(-1, 1));
  EXPECT_EQ(Point(1, -1).PerpendicularLeft(), Point(-1, -1));
}

◆ TEST() [387/689]

impeller::testing::TEST	(	PointTest	,
		PerpendicularRight
	)

Definition at line 101 of file point_unittests.cc.

                                    {
  EXPECT_EQ(Point(1, 0).PerpendicularRight(), Point(0, 1));
  EXPECT_EQ(Point(0, 1).PerpendicularRight(), Point(-1, 0));
  EXPECT_EQ(Point(-1, 0).PerpendicularRight(), Point(0, -1));
  EXPECT_EQ(Point(0, -1).PerpendicularRight(), Point(1, 0));
 
  EXPECT_EQ(Point(1, 1).PerpendicularRight(), Point(-1, 1));
  EXPECT_EQ(Point(-1, 1).PerpendicularRight(), Point(-1, -1));
  EXPECT_EQ(Point(-1, -1).PerpendicularRight(), Point(1, -1));
  EXPECT_EQ(Point(1, -1).PerpendicularRight(), Point(1, 1));
}

◆ TEST() [388/689]

impeller::testing::TEST	(	PointTest	,
		PointToSegment
	)

Definition at line 137 of file point_unittests.cc.

                                {
  // Horizontal segment and points to the left of it on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({0,10} through {10,10})
      {0, 10}, {1, 0}, 11,
      // Distance computation
      [](Point p) {
        Scalar d = 10 - p.x;
        return std::make_pair(d, d * d);
      });
 
  // Horizontal segment and points on the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({11,10} through {19, 10})
      {11, 10}, {1, 0}, 9,
      // Distance computation
      [](Point p) {  //
        return std::make_pair(0.0f, 0.0f);
      });
 
  // Horizontal segment and points to the right of it on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({20,10} through {30,10})
      {20, 10}, {1, 0}, 11,
      // Distance computation
      [](Point p) {
        Scalar d = p.x - 20;
        return std::make_pair(d, d * d);
      });
 
  // Vertical segment and points above the top of it on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({10,0} through {10,10})
      {10, 0}, {0, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d = 10 - p.y;
        return std::make_pair(d, d * d);
      });
 
  // Vertical segment and points on the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({10,11} through {10, 19})
      {10, 11}, {0, 1}, 9,
      // Distance computation
      [](Point p) {  //
        return std::make_pair(0.0f, 0.0f);
      });
 
  // Vertical segment and points below the bottom of it on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({10,20} through {10,30})
      {10, 20}, {0, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d = p.y - 20;
        return std::make_pair(d, d * d);
      });
 
  // Horizontal segment and points 5 pixels above and to the left of it
  // on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({0,5} through {10,5})
      {0, 5}, {1, 0}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (10 - p.x) * (10 - p.x) + 25;
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Horizontal segment and points 5 pixels directly above the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({11,5} through {19, 5})
      {11, 5}, {1, 0}, 9,
      // Distance computation
      [](Point p) {  //
        return std::make_pair(5.0f, 25.0f);
      });
 
  // Horizontal segment and points 5 pixels above and to the right of it
  // on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 10},
      // Starting point, delta, count ({20,5} through {30,5})
      {20, 5}, {1, 0}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (p.x - 20) * (p.x - 20) + 25;
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Vertical segment and points 5 pixels to the left and above the segment
  // on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({5,0} through {5,10})
      {5, 0}, {0, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = 25 + (10 - p.y) * (10 - p.y);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Vertical segment and points 5 pixels directly to the left of the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({5,11} through {5,19,})
      {5, 11}, {0, 1}, 9,
      // Distance computation
      [](Point p) {  //
        return std::make_pair(5.0f, 25.0f);
      });
 
  // Vertical segment and points 5 pixels to the left and below the segment
  // on the same line.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {10, 20},
      // Starting point, delta, count ({20,5} through {30,5})
      {5, 20}, {0, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = 25 + (p.y - 20) * (p.y - 20);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points up and to the right of the top of the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({5,-5} through {15,5})
      {5, -5}, {1, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (p.x - 10) * (p.x - 10) + (p.y - 10) * (p.y - 10);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points up and to the right of the segment itself.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({15,5} through {24,14})
      {15, 5}, {1, 1}, 9,
      // Distance computation
      [](Point p) {
        Scalar d_sq = 50.0f;
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points up and to the right of the bottom of the
  // segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({25,15} through {35,25})
      {25, 15}, {1, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (p.x - 20) * (p.x - 20) + (p.y - 20) * (p.y - 20);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points down and to the left of the top of the segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({-5,5} through {5,15})
      {-5, 5}, {1, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (p.x - 10) * (p.x - 10) + (p.y - 10) * (p.y - 10);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points down and to the left of the segment itself.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({5,15} through {14,24})
      {5, 15}, {1, 1}, 9,
      // Distance computation
      [](Point p) {
        Scalar d_sq = 50.0f;
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
 
  // Diagonal segment and points down and to the left of the bottom of the
  // segment.
  TestPointToSegmentGroup(
      // Segment
      {10, 10}, {20, 20},
      // Starting point, delta, count ({15,25} through {25,35})
      {15, 25}, {1, 1}, 11,
      // Distance computation
      [](Point p) {
        Scalar d_sq = (p.x - 20) * (p.x - 20) + (p.y - 20) * (p.y - 20);
        return std::make_pair(std::sqrt(d_sq), d_sq);
      });
}

References d.

◆ TEST() [389/689]

impeller::testing::TEST	(	PoolTest	,
		Overload
	)

Definition at line 47 of file pool_unittests.cc.

                         {
  Pool<Foobar> pool(1'000);
  {
    std::vector<std::shared_ptr<Foobar>> values;
    values.reserve(20);
    for (int i = 0; i < 20; i++) {
      values.push_back(pool.Grab());
    }
    for (const auto& value : values) {
      value->SetSize(100);
      pool.Recycle(value);
    }
  }
  EXPECT_EQ(pool.GetSize(), 1'000u);
}

References impeller::Pool< T >::GetSize(), impeller::Pool< T >::Grab(), i, impeller::Pool< T >::Recycle(), and value.

◆ TEST() [390/689]

impeller::testing::TEST	(	PoolTest	,
		Simple
	)

Definition at line 33 of file pool_unittests.cc.

                       {
  Pool<Foobar> pool(1'000);
  {
    auto grabbed = pool.Grab();
    grabbed->SetSize(123);
    pool.Recycle(grabbed);
    EXPECT_EQ(pool.GetSize(), 123u);
  }
  auto grabbed = pool.Grab();
  EXPECT_EQ(grabbed->GetSize(), 123u);
  EXPECT_TRUE(grabbed->GetIsReset());
  EXPECT_EQ(pool.GetSize(), 0u);
}

References impeller::Pool< T >::GetSize(), impeller::Pool< T >::Grab(), and impeller::Pool< T >::Recycle().

◆ TEST() [391/689]

impeller::testing::TEST	(	ProcTableGLES	,
		CheckFrameBufferStatusDebugOnly
	)

Definition at line 39 of file proc_table_gles_unittests.cc.

                                                     {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
#ifdef IMPELLER_DEBUG
  EXPECT_CALL(*mock_gles_impl, CheckFramebufferStatus(_)).Times(1);
#else
  EXPECT_CALL(*mock_gles_impl, CheckFramebufferStatus(_)).Times(0);
#endif
  auto mock_gles = MockGLES::Init(std::move(mock_gles_impl));
  mock_gles->GetProcTable().CheckFramebufferStatusDebug(0);
}

References impeller::testing::MockGLES::Init().

◆ TEST() [392/689]

impeller::testing::TEST	(	ProcTableGLES	,
		GLES2VertexAttribDivisor
	)

Definition at line 50 of file proc_table_gles_unittests.cc.

                                              {
  const auto extensions = std::vector<const char*>{"GL_EXT_instanced_arrays"};
  auto mock_gles = MockGLES::Init(extensions);
  EXPECT_TRUE(mock_gles->GetProcTable().VertexAttribDivisorEXT.IsAvailable());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [393/689]

impeller::testing::TEST	(	ProcTableGLES	,
		GLES3VertexAttribDivisor
	)

Definition at line 56 of file proc_table_gles_unittests.cc.

                                              {
  auto mock_gles = MockGLES::Init();
  EXPECT_FALSE(mock_gles->GetProcTable().VertexAttribDivisorEXT.IsAvailable());
  EXPECT_TRUE(mock_gles->GetProcTable().VertexAttribDivisor.IsAvailable());
}

References impeller::testing::MockGLES::Init().

◆ TEST() [394/689]

impeller::testing::TEST	(	ProcTableGLES	,
		ResolvesCorrectClearDepthProcOnDesktopGL
	)

Definition at line 31 of file proc_table_gles_unittests.cc.

                                                              {
  auto mock_gles = MockGLES::Init(std::nullopt, "OpenGL 4.0");
  EXPECT_FALSE(mock_gles->GetProcTable().GetDescription()->IsES());
 
  FOR_EACH_IMPELLER_DESKTOP_ONLY_PROC(EXPECT_AVAILABLE);
  FOR_EACH_IMPELLER_ES_ONLY_PROC(EXPECT_UNAVAILABLE);
}

References EXPECT_AVAILABLE, EXPECT_UNAVAILABLE, FOR_EACH_IMPELLER_DESKTOP_ONLY_PROC, FOR_EACH_IMPELLER_ES_ONLY_PROC, and impeller::testing::MockGLES::Init().

◆ TEST() [395/689]

impeller::testing::TEST	(	ProcTableGLES	,
		ResolvesCorrectClearDepthProcOnES
	)

Definition at line 23 of file proc_table_gles_unittests.cc.

                                                       {
  auto mock_gles = MockGLES::Init(std::nullopt, "OpenGL ES 3.0");
  EXPECT_TRUE(mock_gles->GetProcTable().GetDescription()->IsES());
 
  FOR_EACH_IMPELLER_ES_ONLY_PROC(EXPECT_AVAILABLE);
  FOR_EACH_IMPELLER_DESKTOP_ONLY_PROC(EXPECT_UNAVAILABLE);
}

References EXPECT_AVAILABLE, EXPECT_UNAVAILABLE, FOR_EACH_IMPELLER_DESKTOP_ONLY_PROC, FOR_EACH_IMPELLER_ES_ONLY_PROC, and impeller::testing::MockGLES::Init().

◆ TEST() [396/689]

impeller::testing::TEST	(	ReactorGLES	,
		CanAttachCleanupCallbacksToHandles
	)

Definition at line 30 of file reactor_unittests.cc.

                                                      {
  auto mock_gles = MockGLES::Init();
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  int value = 0;
  auto handle = reactor->CreateHandle(HandleType::kTexture, 1123);
  auto added =
      reactor->RegisterCleanupCallback(handle, [&value]() { value++; });
 
  EXPECT_TRUE(added);
  EXPECT_TRUE(reactor->React());
 
  reactor->CollectHandle(handle);
  EXPECT_TRUE(reactor->AddOperation([](const ReactorGLES& reactor) {}));
  EXPECT_TRUE(reactor->React());
  EXPECT_EQ(value, 1);
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, impeller::kTexture, reactor, and value.

◆ TEST() [397/689]

impeller::testing::TEST	(	ReactorGLES	,
		CanDeferOperations
	)

Definition at line 159 of file reactor_unittests.cc.

                                      {
  auto mock_gles = MockGLES::Init();
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  // Add operation executes tasks as long as the reactor can run tasks on
  // the current thread.
  bool did_run = false;
  EXPECT_TRUE(
      reactor->AddOperation([&](const ReactorGLES&) { did_run = true; }));
  EXPECT_TRUE(did_run);
 
  //...unless defer=true is specified, which only enqueues in the reactor.
  did_run = false;
  EXPECT_TRUE(reactor->AddOperation([&](const ReactorGLES&) { did_run = true; },
                                    /*defer=*/true));
  EXPECT_FALSE(did_run);
  EXPECT_TRUE(reactor->React());
  EXPECT_TRUE(did_run);
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, and reactor.

◆ TEST() [398/689]

impeller::testing::TEST	(	ReactorGLES	,
		DeletesHandlesDuringShutdown
	)

Definition at line 52 of file reactor_unittests.cc.

                                                {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _))
      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
  EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234)))
      .Times(1);
 
  std::shared_ptr<MockGLES> mock_gles =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
  reactor->CreateHandle(HandleType::kTexture);
  reactor.reset();
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, impeller::kTexture, reactor, and flutter::size.

◆ TEST() [399/689]

impeller::testing::TEST	(	ReactorGLES	,
		FramebufferDeletedOnOwnerThread
	)

Definition at line 183 of file reactor_unittests.cc.

                                                   {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, GenFramebuffers(1, _))
      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
 
  std::shared_ptr<MockGLES> mock_gles =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  HandleGLES handle = reactor->CreateHandle(HandleType::kFrameBuffer);
 
  std::thread::id cleanup_thread;
  reactor->RegisterCleanupCallback(
      handle, [&]() { cleanup_thread = std::this_thread::get_id(); });
 
  reactor->CollectHandle(handle);
 
  std::thread thread([&] {
    EXPECT_TRUE(reactor->AddOperation([](const ReactorGLES& reactor) {}));
    EXPECT_TRUE(reactor->React());
  });
  thread.join();
 
  EXPECT_EQ(cleanup_thread, std::thread::id());
 
  EXPECT_TRUE(reactor->AddOperation([](const ReactorGLES& reactor) {}));
  EXPECT_TRUE(reactor->React());
  EXPECT_EQ(cleanup_thread, std::this_thread::get_id());
}

References impeller::testing::MockGLES::Init(), impeller::kFrameBuffer, kMockResolverGLES, reactor, and flutter::size.

◆ TEST() [400/689]

impeller::testing::TEST	(	ReactorGLES	,
		NameUntrackedHandle
	)

Definition at line 99 of file reactor_unittests.cc.

                                       {
  auto mock_gles_impl = std::make_unique<NiceMock<MockGLESImpl>>();
  NiceMock<MockGLESImpl>* raw_mock_gles = mock_gles_impl.get();
 
  std::shared_ptr<MockGLES> mock_gles =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
 
  if (!proc_table->SupportsDebugLabels()) {
    GTEST_SKIP() << "This device doesn't support labelling.";
  }
 
  EXPECT_CALL(*raw_mock_gles, GenTextures(1, _))
      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
  EXPECT_CALL(*raw_mock_gles,
              ObjectLabelKHR(_, 1234, _, ::testing::StrEq("hello, joe!")))
      .Times(1);
  ON_CALL(*raw_mock_gles, IsTexture).WillByDefault(::testing::Return(GL_TRUE));
 
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture);
  reactor->SetDebugLabel(handle, "hello, joe!");
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, impeller::kTexture, reactor, and flutter::size.

◆ TEST() [401/689]

impeller::testing::TEST	(	ReactorGLES	,
		PerThreadOperationQueues
	)

Definition at line 127 of file reactor_unittests.cc.

                                            {
  auto mock_gles = MockGLES::Init();
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  bool op1_called = false;
  EXPECT_TRUE(
      reactor->AddOperation([&](const ReactorGLES&) { op1_called = true; }));
 
  fml::AutoResetWaitableEvent event;
  bool op2_called = false;
  std::thread thread([&] {
    EXPECT_TRUE(reactor->AddOperation(
        [&](const ReactorGLES&) { op2_called = true; }, true));
    event.Wait();
    EXPECT_TRUE(reactor->React());
  });
 
  // Reacting on the main thread should only run the main thread's operation.
  EXPECT_TRUE(reactor->React());
  EXPECT_TRUE(op1_called);
  EXPECT_FALSE(op2_called);
 
  // Reacting on the second thread will run the second thread's operation.
  event.Signal();
  thread.join();
  EXPECT_TRUE(op2_called);
}

References impeller::testing::MockGLES::Init(), kMockResolverGLES, and reactor.

◆ TEST() [402/689]

impeller::testing::TEST	(	ReactorGLES	,
		UntrackedHandle
	)

Definition at line 71 of file reactor_unittests.cc.

                                   {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _))
      .WillOnce([](GLsizei size, GLuint* queries) { queries[0] = 1234; });
  EXPECT_CALL(*mock_gles_impl, DeleteTextures(1, ::testing::Pointee(1234)))
      .Times(1);
 
  std::shared_ptr<MockGLES> mock_gles =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  HandleGLES handle = reactor->CreateUntrackedHandle(HandleType::kTexture);
  EXPECT_FALSE(handle.IsDead());
  std::optional<GLuint> glint = reactor->GetGLHandle(handle);
  EXPECT_TRUE(glint.has_value());
  if (glint.has_value()) {
    EXPECT_EQ(1234u, *glint);
  }
  reactor->CollectHandle(handle);
  EXPECT_TRUE(reactor->AddOperation([&](const ReactorGLES&) {}));
  EXPECT_TRUE(reactor->React());
}

References impeller::testing::MockGLES::Init(), impeller::HandleGLES::IsDead(), kMockResolverGLES, impeller::kTexture, reactor, and flutter::size.

◆ TEST() [403/689]

impeller::testing::TEST	(	RectTest	,
		ContainsFloatingPoint
	)

Definition at line 1553 of file rect_unittests.cc.

                                      {
  auto rect1 =
      Rect::MakeXYWH(472.599945f, 440.999969f, 1102.80005f, 654.000061f);
  auto rect2 = Rect::MakeXYWH(724.f, 618.f, 600.f, 300.f);
  EXPECT_TRUE(rect1.Contains(rect2));
}

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [404/689]

impeller::testing::TEST	(	RectTest	,
		EmptyIRectDoesNotIntersect
	)

Definition at line 1023 of file rect_unittests.cc.

                                           {
  IRect rect = IRect::MakeLTRB(50, 50, 100, 100);
 
  auto test = [&rect](int64_t l, int64_t t, int64_t r, int64_t b,
                      const std::string& label) {
    EXPECT_FALSE(IRect::MakeLTRB(l, b, r, t).IntersectsWithRect(rect))
        << label << " with Top/Bottom swapped";
    EXPECT_FALSE(IRect::MakeLTRB(r, b, l, t).IntersectsWithRect(rect))
        << label << " with Left/Right swapped";
    EXPECT_FALSE(IRect::MakeLTRB(r, t, l, b).IntersectsWithRect(rect))
        << label << " with all sides swapped";
  };
 
  test(20, 20, 30, 30, "Above and Left");
  test(70, 20, 80, 30, "Above");
  test(120, 20, 130, 30, "Above and Right");
  test(120, 70, 130, 80, "Right");
  test(120, 120, 130, 130, "Below and Right");
  test(70, 120, 80, 130, "Below");
  test(20, 120, 30, 130, "Below and Left");
  test(20, 70, 30, 80, "Left");
 
  test(70, 70, 80, 80, "Inside");
 
  test(40, 70, 60, 80, "Straddling Left");
  test(70, 40, 80, 60, "Straddling Top");
  test(90, 70, 110, 80, "Straddling Right");
  test(70, 90, 80, 110, "Straddling Bottom");
}

References impeller::TRect< T >::MakeLTRB().

◆ TEST() [405/689]

impeller::testing::TEST	(	RectTest	,
		EmptyRectDoesNotIntersect
	)

Definition at line 993 of file rect_unittests.cc.

                                          {
  Rect rect = Rect::MakeLTRB(50, 50, 100, 100);
 
  auto test = [&rect](Scalar l, Scalar t, Scalar r, Scalar b,
                      const std::string& label) {
    EXPECT_FALSE(Rect::MakeLTRB(l, b, r, t).IntersectsWithRect(rect))
        << label << " with Top/Bottom swapped";
    EXPECT_FALSE(Rect::MakeLTRB(r, b, l, t).IntersectsWithRect(rect))
        << label << " with Left/Right swapped";
    EXPECT_FALSE(Rect::MakeLTRB(r, t, l, b).IntersectsWithRect(rect))
        << label << " with all sides swapped";
  };
 
  test(20, 20, 30, 30, "Above and Left");
  test(70, 20, 80, 30, "Above");
  test(120, 20, 130, 30, "Above and Right");
  test(120, 70, 130, 80, "Right");
  test(120, 120, 130, 130, "Below and Right");
  test(70, 120, 80, 130, "Below");
  test(20, 120, 30, 130, "Below and Left");
  test(20, 70, 30, 80, "Left");
 
  test(70, 70, 80, 80, "Inside");
 
  test(40, 70, 60, 80, "Straddling Left");
  test(70, 40, 80, 60, "Straddling Top");
  test(90, 70, 110, 80, "Straddling Right");
  test(70, 90, 80, 110, "Straddling Bottom");
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [406/689]

impeller::testing::TEST	(	RectTest	,
		FloatContainsInteger
	)

Definition at line 1560 of file rect_unittests.cc.

                                     {
  auto rect1 =
      Rect::MakeLTRB(472.599945f, 440.999969f, 1574.80005f, 1094.000000f);
  EXPECT_TRUE(rect1.Contains(IRect::MakeLTRB(473, 441, 1574, 1094)));
 
  // Now test failure to contain same rect expanded by 1 on each side
  EXPECT_FALSE(rect1.Contains(IRect::MakeLTRB(472, 441, 1574, 1094)));
  EXPECT_FALSE(rect1.Contains(IRect::MakeLTRB(473, 440, 1574, 1094)));
  EXPECT_FALSE(rect1.Contains(IRect::MakeLTRB(473, 441, 1575, 1094)));
  EXPECT_FALSE(rect1.Contains(IRect::MakeLTRB(473, 441, 1574, 1095)));
}

References impeller::TRect< T >::MakeLTRB(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [407/689]

impeller::testing::TEST	(	RectTest	,
		GetCenter
	)

Definition at line 1363 of file rect_unittests.cc.

                          {
  EXPECT_EQ(Rect::MakeXYWH(10, 30, 20, 20).GetCenter(), Point(20, 40));
  EXPECT_EQ(Rect::MakeXYWH(10, 30, 20, 19).GetCenter(), Point(20, 39.5));
  EXPECT_EQ(Rect::MakeMaximum().GetCenter(), Point(0, 0));
 
  // Note that we expect a Point as the answer from an IRect
  EXPECT_EQ(IRect::MakeXYWH(10, 30, 20, 20).GetCenter(), Point(20, 40));
  EXPECT_EQ(IRect::MakeXYWH(10, 30, 20, 19).GetCenter(), Point(20, 39.5));
  EXPECT_EQ(IRect::MakeMaximum().GetCenter(), Point(0, 0));
}

References impeller::TRect< T >::MakeMaximum(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [408/689]

impeller::testing::TEST	(	RectTest	,
		IRectArea
	)

Definition at line 1149 of file rect_unittests.cc.

                          {
  EXPECT_EQ(IRect::MakeXYWH(0, 0, 100, 200).Area(), 20000);
  EXPECT_EQ(IRect::MakeXYWH(10, 20, 100, 200).Area(), 20000);
  EXPECT_EQ(IRect::MakeXYWH(0, 0, 200, 100).Area(), 20000);
  EXPECT_EQ(IRect::MakeXYWH(10, 20, 200, 100).Area(), 20000);
  EXPECT_EQ(IRect::MakeXYWH(0, 0, 100, 100).Area(), 10000);
  EXPECT_EQ(IRect::MakeXYWH(10, 20, 100, 100).Area(), 10000);
}

References impeller::TRect< T >::MakeXYWH().

◆ TEST() [409/689]

impeller::testing::TEST	(	RectTest	,
		IRectContainsInclusiveIPoint
	)

Definition at line 2653 of file rect_unittests.cc.

                                             {
  auto check_empty_flips = [](const IRect& rect, const IPoint& point,
                              const std::string& label) {
    ASSERT_FALSE(rect.IsEmpty());
 
    EXPECT_FALSE(flip_lr(rect).ContainsInclusive(point)) << label;
    EXPECT_FALSE(flip_tb(rect).ContainsInclusive(point)) << label;
    EXPECT_FALSE(flip_lrtb(rect).ContainsInclusive(point)) << label;
  };
 
  auto test_inside = [&check_empty_flips](const IRect& rect,
                                          const IPoint& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_TRUE(rect.ContainsInclusive(point)) << label;
    check_empty_flips(rect, point, label);
  };
 
  auto test_outside = [&check_empty_flips](const IRect& rect,
                                           const IPoint& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_FALSE(rect.ContainsInclusive(point)) << label;
    check_empty_flips(rect, point, label);
  };
 
  {
    // Origin is inclusive
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(100, 100);
 
    test_inside(r, p);
  }
  {
    // Size is inclusive
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(200, 200);
 
    test_inside(r, p);
  }
  {
    // Size + "epsilon" is exclusive
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(201, 201);
 
    test_outside(r, p);
  }
  {
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(99, 99);
 
    test_outside(r, p);
  }
  {
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(199, 199);
 
    test_inside(r, p);
  }
 
  {
    auto r = IRect::MakeMaximum();
    auto p = IPoint(199, 199);
 
    test_inside(r, p);
  }
}

References impeller::TRect< T >::ContainsInclusive(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [410/689]

impeller::testing::TEST	(	RectTest	,
		IRectContainsIPoint
	)

Definition at line 2491 of file rect_unittests.cc.

                                    {
  auto check_empty_flips = [](const IRect& rect, const IPoint& point,
                              const std::string& label) {
    ASSERT_FALSE(rect.IsEmpty());
 
    EXPECT_FALSE(flip_lr(rect).Contains(point)) << label;
    EXPECT_FALSE(flip_tb(rect).Contains(point)) << label;
    EXPECT_FALSE(flip_lrtb(rect).Contains(point)) << label;
  };
 
  auto test_inside = [&check_empty_flips](const IRect& rect,
                                          const IPoint& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_TRUE(rect.Contains(point)) << label;
    check_empty_flips(rect, point, label);
  };
 
  auto test_outside = [&check_empty_flips](const IRect& rect,
                                           const IPoint& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_FALSE(rect.Contains(point)) << label;
    check_empty_flips(rect, point, label);
  };
 
  {
    // Origin is inclusive
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(100, 100);
 
    test_inside(r, p);
  }
  {
    // Size is exclusive
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(200, 200);
 
    test_outside(r, p);
  }
  {
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(99, 99);
 
    test_outside(r, p);
  }
  {
    auto r = IRect::MakeXYWH(100, 100, 100, 100);
    auto p = IPoint(199, 199);
 
    test_inside(r, p);
  }
 
  {
    auto r = IRect::MakeMaximum();
    auto p = IPoint(199, 199);
 
    test_inside(r, p);
  }
}

References impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [411/689]

impeller::testing::TEST	(	RectTest	,
		IRectContainsIRect
	)

Definition at line 2844 of file rect_unittests.cc.

                                   {
  auto check_empty_flips = [](const IRect& a, const IRect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // test b rects are allowed to have 0 w/h, but not be backwards
    ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
 
    // unflipped a vs flipped (empty) b yields true
    EXPECT_TRUE(a.Contains(flip_lr(b))) << label;
    EXPECT_TRUE(a.Contains(flip_tb(b))) << label;
    EXPECT_TRUE(a.Contains(flip_lrtb(b))) << label;
 
    // flipped (empty) a vs unflipped b yields false
    EXPECT_FALSE(flip_lr(a).Contains(b)) << label;
    EXPECT_FALSE(flip_tb(a).Contains(b)) << label;
    EXPECT_FALSE(flip_lrtb(a).Contains(b)) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).Contains(flip_lr(b))) << label;
    EXPECT_FALSE(flip_tb(a).Contains(flip_tb(b))) << label;
    EXPECT_FALSE(flip_lrtb(a).Contains(flip_lrtb(b))) << label;
  };
 
  auto test_inside = [&check_empty_flips](const IRect& a, const IRect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // test b rects are allowed to have 0 w/h, but not be backwards
    ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
 
    std::stringstream stream;
    stream << a << " contains " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.Contains(b)) << label;
    check_empty_flips(a, b, label);
  };
 
  auto test_not_inside = [&check_empty_flips](const IRect& a, const IRect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // If b was empty, it would be contained and should not be tested with
    // this function - use |test_inside| instead.
    ASSERT_FALSE(b.IsEmpty()) << b;
 
    std::stringstream stream;
    stream << a << " contains " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.Contains(b)) << label;
    check_empty_flips(a, b, label);
  };
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
 
    test_inside(a, a);
  }
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 0, 0);
 
    test_inside(a, b);
  }
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(150, 150, 20, 20);
 
    test_inside(a, b);
  }
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(150, 150, 100, 100);
 
    test_not_inside(a, b);
  }
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(50, 50, 100, 100);
 
    test_not_inside(a, b);
  }
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 300, 300);
 
    test_not_inside(a, b);
  }
  {
    auto a = IRect::MakeMaximum();
    auto b = IRect::MakeXYWH(0, 0, 300, 300);
 
    test_inside(a, b);
  }
}

References impeller::TRect< T >::Contains(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [412/689]

impeller::testing::TEST	(	RectTest	,
		IRectCopy
	)

Definition at line 810 of file rect_unittests.cc.

                          {
  IRect rect = IRect::MakeLTRB(5, 10, 20, 25);
  IRect copy = rect;
 
  EXPECT_EQ(rect, copy);
  EXPECT_EQ(copy.GetLeft(), 5);
  EXPECT_EQ(copy.GetTop(), 10);
  EXPECT_EQ(copy.GetRight(), 20);
  EXPECT_EQ(copy.GetBottom(), 25);
  EXPECT_EQ(copy.GetX(), 5);
  EXPECT_EQ(copy.GetY(), 10);
  EXPECT_EQ(copy.GetWidth(), 15);
  EXPECT_EQ(copy.GetHeight(), 15);
  EXPECT_FALSE(copy.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [413/689]

impeller::testing::TEST	(	RectTest	,
		IRectCutOut
	)

Definition at line 3089 of file rect_unittests.cc.

                            {
  IRect cull_rect = IRect::MakeLTRB(20, 20, 40, 40);
 
  auto check_empty_flips = [&cull_rect](const IRect& diff_rect,
                                        const std::string& label) {
    EXPECT_FALSE(diff_rect.IsEmpty());
    EXPECT_FALSE(cull_rect.IsEmpty());
 
    // unflipped cull_rect vs flipped(empty) diff_rect
    // == cull_rect
    EXPECT_TRUE(cull_rect.Cutout(flip_lr(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_lr(diff_rect)), cull_rect) << label;
    EXPECT_TRUE(cull_rect.Cutout(flip_tb(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_tb(diff_rect)), cull_rect) << label;
    EXPECT_TRUE(cull_rect.Cutout(flip_lrtb(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_lrtb(diff_rect)), cull_rect) << label;
 
    // flipped(empty) cull_rect vs flipped(empty) diff_rect
    // == empty
    EXPECT_FALSE(flip_lr(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
    EXPECT_FALSE(flip_tb(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
    EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(diff_rect), IRect()) << label;
 
    // flipped(empty) cull_rect vs unflipped diff_rect
    // == empty
    EXPECT_FALSE(flip_lr(cull_rect).Cutout(flip_lr(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(flip_lr(diff_rect)), IRect())
        << label;
    EXPECT_FALSE(flip_tb(cull_rect).Cutout(flip_tb(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(flip_tb(diff_rect)), IRect())
        << label;
    EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(flip_lrtb(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(flip_lrtb(diff_rect)), IRect())
        << label;
  };
 
  auto non_reducing = [&cull_rect, &check_empty_flips](
                          const IRect& diff_rect, const std::string& label) {
    EXPECT_EQ(cull_rect.Cutout(diff_rect), cull_rect) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), cull_rect) << label;
    check_empty_flips(diff_rect, label);
  };
 
  auto reducing = [&cull_rect, &check_empty_flips](const IRect& diff_rect,
                                                   const IRect& result_rect,
                                                   const std::string& label) {
    EXPECT_TRUE(!result_rect.IsEmpty());
    EXPECT_EQ(cull_rect.Cutout(diff_rect), result_rect) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), result_rect) << label;
    check_empty_flips(diff_rect, label);
  };
 
  auto emptying = [&cull_rect, &check_empty_flips](const IRect& diff_rect,
                                                   const std::string& label) {
    EXPECT_FALSE(cull_rect.Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), IRect()) << label;
    check_empty_flips(diff_rect, label);
  };
 
  // Skim the corners and edge
  non_reducing(IRect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
  non_reducing(IRect::MakeLTRB(20, 10, 40, 20), "Above");
  non_reducing(IRect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
  non_reducing(IRect::MakeLTRB(40, 20, 50, 40), "Right");
  non_reducing(IRect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
  non_reducing(IRect::MakeLTRB(20, 40, 40, 50), "Below");
  non_reducing(IRect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
  non_reducing(IRect::MakeLTRB(10, 20, 20, 40), "Left");
 
  // Overlap corners
  non_reducing(IRect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
  non_reducing(IRect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
  non_reducing(IRect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
  non_reducing(IRect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
 
  // Overlap edges, but not across an entire side
  non_reducing(IRect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
  non_reducing(IRect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
  non_reducing(IRect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
  non_reducing(IRect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
  non_reducing(IRect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
  non_reducing(IRect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
  non_reducing(IRect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
  non_reducing(IRect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
 
  // Slice all the way through the middle
  non_reducing(IRect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
  non_reducing(IRect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
 
  // Slice off each edge
  reducing(IRect::MakeLTRB(20, 15, 40, 25),  //
           IRect::MakeLTRB(20, 25, 40, 40),  //
           "Slice off top");
  reducing(IRect::MakeLTRB(35, 20, 45, 40),  //
           IRect::MakeLTRB(20, 20, 35, 40),  //
           "Slice off right");
  reducing(IRect::MakeLTRB(20, 35, 40, 45),  //
           IRect::MakeLTRB(20, 20, 40, 35),  //
           "Slice off bottom");
  reducing(IRect::MakeLTRB(15, 20, 25, 40),  //
           IRect::MakeLTRB(25, 20, 40, 40),  //
           "Slice off left");
 
  // cull rect contains diff rect
  non_reducing(IRect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
 
  // cull rect equals diff rect
  emptying(cull_rect, "Perfectly covering");
 
  // diff rect contains cull rect
  emptying(IRect::MakeLTRB(15, 15, 45, 45), "Smothering");
}

References impeller::TRect< T >::Cutout(), impeller::TRect< T >::CutoutOrEmpty(), flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [414/689]

impeller::testing::TEST	(	RectTest	,
		IRectDefaultConstructor
	)

Definition at line 59 of file rect_unittests.cc.

                                        {
  IRect rect = IRect();
 
  EXPECT_EQ(rect.GetLeft(), 0);
  EXPECT_EQ(rect.GetTop(), 0);
  EXPECT_EQ(rect.GetRight(), 0);
  EXPECT_EQ(rect.GetBottom(), 0);
  EXPECT_EQ(rect.GetX(), 0);
  EXPECT_EQ(rect.GetY(), 0);
  EXPECT_EQ(rect.GetWidth(), 0);
  EXPECT_EQ(rect.GetHeight(), 0);
  EXPECT_TRUE(rect.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), and impeller::TRect< T >::IsEmpty().

◆ TEST() [415/689]

impeller::testing::TEST	(	RectTest	,
		IRectDoesNotIntersectEmpty
	)

Definition at line 963 of file rect_unittests.cc.

                                           {
  IRect rect = IRect::MakeLTRB(50, 50, 100, 100);
 
  auto test = [&rect](int64_t l, int64_t t, int64_t r, int64_t b,
                      const std::string& label) {
    EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(l, b, r, t)))
        << label << " with Top/Bottom swapped";
    EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(r, b, l, t)))
        << label << " with Left/Right swapped";
    EXPECT_FALSE(rect.IntersectsWithRect(IRect::MakeLTRB(r, t, l, b)))
        << label << " with all sides swapped";
  };
 
  test(20, 20, 30, 30, "Above and Left");
  test(70, 20, 80, 30, "Above");
  test(120, 20, 130, 30, "Above and Right");
  test(120, 70, 130, 80, "Right");
  test(120, 120, 130, 130, "Below and Right");
  test(70, 120, 80, 130, "Below");
  test(20, 120, 30, 130, "Below and Left");
  test(20, 70, 30, 80, "Left");
 
  test(70, 70, 80, 80, "Inside");
 
  test(40, 70, 60, 80, "Straddling Left");
  test(70, 40, 80, 60, "Straddling Top");
  test(90, 70, 110, 80, "Straddling Right");
  test(70, 90, 80, 110, "Straddling Bottom");
}

References impeller::TRect< T >::IntersectsWithRect(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [416/689]

impeller::testing::TEST	(	RectTest	,
		IRectEmptyDeclaration
	)

Definition at line 29 of file rect_unittests.cc.

                                      {
  IRect rect;
 
  EXPECT_EQ(rect.GetLeft(), 0);
  EXPECT_EQ(rect.GetTop(), 0);
  EXPECT_EQ(rect.GetRight(), 0);
  EXPECT_EQ(rect.GetBottom(), 0);
  EXPECT_EQ(rect.GetX(), 0);
  EXPECT_EQ(rect.GetY(), 0);
  EXPECT_EQ(rect.GetWidth(), 0);
  EXPECT_EQ(rect.GetHeight(), 0);
  EXPECT_TRUE(rect.IsEmpty());
  // EXPECT_TRUE(rect.IsFinite());  // should fail to compile
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), and impeller::TRect< T >::IsEmpty().

◆ TEST() [417/689]

impeller::testing::TEST	(	RectTest	,
		IRectExpand
	)

Definition at line 1407 of file rect_unittests.cc.

                            {
  auto rect = IRect::MakeLTRB(100, 100, 200, 200);
 
  // Expand(T amount)
  EXPECT_EQ(rect.Expand(10), IRect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(-10), IRect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(amount, amount)
  EXPECT_EQ(rect.Expand(10, 10), IRect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(10, -10), IRect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(-10, 10), IRect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(-10, -10), IRect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(amount, amount, amount, amount)
  EXPECT_EQ(rect.Expand(10, 20, 30, 40), IRect::MakeLTRB(90, 80, 230, 240));
  EXPECT_EQ(rect.Expand(-10, 20, 30, 40), IRect::MakeLTRB(110, 80, 230, 240));
  EXPECT_EQ(rect.Expand(10, -20, 30, 40), IRect::MakeLTRB(90, 120, 230, 240));
  EXPECT_EQ(rect.Expand(10, 20, -30, 40), IRect::MakeLTRB(90, 80, 170, 240));
  EXPECT_EQ(rect.Expand(10, 20, 30, -40), IRect::MakeLTRB(90, 80, 230, 160));
 
  // Expand(IPoint amount)
  EXPECT_EQ(rect.Expand(IPoint{10, 10}), IRect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(IPoint{10, -10}), IRect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(IPoint{-10, 10}), IRect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(IPoint{-10, -10}), IRect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(ISize amount)
  EXPECT_EQ(rect.Expand(ISize{10, 10}), IRect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(ISize{10, -10}), IRect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(ISize{-10, 10}), IRect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(ISize{-10, -10}), IRect::MakeLTRB(110, 110, 190, 190));
}

References impeller::TRect< T >::MakeLTRB().

◆ TEST() [418/689]

impeller::testing::TEST	(	RectTest	,
		IRectFromIRect
	)

Definition at line 785 of file rect_unittests.cc.

                               {
  EXPECT_EQ(IRect(IRect::MakeXYWH(2, 3, 7, 15)),  //
            IRect::MakeXYWH(2, 3, 7, 15));
  EXPECT_EQ(IRect(IRect::MakeLTRB(2, 3, 7, 15)),  //
            IRect::MakeLTRB(2, 3, 7, 15));
}

References impeller::TRect< T >::MakeLTRB(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [419/689]

impeller::testing::TEST	(	RectTest	,
		IRectGetNormalizingTransform
	)

Definition at line 1246 of file rect_unittests.cc.

                                             {
  {
    // Checks for expected matrix values
 
    auto r = IRect::MakeXYWH(100, 200, 200, 400);
 
    EXPECT_EQ(r.GetNormalizingTransform(),
              Matrix::MakeScale({0.005, 0.0025, 1.0}) *
                  Matrix::MakeTranslation({-100, -200}));
  }
 
  {
    // Checks for expected transform of points relative to the rect
 
    auto r = IRect::MakeLTRB(300, 500, 400, 700);
    auto m = r.GetNormalizingTransform();
 
    // The 4 corners of the rect => (0, 0) to (1, 1)
    EXPECT_EQ(m * Point(300, 500), Point(0, 0));
    EXPECT_EQ(m * Point(400, 500), Point(1, 0));
    EXPECT_EQ(m * Point(400, 700), Point(1, 1));
    EXPECT_EQ(m * Point(300, 700), Point(0, 1));
 
    // The center => (0.5, 0.5)
    EXPECT_EQ(m * Point(350, 600), Point(0.5, 0.5));
 
    // Outside the 4 corners => (-1, -1) to (2, 2)
    EXPECT_EQ(m * Point(200, 300), Point(-1, -1));
    EXPECT_EQ(m * Point(500, 300), Point(2, -1));
    EXPECT_EQ(m * Point(500, 900), Point(2, 2));
    EXPECT_EQ(m * Point(200, 900), Point(-1, 2));
  }
 
  {
    // Checks for behavior with empty rects
 
    auto zero = Matrix::MakeScale({0.0, 0.0, 1.0});
 
    // Empty for width and/or height == 0
    EXPECT_EQ(IRect::MakeXYWH(10, 10, 0, 10).GetNormalizingTransform(), zero);
    EXPECT_EQ(IRect::MakeXYWH(10, 10, 10, 0).GetNormalizingTransform(), zero);
    EXPECT_EQ(IRect::MakeXYWH(10, 10, 0, 0).GetNormalizingTransform(), zero);
 
    // Empty for width and/or height < 0
    EXPECT_EQ(IRect::MakeXYWH(10, 10, -1, 10).GetNormalizingTransform(), zero);
    EXPECT_EQ(IRect::MakeXYWH(10, 10, 10, -1).GetNormalizingTransform(), zero);
    EXPECT_EQ(IRect::MakeXYWH(10, 10, -1, -1).GetNormalizingTransform(), zero);
  }
}

References impeller::TRect< T >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [420/689]

impeller::testing::TEST	(	RectTest	,
		IRectIntersection
	)

Definition at line 2049 of file rect_unittests.cc.

                                  {
  auto check_empty_flips = [](const IRect& a, const IRect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_FALSE(a.Intersection(flip_lr(b)).has_value()) << label;
    EXPECT_FALSE(a.Intersection(flip_tb(b)).has_value()) << label;
    EXPECT_FALSE(a.Intersection(flip_lrtb(b)).has_value()) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_FALSE(flip_lr(a).Intersection(b).has_value()) << label;
    EXPECT_FALSE(flip_tb(a).Intersection(b).has_value()) << label;
    EXPECT_FALSE(flip_lrtb(a).Intersection(b).has_value()) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).Intersection(flip_lr(b)).has_value()) << label;
    EXPECT_FALSE(flip_tb(a).Intersection(flip_tb(b)).has_value()) << label;
    EXPECT_FALSE(flip_lrtb(a).Intersection(flip_lrtb(b)).has_value()) << label;
  };
 
  auto test_non_empty = [&check_empty_flips](const IRect& a, const IRect& b,
                                             const IRect& result) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.Intersection(b).has_value()) << label;
    EXPECT_TRUE(b.Intersection(a).has_value()) << label;
    EXPECT_EQ(a.Intersection(b), result) << label;
    EXPECT_EQ(b.Intersection(a), result) << label;
    check_empty_flips(a, b, label);
  };
 
  auto test_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.Intersection(b).has_value()) << label;
    EXPECT_FALSE(b.Intersection(a).has_value()) << label;
    check_empty_flips(a, b, label);
  };
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 100, 100);
    auto expected = IRect::MakeXYWH(10, 10, 90, 90);
 
    test_non_empty(a, b, expected);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(100, 100, 100, 100);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeMaximum();
    auto b = IRect::MakeXYWH(10, 10, 300, 300);
 
    test_non_empty(a, b, b);
  }
 
  {
    auto a = IRect::MakeMaximum();
    auto b = IRect::MakeMaximum();
 
    test_non_empty(a, b, IRect::MakeMaximum());
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [421/689]

impeller::testing::TEST	(	RectTest	,
		IRectIntersectsWithRect
	)

Definition at line 2314 of file rect_unittests.cc.

                                        {
  auto check_empty_flips = [](const IRect& a, const IRect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_FALSE(a.IntersectsWithRect(flip_lr(b))) << label;
    EXPECT_FALSE(a.IntersectsWithRect(flip_tb(b))) << label;
    EXPECT_FALSE(a.IntersectsWithRect(flip_lrtb(b))) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_FALSE(flip_lr(a).IntersectsWithRect(b)) << label;
    EXPECT_FALSE(flip_tb(a).IntersectsWithRect(b)) << label;
    EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(b)) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).IntersectsWithRect(flip_lr(b))) << label;
    EXPECT_FALSE(flip_tb(a).IntersectsWithRect(flip_tb(b))) << label;
    EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(flip_lrtb(b))) << label;
  };
 
  auto test_non_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.IntersectsWithRect(b)) << label;
    EXPECT_TRUE(b.IntersectsWithRect(a)) << label;
    check_empty_flips(a, b, label);
  };
 
  auto test_empty = [&check_empty_flips](const IRect& a, const IRect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.IntersectsWithRect(b)) << label;
    EXPECT_FALSE(b.IntersectsWithRect(a)) << label;
    check_empty_flips(a, b, label);
  };
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 100, 100);
 
    test_non_empty(a, b);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(100, 100, 100, 100);
 
    test_empty(a, b);
  }
 
  {
    auto a = IRect::MakeMaximum();
    auto b = IRect::MakeXYWH(10, 10, 100, 100);
 
    test_non_empty(a, b);
  }
 
  {
    auto a = IRect::MakeMaximum();
    auto b = IRect::MakeMaximum();
 
    test_non_empty(a, b);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IntersectsWithRect(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeMaximum(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [422/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeCircleBounds
	)

Definition at line 198 of file rect_unittests.cc.

                                      {
  IRect rect = IRect::MakeCircleBounds(IPoint(100, 200), 20);
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80);
  EXPECT_EQ(rect.GetRight(), 120);
  EXPECT_EQ(rect.GetTop(), 180);
  EXPECT_EQ(rect.GetBottom(), 220);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeCircleBounds().

◆ TEST() [423/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeCircleBoundsNegativeRadius
	)

Definition at line 208 of file rect_unittests.cc.

                                                    {
  IRect rect = IRect::MakeCircleBounds(IPoint(100, 200), -20);
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120);
  EXPECT_EQ(rect.GetRight(), 80);
  EXPECT_EQ(rect.GetTop(), 220);
  EXPECT_EQ(rect.GetBottom(), 180);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeCircleBounds().

◆ TEST() [424/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeEllipseBoundsNegativePoint
	)

Definition at line 292 of file rect_unittests.cc.

                                                    {
  IRect rect = IRect::MakeEllipseBounds(IPoint(100, 200), IPoint(-20, -30));
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120);
  EXPECT_EQ(rect.GetRight(), 80);
  EXPECT_EQ(rect.GetTop(), 230);
  EXPECT_EQ(rect.GetBottom(), 170);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeEllipseBounds().

◆ TEST() [425/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeEllipseBoundsNegativeSize
	)

Definition at line 272 of file rect_unittests.cc.

                                                   {
  IRect rect = IRect::MakeEllipseBounds(IPoint(100, 200), ISize(-20, -30));
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120);
  EXPECT_EQ(rect.GetRight(), 80);
  EXPECT_EQ(rect.GetTop(), 230);
  EXPECT_EQ(rect.GetBottom(), 170);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeEllipseBounds().

◆ TEST() [426/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeEllipseBoundsPoint
	)

Definition at line 282 of file rect_unittests.cc.

                                            {
  IRect rect = IRect::MakeEllipseBounds(IPoint(100, 200), IPoint(20, 30));
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80);
  EXPECT_EQ(rect.GetRight(), 120);
  EXPECT_EQ(rect.GetTop(), 170);
  EXPECT_EQ(rect.GetBottom(), 230);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeEllipseBounds().

◆ TEST() [427/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeEllipseBoundsSize
	)

Definition at line 262 of file rect_unittests.cc.

                                           {
  IRect rect = IRect::MakeEllipseBounds(IPoint(100, 200), ISize(20, 30));
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80);
  EXPECT_EQ(rect.GetRight(), 120);
  EXPECT_EQ(rect.GetTop(), 170);
  EXPECT_EQ(rect.GetBottom(), 230);
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeEllipseBounds().

◆ TEST() [428/689]

impeller::testing::TEST	(	RectTest	,
		IRectMakeMaximum
	)

Definition at line 762 of file rect_unittests.cc.

                                 {
  IRect rect = IRect::MakeMaximum();
  auto min = std::numeric_limits<int64_t>::min();
  auto max = std::numeric_limits<int64_t>::max();
 
  EXPECT_EQ(rect.GetLeft(), min);
  EXPECT_EQ(rect.GetTop(), min);
  EXPECT_EQ(rect.GetRight(), max);
  EXPECT_EQ(rect.GetBottom(), max);
  EXPECT_EQ(rect.GetX(), min);
  EXPECT_EQ(rect.GetY(), min);
  EXPECT_EQ(rect.GetWidth(), max);
  EXPECT_EQ(rect.GetHeight(), max);
  EXPECT_FALSE(rect.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeMaximum().

◆ TEST() [429/689]

impeller::testing::TEST	(	RectTest	,
		IRectOriginSizeXYWHGetters
	)

Definition at line 852 of file rect_unittests.cc.

                                           {
  {
    IRect r = IRect::MakeOriginSize({10, 20}, {50, 40});
    EXPECT_EQ(r.GetOrigin(), IPoint(10, 20));
    EXPECT_EQ(r.GetSize(), ISize(50, 40));
    EXPECT_EQ(r.GetX(), 10);
    EXPECT_EQ(r.GetY(), 20);
    EXPECT_EQ(r.GetWidth(), 50);
    EXPECT_EQ(r.GetHeight(), 40);
    auto expected_array = std::array<int64_t, 4>{10, 20, 50, 40};
    EXPECT_EQ(r.GetXYWH(), expected_array);
  }
 
  {
    IRect r = IRect::MakeLTRB(10, 20, 50, 40);
    EXPECT_EQ(r.GetOrigin(), IPoint(10, 20));
    EXPECT_EQ(r.GetSize(), ISize(40, 20));
    EXPECT_EQ(r.GetX(), 10);
    EXPECT_EQ(r.GetY(), 20);
    EXPECT_EQ(r.GetWidth(), 40);
    EXPECT_EQ(r.GetHeight(), 20);
    auto expected_array = std::array<int64_t, 4>{10, 20, 40, 20};
    EXPECT_EQ(r.GetXYWH(), expected_array);
  }
}

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetXYWH(), impeller::TRect< T >::GetY(), impeller::TRect< T >::MakeLTRB(), and impeller::TRect< T >::MakeOriginSize().

◆ TEST() [430/689]

impeller::testing::TEST	(	RectTest	,
		IRectOverflowLTRB
	)

Definition at line 647 of file rect_unittests.cc.

                                  {
  auto min = std::numeric_limits<int64_t>::min();
  auto max = std::numeric_limits<int64_t>::max();
 
  // 4 cases
  //   negative l, r near max takes width past max
  //   positive l, r near min takes width below min
  //   negative t, b near max takes width past max
  //   positive t, b near min takes width below min
 
  {
    IRect rect = IRect::MakeLTRB(-10, 10, max - 5, 26);
 
    EXPECT_EQ(rect.GetLeft(), -10);
    EXPECT_EQ(rect.GetTop(), 10);
    EXPECT_EQ(rect.GetRight(), max - 5);
    EXPECT_EQ(rect.GetBottom(), 26);
    EXPECT_EQ(rect.GetX(), -10);
    EXPECT_EQ(rect.GetY(), 10);
    EXPECT_EQ(rect.GetWidth(), max);
    EXPECT_EQ(rect.GetHeight(), 16);
    EXPECT_FALSE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeLTRB(10, 10, min + 5, 26);
 
    EXPECT_EQ(rect.GetLeft(), 10);
    EXPECT_EQ(rect.GetTop(), 10);
    EXPECT_EQ(rect.GetRight(), min + 5);
    EXPECT_EQ(rect.GetBottom(), 26);
    EXPECT_EQ(rect.GetX(), 10);
    EXPECT_EQ(rect.GetY(), 10);
    EXPECT_EQ(rect.GetWidth(), min);
    EXPECT_EQ(rect.GetHeight(), 16);
    EXPECT_TRUE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeLTRB(5, -10, 15, max - 5);
 
    EXPECT_EQ(rect.GetLeft(), 5);
    EXPECT_EQ(rect.GetTop(), -10);
    EXPECT_EQ(rect.GetRight(), 15);
    EXPECT_EQ(rect.GetBottom(), max - 5);
    EXPECT_EQ(rect.GetX(), 5);
    EXPECT_EQ(rect.GetY(), -10);
    EXPECT_EQ(rect.GetWidth(), 10);
    EXPECT_EQ(rect.GetHeight(), max);
    EXPECT_FALSE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeLTRB(5, 10, 15, min + 5);
 
    EXPECT_EQ(rect.GetLeft(), 5);
    EXPECT_EQ(rect.GetTop(), 10);
    EXPECT_EQ(rect.GetRight(), 15);
    EXPECT_EQ(rect.GetBottom(), min + 5);
    EXPECT_EQ(rect.GetX(), 5);
    EXPECT_EQ(rect.GetY(), 10);
    EXPECT_EQ(rect.GetWidth(), 10);
    EXPECT_EQ(rect.GetHeight(), min);
    EXPECT_TRUE(rect.IsEmpty());
  }
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [431/689]

impeller::testing::TEST	(	RectTest	,
		IRectOverflowXYWH
	)

Definition at line 441 of file rect_unittests.cc.

                                  {
  auto min = std::numeric_limits<int64_t>::min();
  auto max = std::numeric_limits<int64_t>::max();
 
  // 4 cases
  //   x near max, positive w takes it past max
  //   x near min, negative w takes it below min
  //   y near max, positive h takes it past max
  //   y near min, negative h takes it below min
 
  {
    IRect rect = IRect::MakeXYWH(max - 5, 10, 10, 16);
 
    EXPECT_EQ(rect.GetLeft(), max - 5);
    EXPECT_EQ(rect.GetTop(), 10);
    EXPECT_EQ(rect.GetRight(), max);
    EXPECT_EQ(rect.GetBottom(), 26);
    EXPECT_EQ(rect.GetX(), max - 5);
    EXPECT_EQ(rect.GetY(), 10);
    EXPECT_EQ(rect.GetWidth(), 5);
    EXPECT_EQ(rect.GetHeight(), 16);
    EXPECT_FALSE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeXYWH(min + 5, 10, -10, 16);
 
    EXPECT_EQ(rect.GetLeft(), min + 5);
    EXPECT_EQ(rect.GetTop(), 10);
    EXPECT_EQ(rect.GetRight(), min);
    EXPECT_EQ(rect.GetBottom(), 26);
    EXPECT_EQ(rect.GetX(), min + 5);
    EXPECT_EQ(rect.GetY(), 10);
    EXPECT_EQ(rect.GetWidth(), -5);
    EXPECT_EQ(rect.GetHeight(), 16);
    EXPECT_TRUE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeXYWH(5, max - 10, 10, 16);
 
    EXPECT_EQ(rect.GetLeft(), 5);
    EXPECT_EQ(rect.GetTop(), max - 10);
    EXPECT_EQ(rect.GetRight(), 15);
    EXPECT_EQ(rect.GetBottom(), max);
    EXPECT_EQ(rect.GetX(), 5);
    EXPECT_EQ(rect.GetY(), max - 10);
    EXPECT_EQ(rect.GetWidth(), 10);
    EXPECT_EQ(rect.GetHeight(), 10);
    EXPECT_FALSE(rect.IsEmpty());
  }
 
  {
    IRect rect = IRect::MakeXYWH(5, min + 10, 10, -16);
 
    EXPECT_EQ(rect.GetLeft(), 5);
    EXPECT_EQ(rect.GetTop(), min + 10);
    EXPECT_EQ(rect.GetRight(), 15);
    EXPECT_EQ(rect.GetBottom(), min);
    EXPECT_EQ(rect.GetX(), 5);
    EXPECT_EQ(rect.GetY(), min + 10);
    EXPECT_EQ(rect.GetWidth(), 10);
    EXPECT_EQ(rect.GetHeight(), -10);
    EXPECT_TRUE(rect.IsEmpty());
  }
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [432/689]

impeller::testing::TEST	(	RectTest	,
		IRectRound
	)

Definition at line 3347 of file rect_unittests.cc.

                           {
  {
    auto r = Rect::MakeLTRB(-100, -200, 300, 400);
    auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
    EXPECT_EQ(IRect::Round(r), ir);
  }
  {
    auto r = Rect::MakeLTRB(-100.4, -200.4, 300.4, 400.4);
    auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
    EXPECT_EQ(IRect::Round(r), ir);
  }
  {
    auto r = Rect::MakeLTRB(-100.5, -200.5, 300.5, 400.5);
    auto ir = IRect::MakeLTRB(-101, -201, 301, 401);
    EXPECT_EQ(IRect::Round(r), ir);
  }
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< T >::Round().

◆ TEST() [433/689]

impeller::testing::TEST	(	RectTest	,
		IRectRoundOut
	)

Definition at line 3319 of file rect_unittests.cc.

                              {
  {
    auto r = Rect::MakeLTRB(-100, -200, 300, 400);
    auto ir = IRect::MakeLTRB(-100, -200, 300, 400);
    EXPECT_EQ(IRect::RoundOut(r), ir);
  }
  {
    auto r = Rect::MakeLTRB(-100.1, -200.1, 300.1, 400.1);
    auto ir = IRect::MakeLTRB(-101, -201, 301, 401);
    EXPECT_EQ(IRect::RoundOut(r), ir);
  }
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< T >::RoundOut().

◆ TEST() [434/689]

impeller::testing::TEST	(	RectTest	,
		IRectScale
	)

Definition at line 1098 of file rect_unittests.cc.

                           {
  auto test1 = [](IRect rect, int64_t scale) {
    IRect expected = IRect::MakeXYWH(rect.GetX() * scale,      //
                                     rect.GetY() * scale,      //
                                     rect.GetWidth() * scale,  //
                                     rect.GetHeight() * scale);
 
    EXPECT_EQ(rect.Scale(scale), expected)  //
        << rect << " * " << scale;
    EXPECT_EQ(rect.Scale(scale, scale), expected)  //
        << rect << " * " << scale;
    EXPECT_EQ(rect.Scale(IPoint(scale, scale)), expected)  //
        << rect << " * " << scale;
    EXPECT_EQ(rect.Scale(ISize(scale, scale)), expected)  //
        << rect << " * " << scale;
  };
 
  auto test2 = [&test1](IRect rect, int64_t scale_x, int64_t scale_y) {
    IRect expected = IRect::MakeXYWH(rect.GetX() * scale_x,      //
                                     rect.GetY() * scale_y,      //
                                     rect.GetWidth() * scale_x,  //
                                     rect.GetHeight() * scale_y);
 
    EXPECT_EQ(rect.Scale(scale_x, scale_y), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
    EXPECT_EQ(rect.Scale(IPoint(scale_x, scale_y)), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
    EXPECT_EQ(rect.Scale(ISize(scale_x, scale_y)), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
 
    test1(rect, scale_x);
    test1(rect, scale_y);
  };
 
  test2(IRect::MakeLTRB(10, 15, 100, 150), 2, 3);
  test2(IRect::MakeLTRB(10, 15, 100, 150), 3, 2);
  test2(IRect::MakeLTRB(10, 15, -100, 150), 2, 3);
  test2(IRect::MakeLTRB(10, 15, 100, -150), 2, 3);
  test2(IRect::MakeLTRB(10, 15, 100, 150), -2, 3);
  test2(IRect::MakeLTRB(10, 15, 100, 150), 2, -3);
}

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< T >::Scale().

◆ TEST() [435/689]

impeller::testing::TEST	(	RectTest	,
		IRectSimpleLTRB
	)

Definition at line 89 of file rect_unittests.cc.

                                {
  IRect rect = IRect::MakeLTRB(5, 10, 20, 25);
 
  EXPECT_EQ(rect.GetLeft(), 5);
  EXPECT_EQ(rect.GetTop(), 10);
  EXPECT_EQ(rect.GetRight(), 20);
  EXPECT_EQ(rect.GetBottom(), 25);
  EXPECT_EQ(rect.GetX(), 5);
  EXPECT_EQ(rect.GetY(), 10);
  EXPECT_EQ(rect.GetWidth(), 15);
  EXPECT_EQ(rect.GetHeight(), 15);
  EXPECT_FALSE(rect.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [436/689]

impeller::testing::TEST	(	RectTest	,
		IRectSimpleWH
	)

Definition at line 149 of file rect_unittests.cc.

                              {
  // Using fractional-power-of-2 friendly values for equality tests
  IRect rect = IRect::MakeWH(15, 25);
 
  EXPECT_EQ(rect.GetLeft(), 0);
  EXPECT_EQ(rect.GetTop(), 0);
  EXPECT_EQ(rect.GetRight(), 15);
  EXPECT_EQ(rect.GetBottom(), 25);
  EXPECT_EQ(rect.GetX(), 0);
  EXPECT_EQ(rect.GetY(), 0);
  EXPECT_EQ(rect.GetWidth(), 15);
  EXPECT_EQ(rect.GetHeight(), 25);
  EXPECT_FALSE(rect.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeWH().

◆ TEST() [437/689]

impeller::testing::TEST	(	RectTest	,
		IRectSimpleXYWH
	)

Definition at line 119 of file rect_unittests.cc.

                                {
  IRect rect = IRect::MakeXYWH(5, 10, 15, 16);
 
  EXPECT_EQ(rect.GetLeft(), 5);
  EXPECT_EQ(rect.GetTop(), 10);
  EXPECT_EQ(rect.GetRight(), 20);
  EXPECT_EQ(rect.GetBottom(), 26);
  EXPECT_EQ(rect.GetX(), 5);
  EXPECT_EQ(rect.GetY(), 10);
  EXPECT_EQ(rect.GetWidth(), 15);
  EXPECT_EQ(rect.GetHeight(), 16);
  EXPECT_FALSE(rect.IsEmpty());
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeXYWH().

◆ TEST() [438/689]

impeller::testing::TEST	(	RectTest	,
		IRectUnion
	)

Definition at line 1746 of file rect_unittests.cc.

                           {
  auto check_empty_flips = [](const IRect& a, const IRect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_EQ(a.Union(flip_lr(b)), a) << label;
    EXPECT_EQ(a.Union(flip_tb(b)), a) << label;
    EXPECT_EQ(a.Union(flip_lrtb(b)), a) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_EQ(flip_lr(a).Union(b), b) << label;
    EXPECT_EQ(flip_tb(a).Union(b), b) << label;
    EXPECT_EQ(flip_lrtb(a).Union(b), b) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_TRUE(flip_lr(a).Union(flip_lr(b)).IsEmpty()) << label;
    EXPECT_TRUE(flip_tb(a).Union(flip_tb(b)).IsEmpty()) << label;
    EXPECT_TRUE(flip_lrtb(a).Union(flip_lrtb(b)).IsEmpty()) << label;
  };
 
  auto test = [&check_empty_flips](const IRect& a, const IRect& b,
                                   const IRect& result) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_EQ(a.Union(b), result) << label;
    EXPECT_EQ(b.Union(a), result) << label;
    check_empty_flips(a, b, label);
  };
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 0, 0);
    auto expected = IRect::MakeXYWH(100, 100, 100, 100);
    test(a, b, expected);
  }
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(0, 0, 1, 1);
    auto expected = IRect::MakeXYWH(0, 0, 200, 200);
    test(a, b, expected);
  }
 
  {
    auto a = IRect::MakeXYWH(100, 100, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 1, 1);
    auto expected = IRect::MakeXYWH(10, 10, 190, 190);
    test(a, b, expected);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(10, 10, 100, 100);
    auto expected = IRect::MakeXYWH(0, 0, 110, 110);
    test(a, b, expected);
  }
 
  {
    auto a = IRect::MakeXYWH(0, 0, 100, 100);
    auto b = IRect::MakeXYWH(100, 100, 100, 100);
    auto expected = IRect::MakeXYWH(0, 0, 200, 200);
    test(a, b, expected);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< T >::Union().

◆ TEST() [439/689]

impeller::testing::TEST	(	RectTest	,
		IRectXYWHIsEmpty
	)

Definition at line 1320 of file rect_unittests.cc.

                                 {
  // Non-empty
  EXPECT_FALSE(IRect::MakeXYWH(1, 2, 10, 7).IsEmpty());
 
  // Empty both width and height both 0 or negative, in all combinations
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, 0).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, -1).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, 0).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, -1).IsEmpty());
 
  // Empty for 0 or negative width or height (but not both at the same time)
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, 10, 0).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, 10, -1).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, 0, 7).IsEmpty());
  EXPECT_TRUE(IRect::MakeXYWH(1, 2, -1, 7).IsEmpty());
}

References impeller::TRect< T >::MakeXYWH().

◆ TEST() [440/689]

impeller::testing::TEST	(	RectTest	,
		IsSquare
	)

Definition at line 1351 of file rect_unittests.cc.

                         {
  EXPECT_TRUE(Rect::MakeXYWH(10, 30, 20, 20).IsSquare());
  EXPECT_FALSE(Rect::MakeXYWH(10, 30, 20, 19).IsSquare());
  EXPECT_FALSE(Rect::MakeXYWH(10, 30, 19, 20).IsSquare());
  EXPECT_TRUE(Rect::MakeMaximum().IsSquare());
 
  EXPECT_TRUE(IRect::MakeXYWH(10, 30, 20, 20).IsSquare());
  EXPECT_FALSE(IRect::MakeXYWH(10, 30, 20, 19).IsSquare());
  EXPECT_FALSE(IRect::MakeXYWH(10, 30, 19, 20).IsSquare());
  EXPECT_TRUE(IRect::MakeMaximum().IsSquare());
}

References impeller::TRect< T >::MakeMaximum(), impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< T >::MakeXYWH(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [441/689]

impeller::testing::TEST	(	RectTest	,
		MakePointBoundsQuad
	)

Definition at line 1337 of file rect_unittests.cc.

                                    {
  Quad quad = {
      Point(10, 10),
      Point(20, 10),
      Point(10, 20),
      Point(20, 20),
  };
  std::optional<Rect> bounds = Rect::MakePointBounds(quad);
  EXPECT_TRUE(bounds.has_value());
  if (bounds.has_value()) {
    EXPECT_TRUE(RectNear(bounds.value(), Rect::MakeLTRB(10, 10, 20, 20)));
  }
}

References impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakePointBounds(), and RectNear().

◆ TEST() [442/689]

impeller::testing::TEST	(	RectTest	,
		OptIRectIntersection
	)

Definition at line 2144 of file rect_unittests.cc.

                                     {
  auto a = IRect::MakeLTRB(0, 0, 110, 110);
  auto b = IRect::MakeLTRB(100, 100, 200, 200);
  auto c = IRect::MakeLTRB(100, 0, 200, 110);
 
  // NullOpt, NullOpt
  EXPECT_FALSE(IRect::Intersection(std::nullopt, std::nullopt).has_value());
  EXPECT_EQ(IRect::Intersection(std::nullopt, std::nullopt), std::nullopt);
 
  auto test1 = [](const IRect& r) {
    // Rect, NullOpt
    EXPECT_TRUE(IRect::Intersection(r, std::nullopt).has_value());
    EXPECT_EQ(IRect::Intersection(r, std::nullopt).value(), r);
 
    // OptRect, NullOpt
    EXPECT_TRUE(
        IRect::Intersection(std::optional(r), std::nullopt).has_value());
    EXPECT_EQ(IRect::Intersection(std::optional(r), std::nullopt).value(), r);
 
    // NullOpt, Rect
    EXPECT_TRUE(IRect::Intersection(std::nullopt, r).has_value());
    EXPECT_EQ(IRect::Intersection(std::nullopt, r).value(), r);
 
    // NullOpt, OptRect
    EXPECT_TRUE(
        IRect::Intersection(std::nullopt, std::optional(r)).has_value());
    EXPECT_EQ(IRect::Intersection(std::nullopt, std::optional(r)).value(), r);
  };
 
  test1(a);
  test1(b);
  test1(c);
 
  auto test2 = [](const IRect& a, const IRect& b, const IRect& i) {
    ASSERT_EQ(a.Intersection(b), i);
 
    // Rect, OptRect
    EXPECT_TRUE(IRect::Intersection(a, std::optional(b)).has_value());
    EXPECT_EQ(IRect::Intersection(a, std::optional(b)).value(), i);
 
    // OptRect, Rect
    EXPECT_TRUE(IRect::Intersection(std::optional(a), b).has_value());
    EXPECT_EQ(IRect::Intersection(std::optional(a), b).value(), i);
 
    // OptRect, OptRect
    EXPECT_TRUE(
        IRect::Intersection(std::optional(a), std::optional(b)).has_value());
    EXPECT_EQ(IRect::Intersection(std::optional(a), std::optional(b)).value(),
              i);
  };
 
  test2(a, b, IRect::MakeLTRB(100, 100, 110, 110));
  test2(a, c, IRect::MakeLTRB(100, 0, 110, 110));
  test2(b, c, IRect::MakeLTRB(100, 100, 200, 110));
}

References c, i, impeller::TRect< T >::Intersection(), impeller::TRect< T >::MakeLTRB(), and value.

◆ TEST() [443/689]

impeller::testing::TEST	(	RectTest	,
		OptIRectUnion
	)

Definition at line 1818 of file rect_unittests.cc.

                              {
  auto a = IRect::MakeLTRB(0, 0, 100, 100);
  auto b = IRect::MakeLTRB(100, 100, 200, 200);
  auto c = IRect::MakeLTRB(100, 0, 200, 100);
 
  // NullOpt, NullOpt
  EXPECT_FALSE(IRect::Union(std::nullopt, std::nullopt).has_value());
  EXPECT_EQ(IRect::Union(std::nullopt, std::nullopt), std::nullopt);
 
  auto test1 = [](const IRect& r) {
    // Rect, NullOpt
    EXPECT_EQ(IRect::Union(r, std::nullopt), r);
 
    // OptRect, NullOpt
    EXPECT_TRUE(IRect::Union(std::optional(r), std::nullopt).has_value());
    EXPECT_EQ(IRect::Union(std::optional(r), std::nullopt).value(), r);
 
    // NullOpt, Rect
    EXPECT_EQ(IRect::Union(std::nullopt, r), r);
 
    // NullOpt, OptRect
    EXPECT_TRUE(IRect::Union(std::nullopt, std::optional(r)).has_value());
    EXPECT_EQ(IRect::Union(std::nullopt, std::optional(r)).value(), r);
  };
 
  test1(a);
  test1(b);
  test1(c);
 
  auto test2 = [](const IRect& a, const IRect& b, const IRect& u) {
    ASSERT_EQ(a.Union(b), u);
 
    // Rect, OptRect
    EXPECT_EQ(IRect::Union(a, std::optional(b)), u);
 
    // OptRect, Rect
    EXPECT_EQ(IRect::Union(std::optional(a), b), u);
 
    // OptRect, OptRect
    EXPECT_TRUE(IRect::Union(std::optional(a), std::optional(b)).has_value());
    EXPECT_EQ(IRect::Union(std::optional(a), std::optional(b)).value(), u);
  };
 
  test2(a, b, IRect::MakeLTRB(0, 0, 200, 200));
  test2(a, c, IRect::MakeLTRB(0, 0, 200, 100));
  test2(b, c, IRect::MakeLTRB(100, 0, 200, 200));
}

References c, impeller::TRect< T >::MakeLTRB(), impeller::TRect< T >::Union(), and value.

◆ TEST() [444/689]

impeller::testing::TEST	(	RectTest	,
		OptRectIntersection
	)

Definition at line 1995 of file rect_unittests.cc.

                                    {
  auto a = Rect::MakeLTRB(0, 0, 110, 110);
  auto b = Rect::MakeLTRB(100, 100, 200, 200);
  auto c = Rect::MakeLTRB(100, 0, 200, 110);
 
  // NullOpt, NullOpt
  EXPECT_FALSE(Rect::Intersection(std::nullopt, std::nullopt).has_value());
  EXPECT_EQ(Rect::Intersection(std::nullopt, std::nullopt), std::nullopt);
 
  auto test1 = [](const Rect& r) {
    // Rect, NullOpt
    EXPECT_TRUE(Rect::Intersection(r, std::nullopt).has_value());
    EXPECT_EQ(Rect::Intersection(r, std::nullopt).value(), r);
 
    // OptRect, NullOpt
    EXPECT_TRUE(Rect::Intersection(std::optional(r), std::nullopt).has_value());
    EXPECT_EQ(Rect::Intersection(std::optional(r), std::nullopt).value(), r);
 
    // NullOpt, Rect
    EXPECT_TRUE(Rect::Intersection(std::nullopt, r).has_value());
    EXPECT_EQ(Rect::Intersection(std::nullopt, r).value(), r);
 
    // NullOpt, OptRect
    EXPECT_TRUE(Rect::Intersection(std::nullopt, std::optional(r)).has_value());
    EXPECT_EQ(Rect::Intersection(std::nullopt, std::optional(r)).value(), r);
  };
 
  test1(a);
  test1(b);
  test1(c);
 
  auto test2 = [](const Rect& a, const Rect& b, const Rect& i) {
    ASSERT_EQ(a.Intersection(b), i);
 
    // Rect, OptRect
    EXPECT_TRUE(Rect::Intersection(a, std::optional(b)).has_value());
    EXPECT_EQ(Rect::Intersection(a, std::optional(b)).value(), i);
 
    // OptRect, Rect
    EXPECT_TRUE(Rect::Intersection(std::optional(a), b).has_value());
    EXPECT_EQ(Rect::Intersection(std::optional(a), b).value(), i);
 
    // OptRect, OptRect
    EXPECT_TRUE(
        Rect::Intersection(std::optional(a), std::optional(b)).has_value());
    EXPECT_EQ(Rect::Intersection(std::optional(a), std::optional(b)).value(),
              i);
  };
 
  test2(a, b, Rect::MakeLTRB(100, 100, 110, 110));
  test2(a, c, Rect::MakeLTRB(100, 0, 110, 110));
  test2(b, c, Rect::MakeLTRB(100, 100, 200, 110));
}

References c, i, impeller::TRect< Scalar >::Intersection(), impeller::TRect< Scalar >::MakeLTRB(), and value.

◆ TEST() [445/689]

impeller::testing::TEST	(	RectTest	,
		OptRectUnion
	)

Definition at line 1698 of file rect_unittests.cc.

                             {
  auto a = Rect::MakeLTRB(0, 0, 100, 100);
  auto b = Rect::MakeLTRB(100, 100, 200, 200);
  auto c = Rect::MakeLTRB(100, 0, 200, 100);
 
  // NullOpt, NullOpt
  EXPECT_FALSE(Rect::Union(std::nullopt, std::nullopt).has_value());
  EXPECT_EQ(Rect::Union(std::nullopt, std::nullopt), std::nullopt);
 
  auto test1 = [](const Rect& r) {
    // Rect, NullOpt
    EXPECT_EQ(Rect::Union(r, std::nullopt), r);
 
    // OptRect, NullOpt
    EXPECT_TRUE(Rect::Union(std::optional(r), std::nullopt).has_value());
    EXPECT_EQ(Rect::Union(std::optional(r), std::nullopt).value(), r);
 
    // NullOpt, Rect
    EXPECT_EQ(Rect::Union(std::nullopt, r), r);
 
    // NullOpt, OptRect
    EXPECT_TRUE(Rect::Union(std::nullopt, std::optional(r)).has_value());
    EXPECT_EQ(Rect::Union(std::nullopt, std::optional(r)).value(), r);
  };
 
  test1(a);
  test1(b);
  test1(c);
 
  auto test2 = [](const Rect& a, const Rect& b, const Rect& u) {
    ASSERT_EQ(a.Union(b), u);
 
    // Rect, OptRect
    EXPECT_EQ(Rect::Union(a, std::optional(b)), u);
 
    // OptRect, Rect
    EXPECT_EQ(Rect::Union(std::optional(a), b), u);
 
    // OptRect, OptRect
    EXPECT_TRUE(Rect::Union(std::optional(a), std::optional(b)).has_value());
    EXPECT_EQ(Rect::Union(std::optional(a), std::optional(b)).value(), u);
  };
 
  test2(a, b, Rect::MakeLTRB(0, 0, 200, 200));
  test2(a, c, Rect::MakeLTRB(0, 0, 200, 100));
  test2(b, c, Rect::MakeLTRB(100, 0, 200, 200));
}

References c, impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::Union(), and value.

◆ TEST() [446/689]

impeller::testing::TEST	(	RectTest	,
		RectArea
	)

Definition at line 1140 of file rect_unittests.cc.

                         {
  EXPECT_EQ(Rect::MakeXYWH(0, 0, 100, 200).Area(), 20000);
  EXPECT_EQ(Rect::MakeXYWH(10, 20, 100, 200).Area(), 20000);
  EXPECT_EQ(Rect::MakeXYWH(0, 0, 200, 100).Area(), 20000);
  EXPECT_EQ(Rect::MakeXYWH(10, 20, 200, 100).Area(), 20000);
  EXPECT_EQ(Rect::MakeXYWH(0, 0, 100, 100).Area(), 10000);
  EXPECT_EQ(Rect::MakeXYWH(10, 20, 100, 100).Area(), 10000);
}

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [447/689]

impeller::testing::TEST	(	RectTest	,
		RectContainsInclusivePoint
	)

Definition at line 2560 of file rect_unittests.cc.

                                           {
  auto check_nans = [](const Rect& rect, const Point& point,
                       const std::string& label) {
    ASSERT_TRUE(rect.IsFinite()) << label;
    ASSERT_TRUE(point.IsFinite()) << label;
 
    for (int i = 1; i < 16; i++) {
      EXPECT_FALSE(swap_nan(rect, i).ContainsInclusive(point))
          << label << ", index = " << i;
      for (int j = 1; j < 4; j++) {
        EXPECT_FALSE(swap_nan(rect, i).ContainsInclusive(swap_nan(point, j)))
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& rect, const Point& point,
                              const std::string& label) {
    ASSERT_FALSE(rect.IsEmpty());
 
    EXPECT_FALSE(flip_lr(rect).ContainsInclusive(point)) << label;
    EXPECT_FALSE(flip_tb(rect).ContainsInclusive(point)) << label;
    EXPECT_FALSE(flip_lrtb(rect).ContainsInclusive(point)) << label;
  };
 
  auto test_inside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                       const Point& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_TRUE(rect.ContainsInclusive(point)) << label;
    check_empty_flips(rect, point, label);
    check_nans(rect, point, label);
  };
 
  auto test_outside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                        const Point& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_FALSE(rect.ContainsInclusive(point)) << label;
    check_empty_flips(rect, point, label);
    check_nans(rect, point, label);
  };
 
  {
    // Origin is inclusive
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(100, 100);
 
    test_inside(r, p);
  }
  {
    // Size is inclusive
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(200, 200);
 
    test_inside(r, p);
  }
  {
    // Size + epsilon is exclusive
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(200 + kEhCloseEnough, 200 + kEhCloseEnough);
 
    test_outside(r, p);
  }
  {
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(99, 99);
 
    test_outside(r, p);
  }
  {
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(199, 199);
 
    test_inside(r, p);
  }
 
  {
    auto r = Rect::MakeMaximum();
    auto p = Point(199, 199);
 
    test_inside(r, p);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, flutter::kEhCloseEnough, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [448/689]

impeller::testing::TEST	(	RectTest	,
		RectContainsPoint
	)

Definition at line 2405 of file rect_unittests.cc.

                                  {
  auto check_nans = [](const Rect& rect, const Point& point,
                       const std::string& label) {
    ASSERT_TRUE(rect.IsFinite()) << label;
    ASSERT_TRUE(point.IsFinite()) << label;
 
    for (int i = 1; i < 16; i++) {
      EXPECT_FALSE(swap_nan(rect, i).Contains(point))
          << label << ", index = " << i;
      for (int j = 1; j < 4; j++) {
        EXPECT_FALSE(swap_nan(rect, i).Contains(swap_nan(point, j)))
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& rect, const Point& point,
                              const std::string& label) {
    ASSERT_FALSE(rect.IsEmpty());
 
    EXPECT_FALSE(flip_lr(rect).Contains(point)) << label;
    EXPECT_FALSE(flip_tb(rect).Contains(point)) << label;
    EXPECT_FALSE(flip_lrtb(rect).Contains(point)) << label;
  };
 
  auto test_inside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                       const Point& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_TRUE(rect.Contains(point)) << label;
    check_empty_flips(rect, point, label);
    check_nans(rect, point, label);
  };
 
  auto test_outside = [&check_nans, &check_empty_flips](const Rect& rect,
                                                        const Point& point) {
    ASSERT_FALSE(rect.IsEmpty()) << rect;
 
    std::stringstream stream;
    stream << rect << " contains " << point;
    auto label = stream.str();
 
    EXPECT_FALSE(rect.Contains(point)) << label;
    check_empty_flips(rect, point, label);
    check_nans(rect, point, label);
  };
 
  {
    // Origin is inclusive
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(100, 100);
 
    test_inside(r, p);
  }
  {
    // Size is exclusive
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(200, 200);
 
    test_outside(r, p);
  }
  {
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(99, 99);
 
    test_outside(r, p);
  }
  {
    auto r = Rect::MakeXYWH(100, 100, 100, 100);
    auto p = Point(199, 199);
 
    test_inside(r, p);
  }
 
  {
    auto r = Rect::MakeMaximum();
    auto p = Point(199, 199);
 
    test_inside(r, p);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [449/689]

impeller::testing::TEST	(	RectTest	,
		RectContainsRect
	)

Definition at line 2729 of file rect_unittests.cc.

                                 {
  auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
    ASSERT_TRUE(a.IsFinite()) << label;
    ASSERT_TRUE(b.IsFinite()) << label;
    ASSERT_FALSE(a.IsEmpty());
 
    for (int i = 1; i < 16; i++) {
      // NaN in a produces false
      EXPECT_FALSE(swap_nan(a, i).Contains(b)) << label << ", index = " << i;
      // NaN in b produces false
      EXPECT_TRUE(a.Contains(swap_nan(b, i))) << label << ", index = " << i;
      // NaN in both is false
      for (int j = 1; j < 16; j++) {
        EXPECT_FALSE(swap_nan(a, i).Contains(swap_nan(b, j)))
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& a, const Rect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // test b rects are allowed to have 0 w/h, but not be backwards
    ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
 
    // unflipped a vs flipped (empty) b yields false
    EXPECT_TRUE(a.Contains(flip_lr(b))) << label;
    EXPECT_TRUE(a.Contains(flip_tb(b))) << label;
    EXPECT_TRUE(a.Contains(flip_lrtb(b))) << label;
 
    // flipped (empty) a vs unflipped b yields false
    EXPECT_FALSE(flip_lr(a).Contains(b)) << label;
    EXPECT_FALSE(flip_tb(a).Contains(b)) << label;
    EXPECT_FALSE(flip_lrtb(a).Contains(b)) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).Contains(flip_lr(b))) << label;
    EXPECT_FALSE(flip_tb(a).Contains(flip_tb(b))) << label;
    EXPECT_FALSE(flip_lrtb(a).Contains(flip_lrtb(b))) << label;
  };
 
  auto test_inside = [&check_nans, &check_empty_flips](const Rect& a,
                                                       const Rect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // test b rects are allowed to have 0 w/h, but not be backwards
    ASSERT_FALSE(b.GetLeft() > b.GetRight() || b.GetTop() > b.GetBottom());
 
    std::stringstream stream;
    stream << a << " contains " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.Contains(b)) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  auto test_not_inside = [&check_nans, &check_empty_flips](const Rect& a,
                                                           const Rect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // If b was empty, it would be contained and should not be tested with
    // this function - use |test_inside| instead.
    ASSERT_FALSE(b.IsEmpty()) << b;
 
    std::stringstream stream;
    stream << a << " contains " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.Contains(b)) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
 
    test_inside(a, a);
  }
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 0, 0);
 
    test_inside(a, b);
  }
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(150, 150, 20, 20);
 
    test_inside(a, b);
  }
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(150, 150, 100, 100);
 
    test_not_inside(a, b);
  }
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(50, 50, 100, 100);
 
    test_not_inside(a, b);
  }
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 300, 300);
 
    test_not_inside(a, b);
  }
  {
    auto a = Rect::MakeMaximum();
    auto b = Rect::MakeXYWH(0, 0, 300, 300);
 
    test_inside(a, b);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [450/689]

impeller::testing::TEST	(	RectTest	,
		RectCopy
	)

Definition at line 792 of file rect_unittests.cc.

                         {
  // Using fractional-power-of-2 friendly values for equality tests
  Rect rect = Rect::MakeLTRB(5.125f, 10.25f, 20.625f, 25.375f);
  Rect copy = rect;
 
  EXPECT_EQ(rect, copy);
  EXPECT_EQ(copy.GetLeft(), 5.125f);
  EXPECT_EQ(copy.GetTop(), 10.25f);
  EXPECT_EQ(copy.GetRight(), 20.625f);
  EXPECT_EQ(copy.GetBottom(), 25.375f);
  EXPECT_EQ(copy.GetX(), 5.125f);
  EXPECT_EQ(copy.GetY(), 10.25f);
  EXPECT_EQ(copy.GetWidth(), 15.5f);
  EXPECT_EQ(copy.GetHeight(), 15.125f);
  EXPECT_FALSE(copy.IsEmpty());
  EXPECT_TRUE(copy.IsFinite());
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [451/689]

impeller::testing::TEST	(	RectTest	,
		RectCutOut
	)

Definition at line 2937 of file rect_unittests.cc.

                           {
  Rect cull_rect = Rect::MakeLTRB(20, 20, 40, 40);
 
  auto check_nans = [&cull_rect](const Rect& diff_rect,
                                 const std::string& label) {
    EXPECT_TRUE(cull_rect.IsFinite()) << label;
    EXPECT_TRUE(diff_rect.IsFinite()) << label;
 
    for (int i = 1; i < 16; i++) {
      // NaN in cull_rect produces empty
      EXPECT_FALSE(swap_nan(cull_rect, i).Cutout(diff_rect).has_value())
          << label << ", index " << i;
      EXPECT_EQ(swap_nan(cull_rect, i).CutoutOrEmpty(diff_rect), Rect())
          << label << ", index " << i;
 
      // NaN in diff_rect is nop
      EXPECT_TRUE(cull_rect.Cutout(swap_nan(diff_rect, i)).has_value())
          << label << ", index " << i;
      EXPECT_EQ(cull_rect.CutoutOrEmpty(swap_nan(diff_rect, i)), cull_rect)
          << label << ", index " << i;
 
      for (int j = 1; j < 16; j++) {
        // NaN in both is also empty
        EXPECT_FALSE(
            swap_nan(cull_rect, i).Cutout(swap_nan(diff_rect, j)).has_value())
            << label << ", indices " << i << ", " << j;
        EXPECT_EQ(swap_nan(cull_rect, i).CutoutOrEmpty(swap_nan(diff_rect, j)),
                  Rect())
            << label << ", indices " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [&cull_rect](const Rect& diff_rect,
                                        const std::string& label) {
    EXPECT_FALSE(cull_rect.IsEmpty()) << label;
    EXPECT_FALSE(diff_rect.IsEmpty()) << label;
 
    // unflipped cull_rect vs flipped(empty) diff_rect
    // == cull_rect
    EXPECT_TRUE(cull_rect.Cutout(flip_lr(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_lr(diff_rect)), cull_rect) << label;
    EXPECT_TRUE(cull_rect.Cutout(flip_tb(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_tb(diff_rect)), cull_rect) << label;
    EXPECT_TRUE(cull_rect.Cutout(flip_lrtb(diff_rect)).has_value()) << label;
    EXPECT_EQ(cull_rect.Cutout(flip_lrtb(diff_rect)), cull_rect) << label;
 
    // flipped(empty) cull_rect vs unflipped diff_rect
    // == empty
    EXPECT_FALSE(flip_lr(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
    EXPECT_FALSE(flip_tb(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
    EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(diff_rect), Rect()) << label;
 
    // flipped(empty) cull_rect vs flipped(empty) diff_rect
    // == empty
    EXPECT_FALSE(flip_lr(cull_rect).Cutout(flip_lr(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_lr(cull_rect).CutoutOrEmpty(flip_lr(diff_rect)), Rect())
        << label;
    EXPECT_FALSE(flip_tb(cull_rect).Cutout(flip_tb(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_tb(cull_rect).CutoutOrEmpty(flip_tb(diff_rect)), Rect())
        << label;
    EXPECT_FALSE(flip_lrtb(cull_rect).Cutout(flip_lrtb(diff_rect)).has_value())
        << label;
    EXPECT_EQ(flip_lrtb(cull_rect).CutoutOrEmpty(flip_lrtb(diff_rect)), Rect())
        << label;
  };
 
  auto non_reducing = [&cull_rect, &check_empty_flips, &check_nans](
                          const Rect& diff_rect, const std::string& label) {
    EXPECT_EQ(cull_rect.Cutout(diff_rect), cull_rect) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), cull_rect) << label;
    check_empty_flips(diff_rect, label);
    check_nans(diff_rect, label);
  };
 
  auto reducing = [&cull_rect, &check_empty_flips, &check_nans](
                      const Rect& diff_rect, const Rect& result_rect,
                      const std::string& label) {
    EXPECT_TRUE(!result_rect.IsEmpty());
    EXPECT_EQ(cull_rect.Cutout(diff_rect), result_rect) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), result_rect) << label;
    check_empty_flips(diff_rect, label);
    check_nans(diff_rect, label);
  };
 
  auto emptying = [&cull_rect, &check_empty_flips, &check_nans](
                      const Rect& diff_rect, const std::string& label) {
    EXPECT_FALSE(cull_rect.Cutout(diff_rect).has_value()) << label;
    EXPECT_EQ(cull_rect.CutoutOrEmpty(diff_rect), Rect()) << label;
    check_empty_flips(diff_rect, label);
    check_nans(diff_rect, label);
  };
 
  // Skim the corners and edge
  non_reducing(Rect::MakeLTRB(10, 10, 20, 20), "outside UL corner");
  non_reducing(Rect::MakeLTRB(20, 10, 40, 20), "Above");
  non_reducing(Rect::MakeLTRB(40, 10, 50, 20), "outside UR corner");
  non_reducing(Rect::MakeLTRB(40, 20, 50, 40), "Right");
  non_reducing(Rect::MakeLTRB(40, 40, 50, 50), "outside LR corner");
  non_reducing(Rect::MakeLTRB(20, 40, 40, 50), "Below");
  non_reducing(Rect::MakeLTRB(10, 40, 20, 50), "outside LR corner");
  non_reducing(Rect::MakeLTRB(10, 20, 20, 40), "Left");
 
  // Overlap corners
  non_reducing(Rect::MakeLTRB(15, 15, 25, 25), "covering UL corner");
  non_reducing(Rect::MakeLTRB(35, 15, 45, 25), "covering UR corner");
  non_reducing(Rect::MakeLTRB(35, 35, 45, 45), "covering LR corner");
  non_reducing(Rect::MakeLTRB(15, 35, 25, 45), "covering LL corner");
 
  // Overlap edges, but not across an entire side
  non_reducing(Rect::MakeLTRB(20, 15, 39, 25), "Top edge left-biased");
  non_reducing(Rect::MakeLTRB(21, 15, 40, 25), "Top edge, right biased");
  non_reducing(Rect::MakeLTRB(35, 20, 45, 39), "Right edge, top-biased");
  non_reducing(Rect::MakeLTRB(35, 21, 45, 40), "Right edge, bottom-biased");
  non_reducing(Rect::MakeLTRB(20, 35, 39, 45), "Bottom edge, left-biased");
  non_reducing(Rect::MakeLTRB(21, 35, 40, 45), "Bottom edge, right-biased");
  non_reducing(Rect::MakeLTRB(15, 20, 25, 39), "Left edge, top-biased");
  non_reducing(Rect::MakeLTRB(15, 21, 25, 40), "Left edge, bottom-biased");
 
  // Slice all the way through the middle
  non_reducing(Rect::MakeLTRB(25, 15, 35, 45), "Vertical interior slice");
  non_reducing(Rect::MakeLTRB(15, 25, 45, 35), "Horizontal interior slice");
 
  // Slice off each edge
  reducing(Rect::MakeLTRB(20, 15, 40, 25),  //
           Rect::MakeLTRB(20, 25, 40, 40),  //
           "Slice off top");
  reducing(Rect::MakeLTRB(35, 20, 45, 40),  //
           Rect::MakeLTRB(20, 20, 35, 40),  //
           "Slice off right");
  reducing(Rect::MakeLTRB(20, 35, 40, 45),  //
           Rect::MakeLTRB(20, 20, 40, 35),  //
           "Slice off bottom");
  reducing(Rect::MakeLTRB(15, 20, 25, 40),  //
           Rect::MakeLTRB(25, 20, 40, 40),  //
           "Slice off left");
 
  // cull rect contains diff rect
  non_reducing(Rect::MakeLTRB(21, 21, 39, 39), "Contained, non-covering");
 
  // cull rect equals diff rect
  emptying(cull_rect, "Perfectly covering");
 
  // diff rect contains cull rect
  emptying(Rect::MakeLTRB(15, 15, 45, 45), "Smothering");
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeLTRB(), and swap_nan().

◆ TEST() [452/689]

impeller::testing::TEST	(	RectTest	,
		RectDefaultConstructor
	)

Definition at line 44 of file rect_unittests.cc.

                                       {
  Rect rect = Rect();
 
  EXPECT_EQ(rect.GetLeft(), 0.0f);
  EXPECT_EQ(rect.GetTop(), 0.0f);
  EXPECT_EQ(rect.GetRight(), 0.0f);
  EXPECT_EQ(rect.GetBottom(), 0.0f);
  EXPECT_EQ(rect.GetX(), 0.0f);
  EXPECT_EQ(rect.GetY(), 0.0f);
  EXPECT_EQ(rect.GetWidth(), 0.0f);
  EXPECT_EQ(rect.GetHeight(), 0.0f);
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

◆ TEST() [453/689]

impeller::testing::TEST	(	RectTest	,
		RectDirections
	)

Definition at line 3279 of file rect_unittests.cc.

                               {
  auto r = Rect::MakeLTRB(1, 2, 3, 4);
 
  EXPECT_EQ(r.GetLeft(), 1);
  EXPECT_EQ(r.GetTop(), 2);
  EXPECT_EQ(r.GetRight(), 3);
  EXPECT_EQ(r.GetBottom(), 4);
 
  EXPECT_POINT_NEAR(r.GetLeftTop(), Point(1, 2));
  EXPECT_POINT_NEAR(r.GetRightTop(), Point(3, 2));
  EXPECT_POINT_NEAR(r.GetLeftBottom(), Point(1, 4));
  EXPECT_POINT_NEAR(r.GetRightBottom(), Point(3, 4));
}

References EXPECT_POINT_NEAR, and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [454/689]

impeller::testing::TEST	(	RectTest	,
		RectDoesNotIntersectEmpty
	)

Definition at line 933 of file rect_unittests.cc.

                                          {
  Rect rect = Rect::MakeLTRB(50, 50, 100, 100);
 
  auto test = [&rect](Scalar l, Scalar t, Scalar r, Scalar b,
                      const std::string& label) {
    EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(l, b, r, t)))
        << label << " with Top/Bottom swapped";
    EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(r, b, l, t)))
        << label << " with Left/Right swapped";
    EXPECT_FALSE(rect.IntersectsWithRect(Rect::MakeLTRB(r, t, l, b)))
        << label << " with all sides swapped";
  };
 
  test(20, 20, 30, 30, "Above and Left");
  test(70, 20, 80, 30, "Above");
  test(120, 20, 130, 30, "Above and Right");
  test(120, 70, 130, 80, "Right");
  test(120, 120, 130, 130, "Below and Right");
  test(70, 120, 80, 130, "Below");
  test(20, 120, 30, 130, "Below and Left");
  test(20, 70, 30, 80, "Left");
 
  test(70, 70, 80, 80, "Inside");
 
  test(40, 70, 60, 80, "Straddling Left");
  test(70, 40, 80, 60, "Straddling Top");
  test(90, 70, 110, 80, "Straddling Right");
  test(70, 90, 80, 110, "Straddling Bottom");
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [455/689]

impeller::testing::TEST	(	RectTest	,
		RectEmptyDeclaration
	)

Definition at line 14 of file rect_unittests.cc.

                                     {
  Rect rect;
 
  EXPECT_EQ(rect.GetLeft(), 0.0f);
  EXPECT_EQ(rect.GetTop(), 0.0f);
  EXPECT_EQ(rect.GetRight(), 0.0f);
  EXPECT_EQ(rect.GetBottom(), 0.0f);
  EXPECT_EQ(rect.GetX(), 0.0f);
  EXPECT_EQ(rect.GetY(), 0.0f);
  EXPECT_EQ(rect.GetWidth(), 0.0f);
  EXPECT_EQ(rect.GetHeight(), 0.0f);
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

◆ TEST() [456/689]

impeller::testing::TEST	(	RectTest	,
		RectExpand
	)

Definition at line 1374 of file rect_unittests.cc.

                           {
  auto rect = Rect::MakeLTRB(100, 100, 200, 200);
 
  // Expand(T amount)
  EXPECT_EQ(rect.Expand(10), Rect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(-10), Rect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(amount, amount)
  EXPECT_EQ(rect.Expand(10, 10), Rect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(10, -10), Rect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(-10, 10), Rect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(-10, -10), Rect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(amount, amount, amount, amount)
  EXPECT_EQ(rect.Expand(10, 20, 30, 40), Rect::MakeLTRB(90, 80, 230, 240));
  EXPECT_EQ(rect.Expand(-10, 20, 30, 40), Rect::MakeLTRB(110, 80, 230, 240));
  EXPECT_EQ(rect.Expand(10, -20, 30, 40), Rect::MakeLTRB(90, 120, 230, 240));
  EXPECT_EQ(rect.Expand(10, 20, -30, 40), Rect::MakeLTRB(90, 80, 170, 240));
  EXPECT_EQ(rect.Expand(10, 20, 30, -40), Rect::MakeLTRB(90, 80, 230, 160));
 
  // Expand(Point amount)
  EXPECT_EQ(rect.Expand(Point{10, 10}), Rect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(Point{10, -10}), Rect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(Point{-10, 10}), Rect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(Point{-10, -10}), Rect::MakeLTRB(110, 110, 190, 190));
 
  // Expand(Size amount)
  EXPECT_EQ(rect.Expand(Size{10, 10}), Rect::MakeLTRB(90, 90, 210, 210));
  EXPECT_EQ(rect.Expand(Size{10, -10}), Rect::MakeLTRB(90, 110, 210, 190));
  EXPECT_EQ(rect.Expand(Size{-10, 10}), Rect::MakeLTRB(110, 90, 190, 210));
  EXPECT_EQ(rect.Expand(Size{-10, -10}), Rect::MakeLTRB(110, 110, 190, 190));
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [457/689]

impeller::testing::TEST	(	RectTest	,
		RectExpandToMinTransformedSizeNullForScaledToZero
	)

Definition at line 1440 of file rect_unittests.cc.

                                                                  {
  auto rect = Rect();
  auto transform = Matrix::MakeScale(Vector3(0.0f, 1.0f));
  EXPECT_EQ(rect.ExpandToMinTransformedSize({1.0f, 1.0f}, transform),
            std::nullopt);
}

References impeller::Matrix::MakeScale(), and transform.

◆ TEST() [458/689]

impeller::testing::TEST	(	RectTest	,
		RectExpandToMinTransformedSizeRectWithIdentityTransform
	)

Definition at line 1462 of file rect_unittests.cc.

                                                                        {
  Size size = Size(2.0f, 2.0f);
  Rect rect = Rect::MakeEllipseBounds(Point(), size * 0.5f);
 
  auto transform = Matrix();
 
  // Expand to a width and height less than the original size.
  {
    auto expanded = rect.ExpandToMinTransformedSize({0.5f, 0.75f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), size);
    }
  }
 
  // Expand to a minimum width. Minimum height is less than the original size.
  {
    auto expanded = rect.ExpandToMinTransformedSize({4.0f, 1.5f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(4.0f, 2.0f));
    }
  }
 
  // Expand to a minimum height. Minimum width is less than the original size.
  {
    auto expanded = rect.ExpandToMinTransformedSize({1.5f, 4.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(2.0f, 4.0f));
    }
  }
 
  // Expand to a minimum width and height.
  {
    auto expanded = rect.ExpandToMinTransformedSize({3.0f, 4.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(3.0f, 4.0f));
    }
  }
}

References impeller::TRect< Scalar >::MakeEllipseBounds(), flutter::size, and transform.

◆ TEST() [459/689]

impeller::testing::TEST	(	RectTest	,
		RectExpandToMinTransformedSizeRectWithScalingTransform
	)

Definition at line 1505 of file rect_unittests.cc.

                                                                       {
  Size size = Size(2.0f, 2.0f);
  Rect rect = Rect::MakeEllipseBounds(Point(), size * 0.5f);
 
  // Scale by 2x in the X direction and 3x in the Y direction.
  // Transformed rect size is (4.0, 6.0).
  auto transform = Matrix::MakeScale(Vector3(2.0f, 3.0f));
 
  // Expand to a transformed width and height less than the transformed size of
  // the original rectangle.
  {
    auto expanded = rect.ExpandToMinTransformedSize({3.0f, 4.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), size);
    }
  }
 
  // Expand to 5.0 transformed width.
  // This is equal to 5.0 / 2.0 = 2.5 local width.
  {
    auto expanded = rect.ExpandToMinTransformedSize({5.0f, 4.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(2.5f, 2.0f));
    }
  }
 
  // Expand to 9.0 transformed height.
  // This is equal to 9.0 / 3.0 = 3.0 local height.
  {
    auto expanded = rect.ExpandToMinTransformedSize({3.0f, 9.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(2.0f, 3.0));
    }
  }
 
  // Expand both width and height.
  {
    auto expanded = rect.ExpandToMinTransformedSize({5.0f, 9.0f}, transform);
    ASSERT_TRUE(expanded.has_value());
    if (expanded.has_value()) {
      EXPECT_EQ(expanded.value().GetSize(), Size(2.5f, 3.0f));
    }
  }
}

References impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::Matrix::MakeScale(), flutter::size, and transform.

◆ TEST() [460/689]

impeller::testing::TEST	(	RectTest	,
		RectExpandToMinTransformedSizeReturnsUnmodifiedWhenLargeEnough
	)

Definition at line 1447 of file rect_unittests.cc.

                                                                               {
  Rect rect = Rect::MakeXYWH(0, 0, 10, 20);
  auto transform = Matrix::MakeScale(Vector3(0.5f, 0.5f));
  EXPECT_EQ(rect.ExpandToMinTransformedSize({1.0f, 1.0f}, transform), rect);
}

References impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [461/689]

impeller::testing::TEST	(	RectTest	,
		RectExpandToMinTransformedSizeReturnsUnmodifiedWhenLargeEnoughWithFractionalSize
	)

Definition at line 1453 of file rect_unittests.cc.

                                                                                      {
  // Regression test for https://github.com/flutter/flutter/issues/189807.
  Rect rect = Rect::MakeXYWH(100.0f, 50.0f, 64.2f, 40.0f);
  auto transform = Matrix();
  EXPECT_EQ(rect.ExpandToMinTransformedSize({1.0f, 1.0f}, transform), rect);
}

References impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [462/689]

impeller::testing::TEST	(	RectTest	,
		RectFromIRect
	)

Definition at line 164 of file rect_unittests.cc.

                              {
  IRect irect = IRect::MakeLTRB(10, 20, 30, 40);
  Rect rect = Rect::Make(irect);
 
  EXPECT_EQ(rect.GetLeft(), 10);
  EXPECT_EQ(rect.GetTop(), 20);
  EXPECT_EQ(rect.GetRight(), 30);
  EXPECT_EQ(rect.GetBottom(), 40);
 
  // The following do not compile
  // IRect irect2 = IRect::Make(rect);
  // IRect irect2 = IRect::Make(irect);
}

References impeller::TRect< Scalar >::Make(), and impeller::TRect< T >::MakeLTRB().

◆ TEST() [463/689]

impeller::testing::TEST	(	RectTest	,
		RectFromRect
	)

Definition at line 778 of file rect_unittests.cc.

                             {
  EXPECT_EQ(Rect(Rect::MakeXYWH(2, 3, 7, 15)),
            Rect::MakeXYWH(2.0, 3.0, 7.0, 15.0));
  EXPECT_EQ(Rect(Rect::MakeLTRB(2, 3, 7, 15)),
            Rect::MakeLTRB(2.0, 3.0, 7.0, 15.0));
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [464/689]

impeller::testing::TEST	(	RectTest	,
		RectGetNormalizingTransform
	)

Definition at line 1158 of file rect_unittests.cc.

                                            {
  {
    // Checks for expected matrix values
 
    auto r = Rect::MakeXYWH(100, 200, 200, 400);
 
    EXPECT_EQ(r.GetNormalizingTransform(),
              Matrix::MakeScale({0.005, 0.0025, 1.0}) *
                  Matrix::MakeTranslation({-100, -200}));
  }
 
  {
    // Checks for expected transform of points relative to the rect
 
    auto r = Rect::MakeLTRB(300, 500, 400, 700);
    auto m = r.GetNormalizingTransform();
 
    // The 4 corners of the rect => (0, 0) to (1, 1)
    EXPECT_EQ(m * Point(300, 500), Point(0, 0));
    EXPECT_EQ(m * Point(400, 500), Point(1, 0));
    EXPECT_EQ(m * Point(400, 700), Point(1, 1));
    EXPECT_EQ(m * Point(300, 700), Point(0, 1));
 
    // The center => (0.5, 0.5)
    EXPECT_EQ(m * Point(350, 600), Point(0.5, 0.5));
 
    // Outside the 4 corners => (-1, -1) to (2, 2)
    EXPECT_EQ(m * Point(200, 300), Point(-1, -1));
    EXPECT_EQ(m * Point(500, 300), Point(2, -1));
    EXPECT_EQ(m * Point(500, 900), Point(2, 2));
    EXPECT_EQ(m * Point(200, 900), Point(-1, 2));
  }
 
  {
    // Checks for behavior with empty rects
 
    auto zero = Matrix::MakeScale({0.0, 0.0, 1.0});
 
    // Empty for width and/or height == 0
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 0, 10).GetNormalizingTransform(), zero);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, 0).GetNormalizingTransform(), zero);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 0, 0).GetNormalizingTransform(), zero);
 
    // Empty for width and/or height < 0
    EXPECT_EQ(Rect::MakeXYWH(10, 10, -1, 10).GetNormalizingTransform(), zero);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, -1).GetNormalizingTransform(), zero);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, -1, -1).GetNormalizingTransform(), zero);
  }
 
  {
    // Checks for behavior with non-finite rects
 
    auto z = Matrix::MakeScale({0.0, 0.0, 1.0});
    auto nan = std::numeric_limits<Scalar>::quiet_NaN();
    auto inf = std::numeric_limits<Scalar>::infinity();
 
    // Non-finite for width and/or height == nan
    EXPECT_EQ(Rect::MakeXYWH(10, 10, nan, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, nan).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, nan, nan).GetNormalizingTransform(), z);
 
    // Non-finite for width and/or height == inf
    EXPECT_EQ(Rect::MakeXYWH(10, 10, inf, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, inf).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, inf, inf).GetNormalizingTransform(), z);
 
    // Non-finite for width and/or height == -inf
    EXPECT_EQ(Rect::MakeXYWH(10, 10, -inf, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, 10, -inf).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, 10, -inf, -inf).GetNormalizingTransform(), z);
 
    // Non-finite for origin X and/or Y == nan
    EXPECT_EQ(Rect::MakeXYWH(nan, 10, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, nan, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(nan, nan, 10, 10).GetNormalizingTransform(), z);
 
    // Non-finite for origin X and/or Y == inf
    EXPECT_EQ(Rect::MakeXYWH(inf, 10, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, inf, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(inf, inf, 10, 10).GetNormalizingTransform(), z);
 
    // Non-finite for origin X and/or Y == -inf
    EXPECT_EQ(Rect::MakeXYWH(-inf, 10, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(10, -inf, 10, 10).GetNormalizingTransform(), z);
    EXPECT_EQ(Rect::MakeXYWH(-inf, -inf, 10, 10).GetNormalizingTransform(), z);
  }
}

References impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [465/689]

impeller::testing::TEST	(	RectTest	,
		RectGetPoints
	)

Definition at line 3208 of file rect_unittests.cc.

                              {
  {
    Rect r = Rect::MakeXYWH(100, 200, 300, 400);
    auto points = r.GetPoints();
    EXPECT_POINT_NEAR(points[0], Point(100, 200));
    EXPECT_POINT_NEAR(points[1], Point(400, 200));
    EXPECT_POINT_NEAR(points[2], Point(100, 600));
    EXPECT_POINT_NEAR(points[3], Point(400, 600));
  }
 
  {
    Rect r = Rect::MakeMaximum();
    auto points = r.GetPoints();
    EXPECT_EQ(points[0], Point(std::numeric_limits<float>::lowest(),
                               std::numeric_limits<float>::lowest()));
    EXPECT_EQ(points[1], Point(std::numeric_limits<float>::max(),
                               std::numeric_limits<float>::lowest()));
    EXPECT_EQ(points[2], Point(std::numeric_limits<float>::lowest(),
                               std::numeric_limits<float>::max()));
    EXPECT_EQ(points[3], Point(std::numeric_limits<float>::max(),
                               std::numeric_limits<float>::max()));
  }
}

References EXPECT_POINT_NEAR, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [466/689]

impeller::testing::TEST	(	RectTest	,
		RectGetPositive
	)

Definition at line 3265 of file rect_unittests.cc.

                                {
  {
    Rect r = Rect::MakeXYWH(100, 200, 300, 400);
    auto actual = r.GetPositive();
    EXPECT_RECT_NEAR(r, actual);
  }
  {
    Rect r = Rect::MakeXYWH(100, 200, -100, -100);
    auto actual = r.GetPositive();
    Rect expected = Rect::MakeXYWH(0, 100, 100, 100);
    EXPECT_RECT_NEAR(expected, actual);
  }
}

References EXPECT_RECT_NEAR, and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [467/689]

impeller::testing::TEST	(	RectTest	,
		RectGetTransformedPoints
	)

Definition at line 3239 of file rect_unittests.cc.

                                         {
  Rect r = Rect::MakeXYWH(100, 200, 300, 400);
  auto points = r.GetTransformedPoints(Matrix::MakeTranslation({10, 20}));
  EXPECT_POINT_NEAR(points[0], Point(110, 220));
  EXPECT_POINT_NEAR(points[1], Point(410, 220));
  EXPECT_POINT_NEAR(points[2], Point(110, 620));
  EXPECT_POINT_NEAR(points[3], Point(410, 620));
}

References EXPECT_POINT_NEAR, impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [468/689]

impeller::testing::TEST	(	RectTest	,
		RectIntersection
	)

Definition at line 1866 of file rect_unittests.cc.

                                 {
  auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
    ASSERT_TRUE(a.IsFinite()) << label;
    ASSERT_TRUE(b.IsFinite()) << label;
 
    for (int i = 1; i < 16; i++) {
      // NaN in a produces empty
      EXPECT_FALSE(swap_nan(a, i).Intersection(b).has_value())
          << label << ", index = " << i;
      // NaN in b produces empty
      EXPECT_FALSE(a.Intersection(swap_nan(b, i)).has_value())
          << label << ", index = " << i;
      // NaN in both is empty
      for (int j = 1; j < 16; j++) {
        EXPECT_FALSE(swap_nan(a, i).Intersection(swap_nan(b, j)).has_value())
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& a, const Rect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_FALSE(a.Intersection(flip_lr(b)).has_value()) << label;
    EXPECT_TRUE(a.IntersectionOrEmpty(flip_lr(b)).IsEmpty()) << label;
    EXPECT_FALSE(a.Intersection(flip_tb(b)).has_value()) << label;
    EXPECT_TRUE(a.IntersectionOrEmpty(flip_tb(b)).IsEmpty()) << label;
    EXPECT_FALSE(a.Intersection(flip_lrtb(b)).has_value()) << label;
    EXPECT_TRUE(a.IntersectionOrEmpty(flip_lrtb(b)).IsEmpty()) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_FALSE(flip_lr(a).Intersection(b).has_value()) << label;
    EXPECT_TRUE(flip_lr(a).IntersectionOrEmpty(b).IsEmpty()) << label;
    EXPECT_FALSE(flip_tb(a).Intersection(b).has_value()) << label;
    EXPECT_TRUE(flip_tb(a).IntersectionOrEmpty(b).IsEmpty()) << label;
    EXPECT_FALSE(flip_lrtb(a).Intersection(b).has_value()) << label;
    EXPECT_TRUE(flip_lrtb(a).IntersectionOrEmpty(b).IsEmpty()) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).Intersection(flip_lr(b)).has_value()) << label;
    EXPECT_TRUE(flip_lr(a).IntersectionOrEmpty(flip_lr(b)).IsEmpty()) << label;
    EXPECT_FALSE(flip_tb(a).Intersection(flip_tb(b)).has_value()) << label;
    EXPECT_TRUE(flip_tb(a).IntersectionOrEmpty(flip_tb(b)).IsEmpty()) << label;
    EXPECT_FALSE(flip_lrtb(a).Intersection(flip_lrtb(b)).has_value()) << label;
    EXPECT_TRUE(flip_lrtb(a).IntersectionOrEmpty(flip_lrtb(b)).IsEmpty())
        << label;
  };
 
  auto test_non_empty = [&check_nans, &check_empty_flips](
                            const Rect& a, const Rect& b, const Rect& result) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.Intersection(b).has_value()) << label;
    EXPECT_TRUE(b.Intersection(a).has_value()) << label;
    EXPECT_EQ(a.Intersection(b), result) << label;
    EXPECT_EQ(b.Intersection(a), result) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  auto test_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                      const Rect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.Intersection(b).has_value()) << label;
    EXPECT_TRUE(a.IntersectionOrEmpty(b).IsEmpty()) << label;
    EXPECT_FALSE(b.Intersection(a).has_value()) << label;
    EXPECT_TRUE(b.IntersectionOrEmpty(a).IsEmpty()) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 100, 100);
    auto expected = Rect::MakeXYWH(10, 10, 90, 90);
 
    test_non_empty(a, b, expected);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(100, 100, 100, 100);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeMaximum();
    auto b = Rect::MakeXYWH(10, 10, 300, 300);
 
    test_non_empty(a, b, b);
  }
 
  {
    auto a = Rect::MakeMaximum();
    auto b = Rect::MakeMaximum();
 
    test_non_empty(a, b, Rect::MakeMaximum());
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [469/689]

impeller::testing::TEST	(	RectTest	,
		RectIntersectsWithRect
	)

Definition at line 2200 of file rect_unittests.cc.

                                       {
  auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
    ASSERT_TRUE(a.IsFinite()) << label;
    ASSERT_TRUE(b.IsFinite()) << label;
 
    for (int i = 1; i < 16; i++) {
      // NaN in a produces b
      EXPECT_FALSE(swap_nan(a, i).IntersectsWithRect(b))
          << label << ", index = " << i;
      // NaN in b produces a
      EXPECT_FALSE(a.IntersectsWithRect(swap_nan(b, i)))
          << label << ", index = " << i;
      // NaN in both is empty
      for (int j = 1; j < 16; j++) {
        EXPECT_FALSE(swap_nan(a, i).IntersectsWithRect(swap_nan(b, j)))
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& a, const Rect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_FALSE(a.IntersectsWithRect(flip_lr(b))) << label;
    EXPECT_FALSE(a.IntersectsWithRect(flip_tb(b))) << label;
    EXPECT_FALSE(a.IntersectsWithRect(flip_lrtb(b))) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_FALSE(flip_lr(a).IntersectsWithRect(b)) << label;
    EXPECT_FALSE(flip_tb(a).IntersectsWithRect(b)) << label;
    EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(b)) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_FALSE(flip_lr(a).IntersectsWithRect(flip_lr(b))) << label;
    EXPECT_FALSE(flip_tb(a).IntersectsWithRect(flip_tb(b))) << label;
    EXPECT_FALSE(flip_lrtb(a).IntersectsWithRect(flip_lrtb(b))) << label;
  };
 
  auto test_non_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                          const Rect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_TRUE(a.IntersectsWithRect(b)) << label;
    EXPECT_TRUE(b.IntersectsWithRect(a)) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  auto test_empty = [&check_nans, &check_empty_flips](const Rect& a,
                                                      const Rect& b) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_FALSE(a.IntersectsWithRect(b)) << label;
    EXPECT_FALSE(b.IntersectsWithRect(a)) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 0, 0);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 100, 100);
 
    test_non_empty(a, b);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(100, 100, 100, 100);
 
    test_empty(a, b);
  }
 
  {
    auto a = Rect::MakeMaximum();
    auto b = Rect::MakeXYWH(10, 10, 100, 100);
 
    test_non_empty(a, b);
  }
 
  {
    auto a = Rect::MakeMaximum();
    auto b = Rect::MakeMaximum();
 
    test_non_empty(a, b);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeMaximum(), impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [470/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeCircleBounds
	)

Definition at line 178 of file rect_unittests.cc.

                                     {
  Rect rect = Rect::MakeCircleBounds(Point(100.0f, 200.0f), 20.0f);
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80.0f);
  EXPECT_EQ(rect.GetRight(), 120.0f);
  EXPECT_EQ(rect.GetTop(), 180.0f);
  EXPECT_EQ(rect.GetBottom(), 220.0f);
}

References impeller::TRect< Scalar >::MakeCircleBounds().

◆ TEST() [471/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeCircleBoundsNegativeRadius
	)

Definition at line 188 of file rect_unittests.cc.

                                                   {
  Rect rect = Rect::MakeCircleBounds(Point(100.0f, 200.0f), -20.0f);
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120.0f);
  EXPECT_EQ(rect.GetRight(), 80.0f);
  EXPECT_EQ(rect.GetTop(), 220.0f);
  EXPECT_EQ(rect.GetBottom(), 180.0f);
}

References impeller::TRect< Scalar >::MakeCircleBounds().

◆ TEST() [472/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeEllipseBoundsNegativePoint
	)

Definition at line 251 of file rect_unittests.cc.

                                                   {
  Rect rect =
      Rect::MakeEllipseBounds(Point(100.0f, 200.0f), Point(-20.0f, -30.0f));
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120.0f);
  EXPECT_EQ(rect.GetRight(), 80.0f);
  EXPECT_EQ(rect.GetTop(), 230.0f);
  EXPECT_EQ(rect.GetBottom(), 170.0f);
}

References impeller::TRect< Scalar >::MakeEllipseBounds().

◆ TEST() [473/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeEllipseBoundsNegativeSize
	)

Definition at line 229 of file rect_unittests.cc.

                                                  {
  Rect rect =
      Rect::MakeEllipseBounds(Point(100.0f, 200.0f), Size(-20.0f, -30.0f));
 
  EXPECT_TRUE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 120.0f);
  EXPECT_EQ(rect.GetRight(), 80.0f);
  EXPECT_EQ(rect.GetTop(), 230.0f);
  EXPECT_EQ(rect.GetBottom(), 170.0f);
}

References impeller::TRect< Scalar >::MakeEllipseBounds().

◆ TEST() [474/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeEllipseBoundsPoint
	)

Definition at line 240 of file rect_unittests.cc.

                                           {
  Rect rect =
      Rect::MakeEllipseBounds(Point(100.0f, 200.0f), Point(20.0f, 30.0f));
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80.0f);
  EXPECT_EQ(rect.GetRight(), 120.0f);
  EXPECT_EQ(rect.GetTop(), 170.0f);
  EXPECT_EQ(rect.GetBottom(), 230.0f);
}

References impeller::TRect< Scalar >::MakeEllipseBounds().

◆ TEST() [475/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeEllipseBoundsSize
	)

Definition at line 218 of file rect_unittests.cc.

                                          {
  Rect rect =
      Rect::MakeEllipseBounds(Point(100.0f, 200.0f), Size(20.0f, 30.0f));
 
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_EQ(rect.GetLeft(), 80.0f);
  EXPECT_EQ(rect.GetRight(), 120.0f);
  EXPECT_EQ(rect.GetTop(), 170.0f);
  EXPECT_EQ(rect.GetBottom(), 230.0f);
}

References impeller::TRect< Scalar >::MakeEllipseBounds().

◆ TEST() [476/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeMaximum
	)

Definition at line 744 of file rect_unittests.cc.

                                {
  Rect rect = Rect::MakeMaximum();
  auto inf = std::numeric_limits<Scalar>::infinity();
  auto min = std::numeric_limits<Scalar>::lowest();
  auto max = std::numeric_limits<Scalar>::max();
 
  EXPECT_EQ(rect.GetLeft(), min);
  EXPECT_EQ(rect.GetTop(), min);
  EXPECT_EQ(rect.GetRight(), max);
  EXPECT_EQ(rect.GetBottom(), max);
  EXPECT_EQ(rect.GetX(), min);
  EXPECT_EQ(rect.GetY(), min);
  EXPECT_EQ(rect.GetWidth(), inf);
  EXPECT_EQ(rect.GetHeight(), inf);
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

References impeller::TRect< Scalar >::MakeMaximum().

◆ TEST() [477/689]

impeller::testing::TEST	(	RectTest	,
		RectMakePointBounds
	)

Definition at line 3248 of file rect_unittests.cc.

                                    {
  {
    std::vector<Point> points{{1, 5}, {4, -1}, {0, 6}};
    auto r = Rect::MakePointBounds(points.begin(), points.end());
    auto expected = Rect::MakeXYWH(0, -1, 4, 7);
    EXPECT_TRUE(r.has_value());
    if (r.has_value()) {
      EXPECT_RECT_NEAR(r.value(), expected);
    }
  }
  {
    std::vector<Point> points;
    std::optional<Rect> r = Rect::MakePointBounds(points.begin(), points.end());
    EXPECT_FALSE(r.has_value());
  }
}

References EXPECT_RECT_NEAR, impeller::TRect< Scalar >::MakePointBounds(), impeller::TRect< Scalar >::MakeXYWH(), and points.

◆ TEST() [478/689]

impeller::testing::TEST	(	RectTest	,
		RectMakeSize
	)

Definition at line 714 of file rect_unittests.cc.

                             {
  {
    Size s(100, 200);
    Rect r = Rect::MakeSize(s);
    Rect expected = Rect::MakeLTRB(0, 0, 100, 200);
    EXPECT_RECT_NEAR(r, expected);
  }
 
  {
    ISize s(100, 200);
    Rect r = Rect::MakeSize(s);
    Rect expected = Rect::MakeLTRB(0, 0, 100, 200);
    EXPECT_RECT_NEAR(r, expected);
  }
 
  {
    Size s(100, 200);
    IRect r = IRect::MakeSize(s);
    IRect expected = IRect::MakeLTRB(0, 0, 100, 200);
    EXPECT_EQ(r, expected);
  }
 
  {
    ISize s(100, 200);
    IRect r = IRect::MakeSize(s);
    IRect expected = IRect::MakeLTRB(0, 0, 100, 200);
    EXPECT_EQ(r, expected);
  }
}

References EXPECT_RECT_NEAR, impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< T >::MakeSize(), and impeller::TRect< Scalar >::MakeSize().

◆ TEST() [479/689]

impeller::testing::TEST	(	RectTest	,
		RectOriginSizeXYWHGetters
	)

Definition at line 826 of file rect_unittests.cc.

                                          {
  {
    Rect r = Rect::MakeOriginSize({10, 20}, {50, 40});
    EXPECT_EQ(r.GetOrigin(), Point(10, 20));
    EXPECT_EQ(r.GetSize(), Size(50, 40));
    EXPECT_EQ(r.GetX(), 10);
    EXPECT_EQ(r.GetY(), 20);
    EXPECT_EQ(r.GetWidth(), 50);
    EXPECT_EQ(r.GetHeight(), 40);
    auto expected_array = std::array<Scalar, 4>{10, 20, 50, 40};
    EXPECT_EQ(r.GetXYWH(), expected_array);
  }
 
  {
    Rect r = Rect::MakeLTRB(10, 20, 50, 40);
    EXPECT_EQ(r.GetOrigin(), Point(10, 20));
    EXPECT_EQ(r.GetSize(), Size(40, 20));
    EXPECT_EQ(r.GetX(), 10);
    EXPECT_EQ(r.GetY(), 20);
    EXPECT_EQ(r.GetWidth(), 40);
    EXPECT_EQ(r.GetHeight(), 20);
    auto expected_array = std::array<Scalar, 4>{10, 20, 40, 20};
    EXPECT_EQ(r.GetXYWH(), expected_array);
  }
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeOriginSize().

◆ TEST() [480/689]

impeller::testing::TEST	(	RectTest	,
		RectOverflowLTRB
	)

Definition at line 508 of file rect_unittests.cc.

                                 {
  auto min = std::numeric_limits<Scalar>::lowest();
  auto max = std::numeric_limits<Scalar>::max();
  auto inf = std::numeric_limits<Scalar>::infinity();
 
  // 8 cases:
  //   finite negative X, max W
  //   ~min X, ~max W
  //   finite negative Y, max H
  //   ~min Y, ~max H
  //   finite positive X, min W
  //   ~min X, ~min W
  //   finite positive Y, min H
  //   ~min Y, ~min H
 
  // a small finite value subtracted from a max value will remain max
  // a very large finite value (like min) subtracted from max will go to inf
 
  {
    Rect rect = Rect::MakeLTRB(-5.0f, 10.0f, max, 25.0f);
 
    EXPECT_EQ(rect.GetLeft(), -5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), max);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), -5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), max);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(min + 5.0f, 10.0f, max - 5.0f, 25.0f);
 
    EXPECT_EQ(rect.GetLeft(), min + 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), max - 5.0f);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), min + 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), inf);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(5.0f, -10.0f, 20.0f, max);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), -10.0f);
    EXPECT_EQ(rect.GetRight(), 20.0f);
    EXPECT_EQ(rect.GetBottom(), max);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), -10.0f);
    EXPECT_EQ(rect.GetWidth(), 15.0f);
    EXPECT_EQ(rect.GetHeight(), max);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(5.0f, min + 10.0f, 20.0f, max - 15.0f);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), min + 10.0f);
    EXPECT_EQ(rect.GetRight(), 20.0f);
    EXPECT_EQ(rect.GetBottom(), max - 15.0f);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), min + 10.0f);
    EXPECT_EQ(rect.GetWidth(), 15.0f);
    EXPECT_EQ(rect.GetHeight(), inf);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(5.0f, 10.0f, min, 25.0f);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), min);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), min);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(max - 5.0f, 10.0f, min + 10.0f, 25.0f);
 
    EXPECT_EQ(rect.GetLeft(), max - 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), min + 10.0f);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), max - 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), -inf);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(5.0f, 10.0f, 20.0f, min);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), 20.0f);
    EXPECT_EQ(rect.GetBottom(), min);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), 15.0f);
    EXPECT_EQ(rect.GetHeight(), min);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeLTRB(5.0f, max - 5.0f, 20.0f, min + 10.0f);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), max - 5.0f);
    EXPECT_EQ(rect.GetRight(), 20.0f);
    EXPECT_EQ(rect.GetBottom(), min + 10.0f);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), max - 5.0f);
    EXPECT_EQ(rect.GetWidth(), 15.0f);
    EXPECT_EQ(rect.GetHeight(), -inf);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [481/689]

impeller::testing::TEST	(	RectTest	,
		RectOverflowXYWH
	)

Definition at line 302 of file rect_unittests.cc.

                                 {
  auto min = std::numeric_limits<Scalar>::lowest();
  auto max = std::numeric_limits<Scalar>::max();
  auto inf = std::numeric_limits<Scalar>::infinity();
 
  // 8 cases:
  //   finite X, max W
  //   max X, max W
  //   finite Y, max H
  //   max Y, max H
  //   finite X, min W
  //   min X, min W
  //   finite Y, min H
  //   min Y, min H
 
  // a small finite value added to a max value will remain max
  // a very large finite value (like max) added to max will go to infinity
 
  {
    Rect rect = Rect::MakeXYWH(5.0, 10.0f, max, 15.0f);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), max);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), max);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(max, 10.0f, max, 15.0f);
 
    EXPECT_EQ(rect.GetLeft(), max);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), inf);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), max);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), inf);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_FALSE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(5.0f, 10.0f, 20.0f, max);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), 25.0f);
    EXPECT_EQ(rect.GetBottom(), max);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), 20.0f);
    EXPECT_EQ(rect.GetHeight(), max);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(5.0f, max, 20.0f, max);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), max);
    EXPECT_EQ(rect.GetRight(), 25.0f);
    EXPECT_EQ(rect.GetBottom(), inf);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), max);
    EXPECT_EQ(rect.GetWidth(), 20.0f);
    EXPECT_EQ(rect.GetHeight(), inf);
    EXPECT_FALSE(rect.IsEmpty());
    EXPECT_FALSE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(5.0, 10.0f, min, 15.0f);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), min);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), min);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(min, 10.0f, min, 15.0f);
 
    EXPECT_EQ(rect.GetLeft(), min);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), -inf);
    EXPECT_EQ(rect.GetBottom(), 25.0f);
    EXPECT_EQ(rect.GetX(), min);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), -inf);
    EXPECT_EQ(rect.GetHeight(), 15.0f);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_FALSE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(5.0f, 10.0f, 20.0f, min);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), 10.0f);
    EXPECT_EQ(rect.GetRight(), 25.0f);
    EXPECT_EQ(rect.GetBottom(), min);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), 10.0f);
    EXPECT_EQ(rect.GetWidth(), 20.0f);
    EXPECT_EQ(rect.GetHeight(), min);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_TRUE(rect.IsFinite());
  }
 
  {
    Rect rect = Rect::MakeXYWH(5.0f, min, 20.0f, min);
 
    EXPECT_EQ(rect.GetLeft(), 5.0f);
    EXPECT_EQ(rect.GetTop(), min);
    EXPECT_EQ(rect.GetRight(), 25.0f);
    EXPECT_EQ(rect.GetBottom(), -inf);
    EXPECT_EQ(rect.GetX(), 5.0f);
    EXPECT_EQ(rect.GetY(), min);
    EXPECT_EQ(rect.GetWidth(), 20.0f);
    EXPECT_EQ(rect.GetHeight(), -inf);
    EXPECT_TRUE(rect.IsEmpty());
    EXPECT_FALSE(rect.IsFinite());
  }
}

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [482/689]

impeller::testing::TEST	(	RectTest	,
		RectProject
	)

Definition at line 3293 of file rect_unittests.cc.

                            {
  {
    auto r = Rect::MakeLTRB(-100, -100, 100, 100);
    auto actual = r.Project(r);
    auto expected = Rect::MakeLTRB(0, 0, 1, 1);
    EXPECT_RECT_NEAR(expected, actual);
  }
  {
    auto r = Rect::MakeLTRB(-100, -100, 100, 100);
    auto actual = r.Project(Rect::MakeLTRB(0, 0, 100, 100));
    auto expected = Rect::MakeLTRB(0.5, 0.5, 1, 1);
    EXPECT_RECT_NEAR(expected, actual);
  }
}

References EXPECT_RECT_NEAR, and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [483/689]

impeller::testing::TEST	(	RectTest	,
		RectRound
	)

Definition at line 3332 of file rect_unittests.cc.

                          {
  {
    auto r = Rect::MakeLTRB(-100, -200, 300, 400);
    EXPECT_EQ(Rect::Round(r), r);
  }
  {
    auto r = Rect::MakeLTRB(-100.4, -200.4, 300.4, 400.4);
    EXPECT_EQ(Rect::Round(r), Rect::MakeLTRB(-100, -200, 300, 400));
  }
  {
    auto r = Rect::MakeLTRB(-100.5, -200.5, 300.5, 400.5);
    EXPECT_EQ(Rect::Round(r), Rect::MakeLTRB(-101, -201, 301, 401));
  }
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::Round().

◆ TEST() [484/689]

impeller::testing::TEST	(	RectTest	,
		RectRoundOut
	)

Definition at line 3308 of file rect_unittests.cc.

                             {
  {
    auto r = Rect::MakeLTRB(-100, -200, 300, 400);
    EXPECT_EQ(Rect::RoundOut(r), r);
  }
  {
    auto r = Rect::MakeLTRB(-100.1, -200.1, 300.1, 400.1);
    EXPECT_EQ(Rect::RoundOut(r), Rect::MakeLTRB(-101, -201, 301, 401));
  }
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::RoundOut().

◆ TEST() [485/689]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutEmpty
	)

Definition at line 878 of file rect_unittests.cc.

                                  {
  Rect rect;
 
  EXPECT_EQ(Rect::RoundOut(rect), Rect());
 
  EXPECT_EQ(IRect::RoundOut(rect), IRect());
}

References impeller::TRect< T >::RoundOut(), and impeller::TRect< Scalar >::RoundOut().

◆ TEST() [486/689]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutSimple
	)

Definition at line 886 of file rect_unittests.cc.

                                   {
  Rect rect = Rect::MakeLTRB(5.125f, 10.75f, 20.625f, 25.375f);
 
  EXPECT_EQ(Rect::RoundOut(rect), Rect::MakeLTRB(5.0f, 10.0f, 21.0f, 26.0f));
 
  EXPECT_EQ(IRect::RoundOut(rect), IRect::MakeLTRB(5, 10, 21, 26));
}

References impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< T >::RoundOut(), and impeller::TRect< Scalar >::RoundOut().

◆ TEST() [487/689]

impeller::testing::TEST	(	RectTest	,
		RectRoundOutToIRectHuge
	)

Definition at line 894 of file rect_unittests.cc.

                                        {
  auto test = [](int corners) {
    EXPECT_TRUE(corners >= 0 && corners <= 0xf);
    Scalar l, t, r, b;
    int64_t il, it, ir, ib;
    l = il = 50;
    t = it = 50;
    r = ir = 80;
    b = ib = 80;
    if ((corners & (1 << 0)) != 0) {
      l = -1E20;
      il = std::numeric_limits<int64_t>::min();
    }
    if ((corners & (1 << 1)) != 0) {
      t = -1E20;
      it = std::numeric_limits<int64_t>::min();
    }
    if ((corners & (1 << 2)) != 0) {
      r = +1E20;
      ir = std::numeric_limits<int64_t>::max();
    }
    if ((corners & (1 << 3)) != 0) {
      b = +1E20;
      ib = std::numeric_limits<int64_t>::max();
    }
 
    Rect rect = Rect::MakeLTRB(l, t, r, b);
    IRect irect = IRect::RoundOut(rect);
    EXPECT_EQ(irect.GetLeft(), il) << corners;
    EXPECT_EQ(irect.GetTop(), it) << corners;
    EXPECT_EQ(irect.GetRight(), ir) << corners;
    EXPECT_EQ(irect.GetBottom(), ib) << corners;
  };
 
  for (int corners = 0; corners <= 15; corners++) {
    test(corners);
  }
}

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< T >::RoundOut().

◆ TEST() [488/689]

impeller::testing::TEST	(	RectTest	,
		RectScale
	)

Definition at line 1053 of file rect_unittests.cc.

                          {
  auto test1 = [](Rect rect, Scalar scale) {
    Rect expected = Rect::MakeXYWH(rect.GetX() * scale,      //
                                   rect.GetY() * scale,      //
                                   rect.GetWidth() * scale,  //
                                   rect.GetHeight() * scale);
 
    EXPECT_RECT_NEAR(rect.Scale(scale), expected)  //
        << rect << " * " << scale;
    EXPECT_RECT_NEAR(rect.Scale(scale, scale), expected)  //
        << rect << " * " << scale;
    EXPECT_RECT_NEAR(rect.Scale(Point(scale, scale)), expected)  //
        << rect << " * " << scale;
    EXPECT_RECT_NEAR(rect.Scale(Size(scale, scale)), expected)  //
        << rect << " * " << scale;
  };
 
  auto test2 = [&test1](Rect rect, Scalar scale_x, Scalar scale_y) {
    Rect expected = Rect::MakeXYWH(rect.GetX() * scale_x,      //
                                   rect.GetY() * scale_y,      //
                                   rect.GetWidth() * scale_x,  //
                                   rect.GetHeight() * scale_y);
 
    EXPECT_RECT_NEAR(rect.Scale(scale_x, scale_y), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
    EXPECT_RECT_NEAR(rect.Scale(Point(scale_x, scale_y)), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
    EXPECT_RECT_NEAR(rect.Scale(Size(scale_x, scale_y)), expected)  //
        << rect << " * " << scale_x << ", " << scale_y;
 
    test1(rect, scale_x);
    test1(rect, scale_y);
  };
 
  test2(Rect::MakeLTRB(10, 15, 100, 150), 1.0, 0.0);
  test2(Rect::MakeLTRB(10, 15, 100, 150), 0.0, 1.0);
  test2(Rect::MakeLTRB(10, 15, 100, 150), 0.0, 0.0);
  test2(Rect::MakeLTRB(10, 15, 100, 150), 2.5, 3.5);
  test2(Rect::MakeLTRB(10, 15, 100, 150), 3.5, 2.5);
  test2(Rect::MakeLTRB(10, 15, -100, 150), 2.5, 3.5);
  test2(Rect::MakeLTRB(10, 15, 100, -150), 2.5, 3.5);
  test2(Rect::MakeLTRB(10, 15, 100, 150), -2.5, 3.5);
  test2(Rect::MakeLTRB(10, 15, 100, 150), 2.5, -3.5);
}

References EXPECT_RECT_NEAR, impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [489/689]

impeller::testing::TEST	(	RectTest	,
		RectShift
	)

Definition at line 3232 of file rect_unittests.cc.

                          {
  auto r = Rect::MakeLTRB(0, 0, 100, 100);
 
  EXPECT_EQ(r.Shift(Point(10, 5)), Rect::MakeLTRB(10, 5, 110, 105));
  EXPECT_EQ(r.Shift(Point(-10, -5)), Rect::MakeLTRB(-10, -5, 90, 95));
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [490/689]

impeller::testing::TEST	(	RectTest	,
		RectSimpleLTRB
	)

Definition at line 73 of file rect_unittests.cc.

                               {
  // Using fractional-power-of-2 friendly values for equality tests
  Rect rect = Rect::MakeLTRB(5.125f, 10.25f, 20.625f, 25.375f);
 
  EXPECT_EQ(rect.GetLeft(), 5.125f);
  EXPECT_EQ(rect.GetTop(), 10.25f);
  EXPECT_EQ(rect.GetRight(), 20.625f);
  EXPECT_EQ(rect.GetBottom(), 25.375f);
  EXPECT_EQ(rect.GetX(), 5.125f);
  EXPECT_EQ(rect.GetY(), 10.25f);
  EXPECT_EQ(rect.GetWidth(), 15.5f);
  EXPECT_EQ(rect.GetHeight(), 15.125f);
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

References impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [491/689]

impeller::testing::TEST	(	RectTest	,
		RectSimpleWH
	)

Definition at line 133 of file rect_unittests.cc.

                             {
  // Using fractional-power-of-2 friendly values for equality tests
  Rect rect = Rect::MakeWH(15.5f, 15.125f);
 
  EXPECT_EQ(rect.GetLeft(), 0.0f);
  EXPECT_EQ(rect.GetTop(), 0.0f);
  EXPECT_EQ(rect.GetRight(), 15.5f);
  EXPECT_EQ(rect.GetBottom(), 15.125f);
  EXPECT_EQ(rect.GetX(), 0.0f);
  EXPECT_EQ(rect.GetY(), 0.0f);
  EXPECT_EQ(rect.GetWidth(), 15.5f);
  EXPECT_EQ(rect.GetHeight(), 15.125f);
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

References impeller::TRect< Scalar >::MakeWH().

◆ TEST() [492/689]

impeller::testing::TEST	(	RectTest	,
		RectSimpleXYWH
	)

Definition at line 103 of file rect_unittests.cc.

                               {
  // Using fractional-power-of-2 friendly values for equality tests
  Rect rect = Rect::MakeXYWH(5.125f, 10.25f, 15.5f, 15.125f);
 
  EXPECT_EQ(rect.GetLeft(), 5.125f);
  EXPECT_EQ(rect.GetTop(), 10.25f);
  EXPECT_EQ(rect.GetRight(), 20.625f);
  EXPECT_EQ(rect.GetBottom(), 25.375f);
  EXPECT_EQ(rect.GetX(), 5.125f);
  EXPECT_EQ(rect.GetY(), 10.25f);
  EXPECT_EQ(rect.GetWidth(), 15.5f);
  EXPECT_EQ(rect.GetHeight(), 15.125f);
  EXPECT_FALSE(rect.IsEmpty());
  EXPECT_TRUE(rect.IsFinite());
}

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [493/689]

impeller::testing::TEST	(	RectTest	,
		RectUnion
	)

Definition at line 1607 of file rect_unittests.cc.

                          {
  auto check_nans = [](const Rect& a, const Rect& b, const std::string& label) {
    ASSERT_TRUE(a.IsFinite()) << label;
    ASSERT_TRUE(b.IsFinite()) << label;
    ASSERT_FALSE(a.Union(b).IsEmpty());
 
    for (int i = 1; i < 16; i++) {
      // NaN in a produces b
      EXPECT_EQ(swap_nan(a, i).Union(b), b) << label << ", index = " << i;
      // NaN in b produces a
      EXPECT_EQ(a.Union(swap_nan(b, i)), a) << label << ", index = " << i;
      // NaN in both is empty
      for (int j = 1; j < 16; j++) {
        EXPECT_TRUE(swap_nan(a, i).Union(swap_nan(b, j)).IsEmpty())
            << label << ", indices = " << i << ", " << j;
      }
    }
  };
 
  auto check_empty_flips = [](const Rect& a, const Rect& b,
                              const std::string& label) {
    ASSERT_FALSE(a.IsEmpty());
    // b is allowed to be empty
 
    // unflipped a vs flipped (empty) b yields a
    EXPECT_EQ(a.Union(flip_lr(b)), a) << label;
    EXPECT_EQ(a.Union(flip_tb(b)), a) << label;
    EXPECT_EQ(a.Union(flip_lrtb(b)), a) << label;
 
    // flipped (empty) a vs unflipped b yields b
    EXPECT_EQ(flip_lr(a).Union(b), b) << label;
    EXPECT_EQ(flip_tb(a).Union(b), b) << label;
    EXPECT_EQ(flip_lrtb(a).Union(b), b) << label;
 
    // flipped (empty) a vs flipped (empty) b yields empty
    EXPECT_TRUE(flip_lr(a).Union(flip_lr(b)).IsEmpty()) << label;
    EXPECT_TRUE(flip_tb(a).Union(flip_tb(b)).IsEmpty()) << label;
    EXPECT_TRUE(flip_lrtb(a).Union(flip_lrtb(b)).IsEmpty()) << label;
  };
 
  auto test = [&check_nans, &check_empty_flips](const Rect& a, const Rect& b,
                                                const Rect& result) {
    ASSERT_FALSE(a.IsEmpty()) << a;
    // b is allowed to be empty
 
    std::stringstream stream;
    stream << a << " union " << b;
    auto label = stream.str();
 
    EXPECT_EQ(a.Union(b), result) << label;
    EXPECT_EQ(b.Union(a), result) << label;
    check_empty_flips(a, b, label);
    check_nans(a, b, label);
  };
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 0, 0);
    auto expected = Rect::MakeXYWH(100, 100, 100, 100);
    test(a, b, expected);
  }
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(0, 0, 1, 1);
    auto expected = Rect::MakeXYWH(0, 0, 200, 200);
    test(a, b, expected);
  }
 
  {
    auto a = Rect::MakeXYWH(100, 100, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 1, 1);
    auto expected = Rect::MakeXYWH(10, 10, 190, 190);
    test(a, b, expected);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(10, 10, 100, 100);
    auto expected = Rect::MakeXYWH(0, 0, 110, 110);
    test(a, b, expected);
  }
 
  {
    auto a = Rect::MakeXYWH(0, 0, 100, 100);
    auto b = Rect::MakeXYWH(100, 100, 100, 100);
    auto expected = Rect::MakeXYWH(0, 0, 200, 200);
    test(a, b, expected);
  }
}

References flip_lr(), flip_lrtb(), flip_tb(), i, impeller::TRect< Scalar >::MakeXYWH(), and swap_nan().

◆ TEST() [494/689]

impeller::testing::TEST	(	RectTest	,
		RectXYWHIsEmpty
	)

Definition at line 1296 of file rect_unittests.cc.

                                {
  auto nan = std::numeric_limits<Scalar>::quiet_NaN();
 
  // Non-empty
  EXPECT_FALSE(Rect::MakeXYWH(1.5, 2.3, 10.5, 7.2).IsEmpty());
 
  // Empty both width and height both 0 or negative, in all combinations
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, 0.0).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, -1.0).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, -1.0).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, 0.0).IsEmpty());
 
  // Empty for 0 or negative width or height (but not both at the same time)
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, 0.0).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, -1.0).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 0.0, 7.2).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, -1.0, 7.2).IsEmpty());
 
  // Empty for NaN in width or height or both
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, 10.5, nan).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, nan, 7.2).IsEmpty());
  EXPECT_TRUE(Rect::MakeXYWH(1.5, 2.3, nan, nan).IsEmpty());
}

References impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [495/689]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBoundsAllFourCornersClipped
	)

Definition at line 3567 of file rect_unittests.cc.

                                                            {
  // This matrix should clip all four corners.
  auto matrix = impeller::Matrix::MakeColumn(
      // clang-format off
      2.0f, 0.0f, 0.0f, -.025f,
      0.0f, 2.0f, 0.0f, -.006f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 3.0f
      // clang-format on
  );
  Rect src = Rect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  // All of these should have a W<0
  //
  // When W<0 we interpolate the point back towards the adjacent points
  // that have W>0 to a location just greater than the W=0 half-plane.
  // We interpolate them to W=epsilon where epsilon == 2^-14.
 
  // In this case, none of the homogenous results are in bounds (W > 0)
  // so we can perform no interpolation - the operation is not visible.
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                      Vector3(200.0f, 200.0f, -0.1f));
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                      Vector3(400.0f, 200.0f, -2.6f));
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                      Vector3(200.0f, 400.0f, -0.7f));
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                      Vector3(400.0f, 400.0f, -3.2f));
 
  EXPECT_TRUE(src.TransformAndClipBounds(matrix).IsEmpty());
}

References EXPECT_VECTOR3_NEAR, impeller::Matrix::MakeColumn(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [496/689]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBoundsNoCornersClipped
	)

Definition at line 3365 of file rect_unittests.cc.

                                                       {
  // This matrix should clip no corners.
  auto matrix = impeller::Matrix::MakeColumn(
      // clang-format off
      2.0f, 0.0f, 0.0f, 0.0f,
      0.0f, 4.0f, 0.0f, 0.0f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 8.0f
      // clang-format on
  );
  Rect src = Rect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  // None of these should have a W<0
 
  EXPECT_EQ(matrix.TransformHomogenous(src.GetLeftTop()),
            Vector3(200.0f, 400.0f, 8.0f));
  EXPECT_EQ(matrix.TransformHomogenous(src.GetRightTop()),
            Vector3(400.0f, 400.0f, 8.0f));
  EXPECT_EQ(matrix.TransformHomogenous(src.GetLeftBottom()),
            Vector3(200.0f, 800.0f, 8.0f));
  EXPECT_EQ(matrix.TransformHomogenous(src.GetRightBottom()),
            Vector3(400.0f, 800.0f, 8.0f));
 
  Rect expect = Rect::MakeLTRB(25.0f, 50.0f, 50.0f, 100.0f);
  EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
  EXPECT_EQ(src.TransformAndClipBounds(matrix), expect);
}

References impeller::Matrix::MakeColumn(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [497/689]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBoundsOneCornerClipped
	)

Definition at line 3393 of file rect_unittests.cc.

                                                       {
  // This matrix should clip one corner.
  auto matrix = impeller::Matrix::MakeColumn(
      // clang-format off
      2.0f, 0.0f, 0.0f, -0.01f,
      0.0f, 2.0f, 0.0f, -0.006f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 3.0f
      // clang-format on
  );
  Rect src = Rect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  // Exactly one of these should have a W<0
  //
  // When W<0 we interpolate the point back towards the adjacent points
  // that have W>0 to a location just greater than the W=0 half-plane.
  // We interpolate them to W=epsilon where epsilon == 2^-14.
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                      Vector3(200.0f, 200.0f, 1.4f));
  // Contributes (200, 200) / 1.4 == (142.85714, 142.85714)
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                      Vector3(400.0f, 200.0f, 0.4f));
  // Contributes (400, 200) / 0.4 == (1000, 500)
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                      Vector3(200.0f, 400.0f, 0.8f));
  // Contributes (200, 400) / 0.8 == (250, 500)
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                      Vector3(400.0f, 400.0f, -0.2f));
  // Interpolates at epsilon against RightTop to produce:
  // t = (epsilon - -.2) / (.4 - -.2)
  //   = (epsilon + .2) / .6
  //   = 0.333435
  // Lerp(RightBottom, RightTop, 0.333435) = (400, 333.313, epsilon)
  //                                       = (6553600, 5461000)
  //
  // It also interpolates at epsilon against LeftBottom to produce:
  // t = (epsilon - -.2) / (.8 - -.2)
  //   = (epsilon + .2) / 1
  //   = 0.200061
  // Lerp(RightBottom, LeftBottom, 0.200061) = (359.988, 400, epsilon)
  //                                         = (5898040, 6553600)
 
  // Min/Max X and Y of all the points generated above are:
  // Min X == 142.85714
  // Min Y == 142.85714
  // Max X == 6553600
  // Max Y == 6553600
 
  Rect expect = Rect::MakeLTRB(142.85714f, 142.85714f, 6553600.f, 6553600.f);
  EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
  EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
}

References EXPECT_RECT_NEAR, EXPECT_VECTOR3_NEAR, impeller::Matrix::MakeColumn(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [498/689]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBoundsThreeCornersClipped
	)

Definition at line 3508 of file rect_unittests.cc.

                                                          {
  // This matrix should clip three corners.
  auto matrix = impeller::Matrix::MakeColumn(
      // clang-format off
      2.0f, 0.0f, 0.0f, -.02f,
      0.0f, 2.0f, 0.0f, -.006f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 3.0f
      // clang-format on
  );
  Rect src = Rect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  // Exactly three of these homogenous results should have a W<0
  //
  // When W<0 we interpolate the point back towards the adjacent points
  // that have W>0 to a location just greater than the W=0 half-plane.
  // We interpolate them to W=epsilon where epsilon == 2^-14.
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                      Vector3(200.0f, 200.0f, 0.4f));
  // Contributes (200, 200) / 0.4 == (500, 500) to bounds
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                      Vector3(400.0f, 200.0f, -1.6f));
  // Interpolates at epsilon against LeftTop to produce:
  // t = (epsilon - -1.6) / (.4 - -1.6)
  //   = (epsilon + 1.6) / 2
  //   = 0.8000305
  // Lerp(RightTop, LeftTop, 0.8000305) = (239.9939, 200, epsilon)
  //                                    = (3932060, 3276800)
  // Cannot interpolate against RightBottom because it also has W<0
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                      Vector3(200.0f, 400.0f, -0.2f));
  // Interpolates against LeftTop to produce:
  // t = (epsilon - -.2) / (.4 - -.2)
  //   = (epsilon + .2) / .6
  //   = 0.333435
  // Lerp(LeftBottom, LeftTop, .333435) = (200, 333.31299, epsilon)
  //                                    = (3276800, 5461000)
  // Cannot interpolate against RightBottom because it also has W<0
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                      Vector3(400.0f, 400.0f, -2.2f));
  // Cannot interpolate against either RightTop or LeftBottom because
  // both of those adjacent points transformed to a W<0 homogenous point.
 
  // Min/Max X and Y of all the points generated above are:
  // Min X == 500
  // Min Y == 500
  // Max X == 3932060
  // Max Y == 5461000
 
  Rect expect = Rect::MakeLTRB(500.0f, 500.0f, 3932060.f, 5461000.f);
 
  EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
  EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
}

References EXPECT_RECT_NEAR, EXPECT_VECTOR3_NEAR, impeller::Matrix::MakeColumn(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [499/689]

impeller::testing::TEST	(	RectTest	,
		TransformAndClipBoundsTwoCornersClipped
	)

Definition at line 3450 of file rect_unittests.cc.

                                                        {
  // This matrix should clip two corners.
  auto matrix = impeller::Matrix::MakeColumn(
      // clang-format off
      2.0f, 0.0f, 0.0f, -.015f,
      0.0f, 2.0f, 0.0f, -.006f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 3.0f
      // clang-format on
  );
  Rect src = Rect::MakeLTRB(100.0f, 100.0f, 200.0f, 200.0f);
 
  // Exactly two of these homogenous results should have a W<0
  //
  // When W<0 we interpolate the point back towards the adjacent points
  // that have W>0 to a location just greater than the W=0 half-plane.
  // We interpolate them to W=epsilon where epsilon == 2^-14.
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftTop()),
                      Vector3(200.0f, 200.0f, 0.9f));
  // Contributes (200, 200) / 0.9 == (222.2222, 222.2222) to bounds
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightTop()),
                      Vector3(400.0f, 200.0f, -0.6f));
  // Interpolates at epsilon against LeftTop to produce:
  // t = (epsilon - -.6) / (.9 - -.6)
  //   = (epsilon + .6) / 1.5
  //   = 0.4000407
  // Lerp(RightTop, LeftTop, 0.4000407) = (319.9919, 200, epsilon)
  //                                    = (5242747, 3276800)
  // Cannot interpolate against RightBottom because it also has W<0
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetLeftBottom()),
                      Vector3(200.0f, 400.0f, 0.3f));
  // Contributes (200, 400) / 0.3 == (666.6667, 1333.3333) to bounds
 
  EXPECT_VECTOR3_NEAR(matrix.TransformHomogenous(src.GetRightBottom()),
                      Vector3(400.0f, 400.0f, -1.2f));
  // Interpolates at epsilon against LeftBottom to produce:
  // t = (epsilon - -1.2) / (.3 - -1.2)
  //   = (epsilon + 1.2) / 1.5
  //   = 0.8000407
  // Lerp(RightBottom, LeftBottom, 0.8000407) = (239.9919, 400, epsilon)
  //                                          = (3932026.667, 6553600)
  // Cannot interpolate against RightTop because it also has W<0
 
  // Min/Max X and Y of all the points generated above are:
  // Min X == 222.2222
  // Min Y == 222.2222
  // Max X == 5242747
  // Max Y == 6553600
 
  Rect expect = Rect::MakeLTRB(222.2222f, 222.2222f, 5242747.f, 6553600.f);
 
  EXPECT_FALSE(src.TransformAndClipBounds(matrix).IsEmpty());
  EXPECT_RECT_NEAR(src.TransformAndClipBounds(matrix), expect);
}

References EXPECT_RECT_NEAR, EXPECT_VECTOR3_NEAR, impeller::Matrix::MakeColumn(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [500/689]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesMSAAResolveWithCorrectStore
	)

Definition at line 133 of file render_pass_builder_vk_unittests.cc.

                                                            {
  RenderPassBuilderVK builder = RenderPassBuilderVK();
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create an MSAA color attachment.
  builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                             SampleCount::kCount4, LoadAction::kClear,
                             StoreAction::kMultisampleResolve);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
 
  auto maybe_color = builder.GetColor0();
  ASSERT_TRUE(maybe_color.has_value());
  if (!maybe_color.has_value()) {
    return;
  }
  vk::AttachmentDescription color = maybe_color.value();
 
  // MSAA Texture.
  EXPECT_EQ(color.initialLayout, vk::ImageLayout::eUndefined);
  EXPECT_EQ(color.finalLayout, vk::ImageLayout::eGeneral);
  EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eClear);
  EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eDontCare);
 
  auto maybe_resolve = builder.GetColor0Resolve();
  ASSERT_TRUE(maybe_resolve.has_value());
  if (!maybe_resolve.has_value()) {
    return;
  }
  vk::AttachmentDescription resolve = maybe_resolve.value();
 
  // MSAA Resolve Texture.
  EXPECT_EQ(resolve.initialLayout, vk::ImageLayout::eUndefined);
  EXPECT_EQ(resolve.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
  EXPECT_EQ(resolve.loadOp, vk::AttachmentLoadOp::eClear);
  EXPECT_EQ(resolve.storeOp, vk::AttachmentStoreOp::eStore);
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::RenderPassBuilderVK::Build(), context, impeller::RenderPassBuilderVK::GetColor0(), impeller::RenderPassBuilderVK::GetColor0Resolve(), impeller::kClear, impeller::kCount4, impeller::kMultisampleResolve, impeller::kR8G8B8A8UNormInt, render_pass, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [501/689]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesRenderPassWithCombinedDepthStencil
	)

Definition at line 56 of file render_pass_builder_vk_unittests.cc.

                                                                   {
  RenderPassBuilderVK builder = RenderPassBuilderVK();
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create a single color attachment with a transient depth stencil.
  builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                             SampleCount::kCount1, LoadAction::kClear,
                             StoreAction::kStore, vk::ImageLayout::eGeneral);
  builder.SetDepthStencilAttachment(PixelFormat::kD24UnormS8Uint,
                                    SampleCount::kCount1, LoadAction::kDontCare,
                                    StoreAction::kDontCare);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
 
  std::optional<vk::AttachmentDescription> maybe_color = builder.GetColor0();
  ASSERT_TRUE(maybe_color.has_value());
  if (!maybe_color.has_value()) {
    return;
  }
  vk::AttachmentDescription color = maybe_color.value();
 
  EXPECT_EQ(color.initialLayout, vk::ImageLayout::eUndefined);
  EXPECT_EQ(color.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
  EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eClear);
  EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eStore);
 
  std::optional<vk::AttachmentDescription> maybe_depth_stencil =
      builder.GetDepthStencil();
  ASSERT_TRUE(maybe_depth_stencil.has_value());
  if (!maybe_depth_stencil.has_value()) {
    return;
  }
  vk::AttachmentDescription depth_stencil = maybe_depth_stencil.value();
 
  EXPECT_EQ(depth_stencil.initialLayout, vk::ImageLayout::eUndefined);
  EXPECT_EQ(depth_stencil.finalLayout,
            vk::ImageLayout::eDepthStencilAttachmentOptimal);
  EXPECT_EQ(depth_stencil.loadOp, vk::AttachmentLoadOp::eDontCare);
  EXPECT_EQ(depth_stencil.storeOp, vk::AttachmentStoreOp::eDontCare);
  EXPECT_EQ(depth_stencil.stencilLoadOp, vk::AttachmentLoadOp::eDontCare);
  EXPECT_EQ(depth_stencil.stencilStoreOp, vk::AttachmentStoreOp::eDontCare);
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::RenderPassBuilderVK::Build(), context, impeller::RenderPassBuilderVK::GetColor0(), impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kD24UnormS8Uint, impeller::kDontCare, impeller::kR8G8B8A8UNormInt, impeller::kStore, render_pass, impeller::RenderPassBuilderVK::SetColorAttachment(), and impeller::RenderPassBuilderVK::SetDepthStencilAttachment().

◆ TEST() [502/689]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesRenderPassWithNoDepthStencil
	)

Definition at line 15 of file render_pass_builder_vk_unittests.cc.

                                                             {
  RenderPassBuilderVK builder = RenderPassBuilderVK();
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create a single color attachment with a transient depth stencil.
  builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                             SampleCount::kCount1, LoadAction::kClear,
                             StoreAction::kStore);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
  EXPECT_FALSE(builder.GetDepthStencil().has_value());
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::RenderPassBuilderVK::Build(), context, impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kR8G8B8A8UNormInt, impeller::kStore, render_pass, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [503/689]

impeller::testing::TEST	(	RenderPassBuilder	,
		CreatesRenderPassWithOnlyStencil
	)

Definition at line 101 of file render_pass_builder_vk_unittests.cc.

                                                          {
  RenderPassBuilderVK builder = RenderPassBuilderVK();
  auto const context = MockVulkanContextBuilder().Build();
 
  // Create a single color attachment with a transient depth stencil.
  builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                             SampleCount::kCount1, LoadAction::kClear,
                             StoreAction::kStore);
  builder.SetStencilAttachment(PixelFormat::kS8UInt, SampleCount::kCount1,
                               LoadAction::kDontCare, StoreAction::kDontCare);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
 
  std::optional<vk::AttachmentDescription> maybe_depth_stencil =
      builder.GetDepthStencil();
  ASSERT_TRUE(maybe_depth_stencil.has_value());
  if (!maybe_depth_stencil.has_value()) {
    return;
  }
  vk::AttachmentDescription depth_stencil = maybe_depth_stencil.value();
 
  EXPECT_EQ(depth_stencil.initialLayout, vk::ImageLayout::eUndefined);
  EXPECT_EQ(depth_stencil.finalLayout,
            vk::ImageLayout::eDepthStencilAttachmentOptimal);
  EXPECT_EQ(depth_stencil.loadOp, vk::AttachmentLoadOp::eDontCare);
  EXPECT_EQ(depth_stencil.storeOp, vk::AttachmentStoreOp::eDontCare);
  EXPECT_EQ(depth_stencil.stencilLoadOp, vk::AttachmentLoadOp::eDontCare);
  EXPECT_EQ(depth_stencil.stencilStoreOp, vk::AttachmentStoreOp::eDontCare);
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::RenderPassBuilderVK::Build(), context, impeller::RenderPassBuilderVK::GetDepthStencil(), impeller::kClear, impeller::kCount1, impeller::kDontCare, impeller::kR8G8B8A8UNormInt, impeller::kS8UInt, impeller::kStore, render_pass, impeller::RenderPassBuilderVK::SetColorAttachment(), and impeller::RenderPassBuilderVK::SetStencilAttachment().

◆ TEST() [504/689]

impeller::testing::TEST	(	RenderPassBuilder	,
		RenderPassWithLoadOpUsesCurrentLayout
	)

Definition at line 30 of file render_pass_builder_vk_unittests.cc.

                                                               {
  RenderPassBuilderVK builder = RenderPassBuilderVK();
  auto const context = MockVulkanContextBuilder().Build();
 
  builder.SetColorAttachment(0, PixelFormat::kR8G8B8A8UNormInt,
                             SampleCount::kCount1, LoadAction::kLoad,
                             StoreAction::kStore,
                             vk::ImageLayout::eColorAttachmentOptimal);
 
  auto render_pass = builder.Build(context->GetDevice());
 
  EXPECT_TRUE(!!render_pass);
 
  std::optional<vk::AttachmentDescription> maybe_color = builder.GetColor0();
  ASSERT_TRUE(maybe_color.has_value());
  if (!maybe_color.has_value()) {
    return;
  }
  vk::AttachmentDescription color = maybe_color.value();
 
  EXPECT_EQ(color.initialLayout, vk::ImageLayout::eColorAttachmentOptimal);
  EXPECT_EQ(color.finalLayout, vk::ImageLayout::eShaderReadOnlyOptimal);
  EXPECT_EQ(color.loadOp, vk::AttachmentLoadOp::eLoad);
  EXPECT_EQ(color.storeOp, vk::AttachmentStoreOp::eStore);
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::RenderPassBuilderVK::Build(), context, impeller::RenderPassBuilderVK::GetColor0(), impeller::kCount1, impeller::kLoad, impeller::kR8G8B8A8UNormInt, impeller::kStore, render_pass, and impeller::RenderPassBuilderVK::SetColorAttachment().

◆ TEST() [505/689]

impeller::testing::TEST	(	RenderPassGLESTest	,
		ResolvingMultisampleTextureCachesResolveFBO
	)

Definition at line 173 of file render_pass_gles_unittests.cc.

                                                                      {
  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();
  auto& mock_gl_impl_ref = *mock_gl_impl;
  // Make sure implicit resolving isn't supported so we go down explicit path.
  auto mock_gl =
      MockGLES::Init(std::move(mock_gl_impl), std::nullopt, "OpenGL ES 3.0");
 
  auto context = CreateFakeGLESContext();
  auto dummy_worker = std::make_shared<MockWorker>();
  context->AddReactorWorker(dummy_worker);
  auto reactor = context->GetReactor();
 
  const auto command_buffer =
      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();
 
  const auto msaa_desc =
      TextureDescriptor{.type = TextureType::kTexture2DMultisample,
                        .format = PixelFormat::kR8G8B8A8UNormInt,
                        .size = {10, 10},
                        .usage = TextureUsage::kRenderTarget,
                        .sample_count = SampleCount::kCount4};
  const auto resolve_desc =
      TextureDescriptor{.storage_mode = StorageMode::kDevicePrivate,
                        .type = TextureType::kTexture2D,
                        .format = PixelFormat::kR8G8B8A8UNormInt,
                        .size = {10, 10},
                        .usage = TextureUsage::kRenderTarget,
                        .sample_count = SampleCount::kCount1};
 
  auto msaa_tex = std::make_shared<TextureGLES>(reactor, msaa_desc);
  auto resolve_tex = std::make_shared<TextureGLES>(reactor, resolve_desc);
 
  auto render_target = RenderTarget{};
  auto color_attachment = ColorAttachment{Attachment{
      .texture = msaa_tex,
      .resolve_texture = resolve_tex,
      .load_action = LoadAction::kClear,
      .store_action = StoreAction::kMultisampleResolve,
  }};
  color_attachment.clear_color = Color::Black();
  render_target.SetColorAttachment(color_attachment, 0);
 
  EXPECT_CALL(mock_gl_impl_ref, CheckFramebufferStatus(_))
      .WillRepeatedly(Return(GL_FRAMEBUFFER_COMPLETE));
 
  // Expect GenFramebuffers is called exactly once for the offscreen FBO,
  // and exactly once for the resolve FBO over two passes.
  EXPECT_CALL(mock_gl_impl_ref, GenFramebuffers(_, _)).Times(2);
 
  {
    const auto render_pass = command_buffer->CreateRenderPass(render_target);
    ASSERT_TRUE(render_pass->EncodeCommands());
    ASSERT_TRUE(reactor->React());
  }
  {
    const auto render_pass2 = command_buffer->CreateRenderPass(render_target);
    ASSERT_TRUE(render_pass2->EncodeCommands());
    ASSERT_TRUE(reactor->React());
  }
}

References impeller::Color::Black(), command_buffer, context, dummy_worker, impeller::testing::MockGLES::Init(), impeller::kClear, impeller::kCount1, impeller::kCount4, impeller::kDevicePrivate, impeller::kMultisampleResolve, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kTexture2D, impeller::kTexture2DMultisample, mock_gl, mock_gl_impl_ref, reactor, render_pass, impeller::TextureDescriptor::storage_mode, impeller::Attachment::texture, and impeller::TextureDescriptor::type.

◆ TEST() [506/689]

impeller::testing::TEST	(	RenderPassVK	,
		DoesNotRedundantlySetStencil
	)

Definition at line 18 of file render_pass_vk_unittests.cc.

                                                 {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
  std::shared_ptr<Context> copy = context;
  auto cmd_buffer = context->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(context->GetResourceAllocator());
  RenderTarget target = allocator.CreateOffscreenMSAA(*copy.get(), {1, 1}, 1);
 
  std::shared_ptr<RenderPass> render_pass =
      cmd_buffer->CreateRenderPass(target);
 
  // Stencil reference set once at buffer start.
  auto called_functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                       "vkCmdSetStencilReference"),
            1);
 
  // Duplicate stencil ref is not replaced.
  render_pass->SetStencilReference(0);
  render_pass->SetStencilReference(0);
  render_pass->SetStencilReference(0);
 
  called_functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                       "vkCmdSetStencilReference"),
            1);
 
  // Different stencil value is updated.
  render_pass->SetStencilReference(1);
  called_functions = GetMockVulkanFunctions(context->GetDevice());
  EXPECT_EQ(std::count(called_functions->begin(), called_functions->end(),
                       "vkCmdSetStencilReference"),
            2);
}

References allocator, impeller::testing::MockVulkanContextBuilder::Build(), context, GetMockVulkanFunctions(), render_pass, and target.

◆ TEST() [507/689]

impeller::testing::TEST	(	RenderPassVK	,
		SetViewportPropagatesAllUserSuppliedFields
	)

Definition at line 56 of file render_pass_vk_unittests.cc.

                                                               {
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
  auto cmd_buffer = context->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(context->GetResourceAllocator());
  RenderTarget target = allocator.CreateOffscreenMSAA(*context, {100, 100},
                                                      /*mip_count=*/1);
 
  std::shared_ptr<RenderPass> render_pass =
      cmd_buffer->CreateRenderPass(target);
 
  // The render pass constructor sets an initial full-target viewport. Capture
  // a reference to the recorded viewport list before the user-driven call so
  // we can isolate the call under test.
  VkCommandBuffer raw_cmd_buffer =
      CommandBufferVK::Cast(*cmd_buffer).GetCommandBuffer();
  const std::vector<VkViewport>& recorded =
      GetRecordedViewports(raw_cmd_buffer);
  ASSERT_EQ(recorded.size(), 1u);  // Initial full-target viewport.
 
  render_pass->SetViewport(Viewport{
      .rect = Rect::MakeXYWH(25, 10, 50, 80),
      .depth_range = DepthRange{.z_near = 0.25f, .z_far = 0.75f},
  });
 
  ASSERT_EQ(recorded.size(), 2u);
  const VkViewport& vp = recorded[1];
  EXPECT_FLOAT_EQ(vp.x, 25.0f);
  // Y is computed for the negative-height Y-flip: `y + height` of the
  // original rect.
  EXPECT_FLOAT_EQ(vp.y, 90.0f);
  EXPECT_FLOAT_EQ(vp.width, 50.0f);
  EXPECT_FLOAT_EQ(vp.height, -80.0f);
  EXPECT_FLOAT_EQ(vp.minDepth, 0.25f);
  EXPECT_FLOAT_EQ(vp.maxDepth, 0.75f);
}

References allocator, impeller::testing::MockVulkanContextBuilder::Build(), impeller::BackendCast< CommandBufferVK, CommandBuffer >::Cast(), context, impeller::CommandBufferVK::GetCommandBuffer(), GetRecordedViewports(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Viewport::rect, render_pass, target, and impeller::DepthRange::z_near.

◆ TEST() [508/689]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		CreatesANewInstance
	)

Definition at line 18 of file resource_manager_vk_unittests.cc.

                                                 {
  auto const a = ResourceManagerVK::Create();
  auto const b = ResourceManagerVK::Create();
  EXPECT_NE(a, b);
}

References impeller::ResourceManagerVK::Create().

◆ TEST() [509/689]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		IsThreadSafe
	)

Definition at line 58 of file resource_manager_vk_unittests.cc.

                                          {
  // In a typical app, there is a single ResourceManagerVK per app, shared b/w
  // threads.
  //
  // This test ensures that the ResourceManagerVK is thread-safe.
  std::weak_ptr<ResourceManagerVK> manager;
 
  {
    auto const manager = ResourceManagerVK::Create();
 
    // Spawn two threads, and have them both put resources into the manager.
    struct MockResource {};
 
    std::thread thread1([&manager]() {
      UniqueResourceVKT<MockResource>(manager, MockResource{});
    });
 
    std::thread thread2([&manager]() {
      UniqueResourceVKT<MockResource>(manager, MockResource{});
    });
 
    thread1.join();
    thread2.join();
  }
 
  // The thread should have terminated.
  EXPECT_EQ(manager.lock(), nullptr);
}

References impeller::ResourceManagerVK::Create(), and flutter::manager.

◆ TEST() [510/689]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		ReclaimMovesAResourceAndDestroysIt
	)

Definition at line 24 of file resource_manager_vk_unittests.cc.

                                                                {
  auto const manager = ResourceManagerVK::Create();
 
  auto waiter = fml::AutoResetWaitableEvent();
  auto dead = false;
  auto rattle = fml::ScopedCleanupClosure([&waiter]() { waiter.Signal(); });
 
  // Not killed immediately.
  EXPECT_FALSE(waiter.IsSignaledForTest());
 
  {
    auto resource = UniqueResourceVKT<fml::ScopedCleanupClosure>(
        manager, std::move(rattle));
  }
 
  waiter.Wait();
}

References impeller::ResourceManagerVK::Create(), and flutter::manager.

◆ TEST() [511/689]

impeller::testing::TEST	(	ResourceManagerVKTest	,
		TerminatesWhenOutOfScope
	)

Definition at line 43 of file resource_manager_vk_unittests.cc.

                                                      {
  // Originally, this shared_ptr was never destroyed, and the thread never
  // terminated. This test ensures that the thread terminates when the
  // ResourceManagerVK is out of scope.
  std::weak_ptr<ResourceManagerVK> manager;
 
  {
    auto shared = ResourceManagerVK::Create();
    manager = shared;
  }
 
  // The thread should have terminated.
  EXPECT_EQ(manager.lock(), nullptr);
}

References impeller::ResourceManagerVK::Create(), and flutter::manager.

◆ TEST() [512/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiCornersSameTolerance
	)

Definition at line 281 of file rounding_radii_unittests.cc.

                                                          {
  RoundingRadii radii{
      .top_left = {10, 20},
      .top_right = {10.01, 20.01},
      .bottom_left = {9.99, 19.99},
      .bottom_right = {9.99, 20.01},
  };
 
  EXPECT_TRUE(radii.AreAllCornersSame(.02));
 
  {
    RoundingRadii different = radii;
    different.top_left.width = 10.03;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.top_left.height = 20.03;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.top_right.width = 10.03;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.top_right.height = 20.03;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.bottom_left.width = 9.97;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.bottom_left.height = 19.97;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.bottom_right.width = 9.97;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
  {
    RoundingRadii different = radii;
    different.bottom_right.height = 20.03;
    EXPECT_FALSE(different.AreAllCornersSame(.02));
  }
}

References impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, flutter::Size::height(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and flutter::Size::width().

◆ TEST() [513/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiDefaultConstructor
	)

Definition at line 35 of file rounding_radii_unittests.cc.

                                                        {
  RoundingRadii radii = RoundingRadii();
 
  EXPECT_TRUE(radii.AreAllCornersEmpty());
  EXPECT_TRUE(radii.AreAllCornersSame());
  EXPECT_TRUE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size());
  EXPECT_EQ(radii.top_right, Size());
  EXPECT_EQ(radii.bottom_left, Size());
  EXPECT_EQ(radii.bottom_right, Size());
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [514/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptyDeclaration
	)

Definition at line 14 of file rounding_radii_unittests.cc.

                                                      {
  RoundingRadii radii;
 
  EXPECT_TRUE(radii.AreAllCornersEmpty());
  EXPECT_TRUE(radii.AreAllCornersSame());
  EXPECT_TRUE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size());
  EXPECT_EQ(radii.top_right, Size());
  EXPECT_EQ(radii.bottom_left, Size());
  EXPECT_EQ(radii.bottom_right, Size());
  EXPECT_EQ(radii.top_left.width, 0.0f);
  EXPECT_EQ(radii.top_left.height, 0.0f);
  EXPECT_EQ(radii.top_right.width, 0.0f);
  EXPECT_EQ(radii.top_right.height, 0.0f);
  EXPECT_EQ(radii.bottom_left.width, 0.0f);
  EXPECT_EQ(radii.bottom_left.height, 0.0f);
  EXPECT_EQ(radii.bottom_right.width, 0.0f);
  EXPECT_EQ(radii.bottom_right.height, 0.0f);
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, flutter::Size::height(), impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and flutter::Size::width().

◆ TEST() [515/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptyScalarConstructor
	)

Definition at line 61 of file rounding_radii_unittests.cc.

                                                            {
  RoundingRadii radii = RoundingRadii::MakeRadius(-5.0f);
 
  EXPECT_TRUE(radii.AreAllCornersEmpty());
  EXPECT_TRUE(radii.AreAllCornersSame());
  EXPECT_TRUE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size(-5.0f, -5.0f));
  EXPECT_EQ(radii.top_right, Size(-5.0f, -5.0f));
  EXPECT_EQ(radii.bottom_left, Size(-5.0f, -5.0f));
  EXPECT_EQ(radii.bottom_right, Size(-5.0f, -5.0f));
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [516/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEmptySizeConstructor
	)

Definition at line 87 of file rounding_radii_unittests.cc.

                                                          {
  {
    RoundingRadii radii = RoundingRadii::MakeRadii(Size(-5.0f, 6.0f));
 
    EXPECT_TRUE(radii.AreAllCornersEmpty());
    EXPECT_TRUE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size(-5.0f, 6.0f));
    EXPECT_EQ(radii.top_right, Size(-5.0f, 6.0f));
    EXPECT_EQ(radii.bottom_left, Size(-5.0f, 6.0f));
    EXPECT_EQ(radii.bottom_right, Size(-5.0f, 6.0f));
  }
 
  {
    RoundingRadii radii = RoundingRadii::MakeRadii(Size(5.0f, -6.0f));
 
    EXPECT_TRUE(radii.AreAllCornersEmpty());
    EXPECT_TRUE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size(5.0f, -6.0f));
    EXPECT_EQ(radii.top_right, Size(5.0f, -6.0f));
    EXPECT_EQ(radii.bottom_left, Size(5.0f, -6.0f));
    EXPECT_EQ(radii.bottom_right, Size(5.0f, -6.0f));
  }
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [517/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiEquals
	)

Definition at line 214 of file rounding_radii_unittests.cc.

                                            {
  RoundingRadii radii = {
      .top_left = Size(5.0f, 5.5f),
      .top_right = Size(6.0f, 6.5f),
      .bottom_left = Size(7.0f, 7.5f),
      .bottom_right = Size(8.0f, 8.5f),
  };
  RoundingRadii other = {
      .top_left = Size(5.0f, 5.5f),
      .top_right = Size(6.0f, 6.5f),
      .bottom_left = Size(7.0f, 7.5f),
      .bottom_right = Size(8.0f, 8.5f),
  };
 
  EXPECT_EQ(radii, other);
}

References impeller::RoundingRadii::top_left.

◆ TEST() [518/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiMultiply
	)

Definition at line 195 of file rounding_radii_unittests.cc.

                                              {
  RoundingRadii radii = {
      .top_left = Size(5.0f, 5.5f),
      .top_right = Size(6.0f, 6.5f),
      .bottom_left = Size(7.0f, 7.5f),
      .bottom_right = Size(8.0f, 8.5f),
  };
  RoundingRadii doubled = radii * 2.0f;
 
  EXPECT_FALSE(doubled.AreAllCornersEmpty());
  EXPECT_FALSE(doubled.AreAllCornersSame());
  EXPECT_FALSE(doubled.AreAllCornersCircular());
  EXPECT_TRUE(doubled.IsFinite());
  EXPECT_EQ(doubled.top_left, Size(10.0f, 11.0f));
  EXPECT_EQ(doubled.top_right, Size(12.0f, 13.0f));
  EXPECT_EQ(doubled.bottom_left, Size(14.0f, 15.0f));
  EXPECT_EQ(doubled.bottom_right, Size(16.0f, 17.0f));
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [519/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiNamedSizesConstructor
	)

Definition at line 115 of file rounding_radii_unittests.cc.

                                                           {
  RoundingRadii radii = {
      .top_left = Size(5.0f, 5.5f),
      .top_right = Size(6.0f, 6.5f),
      .bottom_left = Size(7.0f, 7.5f),
      .bottom_right = Size(8.0f, 8.5f),
  };
 
  EXPECT_FALSE(radii.AreAllCornersEmpty());
  EXPECT_FALSE(radii.AreAllCornersSame());
  EXPECT_FALSE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size(5.0f, 5.5f));
  EXPECT_EQ(radii.top_right, Size(6.0f, 6.5f));
  EXPECT_EQ(radii.bottom_left, Size(7.0f, 7.5f));
  EXPECT_EQ(radii.bottom_right, Size(8.0f, 8.5f));
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [520/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiNotEquals
	)

Definition at line 231 of file rounding_radii_unittests.cc.

                                               {
  const RoundingRadii radii = {
      .top_left = Size(5.0f, 5.5f),
      .top_right = Size(6.0f, 6.5f),
      .bottom_left = Size(7.0f, 7.5f),
      .bottom_right = Size(8.0f, 8.5f),
  };
 
  {
    RoundingRadii different = radii;
    different.top_left.width = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.top_left.height = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.top_right.width = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.top_right.height = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.bottom_left.width = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.bottom_left.height = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.bottom_right.width = 100.0f;
    EXPECT_NE(different, radii);
  }
  {
    RoundingRadii different = radii;
    different.bottom_right.height = 100.0f;
    EXPECT_NE(different, radii);
  }
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, flutter::Size::height(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and flutter::Size::width().

◆ TEST() [521/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiPartialNamedSizesConstructor
	)

Definition at line 133 of file rounding_radii_unittests.cc.

                                                                  {
  {
    RoundingRadii radii = {
        .top_left = Size(5.0f, 5.5f),
    };
 
    EXPECT_FALSE(radii.AreAllCornersEmpty());
    EXPECT_FALSE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size(5.0f, 5.5f));
    EXPECT_EQ(radii.top_right, Size());
    EXPECT_EQ(radii.bottom_left, Size());
    EXPECT_EQ(radii.bottom_right, Size());
  }
 
  {
    RoundingRadii radii = {
        .top_right = Size(6.0f, 6.5f),
    };
 
    EXPECT_FALSE(radii.AreAllCornersEmpty());
    EXPECT_FALSE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size());
    EXPECT_EQ(radii.top_right, Size(6.0f, 6.5f));
    EXPECT_EQ(radii.bottom_left, Size());
    EXPECT_EQ(radii.bottom_right, Size());
  }
 
  {
    RoundingRadii radii = {
        .bottom_left = Size(7.0f, 7.5f),
    };
 
    EXPECT_FALSE(radii.AreAllCornersEmpty());
    EXPECT_FALSE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size());
    EXPECT_EQ(radii.top_right, Size());
    EXPECT_EQ(radii.bottom_left, Size(7.0f, 7.5f));
    EXPECT_EQ(radii.bottom_right, Size());
  }
 
  {
    RoundingRadii radii = {
        .bottom_right = Size(8.0f, 8.5f),
    };
 
    EXPECT_FALSE(radii.AreAllCornersEmpty());
    EXPECT_FALSE(radii.AreAllCornersSame());
    EXPECT_FALSE(radii.AreAllCornersCircular());
    EXPECT_TRUE(radii.IsFinite());
    EXPECT_EQ(radii.top_left, Size());
    EXPECT_EQ(radii.top_right, Size());
    EXPECT_EQ(radii.bottom_left, Size());
    EXPECT_EQ(radii.bottom_right, Size(8.0f, 8.5f));
  }
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [522/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiScalarConstructor
	)

Definition at line 48 of file rounding_radii_unittests.cc.

                                                       {
  RoundingRadii radii = RoundingRadii::MakeRadius(5.0f);
 
  EXPECT_FALSE(radii.AreAllCornersEmpty());
  EXPECT_TRUE(radii.AreAllCornersSame());
  EXPECT_TRUE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size(5.0f, 5.0f));
  EXPECT_EQ(radii.top_right, Size(5.0f, 5.0f));
  EXPECT_EQ(radii.bottom_left, Size(5.0f, 5.0f));
  EXPECT_EQ(radii.bottom_right, Size(5.0f, 5.0f));
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [523/689]

impeller::testing::TEST	(	RoudingRadiiTest	,
		RoundingRadiiSizeConstructor
	)

Definition at line 74 of file rounding_radii_unittests.cc.

                                                     {
  RoundingRadii radii = RoundingRadii::MakeRadii(Size(5.0f, 6.0f));
 
  EXPECT_FALSE(radii.AreAllCornersEmpty());
  EXPECT_TRUE(radii.AreAllCornersSame());
  EXPECT_FALSE(radii.AreAllCornersCircular());
  EXPECT_TRUE(radii.IsFinite());
  EXPECT_EQ(radii.top_left, Size(5.0f, 6.0f));
  EXPECT_EQ(radii.top_right, Size(5.0f, 6.0f));
  EXPECT_EQ(radii.bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(radii.bottom_right, Size(5.0f, 6.0f));
}

References impeller::RoundingRadii::AreAllCornersCircular(), impeller::RoundingRadii::AreAllCornersEmpty(), impeller::RoundingRadii::AreAllCornersSame(), impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundingRadii::IsFinite(), impeller::RoundingRadii::MakeRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [524/689]

impeller::testing::TEST	(	RoundRectTest	,
		ContractAndRequireRadiiAdjustment
	)

Definition at line 496 of file round_rect_unittests.cc.

                                                       {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(-12.0);
  // Largest sum of paired radii sizes are the bottom and right edges
  // both of which sum to 12
  // Rect was 30x30 reduced by 12 on all sides leaving only 6x6, so all
  // radii are scaled by half to avoid overflowing the contracted rect
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(22.0f, 22.0f, 28.0f, 28.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(0.5f, 1.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(1.5f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(2.5f, 3.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(3.5f, 4.0f));
 
  // In this test, the MakeRectRadii constructor will make the same
  // adjustment to the radii that the Expand method applied.
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
 
  // In this test, the arguments to the constructor supply the correctly
  // adjusted radii (though there is no real way to tell other than
  // the result is the same).
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(22.0f, 22.0f, 6.0f, 6.0f),
                                     {
                                         .top_left = Size(0.5f, 1.0f),
                                         .top_right = Size(1.5f, 2.0f),
                                         .bottom_left = Size(2.5f, 3.0f),
                                         .bottom_right = Size(3.5f, 4.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [525/689]

impeller::testing::TEST	(	RoundRectTest	,
		ContractFourScalars
	)

Definition at line 464 of file round_rect_unittests.cc.

                                         {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(-1.0, -1.5, -2.0, -2.5);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 11.5f, 38.0f, 37.5f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(11.0f, 11.5f, 27.0f, 26.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [526/689]

impeller::testing::TEST	(	RoundRectTest	,
		ContractScalar
	)

Definition at line 400 of file round_rect_unittests.cc.

                                    {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(-2.0);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(12.0f, 12.0f, 38.0f, 38.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(12.0f, 12.0f, 26.0f, 26.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [527/689]

impeller::testing::TEST	(	RoundRectTest	,
		ContractTwoScalars
	)

Definition at line 432 of file round_rect_unittests.cc.

                                        {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(-1.0, -2.0);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(11.0f, 12.0f, 39.0f, 38.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(11.0f, 12.0f, 28.0f, 26.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [528/689]

impeller::testing::TEST	(	RoundRectTest	,
		DefaultConstructor
	)

Definition at line 41 of file round_rect_unittests.cc.

                                        {
  RoundRect round_rect = RoundRect();
 
  EXPECT_TRUE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect());
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [529/689]

impeller::testing::TEST	(	RoundRectTest	,
		DifferingCornersRoundRectContains
	)

Definition at line 652 of file round_rect_unittests.cc.

                                                       {
  Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  auto round_rect =
      RoundRect::MakeRectRadii(bounds, {
                                           .top_left = Size(2.0, 3.0),
                                           .top_right = Size(4.0, 5.0),
                                           .bottom_left = Size(6.0, 7.0),
                                           .bottom_right = Size(8.0, 9.0),
                                       });
 
  // For a corner with radii {A, B}, the "45 degree point" on the
  // corner curve will be at an offset of:
  //
  // (A * sqrt(2) / 2, B * sqrt(2) / 2)
  //
  // And the center(s) of these corners are at:
  //
  // (+/-(50 - A), +/-(50 - B))
  auto coord = [](Scalar radius) {
    return 50 - radius + radius * kSqrt2 / 2.0f - kEhCloseEnough;
  };
  auto coord_in = [&coord](Scalar radius) {
    return coord(radius) - kEhCloseEnough;
  };
  auto coord_out = [&coord](Scalar radius) {
    // For some reason 1 kEhCloseEnough is not enough to put us outside
    // in some of the cases, so we use 2x the epsilon.
    return coord(radius) + 2 * kEhCloseEnough;
  };
  // Upper left corner (radii = {2.0, 3.0})
  EXPECT_TRUE(round_rect.Contains({-coord_in(2.0), -coord_in(3.0)}));
  EXPECT_FALSE(round_rect.Contains({-coord_out(2.0), -coord_out(3.0)}));
  // Upper right corner (radii = {4.0, 5.0})
  EXPECT_TRUE(round_rect.Contains({coord_in(4.0), -coord_in(5.0)}));
  EXPECT_FALSE(round_rect.Contains({coord_out(4.0), -coord_out(5.0)}));
  // Lower left corner (radii = {6.0, 7.0})
  EXPECT_TRUE(round_rect.Contains({-coord_in(6.0), coord_in(7.0)}));
  EXPECT_FALSE(round_rect.Contains({-coord_out(6.0), coord_out(7.0)}));
  // Lower right corner (radii = {8.0, 9.0})
  EXPECT_TRUE(round_rect.Contains({coord_in(8.0), coord_in(9.0)}));
  EXPECT_FALSE(round_rect.Contains({coord_out(8.0), coord_out(9.0)}));
}

References flutter::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectRadii().

◆ TEST() [530/689]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyDeclaration
	)

Definition at line 14 of file round_rect_unittests.cc.

                                      {
  RoundRect round_rect;
 
  EXPECT_TRUE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect());
  EXPECT_EQ(round_rect.GetBounds().GetLeft(), 0.0f);
  EXPECT_EQ(round_rect.GetBounds().GetTop(), 0.0f);
  EXPECT_EQ(round_rect.GetBounds().GetRight(), 0.0f);
  EXPECT_EQ(round_rect.GetBounds().GetBottom(), 0.0f);
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
  EXPECT_EQ(round_rect.GetRadii().top_left.width, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().top_left.height, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().top_right.width, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().top_right.height, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().bottom_left.width, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().bottom_left.height, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().bottom_right.width, 0.0f);
  EXPECT_EQ(round_rect.GetRadii().bottom_right.height, 0.0f);
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), flutter::Size::height(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, and flutter::Size::width().

◆ TEST() [531/689]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyOvalConstruction
	)

Definition at line 104 of file round_rect_unittests.cc.

                                           {
  RoundRect round_rect = RoundRect::MakeRectXY(
      Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f), 10.0f, 10.0f);
 
  EXPECT_TRUE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [532/689]

impeller::testing::TEST	(	RoundRectTest	,
		EmptyRectConstruction
	)

Definition at line 56 of file round_rect_unittests.cc.

                                           {
  RoundRect round_rect =
      RoundRect::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
 
  EXPECT_TRUE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_TRUE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(20.0f, 20.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [533/689]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandFourScalars
	)

Definition at line 368 of file round_rect_unittests.cc.

                                       {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(5.0, 6.0, 7.0, 8.0);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 47.0f, 48.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 4.0f, 42.0f, 44.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [534/689]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandScalar
	)

Definition at line 304 of file round_rect_unittests.cc.

                                  {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(5.0);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 5.0f, 45.0f, 45.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 5.0f, 40.0f, 40.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [535/689]

impeller::testing::TEST	(	RoundRectTest	,
		ExpandTwoScalars
	)

Definition at line 336 of file round_rect_unittests.cc.

                                      {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect expanded = round_rect.Expand(5.0, 6.0);
 
  EXPECT_FALSE(expanded.IsEmpty());
  EXPECT_FALSE(expanded.IsRect());
  EXPECT_FALSE(expanded.IsOval());
  EXPECT_TRUE(expanded.IsFinite());
  EXPECT_FALSE(expanded.GetBounds().IsEmpty());
  EXPECT_EQ(expanded.GetBounds(), Rect::MakeLTRB(5.0f, 4.0f, 45.0f, 46.0f));
  EXPECT_EQ(expanded.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(expanded.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(expanded.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(expanded,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(5.0f, 4.0f, 40.0f, 42.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::RoundRect::Expand(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST() [536/689]

impeller::testing::TEST	(	RoundRectTest	,
		InvertedOvalConstruction
	)

Definition at line 136 of file round_rect_unittests.cc.

                                              {
  RoundRect round_rect = RoundRect::MakeRectXY(
      Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f), 10.0f, 10.0f);
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_TRUE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(5.0f, 5.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [537/689]

impeller::testing::TEST	(	RoundRectTest	,
		InvertedRectConstruction
	)

Definition at line 88 of file round_rect_unittests.cc.

                                              {
  RoundRect round_rect =
      RoundRect::MakeRect(Rect::MakeLTRB(20.0f, 20.0f, 10.0f, 10.0f));
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_TRUE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [538/689]

impeller::testing::TEST	(	RoundRectTest	,
		NoCornerRoundRectContains
	)

Definition at line 546 of file round_rect_unittests.cc.

                                               {
  Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  // RRect of bounds with no corners contains corners just barely
  auto no_corners = RoundRect::MakeRectXY(bounds, 0.0f, 0.0f);
 
  EXPECT_TRUE(no_corners.Contains({-50, -50}));
  // Rectangles have half-in, half-out containment so we need
  // to be careful about testing containment of right/bottom corners.
  EXPECT_TRUE(no_corners.Contains({-50, 49.99}));
  EXPECT_TRUE(no_corners.Contains({49.99, -50}));
  EXPECT_TRUE(no_corners.Contains({49.99, 49.99}));
  EXPECT_FALSE(no_corners.Contains({-50.01, -50}));
  EXPECT_FALSE(no_corners.Contains({-50, -50.01}));
  EXPECT_FALSE(no_corners.Contains({-50.01, 50}));
  EXPECT_FALSE(no_corners.Contains({-50, 50.01}));
  EXPECT_FALSE(no_corners.Contains({50.01, -50}));
  EXPECT_FALSE(no_corners.Contains({50, -50.01}));
  EXPECT_FALSE(no_corners.Contains({50.01, 50}));
  EXPECT_FALSE(no_corners.Contains({50, 50.01}));
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [539/689]

impeller::testing::TEST	(	RoundRectTest	,
		OvalConstructor
	)

Definition at line 120 of file round_rect_unittests.cc.

                                     {
  RoundRect round_rect =
      RoundRect::MakeOval(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_TRUE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(5.0f, 5.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(5.0f, 5.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeOval(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [540/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectConstructor
	)

Definition at line 72 of file round_rect_unittests.cc.

                                     {
  RoundRect round_rect =
      RoundRect::MakeRect(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_TRUE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size());
  EXPECT_EQ(round_rect.GetRadii().top_right, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size());
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size());
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRect(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [541/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiConstructor
	)

Definition at line 200 of file round_rect_unittests.cc.

                                          {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f),
                               {
                                   .top_left = Size(1.0, 1.5),
                                   .top_right = Size(2.0, 2.5f),
                                   .bottom_left = Size(3.0, 3.5f),
                                   .bottom_right = Size(4.0, 4.5f),
                               });
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(1.0f, 1.5f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 2.5f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(3.0f, 3.5f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(4.0f, 4.5f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [542/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiOverflowHeightConstructor
	)

Definition at line 247 of file round_rect_unittests.cc.

                                                        {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 6.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  // Largest sum of paired radii heights is the right edge which sums to 12
  // Rect is only 6 tall so all radii are scaled by half
  // Rect is 30 wide so no scaling should happen due to radii widths
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 40.0f, 16.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(0.5f, 1.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(1.5f, 2.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.5f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(3.5f, 4.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [543/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiiOverflowWidthConstructor
	)

Definition at line 222 of file round_rect_unittests.cc.

                                                       {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 6.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  // Largest sum of paired radii widths is the bottom edge which sums to 12
  // Rect is only 6 wide so all radii are scaled by half
  // Rect is 30 tall so no scaling should happen due to radii heights
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 16.0f, 40.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(0.5f, 1.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(1.5f, 2.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.5f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(3.5f, 4.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [544/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectRadiusConstructor
	)

Definition at line 152 of file round_rect_unittests.cc.

                                           {
  RoundRect round_rect = RoundRect::MakeRectRadius(
      Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f);
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 2.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 2.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 2.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 2.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadius(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [545/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectSizeConstructor
	)

Definition at line 184 of file round_rect_unittests.cc.

                                         {
  RoundRect round_rect = RoundRect::MakeRectXY(
      Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), Size(2.0f, 3.0f));
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 3.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [546/689]

impeller::testing::TEST	(	RoundRectTest	,
		RectXYConstructor
	)

Definition at line 168 of file round_rect_unittests.cc.

                                       {
  RoundRect round_rect = RoundRect::MakeRectXY(
      Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f), 2.0f, 3.0f);
 
  EXPECT_FALSE(round_rect.IsEmpty());
  EXPECT_FALSE(round_rect.IsRect());
  EXPECT_FALSE(round_rect.IsOval());
  EXPECT_TRUE(round_rect.IsFinite());
  EXPECT_FALSE(round_rect.GetBounds().IsEmpty());
  EXPECT_EQ(round_rect.GetBounds(), Rect::MakeLTRB(10.0f, 10.0f, 20.0f, 20.0f));
  EXPECT_EQ(round_rect.GetRadii().top_left, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().top_right, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_left, Size(2.0f, 3.0f));
  EXPECT_EQ(round_rect.GetRadii().bottom_right, Size(2.0f, 3.0f));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), impeller::RoundRect::IsEmpty(), impeller::RoundRect::IsFinite(), impeller::RoundRect::IsOval(), impeller::RoundRect::IsRect(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::RoundingRadii::top_left, and impeller::RoundingRadii::top_right.

◆ TEST() [547/689]

impeller::testing::TEST	(	RoundRectTest	,
		Shift
	)

Definition at line 272 of file round_rect_unittests.cc.

                           {
  RoundRect round_rect =
      RoundRect::MakeRectRadii(Rect::MakeXYWH(10.0f, 10.0f, 30.0f, 30.0f),
                               {
                                   .top_left = Size(1.0f, 2.0f),
                                   .top_right = Size(3.0f, 4.0f),
                                   .bottom_left = Size(5.0f, 6.0f),
                                   .bottom_right = Size(7.0f, 8.0f),
                               });
  RoundRect shifted = round_rect.Shift(5.0, 6.0);
 
  EXPECT_FALSE(shifted.IsEmpty());
  EXPECT_FALSE(shifted.IsRect());
  EXPECT_FALSE(shifted.IsOval());
  EXPECT_TRUE(shifted.IsFinite());
  EXPECT_FALSE(shifted.GetBounds().IsEmpty());
  EXPECT_EQ(shifted.GetBounds(), Rect::MakeLTRB(15.0f, 16.0f, 45.0f, 46.0f));
  EXPECT_EQ(shifted.GetRadii().top_left, Size(1.0f, 2.0f));
  EXPECT_EQ(shifted.GetRadii().top_right, Size(3.0f, 4.0f));
  EXPECT_EQ(shifted.GetRadii().bottom_left, Size(5.0f, 6.0f));
  EXPECT_EQ(shifted.GetRadii().bottom_right, Size(7.0f, 8.0f));
 
  EXPECT_EQ(shifted,
            RoundRect::MakeRectRadii(Rect::MakeXYWH(15.0f, 16.0f, 30.0f, 30.0f),
                                     {
                                         .top_left = Size(1.0f, 2.0f),
                                         .top_right = Size(3.0f, 4.0f),
                                         .bottom_left = Size(5.0f, 6.0f),
                                         .bottom_right = Size(7.0f, 8.0f),
                                     }));
}

References impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::RoundRect::Shift().

◆ TEST() [548/689]

impeller::testing::TEST	(	RoundRectTest	,
		TinyCornerRoundRectContains
	)

Definition at line 567 of file round_rect_unittests.cc.

                                                 {
  Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  // RRect of bounds with even the tiniest corners does not contain corners
  auto tiny_corners = RoundRect::MakeRectXY(bounds, 0.01f, 0.01f);
 
  EXPECT_FALSE(tiny_corners.Contains({-50, -50}));
  EXPECT_FALSE(tiny_corners.Contains({-50, 50}));
  EXPECT_FALSE(tiny_corners.Contains({50, -50}));
  EXPECT_FALSE(tiny_corners.Contains({50, 50}));
}

References impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [549/689]

impeller::testing::TEST	(	RoundRectTest	,
		UniformCircularRoundRectContains
	)

Definition at line 578 of file round_rect_unittests.cc.

                                                      {
  Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  auto expanded_2_r_2 = RoundRect::MakeRectXY(bounds.Expand(2.0), 2.0f, 2.0f);
 
  // Expanded by 2.0 and then with a corner of 2.0 obviously still
  // contains the corners
  EXPECT_TRUE(expanded_2_r_2.Contains({-50, -50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({-50, 50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({50, -50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({50, 50}));
 
  // Now we try to box in the corner containment to exactly where the
  // rounded corner of the expanded round rect with radii of 2.0 lies.
  // The 45-degree diagonal point of a circle of radius 2.0 lies at:
  //
  // (2 * sqrt(2) / 2, 2 * sqrt(2) / 2)
  // (sqrt(2), sqrt(2))
  //
  // So we test +/- (50 + sqrt(2) +/- epsilon)
  const auto coord_out = 50 + kSqrt2 + kEhCloseEnough;
  const auto coord_in = 50 + kSqrt2 - kEhCloseEnough;
  // Upper left corner
  EXPECT_TRUE(expanded_2_r_2.Contains({-coord_in, -coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({-coord_out, -coord_out}));
  // Upper right corner
  EXPECT_TRUE(expanded_2_r_2.Contains({coord_in, -coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({coord_out, -coord_out}));
  // Lower left corner
  EXPECT_TRUE(expanded_2_r_2.Contains({-coord_in, coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({-coord_out, coord_out}));
  // Lower right corner
  EXPECT_TRUE(expanded_2_r_2.Contains({coord_in, coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({coord_out, coord_out}));
}

References flutter::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [550/689]

impeller::testing::TEST	(	RoundRectTest	,
		UniformEllipticalRoundRectContains
	)

Definition at line 613 of file round_rect_unittests.cc.

                                                        {
  Rect bounds = Rect::MakeLTRB(-50.0f, -50.0f, 50.0f, 50.0f);
  auto expanded_2_r_2 = RoundRect::MakeRectXY(bounds.Expand(2.0), 2.0f, 3.0f);
 
  // Expanded by 2.0 and then with a corner of 2x3 should still
  // contain the corners
  EXPECT_TRUE(expanded_2_r_2.Contains({-50, -50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({-50, 50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({50, -50}));
  EXPECT_TRUE(expanded_2_r_2.Contains({50, 50}));
 
  // Now we try to box in the corner containment to exactly where the
  // rounded corner of the expanded round rect with radii of 2x3 lies.
  // The "45-degree diagonal point" of an ellipse of radii 2x3 lies at:
  //
  // (2 * sqrt(2) / 2, 3 * sqrt(2) / 2)
  // (sqrt(2), 3 * sqrt(2) / 2)
  //
  // And the center(s) of these corners are at:
  // (+/-(50 + 2 - 2), +/-(50 + 2 - 3))
  // = (+/-50, +/-49)
  const auto x_coord_out = 50 + kSqrt2 + kEhCloseEnough;
  const auto x_coord_in = 50 + kSqrt2 - kEhCloseEnough;
  const auto y_coord_out = 49 + 3 * kSqrt2 / 2 + kEhCloseEnough;
  const auto y_coord_in = 49 + 3 * kSqrt2 / 2 - kEhCloseEnough;
  // Upper left corner
  EXPECT_TRUE(expanded_2_r_2.Contains({-x_coord_in, -y_coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({-x_coord_out, -y_coord_out}));
  // Upper right corner
  EXPECT_TRUE(expanded_2_r_2.Contains({x_coord_in, -y_coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({x_coord_out, -y_coord_out}));
  // Lower left corner
  EXPECT_TRUE(expanded_2_r_2.Contains({-x_coord_in, y_coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({-x_coord_out, y_coord_out}));
  // Lower right corner
  EXPECT_TRUE(expanded_2_r_2.Contains({x_coord_in, y_coord_in}));
  EXPECT_FALSE(expanded_2_r_2.Contains({x_coord_out, y_coord_out}));
}

References flutter::kEhCloseEnough, impeller::kSqrt2, impeller::TRect< Scalar >::MakeLTRB(), and impeller::RoundRect::MakeRectXY().

◆ TEST() [551/689]

impeller::testing::TEST	(	RSTransformTest	,
		CompareToMatrix
	)

Definition at line 32 of file rstransform_unittests.cc.

                                       {
  for (int tx = 0; tx <= 100; tx += 10) {
    for (int ty = 0; ty <= 100; ty += 10) {
      Point origin(tx, ty);
      for (int scale = 1; scale <= 20; scale += 5) {
        // Overshoot a full circle by 30 degrees
        for (int degrees = 0; degrees <= 390; degrees += 45) {
          auto matrix = Matrix::MakeTranslation(origin) *
                        Matrix::MakeRotationZ(Degrees(degrees)) *
                        Matrix::MakeScale(Vector2(scale, scale));
          auto rst = RSTransform::Make(origin, scale, Degrees(degrees));
          EXPECT_MATRIX_NEAR(rst.GetMatrix(), matrix);
          for (int w = 10; w <= 100; w += 10) {
            for (int h = 10; h <= 100; h += 10) {
              Quad q = rst.GetQuad(w, h);
              auto points = Rect::MakeWH(w, h).GetTransformedPoints(matrix);
              for (int i = 0; i < 4; i++) {
                EXPECT_NEAR(q[i].x, points[i].x, kEhCloseEnough);
                EXPECT_NEAR(q[i].y, points[i].y, kEhCloseEnough);
              }
            }
          }
        }
      }
    }
  }
}

References EXPECT_MATRIX_NEAR, impeller::TRect< T >::GetTransformedPoints(), flutter::h, i, flutter::kEhCloseEnough, impeller::RSTransform::Make(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeWH(), points, x, and y.

◆ TEST() [552/689]

impeller::testing::TEST	(	RSTransformTest	,
		Construction
	)

Definition at line 14 of file rstransform_unittests.cc.

                                    {
  RSTransform transform = RSTransform::Make({10.0f, 12.0f}, 2.0f, Degrees(90));
 
  EXPECT_EQ(transform.scaled_cos, 0.0f);
  EXPECT_EQ(transform.scaled_sin, 2.0f);
  EXPECT_EQ(transform.translate_x, 10.0f);
  EXPECT_EQ(transform.translate_y, 12.0f);
 
  EXPECT_EQ(transform.GetBounds(20.0f, 30.0f),
            // relative corners are at
            // 0, 0
            // 0, 40
            // -60, 0
            // -60, 40
            // then add 10, 12 to all values
            Rect::MakeLTRB(10 + -2 * 30, 12 + 0, 10 + 0, 12 + 40));
}

References impeller::RSTransform::Make(), impeller::TRect< Scalar >::MakeLTRB(), and transform.

◆ TEST() [553/689]

impeller::testing::TEST	(	SamplerDescriptorTest	,
		ToKeyIncludesAllFields
	)

Definition at line 11 of file sampler_descriptor_unittests.cc.

                                                    {
  SamplerDescriptor a;
  SamplerDescriptor b;
  EXPECT_EQ(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
 
  b.min_filter = MinMagFilter::kLinear;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.mag_filter = MinMagFilter::kLinear;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.mip_filter = MipFilter::kLinear;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.width_address_mode = SamplerAddressMode::kRepeat;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.height_address_mode = SamplerAddressMode::kRepeat;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.depth_address_mode = SamplerAddressMode::kRepeat;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b = SamplerDescriptor{};
 
  b.max_anisotropy = 16;
  EXPECT_NE(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
  b.max_anisotropy = 1;
  EXPECT_EQ(SamplerDescriptor::ToKey(a), SamplerDescriptor::ToKey(b));
}

References impeller::kLinear, impeller::kRepeat, and impeller::SamplerDescriptor::ToKey().

◆ TEST() [554/689]

impeller::testing::TEST	(	SamplerLibraryVK	,
		MaxAnisotropyIsClampedToTheDeviceLimit
	)

Definition at line 38 of file sampler_library_vk_unittests.cc.

                                                               {
  auto const context = MockVulkanContextBuilder().Build();
 
  std::shared_ptr<SamplerLibrary> library = std::make_shared<SamplerLibraryVK>(
      context->GetDeviceHolder(), /*max_sampler_anisotropy=*/4u);
 
  SamplerDescriptor desc;
  desc.min_filter = MinMagFilter::kLinear;
  desc.mag_filter = MinMagFilter::kLinear;
  desc.mip_filter = MipFilter::kLinear;
  desc.max_anisotropy = 16;
 
  auto sampler = library->GetSampler(desc);
  EXPECT_EQ(sampler->GetDescriptor().max_anisotropy, 4u);
 
  // Clamped values share a cache entry.
  desc.max_anisotropy = 8;
  EXPECT_EQ(library->GetSampler(desc), sampler);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::kLinear, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::max_anisotropy, impeller::SamplerDescriptor::min_filter, and impeller::SamplerDescriptor::mip_filter.

◆ TEST() [555/689]

impeller::testing::TEST	(	SamplerLibraryVK	,
		MaxAnisotropyIsDisabledWhenUnsupported
	)

Definition at line 58 of file sampler_library_vk_unittests.cc.

                                                               {
  auto const context = MockVulkanContextBuilder().Build();
 
  std::shared_ptr<SamplerLibrary> library = std::make_shared<SamplerLibraryVK>(
      context->GetDeviceHolder(), /*max_sampler_anisotropy=*/1u);
 
  SamplerDescriptor desc;
  desc.min_filter = MinMagFilter::kLinear;
  desc.mag_filter = MinMagFilter::kLinear;
  desc.mip_filter = MipFilter::kLinear;
  desc.max_anisotropy = 16;
 
  auto sampler = library->GetSampler(desc);
  EXPECT_EQ(sampler->GetDescriptor().max_anisotropy, 1u);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::kLinear, impeller::SamplerDescriptor::mag_filter, impeller::SamplerDescriptor::max_anisotropy, impeller::SamplerDescriptor::min_filter, and impeller::SamplerDescriptor::mip_filter.

◆ TEST() [556/689]

impeller::testing::TEST	(	SamplerLibraryVK	,
		WorkaroundsCanDisableReadingFromMipLevels
	)

Definition at line 18 of file sampler_library_vk_unittests.cc.

                                                                  {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto library_vk = std::make_shared<SamplerLibraryVK>(
      context->GetDeviceHolder(), /*max_sampler_anisotropy=*/1u);
  std::shared_ptr<SamplerLibrary> library = library_vk;
 
  SamplerDescriptor desc;
  desc.mip_filter = MipFilter::kLinear;
 
  auto sampler = library->GetSampler(desc);
  EXPECT_EQ(sampler->GetDescriptor().mip_filter, MipFilter::kLinear);
 
  // Apply mips disabled workaround.
  library_vk->ApplyWorkarounds(WorkaroundsVK{.broken_mipmap_generation = true});
 
  sampler = library->GetSampler(desc);
  EXPECT_EQ(sampler->GetDescriptor().mip_filter, MipFilter::kBase);
}

References impeller::WorkaroundsVK::broken_mipmap_generation, impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::kBase, impeller::kLinear, and impeller::SamplerDescriptor::mip_filter.

◆ TEST() [557/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingFiniteDoubleToFloatStaysFinite
	)

Definition at line 981 of file saturated_math_unittests.cc.

                                                           {
  const double d_max = std::numeric_limits<double>::max();
  const float f_max = std::numeric_limits<float>::max();
 
  {
    const float result = saturated::Cast<double, float>(d_max);
    EXPECT_EQ(result, f_max);
  }
 
  {
    const float result = saturated::Cast<double, float>(-d_max);
    EXPECT_EQ(result, -f_max);
  }
}

◆ TEST() [558/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingInfiniteDoubleToFloatStaysInfinite
	)

Definition at line 996 of file saturated_math_unittests.cc.

                                                               {
  const double d_inf = std::numeric_limits<double>::infinity();
  const float f_max = std::numeric_limits<float>::infinity();
 
  {
    const float result = saturated::Cast<double, float>(d_inf);
    EXPECT_EQ(result, f_max);
  }
 
  {
    const float result = saturated::Cast<double, float>(-d_inf);
    EXPECT_EQ(result, -f_max);
  }
}

◆ TEST() [559/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingInfiniteScalarToSignedIntProducesLimit
	)

Definition at line 1066 of file saturated_math_unittests.cc.

                                                                   {
  // larger than even any [u]int64_t;
  const Scalar inf = std::numeric_limits<Scalar>::infinity();
 
  {
    const auto result = saturated::Cast<Scalar, int8_t>(inf);
    EXPECT_EQ(result, int8_t(0x7F));
  }
  {
    const auto result = saturated::Cast<Scalar, int8_t>(-inf);
    EXPECT_EQ(result, int8_t(0x80));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int16_t>(inf);
    EXPECT_EQ(result, int16_t(0x7FFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int16_t>(-inf);
    EXPECT_EQ(result, int16_t(0x8000));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int32_t>(inf);
    EXPECT_EQ(result, int32_t(0x7FFFFFFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int32_t>(-inf);
    EXPECT_EQ(result, int32_t(0x80000000));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int64_t>(inf);
    EXPECT_EQ(result, int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int64_t>(-inf);
    EXPECT_EQ(result, int64_t(0x8000000000000000));
  }
}

◆ TEST() [560/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingLargeScalarToSignedIntProducesLimit
	)

Definition at line 1025 of file saturated_math_unittests.cc.

                                                                {
  // larger than even any [u]int64_t;
  const Scalar large = 1e20f;
 
  {
    const auto result = saturated::Cast<Scalar, int8_t>(large);
    EXPECT_EQ(result, int8_t(0x7F));
  }
  {
    const auto result = saturated::Cast<Scalar, int8_t>(-large);
    EXPECT_EQ(result, int8_t(0x80));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int16_t>(large);
    EXPECT_EQ(result, int16_t(0x7FFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int16_t>(-large);
    EXPECT_EQ(result, int16_t(0x8000));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int32_t>(large);
    EXPECT_EQ(result, int32_t(0x7FFFFFFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int32_t>(-large);
    EXPECT_EQ(result, int32_t(0x80000000));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int64_t>(large);
    EXPECT_EQ(result, int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    const auto result = saturated::Cast<Scalar, int64_t>(-large);
    EXPECT_EQ(result, int64_t(0x8000000000000000));
  }
}

◆ TEST() [561/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingNaNDoubleToFloatStaysNaN
	)

Definition at line 1011 of file saturated_math_unittests.cc.

                                                     {
  const double d_nan = std::numeric_limits<double>::quiet_NaN();
 
  {
    const float result = saturated::Cast<double, float>(d_nan);
    EXPECT_TRUE(std::isnan(result));
  }
 
  {
    const float result = saturated::Cast<double, float>(-d_nan);
    EXPECT_TRUE(std::isnan(result));
  }
}

◆ TEST() [562/689]

impeller::testing::TEST	(	SaturatedMath	,
		CastingNaNScalarToSignedIntProducesZero
	)

Definition at line 1107 of file saturated_math_unittests.cc.

                                                             {
  // larger than even any [u]int64_t;
  const Scalar nan = std::numeric_limits<Scalar>::quiet_NaN();
 
  {
    const auto result = saturated::Cast<Scalar, int8_t>(nan);
    EXPECT_EQ(result, int8_t(0));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int16_t>(nan);
    EXPECT_EQ(result, int16_t(0));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int32_t>(nan);
    EXPECT_EQ(result, int32_t(0));
  }
 
  {
    const auto result = saturated::Cast<Scalar, int64_t>(nan);
    EXPECT_EQ(result, int64_t(0));
  }
}

◆ TEST() [563/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitAddOfFloatingPoint
	)

Definition at line 136 of file saturated_math_unittests.cc.

                                                {
  {
    const float inf = std::numeric_limits<float>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add<float>(big, big), max);
    EXPECT_EQ(saturated::Add<float>(max, big), inf);
    EXPECT_EQ(saturated::Add<float>(big, max), inf);
    EXPECT_EQ(saturated::Add<float>(max, max), inf);
    EXPECT_EQ(saturated::Add<float>(max, inf), inf);
    EXPECT_EQ(saturated::Add<float>(inf, max), inf);
    EXPECT_EQ(saturated::Add<float>(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add<float>(-big, -big), -max);
    EXPECT_EQ(saturated::Add<float>(-max, -big), -inf);
    EXPECT_EQ(saturated::Add<float>(-big, -max), -inf);
    EXPECT_EQ(saturated::Add<float>(-max, -max), -inf);
    EXPECT_EQ(saturated::Add<float>(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add<float>(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add<float>(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add<float>(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add<float>(max, -big), big);
    EXPECT_EQ(saturated::Add<float>(big, -max), -big);
    EXPECT_EQ(saturated::Add<float>(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add<float>(max, -inf), -inf);
    EXPECT_EQ(saturated::Add<float>(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add<float>(inf, -inf)));
 
    EXPECT_EQ(saturated::Add<float>(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add<float>(-max, big), -big);
    EXPECT_EQ(saturated::Add<float>(-big, max), big);
    EXPECT_EQ(saturated::Add<float>(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add<float>(-max, inf), inf);
    EXPECT_EQ(saturated::Add<float>(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add<float>(-inf, inf)));
  }
  {
    const double inf = std::numeric_limits<double>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add<double>(big, big), max);
    EXPECT_EQ(saturated::Add<double>(max, big), inf);
    EXPECT_EQ(saturated::Add<double>(big, max), inf);
    EXPECT_EQ(saturated::Add<double>(max, max), inf);
    EXPECT_EQ(saturated::Add<double>(max, inf), inf);
    EXPECT_EQ(saturated::Add<double>(inf, max), inf);
    EXPECT_EQ(saturated::Add<double>(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add<double>(-big, -big), -max);
    EXPECT_EQ(saturated::Add<double>(-max, -big), -inf);
    EXPECT_EQ(saturated::Add<double>(-big, -max), -inf);
    EXPECT_EQ(saturated::Add<double>(-max, -max), -inf);
    EXPECT_EQ(saturated::Add<double>(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add<double>(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add<double>(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add<double>(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add<double>(max, -big), big);
    EXPECT_EQ(saturated::Add<double>(big, -max), -big);
    EXPECT_EQ(saturated::Add<double>(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add<double>(max, -inf), -inf);
    EXPECT_EQ(saturated::Add<double>(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add<double>(inf, -inf)));
 
    EXPECT_EQ(saturated::Add<double>(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add<double>(-max, big), -big);
    EXPECT_EQ(saturated::Add<double>(-big, max), big);
    EXPECT_EQ(saturated::Add<double>(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add<double>(-max, inf), inf);
    EXPECT_EQ(saturated::Add<double>(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add<double>(-inf, inf)));
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add<Scalar>(big, big), max);
    EXPECT_EQ(saturated::Add<Scalar>(max, big), inf);
    EXPECT_EQ(saturated::Add<Scalar>(big, max), inf);
    EXPECT_EQ(saturated::Add<Scalar>(max, max), inf);
    EXPECT_EQ(saturated::Add<Scalar>(max, inf), inf);
    EXPECT_EQ(saturated::Add<Scalar>(inf, max), inf);
    EXPECT_EQ(saturated::Add<Scalar>(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add<Scalar>(-big, -big), -max);
    EXPECT_EQ(saturated::Add<Scalar>(-max, -big), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(-big, -max), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(-max, -max), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add<Scalar>(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add<Scalar>(max, -big), big);
    EXPECT_EQ(saturated::Add<Scalar>(big, -max), -big);
    EXPECT_EQ(saturated::Add<Scalar>(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add<Scalar>(max, -inf), -inf);
    EXPECT_EQ(saturated::Add<Scalar>(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add<Scalar>(inf, -inf)));
 
    EXPECT_EQ(saturated::Add<Scalar>(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add<Scalar>(-max, big), -big);
    EXPECT_EQ(saturated::Add<Scalar>(-big, max), big);
    EXPECT_EQ(saturated::Add<Scalar>(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add<Scalar>(-max, inf), inf);
    EXPECT_EQ(saturated::Add<Scalar>(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add<Scalar>(-inf, inf)));
  }
}

◆ TEST() [564/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitAddOfSignedInts
	)

Definition at line 12 of file saturated_math_unittests.cc.

                                             {
  {
    EXPECT_EQ(saturated::Add<int8_t>(0x79, 5), int8_t(0x7E));
    EXPECT_EQ(saturated::Add<int8_t>(0x7A, 5), int8_t(0x7F));
    EXPECT_EQ(saturated::Add<int8_t>(0x7B, 5), int8_t(0x7F));
  }
  {
    EXPECT_EQ(saturated::Add<int8_t>(0x86, -5), int8_t(0x81));
    EXPECT_EQ(saturated::Add<int8_t>(0x85, -5), int8_t(0x80));
    EXPECT_EQ(saturated::Add<int8_t>(0x84, -5), int8_t(0x80));
  }
  {
    EXPECT_EQ(saturated::Add<int16_t>(0x7FF9, 5), int16_t(0x7FFE));
    EXPECT_EQ(saturated::Add<int16_t>(0x7FFA, 5), int16_t(0x7FFF));
    EXPECT_EQ(saturated::Add<int16_t>(0x7FFB, 5), int16_t(0x7FFF));
  }
  {
    EXPECT_EQ(saturated::Add<int16_t>(0x8006, -5), int16_t(0x8001));
    EXPECT_EQ(saturated::Add<int16_t>(0x8005, -5), int16_t(0x8000));
    EXPECT_EQ(saturated::Add<int16_t>(0x8004, -5), int16_t(0x8000));
  }
  {
    EXPECT_EQ(saturated::Add<int32_t>(0x7FFFFFF9, 5), int32_t(0x7FFFFFFE));
    EXPECT_EQ(saturated::Add<int32_t>(0x7FFFFFFA, 5), int32_t(0x7FFFFFFF));
    EXPECT_EQ(saturated::Add<int32_t>(0x7FFFFFFB, 5), int32_t(0x7FFFFFFF));
  }
  {
    EXPECT_EQ(saturated::Add<int32_t>(0x80000006, -5), int32_t(0x80000001));
    EXPECT_EQ(saturated::Add<int32_t>(0x80000005, -5), int32_t(0x80000000));
    EXPECT_EQ(saturated::Add<int32_t>(0x80000004, -5), int32_t(0x80000000));
  }
  {
    EXPECT_EQ(saturated::Add<int64_t>(0x7FFFFFFFFFFFFFF9, 5),
              int64_t(0x7FFFFFFFFFFFFFFE));
    EXPECT_EQ(saturated::Add<int64_t>(0x7FFFFFFFFFFFFFFA, 5),
              int64_t(0x7FFFFFFFFFFFFFFF));
    EXPECT_EQ(saturated::Add<int64_t>(0x7FFFFFFFFFFFFFFB, 5),
              int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    EXPECT_EQ(saturated::Add<int64_t>(0x8000000000000006, -5),
              int64_t(0x8000000000000001));
    EXPECT_EQ(saturated::Add<int64_t>(0x8000000000000005, -5),
              int64_t(0x8000000000000000));
    EXPECT_EQ(saturated::Add<int64_t>(0x8000000000000004, -5),
              int64_t(0x8000000000000000));
  }
}

◆ TEST() [565/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitAverageScalarOfFloatingPoint
	)

Definition at line 828 of file saturated_math_unittests.cc.

                                                          {
  const Scalar s_inf = std::numeric_limits<Scalar>::infinity();
  const Scalar s_max = std::numeric_limits<Scalar>::max();
  const Scalar s_big = s_max * 0.5f;
 
  {
    const float inf = std::numeric_limits<Scalar>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::AverageScalar<float>(big, big), s_big);
    EXPECT_EQ(saturated::AverageScalar<float>(max, max), s_max);
    EXPECT_EQ(saturated::AverageScalar<float>(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<float>(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<float>(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<float>(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<float>(-big, -big), -s_big);
    EXPECT_EQ(saturated::AverageScalar<float>(-max, -max), -s_max);
 
    EXPECT_EQ(saturated::AverageScalar<float>(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar<float>(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<float>(-inf, inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<float>(inf, -inf)));
  }
  {
    const double inf = std::numeric_limits<Scalar>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5;
 
    // Most of the averages below using the double constants will
    // overflow the Scalar return value and result in infinity,
    // so we also test with some Scalar constants (promoted to double)
    // to verify that they don't overflow in the double template
    EXPECT_EQ(saturated::AverageScalar<double>(s_big, s_big), s_big);
    EXPECT_EQ(saturated::AverageScalar<double>(s_max, s_max), s_max);
    EXPECT_EQ(saturated::AverageScalar<double>(-s_big, -s_big), -s_big);
    EXPECT_EQ(saturated::AverageScalar<double>(-s_max, -s_max), -s_max);
 
    // And now testing continues with the double constants which
    // mostly overflow
    EXPECT_EQ(saturated::AverageScalar<double>(big, big), s_inf);
    EXPECT_EQ(saturated::AverageScalar<double>(max, max), s_inf);
    EXPECT_EQ(saturated::AverageScalar<double>(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<double>(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<double>(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<double>(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<double>(-big, -big), -s_inf);
    EXPECT_EQ(saturated::AverageScalar<double>(-max, -max), -s_inf);
 
    EXPECT_EQ(saturated::AverageScalar<double>(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar<double>(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<double>(-inf, inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<double>(inf, -inf)));
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::AverageScalar<Scalar>(big, big), s_big);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(max, max), s_max);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(-big, -big), -s_big);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(-max, -max), -s_max);
 
    EXPECT_EQ(saturated::AverageScalar<Scalar>(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar<Scalar>(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<Scalar>(-inf, s_inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar<Scalar>(inf, -s_inf)));
  }
}

◆ TEST() [566/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitAverageScalarOfSignedInts
	)

Definition at line 716 of file saturated_math_unittests.cc.

                                                       {
  // For each type try:
  //
  // - near the limits, averaging to 0
  // - at the limits, averaging to 0 or 0.5 depending on precision
  // - both large enough for the sum to overflow
  // - both negative enough for the sum to underflow
  {
    EXPECT_EQ(saturated::AverageScalar<int8_t>(0x81, 0x7F), -0.0f);
    EXPECT_EQ(saturated::AverageScalar<int8_t>(0x80, 0x7F), -0.5f);
    EXPECT_EQ(saturated::AverageScalar<int8_t>(0x70, 0x75), 114.5f);
    EXPECT_EQ(saturated::AverageScalar<int8_t>(0x85, 0x8A), -120.5f);
  }
  {
    EXPECT_EQ(saturated::AverageScalar<int16_t>(0x8001, 0x7FFF), -0.0f);
    EXPECT_EQ(saturated::AverageScalar<int16_t>(0x8000, 0x7FFF), -0.5f);
    EXPECT_EQ(saturated::AverageScalar<int16_t>(0x7000, 0x7005), 28674.5f);
    EXPECT_EQ(saturated::AverageScalar<int16_t>(0x8005, 0x800A), -32760.5f);
  }
  {
    EXPECT_EQ(saturated::AverageScalar<int32_t>(0x80000001, 0x7FFFFFFF), -0.0f);
    EXPECT_EQ(saturated::AverageScalar<int32_t>(0x80000000, 0x7FFFFFFF), -0.5f);
    EXPECT_EQ(saturated::AverageScalar<int32_t>(0x70000000, 0x70000005),
              1879048195.5f);
    EXPECT_EQ(saturated::AverageScalar<int32_t>(0x80000005, 0x8000000A),
              -2147483655.5f);
  }
  {
    EXPECT_EQ(saturated::AverageScalar<int64_t>(0x8000000000000001,
                                                0x7FFFFFFFFFFFFFFF),
              0.0f);
    // 64-bit integers overflow the ability of a Scalar (float) to
    // represent discrete integers and so the two numbers we are
    // averaging here will look like the same number with different
    // signs and the answer will be "0"
    EXPECT_EQ(saturated::AverageScalar<int64_t>(0x8000000000000000,
                                                0x7FFFFFFFFFFFFFFF),
              0.0f);
    EXPECT_NEAR(saturated::AverageScalar<int64_t>(0x7000000000000000,
                                                  0x7000000000000005),
                8.07045053e+18, 1e18);
    EXPECT_NEAR(saturated::AverageScalar<int64_t>(0x8000000000000005,
                                                  0x800000000000000A),
                -9.223372e+18, 1e18);
  }
}

◆ TEST() [567/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitSubOfFloatingPoint
	)

Definition at line 488 of file saturated_math_unittests.cc.

                                                {
  {
    const float inf = std::numeric_limits<float>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub<float>(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub<float>(max, big), big);
    EXPECT_EQ(saturated::Sub<float>(big, max), -big);
    EXPECT_EQ(saturated::Sub<float>(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub<float>(max, inf), -inf);
    EXPECT_EQ(saturated::Sub<float>(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<float>(inf, inf)));
 
    EXPECT_EQ(saturated::Sub<float>(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub<float>(-max, -big), -big);
    EXPECT_EQ(saturated::Sub<float>(-big, -max), big);
    EXPECT_EQ(saturated::Sub<float>(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub<float>(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub<float>(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<float>(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub<float>(big, -big), max);
    EXPECT_EQ(saturated::Sub<float>(max, -big), inf);
    EXPECT_EQ(saturated::Sub<float>(big, -max), inf);
    EXPECT_EQ(saturated::Sub<float>(max, -max), inf);
    EXPECT_EQ(saturated::Sub<float>(max, -inf), inf);
    EXPECT_EQ(saturated::Sub<float>(inf, -max), inf);
    EXPECT_EQ(saturated::Sub<float>(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub<float>(-big, big), -max);
    EXPECT_EQ(saturated::Sub<float>(-max, big), -inf);
    EXPECT_EQ(saturated::Sub<float>(-big, max), -inf);
    EXPECT_EQ(saturated::Sub<float>(-max, max), -inf);
    EXPECT_EQ(saturated::Sub<float>(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub<float>(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub<float>(-inf, inf), -inf);
  }
  {
    const double inf = std::numeric_limits<double>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub<double>(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub<double>(max, big), big);
    EXPECT_EQ(saturated::Sub<double>(big, max), -big);
    EXPECT_EQ(saturated::Sub<double>(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub<double>(max, inf), -inf);
    EXPECT_EQ(saturated::Sub<double>(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<double>(inf, inf)));
 
    EXPECT_EQ(saturated::Sub<double>(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub<double>(-max, -big), -big);
    EXPECT_EQ(saturated::Sub<double>(-big, -max), big);
    EXPECT_EQ(saturated::Sub<double>(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub<double>(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub<double>(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<double>(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub<double>(big, -big), max);
    EXPECT_EQ(saturated::Sub<double>(max, -big), inf);
    EXPECT_EQ(saturated::Sub<double>(big, -max), inf);
    EXPECT_EQ(saturated::Sub<double>(max, -max), inf);
    EXPECT_EQ(saturated::Sub<double>(max, -inf), inf);
    EXPECT_EQ(saturated::Sub<double>(inf, -max), inf);
    EXPECT_EQ(saturated::Sub<double>(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub<double>(-big, big), -max);
    EXPECT_EQ(saturated::Sub<double>(-max, big), -inf);
    EXPECT_EQ(saturated::Sub<double>(-big, max), -inf);
    EXPECT_EQ(saturated::Sub<double>(-max, max), -inf);
    EXPECT_EQ(saturated::Sub<double>(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub<double>(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub<double>(-inf, inf), -inf);
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub<Scalar>(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub<Scalar>(max, big), big);
    EXPECT_EQ(saturated::Sub<Scalar>(big, max), -big);
    EXPECT_EQ(saturated::Sub<Scalar>(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub<Scalar>(max, inf), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<Scalar>(inf, inf)));
 
    EXPECT_EQ(saturated::Sub<Scalar>(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, -big), -big);
    EXPECT_EQ(saturated::Sub<Scalar>(-big, -max), big);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub<Scalar>(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub<Scalar>(big, -big), max);
    EXPECT_EQ(saturated::Sub<Scalar>(max, -big), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(big, -max), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(max, -max), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(max, -inf), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(inf, -max), inf);
    EXPECT_EQ(saturated::Sub<Scalar>(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub<Scalar>(-big, big), -max);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, big), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-big, max), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, max), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub<Scalar>(-inf, inf), -inf);
  }
}

◆ TEST() [568/689]

impeller::testing::TEST	(	SaturatedMath	,
		ExplicitSubOfSignedInts
	)

Definition at line 364 of file saturated_math_unittests.cc.

                                             {
  {
    EXPECT_EQ(saturated::Sub<int8_t>(0x79, -5), int8_t(0x7E));
    EXPECT_EQ(saturated::Sub<int8_t>(0x7A, -5), int8_t(0x7F));
    EXPECT_EQ(saturated::Sub<int8_t>(0x7B, -5), int8_t(0x7F));
  }
  {
    EXPECT_EQ(saturated::Sub<int8_t>(0x86, 5), int8_t(0x81));
    EXPECT_EQ(saturated::Sub<int8_t>(0x85, 5), int8_t(0x80));
    EXPECT_EQ(saturated::Sub<int8_t>(0x84, 5), int8_t(0x80));
  }
  {
    EXPECT_EQ(saturated::Sub<int16_t>(0x7FF9, -5), int16_t(0x7FFE));
    EXPECT_EQ(saturated::Sub<int16_t>(0x7FFA, -5), int16_t(0x7FFF));
    EXPECT_EQ(saturated::Sub<int16_t>(0x7FFB, -5), int16_t(0x7FFF));
  }
  {
    EXPECT_EQ(saturated::Sub<int16_t>(0x8006, 5), int16_t(0x8001));
    EXPECT_EQ(saturated::Sub<int16_t>(0x8005, 5), int16_t(0x8000));
    EXPECT_EQ(saturated::Sub<int16_t>(0x8004, 5), int16_t(0x8000));
  }
  {
    EXPECT_EQ(saturated::Sub<int32_t>(0x7FFFFFF9, -5), int32_t(0x7FFFFFFE));
    EXPECT_EQ(saturated::Sub<int32_t>(0x7FFFFFFA, -5), int32_t(0x7FFFFFFF));
    EXPECT_EQ(saturated::Sub<int32_t>(0x7FFFFFFB, -5), int32_t(0x7FFFFFFF));
  }
  {
    EXPECT_EQ(saturated::Sub<int32_t>(0x80000006, 5), int32_t(0x80000001));
    EXPECT_EQ(saturated::Sub<int32_t>(0x80000005, 5), int32_t(0x80000000));
    EXPECT_EQ(saturated::Sub<int32_t>(0x80000004, 5), int32_t(0x80000000));
  }
  {
    EXPECT_EQ(saturated::Sub<int64_t>(0x7FFFFFFFFFFFFFF9, -5),
              int64_t(0x7FFFFFFFFFFFFFFE));
    EXPECT_EQ(saturated::Sub<int64_t>(0x7FFFFFFFFFFFFFFA, -5),
              int64_t(0x7FFFFFFFFFFFFFFF));
    EXPECT_EQ(saturated::Sub<int64_t>(0x7FFFFFFFFFFFFFFB, -5),
              int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    EXPECT_EQ(saturated::Sub<int64_t>(0x8000000000000006, 5),
              int64_t(0x8000000000000001));
    EXPECT_EQ(saturated::Sub<int64_t>(0x8000000000000005, 5),
              int64_t(0x8000000000000000));
    EXPECT_EQ(saturated::Sub<int64_t>(0x8000000000000004, 5),
              int64_t(0x8000000000000000));
  }
}

◆ TEST() [569/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitAddOfFloatingPoint
	)

Definition at line 250 of file saturated_math_unittests.cc.

                                                {
  {
    const float inf = std::numeric_limits<float>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add(big, big), max);
    EXPECT_EQ(saturated::Add(max, big), inf);
    EXPECT_EQ(saturated::Add(big, max), inf);
    EXPECT_EQ(saturated::Add(max, max), inf);
    EXPECT_EQ(saturated::Add(max, inf), inf);
    EXPECT_EQ(saturated::Add(inf, max), inf);
    EXPECT_EQ(saturated::Add(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add(-big, -big), -max);
    EXPECT_EQ(saturated::Add(-max, -big), -inf);
    EXPECT_EQ(saturated::Add(-big, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add(max, -big), big);
    EXPECT_EQ(saturated::Add(big, -max), -big);
    EXPECT_EQ(saturated::Add(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add(max, -inf), -inf);
    EXPECT_EQ(saturated::Add(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add(inf, -inf)));
 
    EXPECT_EQ(saturated::Add(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add(-max, big), -big);
    EXPECT_EQ(saturated::Add(-big, max), big);
    EXPECT_EQ(saturated::Add(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add(-max, inf), inf);
    EXPECT_EQ(saturated::Add(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add(-inf, inf)));
  }
  {
    const double inf = std::numeric_limits<double>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add(big, big), max);
    EXPECT_EQ(saturated::Add(max, big), inf);
    EXPECT_EQ(saturated::Add(big, max), inf);
    EXPECT_EQ(saturated::Add(max, max), inf);
    EXPECT_EQ(saturated::Add(max, inf), inf);
    EXPECT_EQ(saturated::Add(inf, max), inf);
    EXPECT_EQ(saturated::Add(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add(-big, -big), -max);
    EXPECT_EQ(saturated::Add(-max, -big), -inf);
    EXPECT_EQ(saturated::Add(-big, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add(max, -big), big);
    EXPECT_EQ(saturated::Add(big, -max), -big);
    EXPECT_EQ(saturated::Add(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add(max, -inf), -inf);
    EXPECT_EQ(saturated::Add(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add(inf, -inf)));
 
    EXPECT_EQ(saturated::Add(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add(-max, big), -big);
    EXPECT_EQ(saturated::Add(-big, max), big);
    EXPECT_EQ(saturated::Add(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add(-max, inf), inf);
    EXPECT_EQ(saturated::Add(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add(-inf, inf)));
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::Add(big, big), max);
    EXPECT_EQ(saturated::Add(max, big), inf);
    EXPECT_EQ(saturated::Add(big, max), inf);
    EXPECT_EQ(saturated::Add(max, max), inf);
    EXPECT_EQ(saturated::Add(max, inf), inf);
    EXPECT_EQ(saturated::Add(inf, max), inf);
    EXPECT_EQ(saturated::Add(inf, inf), inf);
 
    EXPECT_EQ(saturated::Add(-big, -big), -max);
    EXPECT_EQ(saturated::Add(-max, -big), -inf);
    EXPECT_EQ(saturated::Add(-big, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -max), -inf);
    EXPECT_EQ(saturated::Add(-max, -inf), -inf);
    EXPECT_EQ(saturated::Add(-inf, -max), -inf);
    EXPECT_EQ(saturated::Add(-inf, -inf), -inf);
 
    EXPECT_EQ(saturated::Add(big, -big), 0.0f);
    EXPECT_EQ(saturated::Add(max, -big), big);
    EXPECT_EQ(saturated::Add(big, -max), -big);
    EXPECT_EQ(saturated::Add(max, -max), 0.0f);
    EXPECT_EQ(saturated::Add(max, -inf), -inf);
    EXPECT_EQ(saturated::Add(inf, -max), inf);
    EXPECT_TRUE(std::isnan(saturated::Add(inf, -inf)));
 
    EXPECT_EQ(saturated::Add(-big, big), 0.0f);
    EXPECT_EQ(saturated::Add(-max, big), -big);
    EXPECT_EQ(saturated::Add(-big, max), big);
    EXPECT_EQ(saturated::Add(-max, max), 0.0f);
    EXPECT_EQ(saturated::Add(-max, inf), inf);
    EXPECT_EQ(saturated::Add(-inf, max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Add(-inf, inf)));
  }
}

◆ TEST() [570/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitAddOfSignedInts
	)

Definition at line 61 of file saturated_math_unittests.cc.

                                             {
  {
    int8_t a = 0x79;
    int8_t b = 5;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x7E));
    a = 0x7A;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x7F));
    a = 0x7B;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x7F));
  }
  {
    int8_t a = 0x86;
    int8_t b = -5;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x81));
    a = 0x85;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x80));
    a = 0x84;
    EXPECT_EQ(saturated::Add(a, b), int8_t(0x80));
  }
  {
    int16_t a = 0x7FF9;
    int16_t b = 5;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x7FFE));
    a = 0x7FFA;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x7FFF));
    a = 0x7FFB;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x7FFF));
  }
  {
    int16_t a = 0x8006;
    int16_t b = -5;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x8001));
    a = 0x8005;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x8000));
    a = 0x8004;
    EXPECT_EQ(saturated::Add(a, b), int16_t(0x8000));
  }
  {
    int32_t a = 0x7FFFFFF9;
    int32_t b = 5;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x7FFFFFFE));
    a = 0x7FFFFFFA;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x7FFFFFFF));
    a = 0x7FFFFFFB;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x7FFFFFFF));
  }
  {
    int32_t a = 0x80000006;
    int32_t b = -5;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x80000001));
    a = 0x80000005;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x80000000));
    a = 0x80000004;
    EXPECT_EQ(saturated::Add(a, b), int32_t(0x80000000));
  }
  {
    int64_t a = 0x7FFFFFFFFFFFFFF9;
    int64_t b = 5;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x7FFFFFFFFFFFFFFE));
    a = 0x7FFFFFFFFFFFFFFA;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x7FFFFFFFFFFFFFFF));
    a = 0x7FFFFFFFFFFFFFFB;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    int64_t a = 0x8000000000000006;
    int64_t b = -5;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x8000000000000001));
    a = 0x8000000000000005;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x8000000000000000));
    a = 0x8000000000000004;
    EXPECT_EQ(saturated::Add(a, b), int64_t(0x8000000000000000));
  }
}

◆ TEST() [571/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitAverageScalarOfFloatingPoint
	)

Definition at line 903 of file saturated_math_unittests.cc.

                                                          {
  // All return values are Scalar regardless of the operand types
  // so these constants are used as the expected answers.
  const Scalar s_inf = std::numeric_limits<Scalar>::infinity();
  const Scalar s_max = std::numeric_limits<Scalar>::max();
  const Scalar s_big = s_max * 0.5f;
 
  {
    const float inf = std::numeric_limits<float>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::AverageScalar(big, big), s_big);
    EXPECT_EQ(saturated::AverageScalar(max, max), s_max);
    EXPECT_EQ(saturated::AverageScalar(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, -big), -s_big);
    EXPECT_EQ(saturated::AverageScalar(-max, -max), -s_max);
 
    EXPECT_EQ(saturated::AverageScalar(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(-inf, inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(inf, -inf)));
  }
  {
    const double inf = std::numeric_limits<double>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5;
 
    // The s_constants converted to double. We should get finite results
    // from finding the averages of these values, but we'll get a lot of
    // overflow to infinity when testing the large double constants.
    const double d_s_max = s_max;
    const double d_s_big = s_big;
    EXPECT_EQ(saturated::AverageScalar(d_s_big, d_s_big), s_big);
    EXPECT_EQ(saturated::AverageScalar(d_s_max, d_s_max), s_max);
    EXPECT_EQ(saturated::AverageScalar(-d_s_big, -d_s_big), -s_big);
    EXPECT_EQ(saturated::AverageScalar(-d_s_max, -d_s_max), -s_max);
 
    // And now testing continues with the double constants which
    // mostly overflow
    EXPECT_EQ(saturated::AverageScalar(big, big), s_inf);
    EXPECT_EQ(saturated::AverageScalar(max, max), s_inf);
    EXPECT_EQ(saturated::AverageScalar(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, -big), -s_inf);
    EXPECT_EQ(saturated::AverageScalar(-max, -max), -s_inf);
 
    EXPECT_EQ(saturated::AverageScalar(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(-inf, inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(inf, -inf)));
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::AverageScalar(big, big), s_big);
    EXPECT_EQ(saturated::AverageScalar(max, max), s_max);
    EXPECT_EQ(saturated::AverageScalar(big, -big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(max, -max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, big), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-max, max), 0.0f);
    EXPECT_EQ(saturated::AverageScalar(-big, -big), -s_big);
    EXPECT_EQ(saturated::AverageScalar(-max, -max), -s_max);
 
    EXPECT_EQ(saturated::AverageScalar(inf, inf), s_inf);
    EXPECT_EQ(saturated::AverageScalar(-inf, -inf), -s_inf);
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(-inf, s_inf)));
    EXPECT_TRUE(std::isnan(saturated::AverageScalar(inf, -s_inf)));
  }
}

◆ TEST() [572/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitAverageScalarOfSignedInts
	)

Definition at line 763 of file saturated_math_unittests.cc.

                                                       {
  // For each type try:
  //
  // - near the limits, averaging to 0
  // - at the limits, averaging to 0 or 0.5 depending on precision
  // - both large enough for the sum to overflow
  // - both negative enough for the sum to underflow
  {
    int8_t a = 0x81;
    int8_t b = 0x7f;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.0f);
    a = 0x80;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.5f);
    a = 0x70;
    b = 0x75;
    EXPECT_EQ(saturated::AverageScalar(a, b), 114.5f);
    a = 0x85;
    b = 0x8A;
    EXPECT_EQ(saturated::AverageScalar(a, b), -120.5f);
  }
  {
    int16_t a = 0x8001;
    int16_t b = 0x7FFF;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.0f);
    a = 0x8000;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.5f);
    a = 0x7000;
    b = 0x7005;
    EXPECT_EQ(saturated::AverageScalar(a, b), 28674.5f);
    a = 0x8005;
    b = 0x800A;
    EXPECT_EQ(saturated::AverageScalar(a, b), -32760.5f);
  }
  {
    int32_t a = 0x80000001;
    int32_t b = 0x7FFFFFFF;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.0f);
    a = 0x80000000;
    EXPECT_EQ(saturated::AverageScalar(a, b), -0.5f);
    a = 0x70000000;
    b = 0x70000005;
    EXPECT_EQ(saturated::AverageScalar(a, b), 1879048195.5f);
    a = 0x80000005;
    b = 0x8000000A;
    EXPECT_EQ(saturated::AverageScalar(a, b), -2147483655.5f);
  }
  {
    int64_t a = 0x8000000000000001;
    int64_t b = 0x7FFFFFFFFFFFFFFF;
    EXPECT_EQ(saturated::AverageScalar(a, b), 0.0f);
    // 64-bit integers overflow the ability of a Scalar (float) to
    // represent discrete integers and so the two numbers we are
    // averaging here will look like the same number with different
    // signs and the answer will be "0"
    a = 0x8000000000000000;
    EXPECT_EQ(saturated::AverageScalar<int64_t>(a, b), 0.0f);
    a = 0x7000000000000000;
    b = 0x7000000000000005;
    EXPECT_NEAR(saturated::AverageScalar<int64_t>(a, b), 8.0704505e+18, 1e18);
    a = 0x8000000000000005;
    b = 0x800000000000000A;
    EXPECT_NEAR(saturated::AverageScalar<int64_t>(a, b), -9.223372e+18, 1e18);
  }
}

◆ TEST() [573/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitSubOfFloatingPoint
	)

Definition at line 602 of file saturated_math_unittests.cc.

                                                {
  {
    const float inf = std::numeric_limits<float>::infinity();
    const float max = std::numeric_limits<float>::max();
    const float big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub(max, big), big);
    EXPECT_EQ(saturated::Sub(big, max), -big);
    EXPECT_EQ(saturated::Sub(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub(max, inf), -inf);
    EXPECT_EQ(saturated::Sub(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(inf, inf)));
 
    EXPECT_EQ(saturated::Sub(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -big), -big);
    EXPECT_EQ(saturated::Sub(-big, -max), big);
    EXPECT_EQ(saturated::Sub(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub(big, -big), max);
    EXPECT_EQ(saturated::Sub(max, -big), inf);
    EXPECT_EQ(saturated::Sub(big, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -inf), inf);
    EXPECT_EQ(saturated::Sub(inf, -max), inf);
    EXPECT_EQ(saturated::Sub(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub(-big, big), -max);
    EXPECT_EQ(saturated::Sub(-max, big), -inf);
    EXPECT_EQ(saturated::Sub(-big, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub(-inf, inf), -inf);
  }
  {
    const double inf = std::numeric_limits<double>::infinity();
    const double max = std::numeric_limits<double>::max();
    const double big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub(max, big), big);
    EXPECT_EQ(saturated::Sub(big, max), -big);
    EXPECT_EQ(saturated::Sub(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub(max, inf), -inf);
    EXPECT_EQ(saturated::Sub(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(inf, inf)));
 
    EXPECT_EQ(saturated::Sub(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -big), -big);
    EXPECT_EQ(saturated::Sub(-big, -max), big);
    EXPECT_EQ(saturated::Sub(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub(big, -big), max);
    EXPECT_EQ(saturated::Sub(max, -big), inf);
    EXPECT_EQ(saturated::Sub(big, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -inf), inf);
    EXPECT_EQ(saturated::Sub(inf, -max), inf);
    EXPECT_EQ(saturated::Sub(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub(-big, big), -max);
    EXPECT_EQ(saturated::Sub(-max, big), -inf);
    EXPECT_EQ(saturated::Sub(-big, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub(-inf, inf), -inf);
  }
  {
    const Scalar inf = std::numeric_limits<Scalar>::infinity();
    const Scalar max = std::numeric_limits<Scalar>::max();
    const Scalar big = max * 0.5f;
 
    EXPECT_EQ(saturated::Sub(big, big), 0.0f);
    EXPECT_EQ(saturated::Sub(max, big), big);
    EXPECT_EQ(saturated::Sub(big, max), -big);
    EXPECT_EQ(saturated::Sub(max, max), 0.0f);
    EXPECT_EQ(saturated::Sub(max, inf), -inf);
    EXPECT_EQ(saturated::Sub(inf, max), inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(inf, inf)));
 
    EXPECT_EQ(saturated::Sub(-big, -big), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -big), -big);
    EXPECT_EQ(saturated::Sub(-big, -max), big);
    EXPECT_EQ(saturated::Sub(-max, -max), 0.0f);
    EXPECT_EQ(saturated::Sub(-max, -inf), inf);
    EXPECT_EQ(saturated::Sub(-inf, -max), -inf);
    EXPECT_TRUE(std::isnan(saturated::Sub(-inf, -inf)));
 
    EXPECT_EQ(saturated::Sub(big, -big), max);
    EXPECT_EQ(saturated::Sub(max, -big), inf);
    EXPECT_EQ(saturated::Sub(big, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -max), inf);
    EXPECT_EQ(saturated::Sub(max, -inf), inf);
    EXPECT_EQ(saturated::Sub(inf, -max), inf);
    EXPECT_EQ(saturated::Sub(inf, -inf), inf);
 
    EXPECT_EQ(saturated::Sub(-big, big), -max);
    EXPECT_EQ(saturated::Sub(-max, big), -inf);
    EXPECT_EQ(saturated::Sub(-big, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, max), -inf);
    EXPECT_EQ(saturated::Sub(-max, inf), -inf);
    EXPECT_EQ(saturated::Sub(-inf, max), -inf);
    EXPECT_EQ(saturated::Sub(-inf, inf), -inf);
  }
}

◆ TEST() [574/689]

impeller::testing::TEST	(	SaturatedMath	,
		ImplicitSubOfSignedInts
	)

Definition at line 413 of file saturated_math_unittests.cc.

                                             {
  {
    int8_t a = 0x79;
    int8_t b = -5;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x7E));
    a = 0x7A;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x7F));
    a = 0x7B;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x7F));
  }
  {
    int8_t a = 0x86;
    int8_t b = 5;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x81));
    a = 0x85;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x80));
    a = 0x84;
    EXPECT_EQ(saturated::Sub(a, b), int8_t(0x80));
  }
  {
    int16_t a = 0x7FF9;
    int16_t b = -5;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x7FFE));
    a = 0x7FFA;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x7FFF));
    a = 0x7FFB;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x7FFF));
  }
  {
    int16_t a = 0x8006;
    int16_t b = 5;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x8001));
    a = 0x8005;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x8000));
    a = 0x8004;
    EXPECT_EQ(saturated::Sub(a, b), int16_t(0x8000));
  }
  {
    int32_t a = 0x7FFFFFF9;
    int32_t b = -5;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x7FFFFFFE));
    a = 0x7FFFFFFA;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x7FFFFFFF));
    a = 0x7FFFFFFB;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x7FFFFFFF));
  }
  {
    int32_t a = 0x80000006;
    int32_t b = 5;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x80000001));
    a = 0x80000005;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x80000000));
    a = 0x80000004;
    EXPECT_EQ(saturated::Sub(a, b), int32_t(0x80000000));
  }
  {
    int64_t a = 0x7FFFFFFFFFFFFFF9;
    int64_t b = -5;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x7FFFFFFFFFFFFFFE));
    a = 0x7FFFFFFFFFFFFFFA;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x7FFFFFFFFFFFFFFF));
    a = 0x7FFFFFFFFFFFFFFB;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x7FFFFFFFFFFFFFFF));
  }
  {
    int64_t a = 0x8000000000000006;
    int64_t b = 5;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x8000000000000001));
    a = 0x8000000000000005;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x8000000000000000));
    a = 0x8000000000000004;
    EXPECT_EQ(saturated::Sub(a, b), int64_t(0x8000000000000000));
  }
}

◆ TEST() [575/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BackdropFilterEmptyCoverage
	)

Definition at line 163 of file save_layer_utils_unittests.cc.

                                                      {
  // Empty coverage with backdrop filter.
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/nullptr,                             //
      /*flood_output_coverage=*/true                        //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [576/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BackdropFiterComputedCoverage
	)

Definition at line 29 of file save_layer_utils_unittests.cc.

                                                        {
  // Backdrop Filter, computed coverage
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/nullptr,
      /*flood_output_coverage=*/false,  //
      /*flood_input_coverage=*/true     //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [577/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		BasicEmptyCoverage
	)

Definition at line 137 of file save_layer_utils_unittests.cc.

                                             {
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/nullptr                              //
  );
 
  ASSERT_FALSE(coverage.has_value());
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [578/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageLargerWithImageFilter
	)

Definition at line 246 of file save_layer_utils_unittests.cc.

                                                                                        {
  // Create an image filter that slightly stretches the coverage limit. Even
  // without the special logic for using the original content coverage, we
  // verify that we don't introduce any artifacts from the intersection.
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({0.9, 0.9, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),    //
      /*image_filter=*/image_filter                         //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // The transfomed coverage limit is ((0, 0), (111.111, 111.111)).
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [579/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitIgnoredIfIntersectedValueIsCloseToActualCoverageSmallerWithImageFilter
	)

Definition at line 227 of file save_layer_utils_unittests.cc.

                                                                                         {
  // Create an image filter that slightly shrinks the coverage limit
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({1.1, 1.1, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),    //
      /*image_filter=*/image_filter                         //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // The transfomed coverage limit is ((0, 0), (90.9091, 90.9091)).
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [580/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		CoverageLimitRespectedIfSubstantiallyDifferentFromContentCoverage
	)

Definition at line 267 of file save_layer_utils_unittests.cc.

                                                                        {
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 1000, 1000),  //
      /*effect_transform=*/{},                                //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),      //
      /*image_filter=*/image_filter                           //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 50));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [581/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoverage
	)

Definition at line 94 of file save_layer_utils_unittests.cc.

                                           {
  // No intersection in coverage
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
      /*effect_transform=*/{},                                  //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
      /*image_filter=*/nullptr                                  //
  );
 
  EXPECT_FALSE(coverage.has_value());
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [582/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoverageTransformedByImageFilter
	)

Definition at line 106 of file save_layer_utils_unittests.cc.

                                                                   {
  // Coverage disjoint from parent coverage but transformed into parent space
  // with image filter.
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeTranslation({-200, -200, 0}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
      /*effect_transform=*/{},                                  //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
      /*image_filter=*/image_filter                             //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(200, 200, 210, 210));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeTranslation().

◆ TEST() [583/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DisjointCoveragTransformedByCTM
	)

Definition at line 123 of file save_layer_utils_unittests.cc.

                                                          {
  // Coverage disjoint from parent coverage.
  Matrix ctm = Matrix::MakeTranslation({-200, -200, 0});
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(200, 200, 210, 210),  //
      /*effect_transform=*/ctm,                                 //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),        //
      /*image_filter=*/nullptr                                  //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
}

References impeller::ComputeSaveLayerCoverage(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::Matrix::MakeTranslation().

◆ TEST() [584/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitHeight
	)

Definition at line 311 of file save_layer_utils_unittests.cc.

                                                                               {
  // X varies, translation is performed on coverage.
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 90, 50),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*image_filter=*/nullptr                            //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // Size that matches coverage limit
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 90, 50));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [585/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitWidth
	)

Definition at line 297 of file save_layer_utils_unittests.cc.

                                                                              {
  // X varies, translation is performed on coverage.
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 50, 90),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*image_filter=*/nullptr                            //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // Size that matches coverage limit
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 90));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [586/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		DontRoundUpCoverageWhenNotCloseToCoverageLimitWidthHeight
	)

Definition at line 325 of file save_layer_utils_unittests.cc.

                                                                {
  // X varies, translation is performed on coverage.
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 50, 50),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*image_filter=*/nullptr                            //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // Size that matches coverage limit
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 50, 50));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [587/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverage
	)

Definition at line 177 of file save_layer_utils_unittests.cc.

                                             {
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/nullptr,                             //
      /*flood_output_coverage=*/false,                      //
      /*flood_input_coverage=*/true                         //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2400, 1800));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [588/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverageWithImageFilter
	)

Definition at line 191 of file save_layer_utils_unittests.cc.

                                                            {
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({0.5, 0.5, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/image_filter,                        //
      /*flood_output_coverage=*/false,                      //
      /*flood_input_coverage=*/true                         //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 4800, 3600));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [589/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		FloodInputCoverageWithImageFilterWithNoCoverageProducesNoCoverage
	)

Definition at line 208 of file save_layer_utils_unittests.cc.

                                                                        {
  // Even if we flood the input coverage due to a bdf, we can still cull out the
  // layer if the image filter results in no coverage.
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({1, 1, 0}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/image_filter,                        //
      /*flood_output_coverage=*/false,                      //
      /*flood_input_coverage=*/true                         //
  );
 
  ASSERT_FALSE(coverage.has_value());
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [590/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFilterEmptyCoverage
	)

Definition at line 148 of file save_layer_utils_unittests.cc.

                                                   {
  // Empty coverage with Image Filter
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeTranslation({-200, -200, 0}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 0, 0),      //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/image_filter                         //
  );
 
  ASSERT_FALSE(coverage.has_value());
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeTranslation().

◆ TEST() [591/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterComputedCoverage
	)

Definition at line 44 of file save_layer_utils_unittests.cc.

                                                     {
  // Image Filter, computed coverage
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/image_filter                         //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [592/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterLargeScaleComputedCoverageLargerThanBoundsLimit
	)

Definition at line 77 of file save_layer_utils_unittests.cc.

                                                                {
  // Image Filter scaling small, computed coverage is larger than bounds limit.
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({0.5, 0.5, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 5, 5),      //
      /*image_filter=*/image_filter                       //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [593/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		ImageFiterSmallScaleComputedCoverageLargerThanBoundsLimit
	)

Definition at line 60 of file save_layer_utils_unittests.cc.

                                                                {
  // Image Filter scaling large, computed coverage is larger than bounds limit.
  auto image_filter = FilterContents::MakeMatrixFilter(
      FilterInput::Make(Rect()), Matrix::MakeScale({2, 2, 1}), {});
 
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 5, 5),      //
      /*image_filter=*/image_filter                       //
  );
 
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 2.5, 2.5));
}

References impeller::ComputeSaveLayerCoverage(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::FilterContents::MakeMatrixFilter(), and impeller::Matrix::MakeScale().

◆ TEST() [594/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		RoundUpCoverageWhenCloseToCoverageLimit
	)

Definition at line 283 of file save_layer_utils_unittests.cc.

                                                                  {
  // X varies, translation is performed on coverage.
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 90, 90),  //
      /*effect_transform=*/{},                            //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 100, 100),  //
      /*image_filter=*/nullptr                            //
  );
 
  ASSERT_TRUE(coverage.has_value());
  // Size that matches coverage limit
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 100, 100));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [595/689]

impeller::testing::TEST	(	SaveLayerUtilsTest	,
		SimplePaintComputedCoverage
	)

Definition at line 17 of file save_layer_utils_unittests.cc.

                                                      {
  // Basic Case, simple paint, computed coverage
  auto coverage = ComputeSaveLayerCoverage(
      /*content_coverage=*/Rect::MakeLTRB(0, 0, 10, 10),    //
      /*effect_transform=*/{},                              //
      /*coverage_limit=*/Rect::MakeLTRB(0, 0, 2400, 1800),  //
      /*image_filter=*/nullptr                              //
  );
  ASSERT_TRUE(coverage.has_value());
  EXPECT_EQ(coverage.value(), Rect::MakeLTRB(0, 0, 10, 10));
}

References impeller::ComputeSaveLayerCoverage(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST() [596/689]

impeller::testing::TEST	(	ShaderArchiveTest	,
		CanReadAndWriteBlobs
	)

Definition at line 31 of file shader_archive_unittests.cc.

                                              {
  ShaderArchiveWriter writer;
  ASSERT_TRUE(writer.AddShader(ArchiveShaderType::kVertex, "Hello",
                               CreateMappingFromString("World")));
  ASSERT_TRUE(writer.AddShader(ArchiveShaderType::kFragment, "Foo",
                               CreateMappingFromString("Bar")));
  ASSERT_TRUE(writer.AddShader(ArchiveShaderType::kVertex, "Baz",
                               CreateMappingFromString("Bang")));
  ASSERT_TRUE(writer.AddShader(ArchiveShaderType::kVertex, "Ping",
                               CreateMappingFromString("Pong")));
  ASSERT_TRUE(writer.AddShader(ArchiveShaderType::kFragment, "Pang",
                               CreateMappingFromString("World")));
 
  auto mapping = writer.CreateMapping();
  ASSERT_NE(mapping, nullptr);
 
  auto library = ShaderArchive::Create(mapping);
  ASSERT_TRUE(library.ok());
  ASSERT_EQ(library->GetShaderCount(), 5u);
 
  // Wrong type.
  ASSERT_EQ(library->GetMapping(ArchiveShaderType::kFragment, "Hello"),
            nullptr);
 
  auto hello_vtx = library->GetMapping(ArchiveShaderType::kVertex, "Hello");
  ASSERT_NE(hello_vtx, nullptr);
  ASSERT_EQ(CreateStringFromMapping(*hello_vtx), "World");
}

References impeller::ShaderArchiveWriter::AddShader(), impeller::ShaderArchive::Create(), impeller::ShaderArchiveWriter::CreateMapping(), CreateMappingFromString(), CreateStringFromMapping(), impeller::kFragment, and impeller::kVertex.

◆ TEST() [597/689]

impeller::testing::TEST	(	ShaderArchiveTest	,
		RejectsCorruptBufferWithValidIdentifier
	)

Definition at line 81 of file shader_archive_unittests.cc.

                                                                 {
  // Construct a buffer with a valid "SHAR" file identifier at bytes 4-7
  // but a root table offset that points beyond the buffer. This passes
  // the identifier check but fails FlatBuffer structural verification.
  auto data = std::make_shared<std::vector<uint8_t>>(32, 0);
  (*data)[4] = 'S';
  (*data)[5] = 'H';
  (*data)[6] = 'A';
  (*data)[7] = 'R';
  // Root offset (little-endian uint32 at offset 0) pointing out of bounds.
  (*data)[0] = 0xFF;
  (*data)[1] = 0xFF;
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      data->data(), data->size(), [data](auto, auto) {});
  auto archive = ShaderArchive::Create(mapping);
  ASSERT_FALSE(archive.ok());
  EXPECT_EQ(archive.status().code(), absl::StatusCode::kInvalidArgument);
}

References impeller::ShaderArchive::Create(), and flutter::data.

◆ TEST() [598/689]

impeller::testing::TEST	(	ShaderArchiveTest	,
		ReturnsErrorOnInvalidVersion
	)

Definition at line 60 of file shader_archive_unittests.cc.

                                                      {
  fb::ShaderArchiveT shader_archive;
  shader_archive.format_version = -1;
 
  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
  builder->Finish(fb::ShaderArchive::Pack(*builder.get(), &shader_archive),
                  fb::ShaderArchiveIdentifier());
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      builder->GetBufferPointer(), builder->GetSize(),
      [builder](auto, auto) {});
 
  auto library = ShaderArchive::Create(mapping);
  ASSERT_FALSE(library.ok());
  ASSERT_EQ(library.status().code(), absl::StatusCode::kInvalidArgument);
  std::stringstream stream;
  stream << "Unsupported shader archive format version. Expected: "
         << static_cast<uint32_t>(fb::ShaderArchiveFormatVersion::kVersion)
         << ", Got: 4294967295";
  ASSERT_EQ(library.status().message(), stream.str());
}

References impeller::ShaderArchive::Create().

◆ TEST() [599/689]

impeller::testing::TEST	(	ShaderKeyTest	,
		MakeUserScopedNameContainsColonSeparator
	)

Definition at line 523 of file runtime_stage_unittests.cc.

                                                              {
  // The colon separator is what makes user-scoped names unspoofable from
  // engine-internal entrypoints, since impellerc-generated entrypoints are
  // valid identifiers and cannot contain ':'.
  std::string scoped = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeRuntimeEffect, "asset", "entry");
  EXPECT_NE(scoped.find(':'), std::string::npos);
}

References impeller::ShaderKey::kScopeRuntimeEffect, and impeller::ShaderKey::MakeUserScopedName().

◆ TEST() [600/689]

impeller::testing::TEST	(	ShaderKeyTest	,
		MakeUserScopedNameDifferentLibraryIdsDoNotCollide
	)

Definition at line 532 of file runtime_stage_unittests.cc.

                                                                       {
  // Two user shaders that share an entrypoint name but come from different
  // logical sources must produce different registry keys, so they cannot
  // overwrite each other in the shared shader library.
  std::string a = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeFlutterGPU, "packages/pkg_a/bundle", "main");
  std::string b = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeFlutterGPU, "packages/pkg_b/bundle", "main");
  EXPECT_NE(a, b);
}

References impeller::ShaderKey::kScopeFlutterGPU, and impeller::ShaderKey::MakeUserScopedName().

◆ TEST() [601/689]

impeller::testing::TEST	(	ShaderKeyTest	,
		MakeUserScopedNameDifferentScopesDoNotCollide
	)

Definition at line 543 of file runtime_stage_unittests.cc.

                                                                   {
  // A FragmentProgram and a Flutter GPU shader can independently share an
  // asset path and an entrypoint and must still produce different keys.
  std::string runtime_effect = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeRuntimeEffect, "asset", "main");
  std::string flutter_gpu = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeFlutterGPU, "asset", "main");
  EXPECT_NE(runtime_effect, flutter_gpu);
}

References impeller::ShaderKey::kScopeFlutterGPU, impeller::ShaderKey::kScopeRuntimeEffect, and impeller::ShaderKey::MakeUserScopedName().

◆ TEST() [602/689]

impeller::testing::TEST	(	ShaderKeyTest	,
		MakeUserScopedNameHandlesLongInputs
	)

Definition at line 553 of file runtime_stage_unittests.cc.

                                                         {
  // The scoped name is used solely as a `std::string` key in the per-process
  // shader library registry; there is no fixed length limit. Confirm that
  // long inputs (e.g. deeply-nested package asset paths) round-trip through
  // the builder without truncation.
  const std::string long_library_id(4096, 'a');
  const std::string long_entrypoint(2048, 'b');
  std::string scoped = ShaderKey::MakeUserScopedName(
      ShaderKey::kScopeFlutterGPU, long_library_id, long_entrypoint);
  EXPECT_EQ(scoped.size(), ShaderKey::kScopeFlutterGPU.size() + 1 +
                               long_library_id.size() + 1 +
                               long_entrypoint.size());
  EXPECT_EQ(scoped.substr(0, 3), "fg:");
  EXPECT_EQ(scoped.substr(3, long_library_id.size()), long_library_id);
  EXPECT_EQ(scoped.substr(3 + long_library_id.size(), 1), ":");
  EXPECT_EQ(scoped.substr(3 + long_library_id.size() + 1), long_entrypoint);
}

References impeller::ShaderKey::kScopeFlutterGPU, and impeller::ShaderKey::MakeUserScopedName().

◆ TEST() [603/689]

impeller::testing::TEST	(	ShaderKeyTest	,
		MakeUserScopedNameProducesScopedString
	)

Definition at line 511 of file runtime_stage_unittests.cc.

                                                            {
  EXPECT_EQ(ShaderKey::MakeUserScopedName(ShaderKey::kScopeRuntimeEffect,
                                          "assets/foo.frag", "main"),
            "re:assets/foo.frag:main");
  EXPECT_EQ(
      ShaderKey::MakeUserScopedName(
          ShaderKey::kScopeFlutterGPU,
          "packages/pkg_a/assets/shaders.shaderbundle",
          "solid_fill_fragment_main"),
      "fg:packages/pkg_a/assets/shaders.shaderbundle:solid_fill_fragment_main");
}

References impeller::ShaderKey::kScopeFlutterGPU, impeller::ShaderKey::kScopeRuntimeEffect, and impeller::ShaderKey::MakeUserScopedName().

◆ TEST() [604/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatFloat32
	)

Definition at line 31 of file shader_types_unittests.cc.

                                                    {
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 1u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kFloat32);
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 2u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kFloat32x2);
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 3u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kFloat32x3);
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 4u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kFloat32x4);
}

References impeller::kFloat, impeller::kFloat32, impeller::kFloat32x2, impeller::kFloat32x3, and impeller::kFloat32x4.

◆ TEST() [605/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatHalfFloat
	)

Definition at line 42 of file shader_types_unittests.cc.

                                                      {
  EXPECT_EQ(
      MakeSlot(ShaderType::kHalfFloat, 16u, 1u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kFloat16);
  EXPECT_EQ(
      MakeSlot(ShaderType::kHalfFloat, 16u, 4u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kFloat16x4);
}

References impeller::kFloat16, impeller::kFloat16x4, and impeller::kHalfFloat.

◆ TEST() [606/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatIntegers
	)

Definition at line 51 of file shader_types_unittests.cc.

                                                     {
  EXPECT_EQ(
      MakeSlot(ShaderType::kSignedByte, 8u, 1u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kSInt8);
  EXPECT_EQ(
      MakeSlot(ShaderType::kUnsignedByte, 8u, 4u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kUInt8x4);
  EXPECT_EQ(
      MakeSlot(ShaderType::kSignedShort, 16u, 2u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kSInt16x2);
  EXPECT_EQ(
      MakeSlot(ShaderType::kUnsignedShort, 16u, 3u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kUInt16x3);
  EXPECT_EQ(
      MakeSlot(ShaderType::kSignedInt, 32u, 1u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kSInt32);
  EXPECT_EQ(
      MakeSlot(ShaderType::kUnsignedInt, 32u, 4u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kUInt32x4);
}

References impeller::kSignedByte, impeller::kSignedInt, impeller::kSignedShort, impeller::kSInt16x2, impeller::kSInt32, impeller::kSInt8, impeller::kUInt16x3, impeller::kUInt32x4, impeller::kUInt8x4, impeller::kUnsignedByte, impeller::kUnsignedInt, and impeller::kUnsignedShort.

◆ TEST() [607/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatRejectsBadBitWidth
	)

Definition at line 86 of file shader_types_unittests.cc.

                                                               {
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 16u, 1u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
  EXPECT_EQ(
      MakeSlot(ShaderType::kSignedInt, 16u, 1u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kInvalid);
}

References impeller::kFloat, impeller::kInvalid, and impeller::kSignedInt.

◆ TEST() [608/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatRejectsBadComponentCount
	)

Definition at line 79 of file shader_types_unittests.cc.

                                                                     {
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 0u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 5u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
}

References impeller::kFloat, and impeller::kInvalid.

◆ TEST() [609/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatRejectsMatrices
	)

Definition at line 72 of file shader_types_unittests.cc.

                                                            {
  // Columns greater than one is a matrix input, which is unsupported.
  EXPECT_EQ(MakeSlot(ShaderType::kFloat, 32u, 4u, /*columns=*/4u)
                .GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
}

References impeller::kFloat, and impeller::kInvalid.

◆ TEST() [610/689]

impeller::testing::TEST	(	ShaderTypesTest	,
		VertexAttributeFormatRejectsUnsupportedScalarKinds
	)

Definition at line 94 of file shader_types_unittests.cc.

                                                                          {
  EXPECT_EQ(MakeSlot(ShaderType::kBoolean, 8u, 1u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
  EXPECT_EQ(MakeSlot(ShaderType::kDouble, 64u, 1u).GetVertexAttributeFormat(),
            VertexAttributeFormat::kInvalid);
  EXPECT_EQ(
      MakeSlot(ShaderType::kSignedInt64, 64u, 1u).GetVertexAttributeFormat(),
      VertexAttributeFormat::kInvalid);
}

References impeller::kBoolean, impeller::kDouble, impeller::kInvalid, and impeller::kSignedInt64.

◆ TEST() [611/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseOctagonCollapsedUmbraPolygonTest
	)

Definition at line 972 of file shadow_path_geometry_unittests.cc.

                                                                        {
  const Matrix matrix = Matrix::MakeScale({2, 2, 1});
  const Scalar height = 100.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 125));
  path_builder.LineTo(DlPoint(125, 100));
  path_builder.LineTo(DlPoint(275, 100));
  path_builder.LineTo(DlPoint(300, 125));
  path_builder.LineTo(DlPoint(300, 275));
  path_builder.LineTo(DlPoint(275, 300));
  path_builder.LineTo(DlPoint(125, 300));
  path_builder.LineTo(DlPoint(100, 275));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 87u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 267u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 87u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 87u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 267u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  // There are a couple additional duplicate vertices in this case.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 3u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), impeller::Matrix::MakeScale(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [612/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseRectExtraColinearPointsTest
	)

Definition at line 417 of file shadow_path_geometry_unittests.cc.

                                                                   {
  // This path includes a colinear point to each edge of the rectangle
  // which should be trimmed out and ignored when generating the mesh
  // resulting in the same number of vertices and triangles as the mesh
  // above.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(50, 0));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(100, 40));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(50, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(0, 40));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [613/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseRectNearlyColinearPointsTest
	)

Definition at line 677 of file shadow_path_geometry_unittests.cc.

                                                                    {
  // This path includes a bunch of colinear points and one point that
  // is barely non-colinear but still convex. It should add exactly
  // one extra set of vertices to the mesh (3 points and 3 triangles)
  // compared to the regular rects.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(50, -0.065));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(100, 40));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(50, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(0, 40));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 37u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 120u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 37u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 37u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 120u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [614/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseRectTest
	)

Definition at line 349 of file shadow_path_geometry_unittests.cc.

                                                {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [615/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseRectTrickyColinearPointsTest
	)

Definition at line 501 of file shadow_path_geometry_unittests.cc.

                                                                    {
  // This path includes a colinear point added to each edge of the rectangle
  // which seems to violate convexity, but is eliminated as not contributing
  // to the path. We should be able to process the path anyway.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(-10, 0));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(100, -10));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(110, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(0, 90));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [616/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseRectTrickyDupColinearPointsTest
	)

Definition at line 583 of file shadow_path_geometry_unittests.cc.

                                                                       {
  // This path includes a colinear point added to each edge of the rectangle
  // which seems to violate convexity, but is eliminated as not contributing
  // to the path. We should be able to process the path anyway.
  // It also includes multiple collinear points on the first and last points
  // that end up back where we started to make sure that in that case we
  // eliminate all of the collinear points and the duplicate, rather than
  // just the intermediate collinear points.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(-10, 0));
  path_builder.LineTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(100, -10));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(110, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(0, 90));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [617/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ClockwiseTriangleTest
	)

Definition at line 281 of file shadow_path_geometry_unittests.cc.

                                                    {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(200, 110));
  path_builder.LineTo(DlPoint(0, 110));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 33u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 102u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 33u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 33u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 102u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  // There is another duplicate vertex from somewhere else not yet realized.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 2u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [618/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseOctagonCollapsedUmbraPolygonTest
	)

Definition at line 1008 of file shadow_path_geometry_unittests.cc.

                                                                               {
  const Matrix matrix = Matrix::MakeScale({2, 2, 1});
  const Scalar height = 100.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 125));
  path_builder.LineTo(DlPoint(100, 275));
  path_builder.LineTo(DlPoint(125, 300));
  path_builder.LineTo(DlPoint(275, 300));
  path_builder.LineTo(DlPoint(300, 275));
  path_builder.LineTo(DlPoint(300, 125));
  path_builder.LineTo(DlPoint(275, 100));
  path_builder.LineTo(DlPoint(125, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 88u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 267u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 88u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 88u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 267u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  // There are a couple additional duplicate vertices in this case.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 3u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), impeller::Matrix::MakeScale(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [619/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseRectExtraColinearPointsTest
	)

Definition at line 459 of file shadow_path_geometry_unittests.cc.

                                                                          {
  // This path includes a colinear point to each edge of the rectangle
  // which should be trimmed out and ignored when generating the mesh
  // resulting in the same number of vertices and triangles as the mesh
  // above.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(0, 40));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(50, 80));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 40));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(50, 0));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
  Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [620/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseRectNearlyColinearPointsTest
	)

Definition at line 719 of file shadow_path_geometry_unittests.cc.

                                                                           {
  // This path includes a bunch of colinear points and one point that
  // is barely non-colinear but still convex. It should add exactly
  // one extra set of vertices to the mesh (3 points and 3 triangles)
  // compared to the regular rects.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(-0.065, 40));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(50, 80));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 40));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(50, 0));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
  Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 37u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 120u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 37u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 37u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 120u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [621/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseRectTest
	)

Definition at line 383 of file shadow_path_geometry_unittests.cc.

                                                       {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
  Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [622/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseRectTrickyColinearPointsTest
	)

Definition at line 542 of file shadow_path_geometry_unittests.cc.

                                                                           {
  // This path includes a colinear point added to each edge of the rectangle
  // which seems to violate convexity, but is eliminated as not contributing
  // to the path. We should be able to process the path anyway.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(0, -10));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(-10, 80));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 90));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(110, 0));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
  Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [623/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseRectTrickyDupColinearPointsTest
	)

Definition at line 630 of file shadow_path_geometry_unittests.cc.

                                                                              {
  // This path includes a colinear point added to each edge of the rectangle
  // which seems to violate convexity, but is eliminated as not contributing
  // to the path. We should be able to process the path anyway.
  // It also includes multiple collinear points on the first and last points
  // that end up back where we started to make sure that in that case we
  // eliminate all of the collinear points and the duplicate, rather than
  // just the intermediate collinear points.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(0, -10));
  path_builder.LineTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(-10, 80));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 90));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(110, 0));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
  Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [624/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		CounterClockwiseTriangleTest
	)

Definition at line 315 of file shadow_path_geometry_unittests.cc.

                                                           {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(0, 110));
  path_builder.LineTo(DlPoint(200, 110));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 33u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 102u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 33u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 33u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 102u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  // There is another duplicate vertex from somewhere else not yet realized.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 2u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [625/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		EllipseTest
	)

Definition at line 789 of file shadow_path_geometry_unittests.cc.

                                          {
  Tessellator tessellator;
  DlPath path = DlPath::MakeOval(DlRect::MakeLTRB(0, 0, 100, 80));
  Matrix matrix;
  const Scalar height = 10.0f;
 
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 122u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 480u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 122u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 122u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 480u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
}

References height, impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeOval(), and flutter::path.

◆ TEST() [626/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		EmptyPathTest
	)

Definition at line 175 of file shadow_path_geometry_unittests.cc.

                                            {
  DlPathBuilder path_builder;
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_TRUE(shadow_vertices->IsEmpty());
}

References height, impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [627/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		EmptyRectTest
	)

Definition at line 241 of file shadow_path_geometry_unittests.cc.

                                            {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(100, 100));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_TRUE(shadow_vertices->IsEmpty());
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [628/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		GetAndTakeVertices
	)

Definition at line 261 of file shadow_path_geometry_unittests.cc.

                                                 {
  DlPath path = DlPath::MakeRectLTRB(100, 100, 200, 200);
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  ShadowPathGeometry geometry(tessellator, {}, path, height);
 
  // Can call Get as many times as you want.
  for (int i = 0; i < 10; i++) {
    EXPECT_TRUE(geometry.GetShadowVertices());
  }
 
  // Can only call Take once.
  EXPECT_TRUE(geometry.TakeShadowVertices());
 
  // Further access wll then fail.
  EXPECT_FALSE(geometry.GetShadowVertices());
  EXPECT_FALSE(geometry.TakeShadowVertices());
}

References height, i, flutter::DlPath::MakeRectLTRB(), and flutter::path.

◆ TEST() [629/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		HourglassSelfIntersectingTest
	)

Definition at line 838 of file shadow_path_geometry_unittests.cc.

                                                            {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [630/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		InnerToOuterOverturningSpiralTest
	)

Definition at line 876 of file shadow_path_geometry_unittests.cc.

                                                                {
  const Matrix matrix;
  const Scalar height = 10.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(300, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = (k2Pi * i) / step_count;
    Scalar radius = 80.0f + std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, i, impeller::k2Pi, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [631/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		MoveToOnlyTest
	)

Definition at line 190 of file shadow_path_geometry_unittests.cc.

                                             {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_TRUE(shadow_vertices->IsEmpty());
}

References height, impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [632/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		MultipleContoursTest
	)

Definition at line 1044 of file shadow_path_geometry_unittests.cc.

                                                   {
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(150, 100));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.Close();
  path_builder.MoveTo(DlPoint(250, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [633/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		OnePathSegmentTest
	)

Definition at line 206 of file shadow_path_geometry_unittests.cc.

                                                 {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(200, 100));
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_TRUE(shadow_vertices->IsEmpty());
}

References height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [634/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		OuterToInnerOverturningSpiralTest
	)

Definition at line 924 of file shadow_path_geometry_unittests.cc.

                                                                {
  const Matrix matrix;
  const Scalar height = 10.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(280, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = (k2Pi * i) / step_count;
    Scalar radius = 100.0f - std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, i, impeller::k2Pi, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [635/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ReverseHourglassSelfIntersectingTest
	)

Definition at line 857 of file shadow_path_geometry_unittests.cc.

                                                                   {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.LineTo(DlPoint(100, 80));
  path_builder.LineTo(DlPoint(0, 80));
  path_builder.LineTo(DlPoint(100, 0));
  path_builder.Close();
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [636/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ReverseInnerToOuterOverturningSpiralTest
	)

Definition at line 900 of file shadow_path_geometry_unittests.cc.

                                                                       {
  const Matrix matrix;
  const Scalar height = 10.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(300, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = -(k2Pi * i) / step_count;
    Scalar radius = 80.0f + std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, i, impeller::k2Pi, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [637/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ReverseOuterToInnerOverturningSpiralTest
	)

Definition at line 948 of file shadow_path_geometry_unittests.cc.

                                                                       {
  const Matrix matrix;
  const Scalar height = 10.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(280, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = -(k2Pi * i) / step_count;
    Scalar radius = 100.0f - std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  EXPECT_EQ(shadow_vertices, nullptr);
}

References flutter::DlPathBuilder::Close(), height, i, impeller::k2Pi, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [638/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		RoundRectTest
	)

Definition at line 813 of file shadow_path_geometry_unittests.cc.

                                            {
  Tessellator tessellator;
  DlPath path = DlPath::MakeRoundRectXY(DlRect::MakeLTRB(0, 0, 100, 80), 5, 4);
  Matrix matrix;
  const Scalar height = 10.0f;
 
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 55u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 168u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 55u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 55u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 168u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  // There is another duplicate vertex from somewhere else not yet realized.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 2u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
}

References height, impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRoundRectXY(), and flutter::path.

◆ TEST() [639/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		ScaledRectTest
	)

Definition at line 761 of file shadow_path_geometry_unittests.cc.

                                             {
  Tessellator tessellator;
  DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 100, 80));
  Matrix matrix = Matrix::MakeScale({2, 3, 1});
  const Scalar height = 10.0f;
 
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_FALSE(shadow_vertices->IsEmpty());
  EXPECT_EQ(shadow_vertices->GetVertexCount(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndexCount(), 108u);
  EXPECT_EQ(shadow_vertices->GetVertices().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetGaussians().size(), 34u);
  EXPECT_EQ(shadow_vertices->GetIndices().size(), 108u);
  EXPECT_EQ((shadow_vertices->GetIndices().size() % 3u), 0u);
  // We repeat the first and last vertex that is on the outer umbra.
  EXPECT_LE(CountDuplicateVertices(shadow_vertices), 1u);
  EXPECT_EQ(CountDuplicateTriangles(shadow_vertices), 0u);
  EXPECT_FALSE(DoTrianglesOverlap(shadow_vertices));
 
#if SHADOW_UNITTEST_SHOW_VERTICES
  ShowVertices("Impeller Vertices", shadow_vertices);
#endif
}

References height, impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeScale(), and flutter::path.

◆ TEST() [640/689]

impeller::testing::TEST	(	ShadowPathGeometryTest	,
		TwoColinearSegmentsTest
	)

Definition at line 223 of file shadow_path_geometry_unittests.cc.

                                                      {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(300, 100));
  const DlPath path = path_builder.TakePath();
  const Matrix matrix;
  const Scalar height = 10.0f;
 
  Tessellator tessellator;
  std::shared_ptr<ShadowVertices> shadow_vertices =
      ShadowPathGeometry::MakeAmbientShadowVertices(tessellator, path, height,
                                                    matrix);
 
  ASSERT_NE(shadow_vertices, nullptr);
  EXPECT_TRUE(shadow_vertices->IsEmpty());
}

References height, flutter::DlPathBuilder::LineTo(), impeller::ShadowPathGeometry::MakeAmbientShadowVertices(), flutter::DlPathBuilder::MoveTo(), flutter::path, and flutter::DlPathBuilder::TakePath().

◆ TEST() [641/689]

impeller::testing::TEST	(	SizeTest	,
		ISizeIsEmpty
	)

Definition at line 36 of file size_unittests.cc.

                             {
  // Non-empty
  EXPECT_FALSE(ISize(10, 7).IsEmpty());
 
  // Empty both width and height both 0 or negative, in all combinations
  EXPECT_TRUE(ISize(0, 0).IsEmpty());
  EXPECT_TRUE(ISize(-1, -1).IsEmpty());
  EXPECT_TRUE(ISize(-1, 0).IsEmpty());
  EXPECT_TRUE(ISize(0, -1).IsEmpty());
 
  // Empty for 0 or negative width or height (but not both at the same time)
  EXPECT_TRUE(ISize(10, 0).IsEmpty());
  EXPECT_TRUE(ISize(10, -1).IsEmpty());
  EXPECT_TRUE(ISize(0, 7).IsEmpty());
  EXPECT_TRUE(ISize(-1, 7).IsEmpty());
}

◆ TEST() [642/689]

impeller::testing::TEST	(	SizeTest	,
		IsSquare
	)

Definition at line 53 of file size_unittests.cc.

                         {
  EXPECT_TRUE(Size(20, 20).IsSquare());
  EXPECT_FALSE(Size(20, 19).IsSquare());
  EXPECT_FALSE(Size(19, 20).IsSquare());
 
  EXPECT_TRUE(ISize(20, 20).IsSquare());
  EXPECT_FALSE(ISize(20, 19).IsSquare());
  EXPECT_FALSE(ISize(19, 20).IsSquare());
}

◆ TEST() [643/689]

impeller::testing::TEST	(	SizeTest	,
		MaxDimension
	)

Definition at line 63 of file size_unittests.cc.

                             {
  EXPECT_EQ(Size(20, 20).MaxDimension(), 20);
  EXPECT_EQ(Size(20, 19).MaxDimension(), 20);
  EXPECT_EQ(Size(19, 20).MaxDimension(), 20);
  EXPECT_EQ(Size(20, 21).MaxDimension(), 21);
  EXPECT_EQ(Size(21, 20).MaxDimension(), 21);
 
  EXPECT_EQ(ISize(20, 20).MaxDimension(), 20);
  EXPECT_EQ(ISize(20, 19).MaxDimension(), 20);
  EXPECT_EQ(ISize(19, 20).MaxDimension(), 20);
  EXPECT_EQ(ISize(20, 21).MaxDimension(), 21);
  EXPECT_EQ(ISize(21, 20).MaxDimension(), 21);
}

◆ TEST() [644/689]

impeller::testing::TEST	(	SizeTest	,
		NegationOperator
	)

Definition at line 77 of file size_unittests.cc.

                                 {
  EXPECT_EQ(-Size(10, 20), Size(-10, -20));
  EXPECT_EQ(-Size(-10, 20), Size(10, -20));
  EXPECT_EQ(-Size(10, -20), Size(-10, 20));
  EXPECT_EQ(-Size(-10, -20), Size(10, 20));
}

◆ TEST() [645/689]

impeller::testing::TEST	(	SizeTest	,
		SizeIsEmpty
	)

Definition at line 12 of file size_unittests.cc.

                            {
  auto nan = std::numeric_limits<Scalar>::quiet_NaN();
 
  // Non-empty
  EXPECT_FALSE(Size(10.5, 7.2).IsEmpty());
 
  // Empty both width and height both 0 or negative, in all combinations
  EXPECT_TRUE(Size(0.0, 0.0).IsEmpty());
  EXPECT_TRUE(Size(-1.0, -1.0).IsEmpty());
  EXPECT_TRUE(Size(-1.0, 0.0).IsEmpty());
  EXPECT_TRUE(Size(0.0, -1.0).IsEmpty());
 
  // Empty for 0 or negative width or height (but not both at the same time)
  EXPECT_TRUE(Size(10.5, 0.0).IsEmpty());
  EXPECT_TRUE(Size(10.5, -1.0).IsEmpty());
  EXPECT_TRUE(Size(0.0, 7.2).IsEmpty());
  EXPECT_TRUE(Size(-1.0, 7.2).IsEmpty());
 
  // Empty for NaN in width or height or both
  EXPECT_TRUE(Size(10.5, nan).IsEmpty());
  EXPECT_TRUE(Size(nan, 7.2).IsEmpty());
  EXPECT_TRUE(Size(nan, nan).IsEmpty());
}

◆ TEST() [646/689]

impeller::testing::TEST	(	SkiaConversionsTest	,
		ToColor
	)

Definition at line 46 of file skia_conversions_unittests.cc.

                                   {
  // Create a color with alpha, red, green, and blue values that are all
  // trivially divisible by 255 so that we can test the conversion results in
  // correct scalar values.
  //                                                AARRGGBB
  const flutter::DlColor color = flutter::DlColor(0x8040C020);
  auto converted_color = skia_conversions::ToColor(color);
 
  ASSERT_TRUE(ScalarNearlyEqual(converted_color.alpha, 0x80 * (1.0f / 255)));
  ASSERT_TRUE(ScalarNearlyEqual(converted_color.red, 0x40 * (1.0f / 255)));
  ASSERT_TRUE(ScalarNearlyEqual(converted_color.green, 0xC0 * (1.0f / 255)));
  ASSERT_TRUE(ScalarNearlyEqual(converted_color.blue, 0x20 * (1.0f / 255)));
}

References impeller::ScalarNearlyEqual(), and impeller::skia_conversions::ToColor().

◆ TEST() [647/689]

impeller::testing::TEST	(	SkiaConversionTest	,
		ToSamplerDescriptor
	)

Definition at line 17 of file skia_conversions_unittests.cc.

                                              {
  EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                flutter::DlImageSampling::kNearestNeighbor)
                .min_filter,
            impeller::MinMagFilter::kNearest);
  EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                flutter::DlImageSampling::kNearestNeighbor)
                .mip_filter,
            impeller::MipFilter::kBase);
 
  EXPECT_EQ(
      skia_conversions::ToSamplerDescriptor(flutter::DlImageSampling::kLinear)
          .min_filter,
      impeller::MinMagFilter::kLinear);
  EXPECT_EQ(
      skia_conversions::ToSamplerDescriptor(flutter::DlImageSampling::kLinear)
          .mip_filter,
      impeller::MipFilter::kBase);
 
  EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                flutter::DlImageSampling::kMipmapLinear)
                .min_filter,
            impeller::MinMagFilter::kLinear);
  EXPECT_EQ(skia_conversions::ToSamplerDescriptor(
                flutter::DlImageSampling::kMipmapLinear)
                .mip_filter,
            impeller::MipFilter::kLinear);
}

References impeller::kBase, flutter::kLinear, impeller::kLinear, flutter::kMipmapLinear, impeller::kNearest, flutter::kNearestNeighbor, and impeller::skia_conversions::ToSamplerDescriptor().

◆ TEST() [648/689]

impeller::testing::TEST	(	SpecConstant	,
		CanCreateShaderWithSpecializationConstant
	)

Definition at line 14 of file specialization_constants_unittests.cc.

                                                              {
  auto mock_gles = MockGLES::Init();
  auto& proc_table = mock_gles->GetProcTable();
  auto shader_source =
      "#version 100\n"
      "#ifndef SPIRV_CROSS_CONSTANT_ID_0\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 1\n"
      "#endif\n"
      "void main() { return vec4(0.0); }";
  auto test_shader = std::make_shared<fml::DataMapping>(shader_source);
 
  auto result = proc_table.ComputeShaderWithDefines(*test_shader, {0});
 
  auto expected_shader_source =
      "#version 100\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 0.000000\n"
      "#ifndef SPIRV_CROSS_CONSTANT_ID_0\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 1\n"
      "#endif\n"
      "void main() { return vec4(0.0); }";
 
  if (!result.has_value()) {
    GTEST_FAIL() << "Expected shader source";
  }
  ASSERT_EQ(result.value(), expected_shader_source);
}

References impeller::testing::MockGLES::Init().

◆ TEST() [649/689]

impeller::testing::TEST	(	SpecConstant	,
		CanCreateShaderWithSpecializationConstantMultipleValues
	)

Definition at line 41 of file specialization_constants_unittests.cc.

                                                                            {
  auto mock_gles = MockGLES::Init();
  auto& proc_table = mock_gles->GetProcTable();
  auto shader_source =
      "#version 100\n"
      "#ifndef SPIRV_CROSS_CONSTANT_ID_0\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 1\n"
      "#endif\n"
      "void main() { return vec4(0.0); }";
  auto test_shader = std::make_shared<fml::DataMapping>(shader_source);
 
  auto result =
      proc_table.ComputeShaderWithDefines(*test_shader, {0, 1, 2, 3, 4, 5});
 
  auto expected_shader_source =
      "#version 100\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 0.000000\n"
      "#define SPIRV_CROSS_CONSTANT_ID_1 1.000000\n"
      "#define SPIRV_CROSS_CONSTANT_ID_2 2.000000\n"
      "#define SPIRV_CROSS_CONSTANT_ID_3 3.000000\n"
      "#define SPIRV_CROSS_CONSTANT_ID_4 4.000000\n"
      "#define SPIRV_CROSS_CONSTANT_ID_5 5.000000\n"
      "#ifndef SPIRV_CROSS_CONSTANT_ID_0\n"
      "#define SPIRV_CROSS_CONSTANT_ID_0 1\n"
      "#endif\n"
      "void main() { return vec4(0.0); }";
 
  if (!result.has_value()) {
    GTEST_FAIL() << "Expected shader source";
  }
  ASSERT_EQ(result.value(), expected_shader_source);
}

References impeller::testing::MockGLES::Init().

◆ TEST() [650/689]

impeller::testing::TEST	(	SurfaceContextVK	,
		TearsDownSwapchain
	)

Definition at line 31 of file surface_context_vk_unittests.cc.

                                           {
  SetSwapchainImageSize({100, 100});
  std::shared_ptr<ContextVK> context = MockVulkanContextBuilder().Build();
 
  vk::UniqueSurfaceKHR surface = CreateSurface(*context);
  SurfaceContextVK surface_context(context);
 
  EXPECT_TRUE(surface_context.SetWindowSurface(std::move(surface), {100, 100}));
  EXPECT_NE(surface_context.AcquireNextSurface(), nullptr);
 
  surface_context.TeardownSwapchain();
 
  EXPECT_EQ(surface_context.AcquireNextSurface(), nullptr);
}

References impeller::SurfaceContextVK::AcquireNextSurface(), impeller::testing::MockVulkanContextBuilder::Build(), context, CreateSurface(), SetSwapchainImageSize(), impeller::SurfaceContextVK::SetWindowSurface(), surface, and impeller::SurfaceContextVK::TeardownSwapchain().

◆ TEST() [651/689]

impeller::testing::TEST	(	SwapchainTest	,
		CachesRenderPassOnSwapchainImage
	)

Definition at line 58 of file swapchain_unittests.cc.

                                                      {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto surface = CreateSurface(*context);
  auto swapchain =
      KHRSwapchainVK::Create(context, std::move(surface), ISize{1, 1});
 
  EXPECT_TRUE(swapchain->IsValid());
 
  // The mock swapchain will always create 3 images, verify each one starts
  // out with the same MSAA and depth+stencil texture, and no cached
  // framebuffer.
  std::vector<std::shared_ptr<Texture>> msaa_textures;
  std::vector<std::shared_ptr<Texture>> depth_stencil_textures;
  for (auto i = 0u; i < 3u; i++) {
    auto drawable = swapchain->AcquireNextDrawable();
    RenderTarget render_target = drawable->GetRenderTarget();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
              nullptr);
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
              nullptr);
 
    auto command_buffer = context->CreateCommandBuffer();
    auto render_pass = command_buffer->CreateRenderPass(render_target);
    render_pass->EncodeCommands();
 
    auto& depth = render_target.GetDepthAttachment();
    depth_stencil_textures.push_back(depth.has_value() ? depth->texture
                                                       : nullptr);
    msaa_textures.push_back(render_target.GetColorAttachment(0).texture);
  }
 
  for (auto i = 1; i < 3; i++) {
    EXPECT_EQ(msaa_textures[i - 1], msaa_textures[i]);
    EXPECT_EQ(depth_stencil_textures[i - 1], depth_stencil_textures[i]);
  }
 
  // After each images has been acquired once and the render pass presented,
  // each should have a cached framebuffer and render pass.
 
  std::vector<SharedHandleVK<vk::Framebuffer>> framebuffers;
  std::vector<SharedHandleVK<vk::RenderPass>> render_passes;
  for (auto i = 0u; i < 3u; i++) {
    auto drawable = swapchain->AcquireNextDrawable();
    RenderTarget render_target = drawable->GetRenderTarget();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
 
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
              nullptr);
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
              nullptr);
    framebuffers.push_back(
        texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer);
    render_passes.push_back(
        texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass);
  }
 
  // Iterate through once more to verify render passes and framebuffers are
  // unchanged.
  for (auto i = 0u; i < 3u; i++) {
    auto drawable = swapchain->AcquireNextDrawable();
    RenderTarget render_target = drawable->GetRenderTarget();
 
    auto texture = render_target.GetRenderTargetTexture();
    auto& texture_vk = TextureVK::Cast(*texture);
 
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
              framebuffers[i]);
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
              render_passes[i]);
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
              framebuffers[i]);
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
              render_passes[i]);
  }
}

References impeller::testing::MockVulkanContextBuilder::Build(), impeller::BackendCast< TextureVK, Texture >::Cast(), command_buffer, context, impeller::SwapchainVK::Create(), CreateSurface(), impeller::RenderTarget::GetColorAttachment(), impeller::RenderTarget::GetDepthAttachment(), impeller::RenderTarget::GetRenderTargetTexture(), i, impeller::kCount1, impeller::kCount4, render_pass, surface, swapchain, impeller::Attachment::texture, and texture.

◆ TEST() [652/689]

impeller::testing::TEST	(	SwapchainTest	,
		CanCreateSwapchain
	)

Definition at line 28 of file swapchain_unittests.cc.

                                        {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto surface = CreateSurface(*context);
  auto swapchain =
      KHRSwapchainVK::Create(context, std::move(surface), ISize{1, 1});
 
  EXPECT_TRUE(swapchain->IsValid());
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::SwapchainVK::Create(), CreateSurface(), surface, and swapchain.

◆ TEST() [653/689]

impeller::testing::TEST	(	SwapchainTest	,
		NoFenceWaitAfterAcquireNextImageFailure
	)

Definition at line 140 of file swapchain_unittests.cc.

                                                             {
  bool wait_for_fences_called = false;
  auto const context =
      MockVulkanContextBuilder()
          .SetAcquireNextImageCallback(
              [](VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence,
                 uint32_t*) -> VkResult { return VK_ERROR_SURFACE_LOST_KHR; })
          .SetWaitForFencesCallback([&](VkDevice, uint32_t, const VkFence*,
                                        VkBool32, uint64_t) -> VkResult {
            wait_for_fences_called = true;
            return VK_SUCCESS;
          })
          .Build();
 
  auto surface = CreateSurface(*context);
  SetSwapchainImageSize(ISize{1, 1});
  auto swapchain =
      KHRSwapchainVK::Create(context, std::move(surface), ISize{1, 1},
                             /*enable_msaa=*/false);
  auto image = swapchain->AcquireNextDrawable();
  EXPECT_FALSE(image);
 
  swapchain->AcquireNextDrawable();
  EXPECT_FALSE(wait_for_fences_called);
}

References context, impeller::SwapchainVK::Create(), CreateSurface(), image, impeller::testing::MockVulkanContextBuilder::SetAcquireNextImageCallback(), SetSwapchainImageSize(), surface, and swapchain.

◆ TEST() [654/689]

impeller::testing::TEST	(	SwapchainTest	,
		RecreateSwapchainWhenSizeChanges
	)

Definition at line 38 of file swapchain_unittests.cc.

                                                      {
  auto const context = MockVulkanContextBuilder().Build();
 
  auto surface = CreateSurface(*context);
  SetSwapchainImageSize(ISize{1, 1});
  auto swapchain =
      KHRSwapchainVK::Create(context, std::move(surface), ISize{1, 1},
                             /*enable_msaa=*/false);
  auto image = swapchain->AcquireNextDrawable();
  auto expected_size = ISize{1, 1};
  EXPECT_EQ(image->GetSize(), expected_size);
 
  SetSwapchainImageSize(ISize{100, 100});
  swapchain->UpdateSurfaceSize(ISize{100, 100});
 
  auto image_b = swapchain->AcquireNextDrawable();
  expected_size = ISize{100, 100};
  EXPECT_EQ(image_b->GetSize(), expected_size);
}

References impeller::testing::MockVulkanContextBuilder::Build(), context, impeller::SwapchainVK::Create(), CreateSurface(), image, SetSwapchainImageSize(), surface, and swapchain.

◆ TEST() [655/689]

impeller::testing::TEST	(	TessellatorTest	,
		CircleVertexCounts
	)

Definition at line 154 of file tessellator_unittests.cc.

                                          {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, Scalar radius) {
    auto generator = tessellator.FilledCircle(transform, {}, radius);
    size_t quadrant_divisions = generator.GetVertexCount() / 4;
 
    // Confirm the approximation error is within the currently accepted
    // |kCircleTolerance| value advertised by |CircleTessellator|.
    // (With an additional 1% tolerance for floating point rounding.)
    double angle = kPiOver2 / quadrant_divisions;
    Point first = {radius, 0};
    Point next = {static_cast<Scalar>(cos(angle) * radius),
                  static_cast<Scalar>(sin(angle) * radius)};
    Point midpoint = (first + next) * 0.5;
    EXPECT_GE(midpoint.GetLength(),
              radius - Tessellator::kCircleTolerance * 1.01)
        << ", transform = " << transform << ", radius = " << radius
        << ", divisions = " << quadrant_divisions;
  };
 
  test({}, 0.0);
  test({}, 0.9);
  test({}, 1.0);
  test({}, 1.9);
  test(Matrix::MakeScale(Vector2(2.0, 2.0)), 0.95);
  test({}, 2.0);
  test(Matrix::MakeScale(Vector2(2.0, 2.0)), 1.0);
  test({}, 11.9);
  test({}, 12.0);
  test({}, 35.9);
  for (int i = 36; i < 10000; i += 4) {
    test({}, i);
  }
}

References impeller::Tessellator::FilledCircle(), impeller::Tessellator::EllipticalVertexGenerator::GetVertexCount(), i, impeller::Tessellator::kCircleTolerance, impeller::kPiOver2, impeller::Matrix::MakeScale(), and transform.

◆ TEST() [656/689]

impeller::testing::TEST	(	TessellatorTest	,
		EarlyReturnEmptyConvexShape
	)

Definition at line 590 of file tessellator_unittests.cc.

                                                   {
  // This path is not technically empty (it has a size in one dimension), but
  // it contains only move commands and no actual path segment definitions.
  flutter::DlPathBuilder builder;
  builder.MoveTo({0, 0});
  builder.MoveTo({10, 10});
 
  std::vector<Point> points;
  std::vector<uint16_t> indices;
  Tessellator::TessellateConvexInternal(builder.TakePath(), points, indices,
                                        3.0f);
 
  EXPECT_TRUE(points.empty());
  EXPECT_TRUE(indices.empty());
}

References flutter::DlPathBuilder::MoveTo(), points, flutter::DlPathBuilder::TakePath(), and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [657/689]

impeller::testing::TEST	(	TessellatorTest	,
		FilledArcStripTessellationVertices
	)

Definition at line 306 of file tessellator_unittests.cc.

                                                          {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Arc& arc) {
    auto generator = tessellator.FilledArc(transform, arc,
                                           /*supports_triangle_fans=*/false);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
 
    auto center = arc.GetOvalBounds().GetCenter();
    auto radius = arc.GetOvalSize().width * 0.5;
 
    // Test position of first point
    EXPECT_POINT_NEAR(
        vertices[0],
        Point(center.x + cos(Radians(arc.GetStart()).radians) * radius,
              center.y + sin(Radians(arc.GetStart()).radians) * radius));
 
    // Test position of last point
    auto last_angle = arc.GetStart() + arc.GetSweep();
    EXPECT_POINT_NEAR(
        vertices[vertex_count - 1],
        Point(center.x + cos(Radians(last_angle).radians) * radius,
              center.y + sin(Radians(last_angle).radians) * radius));
 
    // Test odd-indexed points. These are all the origin.
    Point origin = arc.IncludeCenter()
                       ? center
                       : (vertices[0] + vertices[vertex_count - 1]) * 0.5f;
    for (size_t i = 1; i < vertex_count; i += 2) {
      EXPECT_POINT_NEAR(vertices[i], origin);
    }
 
    // Test even-indexed points. These are points on the outer edge of the arc.
    auto previous_outer_point = vertices[0];
    auto outer_increment_distance = (vertices[4] - vertices[2]).GetLength();
    for (size_t i = 2; i < vertex_count; i += 2) {
      // Each is |radius| from the center.
      EXPECT_NEAR((vertices[i] - center).GetLength(), radius, kEhCloseEnough);
 
      // Each is within |outer_increment_distance| from the previous
      if (i == 2 || i == vertex_count - 1) {
        // The very first and last points may be closer than
        // |outer_increment_distance| to their adjacent outer points
        EXPECT_LE((vertices[i] - previous_outer_point).GetLength(),
                  outer_increment_distance + kEhCloseEnough);
      } else {
        // Other outer points are |outer_increment_distance| apart
        EXPECT_NEAR((vertices[i] - previous_outer_point).GetLength(),
                    outer_increment_distance, kEhCloseEnough);
      }
 
      previous_outer_point = vertices[i];
    }
  };
 
  test({}, Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(0), Degrees(90), false));
  test({}, Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(0), Degrees(90), true));
 
  test({},
       Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(0), Degrees(-270), false));
  test({},
       Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(0), Degrees(-270), true));
 
  test({},
       Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(94), Degrees(322), false));
  test({},
       Arc(Rect::MakeXYWH(0, 0, 100, 100), Degrees(94), Degrees(322), true));
}

References EXPECT_POINT_NEAR, impeller::Tessellator::FilledArc(), i, flutter::kEhCloseEnough, impeller::kTriangleStrip, impeller::TRect< Scalar >::MakeXYWH(), impeller::Radians::radians, and transform.

◆ TEST() [658/689]

impeller::testing::TEST	(	TessellatorTest	,
		FilledCircleTessellationVertices
	)

Definition at line 190 of file tessellator_unittests.cc.

                                                        {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Point& center,
                             Scalar radius) {
    auto generator = tessellator.FilledCircle(transform, center, radius);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
    ASSERT_EQ(vertex_count % 4, 0u);
 
    auto quadrant_count = vertex_count / 4;
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      double rsin = sin(angle) * radius;
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      double rcos = (i == quadrant_count - 1) ? 0.0f : cos(angle) * radius;
      EXPECT_POINT_NEAR(vertices[i * 2],
                        Point(center.x - rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[i * 2 + 1],
                        Point(center.x - rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 1],
                        Point(center.x + rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 2],
                        Point(center.x + rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
    }
  };
 
  test({}, {}, 2.0);
  test({}, {10, 10}, 2.0);
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), {}, 2.0);
  test(Matrix::MakeScale({0.002, 0.002, 0.0}), {}, 1000.0);
}

References EXPECT_POINT_NEAR, impeller::Tessellator::FilledCircle(), i, flutter::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), and transform.

◆ TEST() [659/689]

impeller::testing::TEST	(	TessellatorTest	,
		FilledEllipseTessellationVertices
	)

Definition at line 455 of file tessellator_unittests.cc.

                                                         {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Rect& bounds) {
    auto center = bounds.GetCenter();
    auto half_size = bounds.GetSize() * 0.5f;
 
    auto generator = tessellator.FilledEllipse(transform, bounds);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
    ASSERT_EQ(vertex_count % 4, 0u);
 
    auto quadrant_count = vertex_count / 4;
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      double rcos =
          (i == quadrant_count - 1) ? 0.0f : cos(angle) * half_size.width;
      double rsin = sin(angle) * half_size.height;
      EXPECT_POINT_NEAR(vertices[i * 2],
                        Point(center.x - rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[i * 2 + 1],
                        Point(center.x - rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 1],
                        Point(center.x + rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 2],
                        Point(center.x + rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
    }
  };
 
  // Square bounds should actually use the circle generator, but its
  // results should match the same math as the ellipse generator.
  test({}, Rect::MakeXYWH(0, 0, 2, 2));
 
  test({}, Rect::MakeXYWH(0, 0, 2, 3));
  test({}, Rect::MakeXYWH(0, 0, 3, 2));
  test({}, Rect::MakeXYWH(5, 10, 2, 3));
  test({}, Rect::MakeXYWH(16, 7, 3, 2));
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), Rect::MakeXYWH(5, 10, 3, 2));
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), Rect::MakeXYWH(5, 10, 2, 3));
  test(Matrix::MakeScale({0.002, 0.002, 0.0}),
       Rect::MakeXYWH(5000, 10000, 3000, 2000));
  test(Matrix::MakeScale({0.002, 0.002, 0.0}),
       Rect::MakeXYWH(5000, 10000, 2000, 3000));
}

References EXPECT_POINT_NEAR, impeller::Tessellator::FilledEllipse(), i, flutter::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [660/689]

impeller::testing::TEST	(	TessellatorTest	,
		FilledRoundRectTessellationVertices
	)

Definition at line 516 of file tessellator_unittests.cc.

                                                           {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Rect& bounds,
                             const Size& radii) {
    FML_DCHECK(radii.width * 2 <= bounds.GetWidth()) << radii << bounds;
    FML_DCHECK(radii.height * 2 <= bounds.GetHeight()) << radii << bounds;
 
    Scalar middle_left = bounds.GetX() + radii.width;
    Scalar middle_top = bounds.GetY() + radii.height;
    Scalar middle_right = bounds.GetX() + bounds.GetWidth() - radii.width;
    Scalar middle_bottom = bounds.GetY() + bounds.GetHeight() - radii.height;
 
    auto generator = tessellator.FilledRoundRect(transform, bounds, radii);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
    ASSERT_EQ(vertex_count % 4, 0u);
 
    auto quadrant_count = vertex_count / 4;
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      double rcos = (i == quadrant_count - 1) ? 0.0f : cos(angle) * radii.width;
      double rsin = sin(angle) * radii.height;
      EXPECT_POINT_NEAR(vertices[i * 2],
                        Point(middle_left - rcos, middle_bottom + rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[i * 2 + 1],
                        Point(middle_left - rcos, middle_top - rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 1],
                        Point(middle_right + rcos, middle_top - rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 2],
                        Point(middle_right + rcos, middle_bottom + rsin))
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "bounds = " << bounds << std::endl;
    }
  };
 
  // Both radii spanning the bounds should actually use the circle/ellipse
  // generator, but their results should match the same math as the round
  // rect generator.
  test({}, Rect::MakeXYWH(0, 0, 20, 20), {10, 10});
 
  // One radius spanning the bounds, but not the other will not match the
  // round rect math if the generator transfers to circle/ellipse
  test({}, Rect::MakeXYWH(0, 0, 20, 20), {10, 5});
  test({}, Rect::MakeXYWH(0, 0, 20, 20), {5, 10});
 
  test({}, Rect::MakeXYWH(0, 0, 20, 30), {2, 2});
  test({}, Rect::MakeXYWH(0, 0, 30, 20), {2, 2});
  test({}, Rect::MakeXYWH(5, 10, 20, 30), {2, 3});
  test({}, Rect::MakeXYWH(16, 7, 30, 20), {2, 3});
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), Rect::MakeXYWH(5, 10, 30, 20),
       {2, 3});
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), Rect::MakeXYWH(5, 10, 20, 30),
       {2, 3});
  test(Matrix::MakeScale({0.002, 0.002, 0.0}),
       Rect::MakeXYWH(5000, 10000, 3000, 2000), {50, 70});
  test(Matrix::MakeScale({0.002, 0.002, 0.0}),
       Rect::MakeXYWH(5000, 10000, 2000, 3000), {50, 70});
}

References EXPECT_POINT_NEAR, impeller::Tessellator::FilledRoundRect(), FML_DCHECK, i, flutter::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST() [661/689]

impeller::testing::TEST	(	TessellatorTest	,
		RoundCapLineTessellationVertices
	)

Definition at line 382 of file tessellator_unittests.cc.

                                                        {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Point& p0,
                             const Point& p1, Scalar radius) {
    auto generator = tessellator.RoundCapLine(transform, p0, p1, radius);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
    ASSERT_EQ(vertex_count % 4, 0u);
 
    Point along = p1 - p0;
    Scalar length = along.GetLength();
    if (length > 0) {
      along *= radius / length;
    } else {
      along = {radius, 0};
    }
    Point across = {-along.y, along.x};
 
    auto quadrant_count = vertex_count / 4;
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      Point relative_along =
          along * ((i == quadrant_count - 1) ? 0.0f : cos(angle));
      Point relative_across = across * sin(angle);
      EXPECT_POINT_NEAR(vertices[i * 2],  //
                        p0 - relative_along + relative_across)
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "line = " << p0 << " => " << p1 << ", "            //
          << "radius = " << radius << std::endl;
      EXPECT_POINT_NEAR(vertices[i * 2 + 1],  //
                        p0 - relative_along - relative_across)
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "line = " << p0 << " => " << p1 << ", "            //
          << "radius = " << radius << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 1],  //
                        p1 + relative_along - relative_across)
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "line = " << p0 << " => " << p1 << ", "            //
          << "radius = " << radius << std::endl;
      EXPECT_POINT_NEAR(vertices[vertex_count - i * 2 - 2],  //
                        p1 + relative_along + relative_across)
          << "vertex " << i << ", angle = " << degrees << ", "  //
          << "line = " << p0 << " => " << p1 << ", "            //
          << "radius = " << radius << std::endl;
    }
  };
 
  // Empty line should actually use the circle generator, but its
  // results should match the same math as the round cap generator.
  test({}, {0, 0}, {0, 0}, 10);
 
  test({}, {0, 0}, {10, 0}, 2);
  test({}, {10, 0}, {0, 0}, 2);
  test({}, {0, 0}, {10, 10}, 2);
 
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), {0, 0}, {10, 0}, 2);
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), {10, 0}, {0, 0}, 2);
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), {0, 0}, {10, 10}, 2);
 
  test(Matrix::MakeScale({0.002, 0.002, 0.0}), {0, 0}, {10, 0}, 2);
  test(Matrix::MakeScale({0.002, 0.002, 0.0}), {10, 0}, {0, 0}, 2);
  test(Matrix::MakeScale({0.002, 0.002, 0.0}), {0, 0}, {10, 10}, 2);
}

References EXPECT_POINT_NEAR, i, flutter::kPi, impeller::kPiOver2, impeller::kTriangleStrip, length, impeller::Matrix::MakeScale(), p1, impeller::Tessellator::RoundCapLine(), transform, flutter::Point::x(), and flutter::Point::y().

◆ TEST() [662/689]

impeller::testing::TEST	(	TessellatorTest	,
		StrokedCircleTessellationVertices
	)

Definition at line 234 of file tessellator_unittests.cc.

                                                         {
  Tessellator tessellator;
 
  auto test = [&tessellator](const Matrix& transform, const Point& center,
                             Scalar radius, Scalar half_width) {
    ASSERT_GT(radius, half_width);
    auto generator =
        tessellator.StrokedCircle(transform, center, radius, half_width);
    EXPECT_EQ(generator.GetTriangleType(), PrimitiveType::kTriangleStrip);
 
    auto vertex_count = generator.GetVertexCount();
    auto vertices = std::vector<Point>();
    generator.GenerateVertices([&vertices](const Point& p) {  //
      vertices.push_back(p);
    });
    EXPECT_EQ(vertices.size(), vertex_count);
    ASSERT_EQ(vertex_count % 4, 0u);
 
    auto quadrant_count = vertex_count / 8;
 
    // Test outer points first
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      double rsin = sin(angle) * (radius + half_width);
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      double rcos =
          (i == quadrant_count - 1) ? 0.0f : cos(angle) * (radius + half_width);
      EXPECT_POINT_NEAR(vertices[i * 2],
                        Point(center.x - rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 2 + i * 2],
                        Point(center.x + rsin, center.y - rcos))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 4 + i * 2],
                        Point(center.x + rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 6 + i * 2],
                        Point(center.x - rsin, center.y + rcos))
          << "vertex " << i << ", angle = " << degrees << std::endl;
    }
 
    // Then test innerer points
    for (size_t i = 0; i < quadrant_count; i++) {
      double angle = kPiOver2 * i / (quadrant_count - 1);
      double degrees = angle * 180.0 / kPi;
      double rsin = sin(angle) * (radius - half_width);
      // Note that cos(radians(90 degrees)) isn't exactly 0.0 like it should be
      double rcos =
          (i == quadrant_count - 1) ? 0.0f : cos(angle) * (radius - half_width);
      EXPECT_POINT_NEAR(vertices[i * 2 + 1],
                        Point(center.x - rcos, center.y - rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 2 + i * 2 + 1],
                        Point(center.x + rsin, center.y - rcos))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 4 + i * 2 + 1],
                        Point(center.x + rcos, center.y + rsin))
          << "vertex " << i << ", angle = " << degrees << std::endl;
      EXPECT_POINT_NEAR(vertices[quadrant_count * 6 + i * 2 + 1],
                        Point(center.x - rsin, center.y + rcos))
          << "vertex " << i << ", angle = " << degrees << std::endl;
    }
  };
 
  test({}, {}, 2.0, 1.0);
  test({}, {}, 2.0, 0.5);
  test({}, {10, 10}, 2.0, 1.0);
  test(Matrix::MakeScale({500.0, 500.0, 0.0}), {}, 2.0, 1.0);
  test(Matrix::MakeScale({0.002, 0.002, 0.0}), {}, 1000.0, 10.0);
}

References EXPECT_POINT_NEAR, i, flutter::kPi, impeller::kPiOver2, impeller::kTriangleStrip, impeller::Matrix::MakeScale(), impeller::Tessellator::StrokedCircle(), and transform.

◆ TEST() [663/689]

impeller::testing::TEST	(	TessellatorTest	,
		TessellateConvex
	)

Definition at line 97 of file tessellator_unittests.cc.

                                        {
  {
    std::vector<Point> points;
    std::vector<uint16_t> indices;
    // Sanity check simple rectangle.
    Tessellator::TessellateConvexInternal(
        flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 10, 10)), points,
        indices, 1.0);
 
    // Note: the origin point is repeated but not referenced in the indices
    // below
    std::vector<Point> expected = {{0, 0}, {10, 0}, {10, 10}, {0, 10}, {0, 0}};
    std::vector<uint16_t> expected_indices = {0, 1, 3, 2};
    EXPECT_EQ(points, expected);
    EXPECT_EQ(indices, expected_indices);
  }
 
  {
    std::vector<Point> points;
    std::vector<uint16_t> indices;
    Tessellator::TessellateConvexInternal(
        flutter::DlPath(flutter::DlPathBuilder{}
                            .AddRect(Rect::MakeLTRB(0, 0, 10, 10))
                            .AddRect(Rect::MakeLTRB(20, 20, 30, 30))
                            .TakePath()),
        points, indices, 1.0);
 
    std::vector<Point> expected = {{0, 0},   {10, 0},  {10, 10}, {0, 10},
                                   {0, 0},   {20, 20}, {30, 20}, {30, 30},
                                   {20, 30}, {20, 20}};
    std::vector<uint16_t> expected_indices = {0, 1, 3, 2, 2, 5, 5, 6, 8, 7};
    EXPECT_EQ(points, expected);
    EXPECT_EQ(indices, expected_indices);
  }
}

References flutter::DlPathBuilder::AddRect(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), points, and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [664/689]

impeller::testing::TEST	(	TessellatorTest	,
		TessellateConvexUnclosedPath
	)

Definition at line 134 of file tessellator_unittests.cc.

                                                    {
  std::vector<Point> points;
  std::vector<uint16_t> indices;
 
  // Create a rectangle that lacks an explicit close.
  flutter::DlPath path = flutter::DlPathBuilder{}
                             .LineTo({100, 0})
                             .LineTo({100, 100})
                             .LineTo({0, 100})
                             .TakePath();
  Tessellator::TessellateConvexInternal(flutter::DlPath(path), points, indices,
                                        1.0);
 
  std::vector<Point> expected = {
      {0, 0}, {100, 0}, {100, 100}, {0, 100}, {0, 0}};
  std::vector<uint16_t> expected_indices = {0, 1, 3, 2};
  EXPECT_EQ(points, expected);
  EXPECT_EQ(indices, expected_indices);
}

References flutter::DlPathBuilder::LineTo(), impeller::LineTo(), flutter::path, points, and impeller::Tessellator::TessellateConvexInternal().

◆ TEST() [665/689]

impeller::testing::TEST	(	TessellatorTest	,
		TessellatorBuilderReturnsCorrectResultStatus
	)

Definition at line 17 of file tessellator_unittests.cc.

                                                                    {
  // Zero points.
  {
    TessellatorLibtess t;
    auto path = flutter::DlPathBuilder{}  //
                    .SetFillType(FillType::kOdd)
                    .TakePath();
    TessellatorLibtess::Result result = t.Tessellate(
        path, 1.0f,
        [](const float* vertices, size_t vertices_count,
           const uint16_t* indices, size_t indices_count) { return true; });
 
    ASSERT_EQ(result, TessellatorLibtess::Result::kInputError);
  }
 
  // One point.
  {
    TessellatorLibtess t;
    auto path = flutter::DlPathBuilder{}
                    .LineTo({0, 0})
                    .SetFillType(FillType::kOdd)
                    .TakePath();
    TessellatorLibtess::Result result = t.Tessellate(
        path, 1.0f,
        [](const float* vertices, size_t vertices_count,
           const uint16_t* indices, size_t indices_count) { return true; });
 
    ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
  }
 
  // Two points.
  {
    TessellatorLibtess t;
    auto path = flutter::DlPathBuilder{}
                    .MoveTo({0, 0})
                    .LineTo({0, 1})
                    .SetFillType(FillType::kOdd)
                    .TakePath();
    TessellatorLibtess::Result result = t.Tessellate(
        path, 1.0f,
        [](const float* vertices, size_t vertices_count,
           const uint16_t* indices, size_t indices_count) { return true; });
 
    ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
  }
 
  // Many points.
  {
    TessellatorLibtess t;
    flutter::DlPathBuilder builder;
    for (int i = 0; i < 1000; i++) {
      auto coord = i * 1.0f;
      builder.MoveTo({coord, coord}).LineTo({coord + 1, coord + 1});
    }
    auto path = builder.SetFillType(FillType::kOdd).TakePath();
    TessellatorLibtess::Result result = t.Tessellate(
        path, 1.0f,
        [](const float* vertices, size_t vertices_count,
           const uint16_t* indices, size_t indices_count) { return true; });
 
    ASSERT_EQ(result, TessellatorLibtess::Result::kSuccess);
  }
 
  // Closure fails.
  {
    TessellatorLibtess t;
    auto path = flutter::DlPathBuilder{}
                    .MoveTo({0, 0})
                    .LineTo({0, 1})
                    .SetFillType(FillType::kOdd)
                    .TakePath();
    TessellatorLibtess::Result result = t.Tessellate(
        path, 1.0f,
        [](const float* vertices, size_t vertices_count,
           const uint16_t* indices, size_t indices_count) { return false; });
 
    ASSERT_EQ(result, TessellatorLibtess::Result::kInputError);
  }
}

References i, impeller::TessellatorLibtess::kInputError, impeller::kOdd, impeller::TessellatorLibtess::kSuccess, flutter::DlPathBuilder::LineTo(), impeller::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::SetFillType(), flutter::DlPathBuilder::TakePath(), and impeller::TessellatorLibtess::Tessellate().

◆ TEST() [666/689]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateMutex
	)

Definition at line 36 of file base_unittests.cc.

                                 {
  Foo f = {};
 
  // f.a = 100; <--- Static analysis error.
  f.mtx.Lock();
  f.a = 100;
  f.mtx.Unlock();
}

References impeller::testing::Foo::mtx.

◆ TEST() [667/689]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateMutexLock
	)

Definition at line 45 of file base_unittests.cc.

                                     {
  Foo f = {};
 
  // f.a = 100; <--- Static analysis error.
  auto a = Lock(f.mtx);
  f.a = 100;
}

References impeller::testing::Foo::mtx.

◆ TEST() [668/689]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateRWMutex
	)

Definition at line 53 of file base_unittests.cc.

                                   {
  RWFoo f = {};
 
  // f.a = 100; <--- Static analysis error.
  f.mtx.LockWriter();
  f.a = 100;
  f.mtx.UnlockWriter();
  // int b = f.a; <--- Static analysis error.
  f.mtx.LockReader();
  [[maybe_unused]] int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
  f.mtx.UnlockReader();
}

References impeller::testing::RWFoo::mtx.

◆ TEST() [669/689]

impeller::testing::TEST	(	ThreadTest	,
		CanCreateRWMutexLock
	)

Definition at line 66 of file base_unittests.cc.

                                       {
  RWFoo f = {};
 
  // f.a = 100; <--- Static analysis error.
  {
    auto write_lock = WriterLock{f.mtx};
    f.a = 100;
  }
 
  // int b = f.a; <--- Static analysis error.
  {
    auto read_lock = ReaderLock(f.mtx);
    [[maybe_unused]] int b = f.a;  // NOLINT(clang-analyzer-deadcode.DeadStores)
  }
 
  // f.mtx.UnlockReader(); <--- Static analysis error.
}

References impeller::testing::RWFoo::mtx.

◆ TEST() [670/689]

impeller::testing::TEST	(	TrigTest	,
		MultiplyByScalarRadius
	)

Definition at line 65 of file trig_unittests.cc.

                                       {
  for (int i = 0; i <= 360; i++) {
    for (int i = 1; i <= 10; i++) {
      Scalar radius = i * 5.0f;
      EXPECT_EQ(Trig(Degrees(i)) * radius,
                Point(radius * std::cos(i * kPi / 180),
                      radius * std::sin(i * kPi / 180)))
          << "at " << i << " degrees and radius " << radius;
    }
  }
}

References i, and flutter::kPi.

◆ TEST() [671/689]

impeller::testing::TEST	(	TrigTest	,
		TrigAngles
	)

Definition at line 15 of file trig_unittests.cc.

                           {
  {
    Trig trig(Degrees(0.0));
    EXPECT_EQ(trig.cos, 1.0);
    EXPECT_EQ(trig.sin, 0.0);
  }
 
  {
    Trig trig(Radians(0.0));
    EXPECT_EQ(trig.cos, 1.0);
    EXPECT_EQ(trig.sin, 0.0);
  }
 
  {
    Trig trig(Degrees(30.0));
    EXPECT_NEAR(trig.cos, sqrt(0.75), kEhCloseEnough);
    EXPECT_NEAR(trig.sin, 0.5, kEhCloseEnough);
  }
 
  {
    Trig trig(Radians(kPi / 6.0));
    EXPECT_NEAR(trig.cos, sqrt(0.75), kEhCloseEnough);
    EXPECT_NEAR(trig.sin, 0.5, kEhCloseEnough);
  }
 
  {
    Trig trig(Degrees(60.0));
    EXPECT_NEAR(trig.cos, 0.5, kEhCloseEnough);
    EXPECT_NEAR(trig.sin, sqrt(0.75), kEhCloseEnough);
  }
 
  {
    Trig trig(Radians(kPi / 3.0));
    EXPECT_NEAR(trig.cos, 0.5, kEhCloseEnough);
    EXPECT_NEAR(trig.sin, sqrt(0.75), kEhCloseEnough);
  }
 
  {
    Trig trig(Degrees(90.0));
    EXPECT_NEAR(trig.cos, 0.0, kEhCloseEnough);
    EXPECT_NEAR(trig.sin, 1.0, kEhCloseEnough);
  }
 
  {
    Trig trig(Radians(kPi / 2.0));
    EXPECT_NEAR(trig.cos, 0.0, kEhCloseEnough);
    EXPECT_NEAR(trig.sin, 1.0, kEhCloseEnough);
  }
}

References impeller::Trig::cos, flutter::kEhCloseEnough, flutter::kPi, and impeller::Trig::sin.

◆ TEST() [672/689]

impeller::testing::TEST	(	TypographerTest	,
		RectanglePackerFillsRows
	)

Definition at line 456 of file typographer_unittests.cc.

                                                {
  auto skyline = RectanglePacker::Factory(257, 256);
 
  // Fill up the first row.
  IPoint16 loc;
  for (auto i = 0u; i < 16; i++) {
    skyline->AddRect(16, 16, &loc);
  }
  // Last rectangle still in first row.
  EXPECT_EQ(loc.x(), 256 - 16);
  EXPECT_EQ(loc.y(), 0);
 
  // Fill up second row.
  for (auto i = 0u; i < 16; i++) {
    skyline->AddRect(16, 16, &loc);
  }
 
  EXPECT_EQ(loc.x(), 256 - 16);
  EXPECT_EQ(loc.y(), 16);
}

References impeller::RectanglePacker::Factory(), i, impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ TEST() [673/689]

impeller::testing::TEST	(	UberSDFContentsTest	,
		ApplyColorFilter
	)

Definition at line 16 of file uber_sdf_contents_unittests.cc.

                                            {
  auto rect = Rect::MakeXYWH(100, 100, 200, 200);
  auto params =
      UberSDFParameters::MakeRect(Color::Red(), rect, /*stroke=*/std::nullopt);
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  EXPECT_EQ(contents->GetColor(), Color::Red());
 
  bool result =
      contents->ApplyColorFilter([](Color color) { return Color::Blue(); });
 
  EXPECT_TRUE(result);
  EXPECT_EQ(contents->GetColor(), Color::Blue());
}

References impeller::Color::Blue(), impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, and impeller::Color::Red().

◆ TEST() [674/689]

impeller::testing::TEST	(	UberSDFContentsTest	,
		AsBackgroundColor
	)

Definition at line 32 of file uber_sdf_contents_unittests.cc.

                                             {
  auto rect = Rect::MakeXYWH(-2, -2, 504, 504);
  auto params =
      UberSDFParameters::MakeRect(Color::Red(), rect, /*stroke=*/std::nullopt);
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  entity.SetTransform(Matrix());
 
  EXPECT_EQ(contents->AsBackgroundColor(entity, ISize(500, 500)), Color::Red());
 
  auto small_bg_color = contents->AsBackgroundColor(entity, ISize(400, 400));
  EXPECT_TRUE(small_bg_color.has_value());
  if (small_bg_color.has_value()) {
    EXPECT_EQ(small_bg_color.value(), Color::Red());
  }
 
  auto huge_bg_color = contents->AsBackgroundColor(entity, ISize(600, 600));
  EXPECT_FALSE(huge_bg_color.has_value());
}

References impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::Entity::SetTransform().

◆ TEST() [675/689]

impeller::testing::TEST	(	UberSDFContentsTest	,
		AsBackgroundColorExactSize
	)

Definition at line 54 of file uber_sdf_contents_unittests.cc.

                                                      {
  auto rect = Rect::MakeXYWH(0, 0, 500, 500);
  auto params =
      UberSDFParameters::MakeRect(Color::Red(), rect, /*stroke=*/std::nullopt);
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  entity.SetTransform(Matrix());
 
  auto bg_color = contents->AsBackgroundColor(entity, ISize(500, 500));
  // The exact size now returns true because over-conservative AA insets are
  // removed
  EXPECT_TRUE(bg_color.has_value());
  if (bg_color.has_value()) {
    EXPECT_EQ(bg_color.value(), Color::Red());
  }
}

References impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::Entity::SetTransform().

◆ TEST() [676/689]

impeller::testing::TEST	(	UberSDFContentsTest	,
		AsBackgroundColorNonRect
	)

Definition at line 73 of file uber_sdf_contents_unittests.cc.

                                                    {
  Entity entity;
  entity.SetTransform(Matrix());
 
  // Non-rect shape (Circle) should return nullopt
  auto circle_params = UberSDFParameters::MakeCircle(
      Color::Red(), Point(250, 250), 250.0f, /*stroke=*/std::nullopt);
  auto circle_geometry = std::make_unique<UberSDFGeometry>(circle_params);
  auto circle_contents =
      UberSDFContents::Make(circle_params, std::move(circle_geometry));
 
  auto circle_bg_color =
      circle_contents->AsBackgroundColor(entity, ISize(500, 500));
  EXPECT_FALSE(circle_bg_color.has_value());
}

References impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeCircle(), impeller::Color::Red(), and impeller::Entity::SetTransform().

◆ TEST() [677/689]

impeller::testing::TEST	(	UberSDFContentsTest	,
		AsBackgroundColorStrokedRect
	)

Definition at line 89 of file uber_sdf_contents_unittests.cc.

                                                        {
  auto rect = Rect::MakeXYWH(-2, -2, 504, 504);
  auto params = UberSDFParameters::MakeRect(Color::Red(), rect,
                                            StrokeParameters{.width = 2.0f});
  auto geometry = std::make_unique<UberSDFGeometry>(params);
  auto contents = UberSDFContents::Make(params, std::move(geometry));
 
  Entity entity;
  entity.SetTransform(Matrix());
 
  auto bg_color = contents->AsBackgroundColor(entity, ISize(500, 500));
  EXPECT_FALSE(bg_color.has_value());
}

References impeller::UberSDFContents::Make(), impeller::UberSDFParameters::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), impeller::Entity::SetTransform(), and impeller::StrokeParameters::width.

◆ TEST() [678/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeFillCircle
	)

Definition at line 49 of file uber_sdf_parameters_unittests.cc.

                                            {
  Point center = {50, 50};
  auto params =
      UberSDFParameters::MakeCircle(Color::Red(), center, 10.0f, std::nullopt);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kCircle);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, center);
  EXPECT_EQ(params.size, Point(10.0f, 10.0f));
  EXPECT_FALSE(params.stroke.has_value());
}

References impeller::UberSDFParameters::kCircle, impeller::UberSDFParameters::MakeCircle(), params, and impeller::Color::Red().

◆ TEST() [679/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeFillOval
	)

Definition at line 74 of file uber_sdf_parameters_unittests.cc.

                                          {
  Point center = {25, 25};
  Size size = Size(50, 50);
  Rect bounds = Rect::MakeOriginSize(Point(), size);
 
  auto params = UberSDFParameters::MakeOval(Color::Red(), bounds, std::nullopt);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kOval);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, center);
  EXPECT_EQ(params.size, Point(size) * 0.5f);
  EXPECT_FALSE(params.stroke.has_value());
}

References impeller::UberSDFParameters::kOval, impeller::TRect< Scalar >::MakeOriginSize(), impeller::UberSDFParameters::MakeOval(), params, impeller::Color::Red(), and flutter::size.

◆ TEST() [680/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeFillRect
	)

Definition at line 12 of file uber_sdf_parameters_unittests.cc.

                                          {
  auto rect = Rect::MakeLTRB(100, 100, 200, 200);
  auto params = UberSDFParameters::MakeRect(Color::Red(), rect, std::nullopt);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kRect);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, Point(150, 150));
  EXPECT_EQ(params.size, Point(50, 50));
  EXPECT_FALSE(params.stroke.has_value());
}

References impeller::UberSDFParameters::kRect, impeller::TRect< Scalar >::MakeLTRB(), impeller::UberSDFParameters::MakeRect(), params, and impeller::Color::Red().

◆ TEST() [681/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeRoundedRect
	)

Definition at line 103 of file uber_sdf_parameters_unittests.cc.

                                             {
  Rect rect = Rect::MakeXYWH(10, 20, 100, 100);
  RoundingRadii radii = {
      .top_left = Size(1.0f, 1.0f),
      .top_right = Size(2.0f, 2.0f),
      .bottom_left = Size(3.0f, 3.0f),
      .bottom_right = Size(4.0f, 4.0f),
  };
  auto params = UberSDFParameters::MakeRoundedRect(
      /*color=*/Color::Red(), /*rect=*/rect, /*radii=*/radii,
      /*stroke=*/std::nullopt);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kRoundedRect);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, Point(60, 70));
  EXPECT_EQ(params.size, Point(50, 50));
  EXPECT_EQ(params.radii.w, 1.0f);
  EXPECT_EQ(params.radii.y, 2.0f);
  EXPECT_EQ(params.radii.z, 3.0f);
  EXPECT_EQ(params.radii.x, 4.0f);
  EXPECT_FALSE(params.stroke.has_value());
}

References impeller::UberSDFParameters::kRoundedRect, impeller::UberSDFParameters::MakeRoundedRect(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::RoundingRadii::top_left.

◆ TEST() [682/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeRoundedSuperellipse
	)

Definition at line 126 of file uber_sdf_parameters_unittests.cc.

                                                     {
  Rect rect = Rect::MakeXYWH(10, 20, 100, 100);
  RoundingRadii radii = {
      .top_left = Size(10.0f, 10.0f),
      .top_right = Size(10.0f, 10.0f),
      .bottom_left = Size(10.0f, 10.0f),
      .bottom_right = Size(10.0f, 10.0f),
  };
  auto round_superellipse_params =
      RoundSuperellipseParam::MakeBoundsRadii(rect, radii);
  auto params = UberSDFParameters::MakeRoundedSuperellipse(
      /*color=*/Color::Red(), /*bounds=*/rect,
      /*round_superellipse_params=*/round_superellipse_params,
      /*stroke=*/std::nullopt);
 
  EXPECT_EQ(params.type,
            UberSDFParameters::Type::kRoundedSuperellipseSymmetric);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, Point(60, 70));
  EXPECT_EQ(params.size, Point(50, 50));
  EXPECT_FALSE(params.stroke.has_value());
 
  EXPECT_EQ(params.radii.x,
            round_superellipse_params.top_right.top.circle_radius);
  EXPECT_EQ(params.radii.y,
            round_superellipse_params.top_right.right.circle_radius);
 
  EXPECT_EQ(params.superellipse_degree.x,
            round_superellipse_params.top_right.top.se_n);
  EXPECT_EQ(params.superellipse_degree.y,
            round_superellipse_params.top_right.right.se_n);
 
  EXPECT_EQ(params.superellipse_scale.x,
            round_superellipse_params.top_right.signed_scale.Abs().x);
  EXPECT_EQ(params.superellipse_scale.y,
            round_superellipse_params.top_right.signed_scale.Abs().y);
}

References impeller::UberSDFParameters::kRoundedSuperellipseSymmetric, impeller::RoundSuperellipseParam::MakeBoundsRadii(), impeller::UberSDFParameters::MakeRoundedSuperellipse(), impeller::TRect< Scalar >::MakeXYWH(), params, impeller::Color::Red(), and impeller::RoundingRadii::top_left.

◆ TEST() [683/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeStrokeCircle
	)

Definition at line 61 of file uber_sdf_parameters_unittests.cc.

                                              {
  Point center = {50, 50};
  StrokeParameters stroke = {.width = 4.0f};
  auto params =
      UberSDFParameters::MakeCircle(Color::Red(), center, 10.0f, stroke);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kCircle);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, center);
  EXPECT_EQ(params.size, Point(10.0f, 10.0f));
  EXPECT_EQ(params.stroke, stroke);
}

References impeller::UberSDFParameters::kCircle, impeller::UberSDFParameters::MakeCircle(), params, impeller::Color::Red(), and impeller::StrokeParameters::width.

◆ TEST() [684/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeStrokeOval
	)

Definition at line 88 of file uber_sdf_parameters_unittests.cc.

                                            {
  Point center = {25, 25};
  Size size = Size(50, 50);
  Rect bounds = Rect::MakeOriginSize(Point(), size);
  StrokeParameters stroke = {.width = 4.0f};
 
  auto params = UberSDFParameters::MakeOval(Color::Red(), bounds, stroke);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kOval);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, center);
  EXPECT_EQ(params.size, Point(size) * 0.5f);
  EXPECT_EQ(params.stroke, stroke);
}

References impeller::UberSDFParameters::kOval, impeller::TRect< Scalar >::MakeOriginSize(), impeller::UberSDFParameters::MakeOval(), params, impeller::Color::Red(), flutter::size, and impeller::StrokeParameters::width.

◆ TEST() [685/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeStrokeRect
	)

Definition at line 23 of file uber_sdf_parameters_unittests.cc.

                                            {
  auto rect = Rect::MakeLTRB(100, 100, 200, 200);
  StrokeParameters stroke = {.width = 4.0f};
  auto params = UberSDFParameters::MakeRect(Color::Red(), rect, stroke);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kRect);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, Point(150, 150));
  EXPECT_EQ(params.size, Point(50, 50));
  EXPECT_EQ(params.stroke, stroke);
}

References impeller::UberSDFParameters::kRect, impeller::TRect< Scalar >::MakeLTRB(), impeller::UberSDFParameters::MakeRect(), params, impeller::Color::Red(), and impeller::StrokeParameters::width.

◆ TEST() [686/689]

impeller::testing::TEST	(	UberSDFParametersTest	,
		MakeStrokeRectLowMiterLimitBecomesBevel
	)

Definition at line 35 of file uber_sdf_parameters_unittests.cc.

                                                                     {
  auto rect = Rect::MakeLTRB(100, 100, 200, 200);
  StrokeParameters stroke = {
      .width = 4.0f, .join = Join::kMiter, .miter_limit = 1.0f};
  auto params = UberSDFParameters::MakeRect(Color::Red(), rect, stroke);
 
  EXPECT_EQ(params.type, UberSDFParameters::Type::kRect);
  EXPECT_EQ(params.color, Color::Red());
  EXPECT_EQ(params.center, Point(150, 150));
  EXPECT_EQ(params.size, Point(50, 50));
  StrokeParameters expected_stroke = {.width = 4.0f, .join = Join::kBevel};
  EXPECT_EQ(params.stroke, expected_stroke);
}

References impeller::kBevel, impeller::kMiter, impeller::UberSDFParameters::kRect, impeller::TRect< Scalar >::MakeLTRB(), impeller::UberSDFParameters::MakeRect(), params, impeller::Color::Red(), and impeller::StrokeParameters::width.

◆ TEST() [687/689]

impeller::testing::TEST	(	UniqueHandleGLES	,
		MakeUntracked
	)

Definition at line 26 of file unique_handle_gles_unittests.cc.

                                      {
  auto mock_gles_impl = std::make_unique<MockGLESImpl>();
 
  EXPECT_CALL(*mock_gles_impl, GenTextures(1, _)).Times(1);
 
  std::shared_ptr<MockGLES> mock_gled =
      MockGLES::Init(std::move(mock_gles_impl));
  ProcTableGLES::Resolver resolver = kMockResolverGLES;
  auto proc_table = std::make_unique<ProcTableGLES>(resolver);
  auto worker = std::make_shared<TestWorker>();
  auto reactor = std::make_shared<ReactorGLES>(std::move(proc_table));
  reactor->AddWorker(worker);
 
  UniqueHandleGLES handle =
      UniqueHandleGLES::MakeUntracked(reactor, HandleType::kTexture);
  EXPECT_FALSE(handle.Get().IsDead());
}

References impeller::UniqueHandleGLES::Get(), impeller::testing::MockGLES::Init(), impeller::HandleGLES::IsDead(), kMockResolverGLES, impeller::kTexture, impeller::UniqueHandleGLES::MakeUntracked(), and reactor.

◆ TEST() [688/689]

impeller::testing::TEST	(	WangsFormulaTest	,
		Cubic
	)

Definition at line 12 of file wangs_formula_unittests.cc.

                              {
  Point p0{300, 0};
  Point p1{0, 0};
  Point p2{0, 0};
  Point p3{0, 300};
  Scalar result = ComputeCubicSubdivisions(1.0, p0, p1, p2, p3);
  EXPECT_FLOAT_EQ(result, 30.f);
}

References impeller::ComputeCubicSubdivisions(), p1, and p2.

◆ TEST() [689/689]

impeller::testing::TEST	(	WangsFormulaTest	,
		Quadratic
	)

Definition at line 21 of file wangs_formula_unittests.cc.

                                  {
  Point p0{15, 0};
  Point p1{0, 0};
  Point p2{0, 20};
  Scalar result = ComputeQuadradicSubdivisions(1.0, p0, p1, p2);
  EXPECT_FLOAT_EQ(result, 5.f);
}

References impeller::ComputeQuadradicSubdivisions(), p1, and p2.

◆ TEST_F() [1/10]

impeller::testing::TEST_F	(	GoldenTests	,
		ConicalGradient
	)

Definition at line 79 of file golden_tests.cc.

                                     {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  paint.setDrawStyle(flutter::DlDrawStyle::kFill);
 
  flutter::DlColor colors[2] = {flutter::DlColor::RGBA(1, 0, 0, 1),
                                flutter::DlColor::RGBA(0, 0, 1, 1)};
  Scalar stops[2] = {0, 1};
 
  paint.setColorSource(flutter::DlColorSource::MakeConical(
      /*start_center=*/{125, 125},               //
      /*start_radius=*/125, {180, 180},          //
      /*end_radius=*/0,                          //
      /*stop_count=*/2,                          //
      /*colors=*/colors,                         //
      /*stops=*/stops,                           //
      /*tile_mode=*/flutter::DlTileMode::kClamp  //
      ));
 
  builder.DrawRect(DlRect::MakeXYWH(10, 10, 250, 250), paint);
 
  auto aiks_context =
      AiksContext(Screenshotter().GetPlayground().GetContext(), nullptr);
  auto screenshot = Screenshotter().MakeScreenshot(
      aiks_context,
      DisplayListToTexture(builder.Build(), {240, 240}, aiks_context));
  ASSERT_TRUE(SaveScreenshot(std::move(screenshot)));
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawRect(), flutter::kClamp, flutter::kFill, flutter::DlColorSource::MakeConical(), impeller::testing::Screenshotter::MakeScreenshot(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DlPaint::setColorSource(), and flutter::DlPaint::setDrawStyle().

◆ TEST_F() [2/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		CommandsWithoutViewportGetRenderPassViewport
	)

Definition at line 328 of file render_pass_gles_unittests.cc.

                                                     {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetViewport(
      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});
  EXPECT_TRUE(render_pass->Draw().ok());
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);
  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 100, 100)).Times(2);
  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 50, 50)).Times(1);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, impeller::TRect< Scalar >::MakeXYWH(), mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [3/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		EmulatedInstancedArrayDraw
	)

Definition at line 448 of file render_pass_gles_unittests.cc.

                                                              {
  auto ctx = CreateRenderPassGLESContext(kMockResolverGLESWithoutInstancing);
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(3);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetInstanceCount(4);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref,
              DrawArrays(/*mode=*/_, /*first=*/0, /*count=*/3))
      .Times(4);
  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References kMockResolverGLESWithoutInstancing, impeller::kNone, mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [4/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		EmulatedInstancedElementsDraw
	)

Definition at line 472 of file render_pass_gles_unittests.cc.

                                                                 {
  auto ctx = CreateRenderPassGLESContext(kMockResolverGLESWithoutInstancing);
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  DeviceBufferDescriptor index_desc;
  index_desc.size = 6 * sizeof(uint16_t);
  index_desc.storage_mode = StorageMode::kHostVisible;
  auto index_buffer = std::static_pointer_cast<Context>(ctx.context)
                          ->GetResourceAllocator()
                          ->CreateBuffer(index_desc);
  ASSERT_TRUE(index_buffer);
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(6);
  ASSERT_TRUE(render_pass->SetIndexBuffer(
      DeviceBuffer::AsBufferView(index_buffer), IndexType::k16bit));
  render_pass->SetInstanceCount(4);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref,
              DrawElements(/*mode=*/_, /*count=*/6, /*type=*/_, /*indices=*/_))
      .Times(4);
  EXPECT_CALL(mock_gl_impl_ref, DrawElementsInstanced(_, _, _, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::DeviceBuffer::AsBufferView(), impeller::k16bit, impeller::kHostVisible, kMockResolverGLESWithoutInstancing, mock_gl_impl_ref, pipeline, reactor, render_pass, impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ TEST_F() [5/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		HardwareInstancedArrayDraw
	)

Definition at line 388 of file render_pass_gles_unittests.cc.

                                                              {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(3);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetInstanceCount(4);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref,
              DrawArraysInstanced(/*mode=*/_, /*first=*/0, /*count=*/3,
                                  /*instancecount=*/4))
      .Times(1);
  EXPECT_CALL(mock_gl_impl_ref, DrawArrays(_, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [6/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		HardwareInstancedElementsDraw
	)

Definition at line 413 of file render_pass_gles_unittests.cc.

                                                                 {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  DeviceBufferDescriptor index_desc;
  index_desc.size = 6 * sizeof(uint16_t);
  index_desc.storage_mode = StorageMode::kHostVisible;
  auto index_buffer = std::static_pointer_cast<Context>(ctx.context)
                          ->GetResourceAllocator()
                          ->CreateBuffer(index_desc);
  ASSERT_TRUE(index_buffer);
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(6);
  ASSERT_TRUE(render_pass->SetIndexBuffer(
      DeviceBuffer::AsBufferView(index_buffer), IndexType::k16bit));
  render_pass->SetInstanceCount(4);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref,
              DrawElementsInstanced(/*mode=*/_, /*count=*/6, /*type=*/_,
                                    /*indices=*/_, /*instancecount=*/4))
      .Times(1);
  EXPECT_CALL(mock_gl_impl_ref, DrawElements(_, _, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::DeviceBuffer::AsBufferView(), impeller::k16bit, impeller::kHostVisible, mock_gl_impl_ref, pipeline, reactor, render_pass, impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ TEST_F() [7/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		NonInstancedDrawIssuesSingleDrawArrays
	)

Definition at line 505 of file render_pass_gles_unittests.cc.

                                                                          {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(3);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref,
              DrawArrays(/*mode=*/_, /*first=*/0, /*count=*/3))
      .Times(1);
  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [8/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		ViewportCachedAcrossCommands
	)

Definition at line 292 of file render_pass_gles_unittests.cc.

                                                                {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetViewport(
      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});
  EXPECT_TRUE(render_pass->Draw().ok());
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetViewport(
      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});
  EXPECT_TRUE(render_pass->Draw().ok());
 
  // Viewport should only be called twice. Once for the fallback, once for the
  // first override. We set a catch-all to 0 to ensure no other calls occur.
  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);
  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 100, 100)).Times(1);
  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 50, 50)).Times(1);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, impeller::TRect< Scalar >::MakeXYWH(), mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [9/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		ViewportWithNonZeroXOffsetReachesGL
	)

Definition at line 364 of file render_pass_gles_unittests.cc.

                                                                       {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(1);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetViewport(
      Viewport{Rect::MakeXYWH(25, 0, 50, 100), DepthRange{0.0f, 1.0f}});
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);
  EXPECT_CALL(mock_gl_impl_ref, Viewport(25, 0, 50, 100)).Times(1);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, impeller::TRect< Scalar >::MakeXYWH(), mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_F() [10/10]

impeller::testing::TEST_F	(	RenderPassGLESCommandTest	,
		ZeroInstanceCountIssuesNoDraw
	)

Definition at line 528 of file render_pass_gles_unittests.cc.

                                                                 {
  auto ctx = CreateRenderPassGLESContext();
  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;
  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;
  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;
  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;
 
  render_pass->SetPipeline(PipelineRef(pipeline));
  render_pass->SetElementCount(3);
  render_pass->SetIndexBuffer({}, IndexType::kNone);
  render_pass->SetInstanceCount(0);
  EXPECT_TRUE(render_pass->Draw().ok());
 
  EXPECT_CALL(mock_gl_impl_ref, DrawArrays(_, _, _)).Times(0);
  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);
 
  EXPECT_TRUE(render_pass->EncodeCommands());
  EXPECT_TRUE(reactor->React());
}

References impeller::kNone, mock_gl_impl_ref, pipeline, reactor, and render_pass.

◆ TEST_P() [1/662]

impeller::testing::TEST_P	(	AiksTest	,
		AdvancedBlendColorFilterWithDestinationOpacity
	)

Definition at line 917 of file aiks_dl_blend_unittests.cc.

                                                                 {
  DisplayListBuilder builder;
 
  builder.DrawPaint(DlPaint(DlColor::kWhite()));
 
  DlPaint save_paint;
  save_paint.setOpacity(0.3);
  save_paint.setColorFilter(DlColorFilter::MakeBlend(DlColor::kTransparent(),
                                                     DlBlendMode::kSaturation));
  builder.SaveLayer(std::nullopt, &save_paint);
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300),
                   DlPaint(DlColor::kMaroon()));
  builder.DrawRect(DlRect::MakeXYWH(200, 200, 300, 300),
                   DlPaint(DlColor::kBlue()));
  builder.Restore();
 
  // Should be solid red as the destructive color filter floods the clip.
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kMaroon(), flutter::DlColor::kTransparent(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setOpacity().

◆ TEST_P() [2/662]

impeller::testing::TEST_P	(	AiksTest	,
		ArcWithZeroSweepAndBlur
	)

Definition at line 727 of file aiks_dl_path_unittests.cc.

                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
 
  std::vector<DlColor> colors = {DlColor::RGBA(1.0, 0.0, 0.0, 1.0),
                                 DlColor::RGBA(0.0, 0.0, 0.0, 1.0)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(
      DlColorSource::MakeSweep({100, 100}, 45, 135, stops.size(), colors.data(),
                               stops.data(), DlTileMode::kMirror));
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
 
  DlPathBuilder path_builder;
  path_builder.AddArc(DlRect::MakeXYWH(10, 10, 100, 100),  //
                      DlDegrees(0), DlDegrees(0));
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Check that this empty picture can be created without crashing.
  builder.Build();
}

References flutter::DlPathBuilder::AddArc(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeSweep(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [3/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownBackdropId
	)

Definition at line 177 of file canvas_unittests.cc.

                                              {
  ContentContext& context = GetContentContext();
  if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
    GTEST_SKIP() << "Test requires device with framebuffer fetch";
  }
  auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                 /*requires_readback=*/true);
  // 3 backdrop filters all with same id.
  std::unordered_map<int64_t, BackdropData> data;
  data[1] = BackdropData{.backdrop_count = 3};
  canvas->SetBackdropData(data, 3);
 
  auto blur =
      flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
 
  EXPECT_TRUE(canvas->RequiresReadback());
  canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                   {.color = Color::Azure()});
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                    /*backdrop_id=*/1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                    /*backdrop_id=*/1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1, /*can_distribute_opacity=*/false,
                    /*backdrop_id=*/1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
}

References impeller::Color::Azure(), impeller::BackdropData::backdrop_count, context, CreateTestCanvas(), flutter::data, flutter::kClamp, impeller::kContainsContents, flutter::DlImageFilter::MakeBlur(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [4/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownBackdropIdMixed
	)

Definition at line 217 of file canvas_unittests.cc.

                                                   {
  ContentContext& context = GetContentContext();
  if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
    GTEST_SKIP() << "Test requires device with framebuffer fetch";
  }
  auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                 /*requires_readback=*/true);
  // 3 backdrop filters, 2 with same id.
  std::unordered_map<int64_t, BackdropData> data;
  data[1] = BackdropData{.backdrop_count = 2};
  canvas->SetBackdropData(data, 3);
 
  auto blur =
      flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
 
  EXPECT_TRUE(canvas->RequiresReadback());
  canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                   {.color = Color::Azure()});
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents, 1, false);
  canvas->Restore();
  EXPECT_TRUE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents, 1, false, 1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents, 1, false, 1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
}

References impeller::Color::Azure(), impeller::BackdropData::backdrop_count, context, CreateTestCanvas(), flutter::data, flutter::kClamp, impeller::kContainsContents, flutter::DlImageFilter::MakeBlur(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [5/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownNormal
	)

Definition at line 142 of file canvas_unittests.cc.

                                          {
  ContentContext& context = GetContentContext();
  if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
    GTEST_SKIP() << "Test requires device with framebuffer fetch";
  }
  auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                 /*requires_readback=*/true);
  // 3 backdrop filters
  canvas->SetBackdropData({}, 3);
 
  auto blur =
      flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
  flutter::DlRect rect = flutter::DlRect::MakeLTRB(0, 0, 50, 50);
 
  EXPECT_TRUE(canvas->RequiresReadback());
  canvas->DrawRect(rect, {.color = Color::Azure()});
  canvas->SaveLayer({}, rect, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1);
  canvas->Restore();
  EXPECT_TRUE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, rect, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1);
  canvas->Restore();
  EXPECT_TRUE(canvas->RequiresReadback());
 
  canvas->SaveLayer({}, rect, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1);
  canvas->Restore();
  EXPECT_FALSE(canvas->RequiresReadback());
}

References impeller::Color::Azure(), context, CreateTestCanvas(), flutter::kClamp, impeller::kContainsContents, flutter::DlImageFilter::MakeBlur(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [6/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropCountDownWithNestedSaveLayers
	)

Definition at line 254 of file canvas_unittests.cc.

                                                        {
  ContentContext& context = GetContentContext();
  if (!context.GetDeviceCapabilities().SupportsFramebufferFetch()) {
    GTEST_SKIP() << "Test requires device with framebuffer fetch";
  }
  auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                 /*requires_readback=*/true);
 
  canvas->SetBackdropData({}, 2);
 
  auto blur =
      flutter::DlImageFilter::MakeBlur(4, 4, flutter::DlTileMode::kClamp);
 
  EXPECT_TRUE(canvas->RequiresReadback());
  canvas->DrawRect(flutter::DlRect::MakeLTRB(0, 0, 50, 50),
                   {.color = Color::Azure()});
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/3);
 
  // This filter is nested in the first saveLayer. We cannot restore to onscreen
  // here.
  canvas->SaveLayer({}, std::nullopt, blur.get(),
                    ContentBoundsPromise::kContainsContents,
                    /*total_content_depth=*/1);
  canvas->Restore();
  EXPECT_TRUE(canvas->RequiresReadback());
 
  canvas->Restore();
  EXPECT_TRUE(canvas->RequiresReadback());
}

References impeller::Color::Azure(), context, CreateTestCanvas(), flutter::kClamp, impeller::kContainsContents, flutter::DlImageFilter::MakeBlur(), and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [7/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropFilterOverUnclosedClip
	)

Definition at line 2413 of file aiks_dl_basic_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  builder.Save();
  {
    builder.ClipRect(DlRect::MakeLTRB(100, 100, 800, 800));
 
    builder.Save();
    {
      builder.ClipRect(DlRect::MakeLTRB(600, 600, 800, 800));
      builder.DrawPaint(DlPaint().setColor(DlColor::kRed()));
      builder.DrawPaint(DlPaint().setColor(DlColor::kBlue().withAlphaF(0.5)));
      builder.ClipRect(DlRect::MakeLTRB(700, 700, 750, 800));
      builder.DrawPaint(DlPaint().setColor(DlColor::kRed().withAlphaF(0.5)));
    }
    builder.Restore();
 
    auto image_filter = DlImageFilter::MakeBlur(10, 10, DlTileMode::kDecal);
    builder.SaveLayer(std::nullopt, nullptr, image_filter.get());
  }
  builder.Restore();
  builder.DrawCircle(DlPoint(100, 100), 100,
                     DlPaint().setColor(DlColor::kAqua()));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kAqua(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), and flutter::DisplayListBuilder::SaveLayer().

◆ TEST_P() [8/662]

impeller::testing::TEST_P	(	AiksTest	,
		BackdropRestoreUsesCorrectCoverageForFirstRestoredClip
	)

Definition at line 906 of file aiks_dl_unittests.cc.

                                                                         {
  DisplayListBuilder builder;
 
  DlPaint paint;
  // Add a difference clip that cuts out the bottom right corner
  builder.ClipRect(DlRect::MakeLTRB(50, 50, 100, 100), DlClipOp::kDifference);
 
  // Draw a red rectangle that's going to be completely covered by green later.
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
 
  // Add a clip restricting the backdrop filter to the top right corner.
  auto count = builder.GetSaveCount();
  builder.Save();
  {
    builder.ClipRect(DlRect::MakeLTRB(0, 0, 100, 100));
    {
      // Create a save layer with a backdrop blur filter.
      auto backdrop_filter =
          DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal);
      builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
    }
  }
  builder.RestoreToCount(count);
 
  // Finally, overwrite all the previous stuff with green.
  paint.setColor(DlColor::kGreen());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::GetSaveCount(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::RestoreToCount(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [9/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModeCompatibilityWithSDFRendering
	)

Verifies blend mode compatibility with SDF rendering.

The compatibility condition is: mix(blend(src, dst), dst, 1 - sdf_alpha) == blend(src * sdf_alpha, dst)

Definition at line 498 of file canvas_unittests.cc.

                                                         {
  std::vector<Color> colors = {
      Color::BlackTransparent(),
      Color::Black(),
      Color::White(),
      Color::LimeGreen(),
      Color::CornflowerBlue(),
      Color::LimeGreen().WithAlpha(0.8),
      Color::CornflowerBlue().WithAlpha(0.7),
  };
 
  for (int i = 0; i <= static_cast<int>(BlendMode::kLastMode); i++) {
    BlendMode blend_mode = static_cast<BlendMode>(i);
    bool blend_mode_is_compatible = true;
 
    for (const auto& src : colors) {
      for (const auto& dst : colors) {
        for (Scalar sdf_alpha = 0.0; sdf_alpha < 1.01; sdf_alpha += 0.2) {
          // `mix(blend(src, dst), dst, 1 - sdf_alpha)`:
          // 1. Blend src onto dst.
          Color blended = dst.Blend(src, blend_mode);
          // 2. Mix with dst using sdf_alpha. Mix by lerping using
          // pre-multiplied colors.
          Color blended_then_sdf_alpha_applied =
              Color::Lerp(blended.Premultiply(), dst.Premultiply(),
                          1.0 - sdf_alpha)
                  .Unpremultiply();
 
          // `blend(src * sdf_alpha, dst)`:
          // 1. Apply sdf_alpha to src's alpha.
          Color sdf_alpha_applied = src.WithAlpha(src.alpha * sdf_alpha);
          // 2. Blend onto dst.
          Color sdf_alpha_applied_then_blended =
              dst.Blend(sdf_alpha_applied, blend_mode);
 
          // Compare results.
          if (blended_then_sdf_alpha_applied !=
              sdf_alpha_applied_then_blended) {
            blend_mode_is_compatible = false;
          }
        }
      }
    }
 
    Paint paint = {.blend_mode = blend_mode};
    EXPECT_EQ(blend_mode_is_compatible,
              Canvas::IsCompatibleWithSDFRendering(paint))
        << "Failure for BlendMode: " << BlendModeToString(blend_mode);
  }
}

References impeller::Color::Black(), impeller::Color::BlackTransparent(), impeller::Color::Blend(), impeller::Paint::blend_mode, impeller::BlendModeToString(), impeller::Color::CornflowerBlue(), i, impeller::Canvas::IsCompatibleWithSDFRendering(), impeller::kLastMode, impeller::Color::Lerp(), impeller::Color::LimeGreen(), impeller::Color::Premultiply(), impeller::Color::Unpremultiply(), impeller::Color::White(), and impeller::Color::WithAlpha().

◆ TEST_P() [10/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaColorFilterWideGamut
	)

Definition at line 435 of file aiks_dl_blend_unittests.cc.

                                                         {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with wide gamut support.
  if (!EnsureContextSupportsWideGamut()) {
    GTEST_SKIP() << "This backend doesn't yet support wide gamut.";
  }
 
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.2, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  DlPaint save_paint;
  save_paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::RGBA(1, 0, 0, 1), DlBlendMode::kPlus));
  builder.SaveLayer(std::nullopt, &save_paint);
 
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
 
  paint.setColor(DlColor::kWhite());
 
  auto rect = Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100);
  builder.DrawImageRect(
      DlImageImpeller::Make(texture),
      DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
      DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),  //
                       rect.GetRight(), rect.GetBottom()),
      DlImageSampling::kMipmapLinear, &paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), impeller::TRect< T >::Expand(), impeller::kB10G10R10A10XR, flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), texture, x, and y.

◆ TEST_P() [11/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModePlusAlphaWideGamut
	)

Definition at line 397 of file aiks_dl_blend_unittests.cc.

                                              {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with wide gamut support.
  if (!EnsureContextSupportsWideGamut()) {
    GTEST_SKIP() << "This backend doesn't yet support wide gamut.";
  }
 
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  paint.setColor(DlColor::RGBA(0.9, 1, 0.9, 1.0));
  builder.DrawPaint(paint);
  builder.SaveLayer(std::nullopt);
 
  paint.setBlendMode(DlBlendMode::kPlus);
  paint.setColor(DlColor::kRed());
 
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
  paint.setColor(DlColor::kWhite());
 
  auto rect = Rect::MakeXYWH(100, 100, 400, 400).Expand(-100, -100);
  builder.DrawImageRect(
      DlImageImpeller::Make(texture),
      DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
      DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),  //
                       rect.GetRight(), rect.GetBottom()),
      DlImageSampling::kMipmapLinear, &paint);
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), impeller::TRect< T >::Expand(), impeller::kB10G10R10A10XR, flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), texture, x, and y.

◆ TEST_P() [12/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlendModeShouldCoverWholeScreen
	)

Definition at line 82 of file aiks_dl_blend_unittests.cc.

                                                  {
  DisplayListBuilder builder;
  DlPaint paint;
 
  paint.setColor(DlColor::kRed());
  builder.DrawPaint(paint);
 
  paint.setBlendMode(DlBlendMode::kSrcOver);
  builder.SaveLayer(std::nullopt, &paint);
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 400, 400), paint);
 
  paint.setBlendMode(DlBlendMode::kSrc);
  builder.SaveLayer(std::nullopt, &paint);
 
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(200, 200, 200, 200), paint);
 
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [13/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlurGradientWithOpacity
	)

Definition at line 1440 of file aiks_dl_blur_unittests.cc.

                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  std::vector<DlColor> colors = {DlColor(0xFFFF0000), DlColor(0xFF00FF00)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  auto gradient = DlColorSource::MakeLinear(
      {0, 0}, {400, 400}, 2, colors.data(), stops.data(), DlTileMode::kClamp);
 
  DlPaint save_paint;
  save_paint.setOpacity(0.5);
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint paint;
  paint.setColorSource(gradient);
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
 
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DlPaint::setOpacity(), x, and y.

◆ TEST_P() [14/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlurHasNoEdge
	)

Definition at line 531 of file aiks_dl_blur_unittests.cc.

                                {
  Scalar sigma = 47.6;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Sigma", &sigma, 0, 50);
      ImGui::End();
    }
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.DrawPaint({});
 
    DlPaint paint;
    paint.setColor(DlColor::kGreen());
    paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
 
    builder.DrawRect(DlRect::MakeXYWH(300, 300, 200, 200), paint);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), x, and y.

◆ TEST_P() [15/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlurredCircleWithStrokeWidth
	)

Definition at line 994 of file aiks_dl_path_unittests.cc.

                                               {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(30);
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 5));
 
  builder.DrawCircle(DlPoint(200, 200), 100, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlBlurMaskFilter::Make(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setMaskFilter(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [16/662]

impeller::testing::TEST_P	(	AiksTest	,
		BlurredRectangleWithShader
	)

Definition at line 1293 of file aiks_dl_blur_unittests.cc.

                                             {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  auto paint_lines = [&builder](Scalar dx, Scalar dy, DlPaint paint) {
    auto draw_line = [&builder, &paint](DlPoint a, DlPoint b) {
      DlPath line = DlPath::MakeLine(a, b);
      builder.DrawPath(line, paint);
    };
    paint.setStrokeWidth(5);
    paint.setDrawStyle(DlDrawStyle::kStroke);
    draw_line(DlPoint(dx + 100, dy + 100), DlPoint(dx + 200, dy + 200));
    draw_line(DlPoint(dx + 100, dy + 200), DlPoint(dx + 200, dy + 100));
    draw_line(DlPoint(dx + 150, dy + 100), DlPoint(dx + 200, dy + 150));
    draw_line(DlPoint(dx + 100, dy + 150), DlPoint(dx + 150, dy + 200));
  };
 
  AiksContext renderer(GetContext(), nullptr);
  DisplayListBuilder recorder_builder;
  for (int x = 0; x < 5; ++x) {
    for (int y = 0; y < 5; ++y) {
      DlRect rect = DlRect::MakeXYWH(x * 20, y * 20, 20, 20);
      DlPaint paint;
      paint.setColor(((x + y) & 1) == 0 ? DlColor::kYellow()
                                        : DlColor::kBlue());
 
      recorder_builder.DrawRect(rect, paint);
    }
  }
  auto texture =
      DisplayListToTexture(recorder_builder.Build(), {100, 100}, renderer);
 
  auto image_source = DlColorSource::MakeImage(
      DlImageImpeller::Make(texture), DlTileMode::kRepeat, DlTileMode::kRepeat);
  auto blur_filter = DlImageFilter::MakeBlur(5, 5, DlTileMode::kDecal);
 
  DlPaint paint;
  paint.setColor(DlColor::kDarkGreen());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 300, 600), paint);
 
  paint.setColorSource(image_source);
  builder.DrawRect(DlRect::MakeLTRB(100, 100, 200, 200), paint);
 
  paint.setColorSource(nullptr);
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeLTRB(300, 0, 600, 600), paint);
 
  paint.setColorSource(image_source);
  paint.setImageFilter(blur_filter);
  builder.DrawRect(DlRect::MakeLTRB(400, 100, 500, 200), paint);
 
  paint.setImageFilter(nullptr);
  paint_lines(0, 300, paint);
 
  paint.setImageFilter(blur_filter);
  paint_lines(300, 300, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kDarkGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), flutter::DlColorSource::MakeImage(), flutter::DlPath::MakeLine(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setImageFilter(), texture, x, and y.

◆ TEST_P() [17/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanConvertTriangleFanToTriangles
	)

Definition at line 159 of file aiks_dl_vertices_unittests.cc.

                                                   {
  constexpr Scalar hexagon_radius = 125;
  auto hex_start = Point(200.0, -hexagon_radius + 200.0);
  auto center_to_flat = 1.73 / 2 * hexagon_radius;
 
  // clang-format off
  std::vector<DlPoint> vertices = {
    DlPoint(hex_start.x, hex_start.y),
    DlPoint(hex_start.x + center_to_flat, hex_start.y + 0.5 * hexagon_radius),
    DlPoint(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    DlPoint(hex_start.x + center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    DlPoint(hex_start.x, hex_start.y + 2 * hexagon_radius),
    DlPoint(hex_start.x, hex_start.y + 2 * hexagon_radius),
    DlPoint(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    DlPoint(hex_start.x - center_to_flat, hex_start.y + 1.5 * hexagon_radius),
    DlPoint(hex_start.x - center_to_flat, hex_start.y + 0.5 * hexagon_radius)
  };
  // clang-format on
  auto paint = flutter::DlPaint(flutter::DlColor::kDarkGrey());
  auto dl_vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleFan, vertices.size(), vertices.data(),
      nullptr, nullptr);
  flutter::DisplayListBuilder builder;
  builder.DrawVertices(dl_vertices, flutter::DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kDarkGrey(), flutter::kTriangleFan, and flutter::DlVertices::Make().

◆ TEST_P() [18/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPath
	)

Definition at line 475 of file aiks_dl_path_unittests.cc.

                                    {
  DisplayListBuilder builder;
 
  // Starting at (50, 50), draw lines from:
  // 1. (50, height)
  // 2. (width, height)
  // 3. (width, 50)
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(50, 100));
  path_builder.LineTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(100, 50));
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(10);
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [19/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawAnOpenPathThatIsntARect
	)

Definition at line 498 of file aiks_dl_path_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  // Draw a stroked path that is explicitly closed to verify
  // It doesn't become a rectangle.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(520, 120));
  path_builder.LineTo(DlPoint(300, 310));
  path_builder.LineTo(DlPoint(100, 50));
  path_builder.Close();
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(10);
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [20/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawMultiContourConvexPath
	)

Definition at line 699 of file aiks_dl_path_unittests.cc.

                                                {
  DlPathBuilder path_builder;
  for (auto i = 0; i < 10; i++) {
    if (i % 2 == 0) {
      // We use the factory method to convert the circle to a path so that it
      // uses the legacy conics for legacy golden output.
      DlPath circle =
          DlPath::MakeCircle(DlPoint(100 + 50 * i, 100 + 50 * i), 100);
      path_builder.AddPath(circle);
      path_builder.Close();
    } else {
      path_builder.MoveTo(DlPoint(100.f + 50.f * i - 100, 100.f + 50.f * i));
      path_builder.LineTo(DlPoint(100.f + 50.f * i, 100.f + 50.f * i - 100));
      path_builder.LineTo(DlPoint(100.f + 50.f * i - 100,  //
                                  100.f + 50.f * i - 100));
      path_builder.Close();
    }
  }
  DlPath path = path_builder.TakePath();
 
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed().withAlpha(102));
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlPathBuilder::AddPath(), flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), i, flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlPath::MakeCircle(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPaint::setColor(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [21/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawNonuniformScaleConvexShadow
	)

Definition at line 1053 of file aiks_dl_shadow_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(-50, -50));
  path_builder.LineTo(DlPoint(50, -50));
  path_builder.LineTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(0, 75));
  path_builder.LineTo(DlPoint(-50, 50));
  path_builder.Close();
  DlPath pentagon_path = path_builder.TakePath();
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen().withAlphaF(0.25f));
 
  DlPaint shadow_paint;
  shadow_paint.setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10.0f));
 
  // The first row and column will be right at the edge of the screen
  // but they should not draw anything anyway.
  builder.Translate(50, 50);
 
  for (int y = 0; y <= 5; y++) {
    Scalar y_scale = y / 5.0f;
    builder.Save();
    for (int x = 0; x <= 10; x++) {
      Scalar x_scale = x / 10.0f;
      builder.Save();
      builder.Scale(x_scale, y_scale);
      builder.DrawPath(pentagon_path, shadow_paint);
      builder.DrawPath(pentagon_path, paint);
      builder.Restore();
      builder.Translate(100 * x_scale + 20, 0);
    }
    builder.Restore();
    builder.Translate(0, 125 * y_scale + 50);
  }
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlPathBuilder::MoveTo(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [22/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaint
	)

Definition at line 515 of file aiks_dl_basic_unittests.cc.

                               {
  auto medium_turquoise =
      DlColor::RGBA(72.0f / 255.0f, 209.0f / 255.0f, 204.0f / 255.0f, 1.0f);
 
  DisplayListBuilder builder;
  builder.Scale(0.2, 0.2);
  builder.DrawPaint(DlPaint().setColor(medium_turquoise));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::RGBA(), and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [23/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimes
	)

Definition at line 525 of file aiks_dl_basic_unittests.cc.

                                            {
  auto medium_turquoise =
      DlColor::RGBA(72.0f / 255.0f, 209.0f / 255.0f, 204.0f / 255.0f, 1.0f);
  auto orange_red =
      DlColor::RGBA(255.0f / 255.0f, 69.0f / 255.0f, 0.0f / 255.0f, 1.0f);
 
  DisplayListBuilder builder;
  builder.Scale(0.2, 0.2);
  builder.DrawPaint(DlPaint().setColor(medium_turquoise));
  builder.DrawPaint(DlPaint().setColor(orange_red.modulateOpacity(0.5f)));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::RGBA(), and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [24/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintMultipleTimesInteractive
	)

Definition at line 692 of file aiks_dl_blend_unittests.cc.

                                                       {
  auto modes = GetBlendModeSelection();
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    static Color background = Color::MediumTurquoise();
    static Color foreground = Color::Color::OrangeRed().WithAlpha(0.5);
    static int current_blend_index = 3;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::ColorEdit4("Background", reinterpret_cast<float*>(&background));
      ImGui::ColorEdit4("Foreground", reinterpret_cast<float*>(&foreground));
      ImGui::ListBox("Blend mode", &current_blend_index,
                     modes.blend_mode_names.data(),
                     modes.blend_mode_names.size());
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(0.2, 0.2);
    DlPaint paint;
    paint.setColor(DlColor(background.ToARGB()));
    builder.DrawPaint(paint);
 
    paint.setColor(DlColor(foreground.ToARGB()));
    paint.setBlendMode(static_cast<DlBlendMode>(current_blend_index));
    builder.DrawPaint(paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), GetBlendModeSelection(), impeller::Color::MediumTurquoise(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), impeller::Color::ToARGB(), and impeller::Color::WithAlpha().

◆ TEST_P() [25/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPaintWithAdvancedBlend
	)

Definition at line 107 of file aiks_dl_blend_unittests.cc.

                                                {
  DisplayListBuilder builder;
 
  builder.Scale(0.2, 0.2);
  DlPaint paint;
  paint.setColor(DlColor::RGBA(
      Color::MediumTurquoise().red, Color::MediumTurquoise().green,
      Color::MediumTurquoise().blue, Color::MediumTurquoise().alpha));
  builder.DrawPaint(paint);
 
  paint.setColor(DlColor::RGBA(Color::OrangeRed().red, Color::OrangeRed().green,
                               Color::OrangeRed().blue, 0.5));
  paint.setBlendMode(DlBlendMode::kHue);
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), impeller::Color::MediumTurquoise(), impeller::Color::OrangeRed(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [26/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPerspectiveConvexShadow
	)

Definition at line 933 of file aiks_dl_shadow_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  // The rect path should be optimized to a rect-specific shadow shader.
  DlPath rect_path = DlPath::MakeRectLTRB(-50, -50, 50, 75);
 
  // The pentagon path should go through the general convex path shadow
  // tessellator.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(-50, -50));
  path_builder.LineTo(DlPoint(50, -50));
  path_builder.LineTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(0, 75));
  path_builder.LineTo(DlPoint(-50, 50));
  path_builder.Close();
  DlPath pentagon_path = path_builder.TakePath();
 
  Matrix simple_y_rotate_matrix = Matrix::MakeRotationY(Degrees(45));
 
  Matrix perspective_matrix;
  perspective_matrix.e[2][3] = 0.0015f;
  perspective_matrix = perspective_matrix * simple_y_rotate_matrix;
 
  auto draw_paths_and_shadows = [&builder](const DlPath& path,
                                           const DlColor& color,
                                           const Matrix& matrix) {
    builder.Save();
 
    DlPaint paint;
    paint.setColor(color.withAlphaF(0.25f));
 
    DlPaint shadow_paint;
    shadow_paint.setMaskFilter(
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10.0f));
 
    builder.Save();
    builder.Transform(matrix);
    builder.DrawPath(path, paint);
    builder.Restore();
 
    builder.Translate(150, 0);
 
    builder.Save();
    builder.Transform(matrix);
    builder.DrawPath(path, shadow_paint);
    builder.Restore();
 
    builder.Translate(150, 0);
 
    builder.Save();
    builder.Transform(matrix);
    builder.DrawPath(path, shadow_paint);
    builder.DrawPath(path, paint);
    builder.Restore();
 
    builder.Restore();
  };
 
  auto draw_test = [&](const DlPath& path) {
    builder.Save();
 
    builder.Translate(0, 75);
    builder.DrawPath(path, DlPaint(DlColor::kPurple()));
 
    builder.Translate(150, -75);
    draw_paths_and_shadows(path, DlColor::kGreen(), simple_y_rotate_matrix);
    builder.Translate(0, 175);
    draw_paths_and_shadows(path, DlColor::kBlue(), perspective_matrix);
 
    builder.Restore();
  };
 
  builder.Translate(100, 100);
 
  draw_test(rect_path);
  builder.Translate(0, 350);
  draw_test(pentagon_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), impeller::Matrix::e, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kPurple(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlPath::MakeRectLTRB(), impeller::Matrix::MakeRotationY(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), flutter::DisplayListBuilder::Transform(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [27/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPerspectiveTransformWithClips
	)

Definition at line 1620 of file aiks_dl_basic_unittests.cc.

                                                       {
  // Avoiding `GetSecondsElapsed()` to reduce risk of golden flakiness.
  int time = 0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
 
    builder.Save();
    {
      builder.Translate(300, 300);
 
      // 1. Draw/restore a clip before drawing the image, which will get drawn
      //    to the depth buffer behind the image.
      builder.Save();
      {
        DlPaint paint;
        paint.setColor(DlColor::kGreen());
        builder.DrawPaint(paint);
        builder.ClipRect(DlRect::MakeLTRB(-180, -180, 180, 180),
                         DlClipOp::kDifference);
 
        paint.setColor(DlColor::kBlack());
        builder.DrawPaint(paint);
      }
      builder.Restore();  // Restore rectangle difference clip.
 
      builder.Save();
      {
        // 2. Draw an oval clip that applies to the image, which will get drawn
        //    in front of the image on the depth buffer.
        builder.ClipOval(DlRect::MakeLTRB(-200, -200, 200, 200));
 
        Matrix result =
            Matrix(1.0, 0.0, 0.0, 0.0,    //
                   0.0, 1.0, 0.0, 0.0,    //
                   0.0, 0.0, 1.0, 0.003,  //
                   0.0, 0.0, 0.0, 1.0) *
            Matrix::MakeRotationY({Radians{-1.0f + (time++ / 60.0f)}});
 
        // 3. Draw the rotating image with a perspective transform.
        builder.Transform(result);
 
        auto image =
            DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
        auto position =
            -DlPoint(image->GetSize().width, image->GetSize().height) * 0.5;
        builder.DrawImage(image, position, {});
      }
      builder.Restore();  // Restore oval intersect clip.
 
      // 4. Draw a semi-translucent blue circle atop all previous draws.
      DlPaint paint;
      paint.setColor(DlColor::kBlue().modulateOpacity(0.4));
      builder.DrawCircle(DlPoint(), 230, paint);
    }
    builder.Restore();  // Restore translation.
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [28/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPoints
	)

Definition at line 405 of file aiks_dl_unittests.cc.

                                {
  std::vector<DlPoint> points = {
      {0, 0},      //
      {100, 100},  //
      {100, 0},    //
      {0, 100},    //
      {0, 0},      //
      {48, 48},    //
      {52, 52},    //
  };
  DlPaint paint_round;
  paint_round.setColor(DlColor::kYellow().withAlpha(128));
  paint_round.setStrokeCap(DlStrokeCap::kRound);
  paint_round.setStrokeWidth(20);
 
  DlPaint paint_square;
  paint_square.setColor(DlColor::kYellow().withAlpha(128));
  paint_square.setStrokeCap(DlStrokeCap::kSquare);
  paint_square.setStrokeWidth(20);
 
  DlPaint background;
  background.setColor(DlColor::kBlack());
 
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.DrawPaint(background);
  builder.Translate(200, 200);
 
  builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                     paint_round);
  builder.Translate(150, 0);
  builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                     paint_square);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlColor::kBlack(), flutter::DlColor::kYellow(), impeller::TRect< Scalar >::MakeSize(), points, flutter::DlPaint::setColor(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [29/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawPointsWithTextureMap
	)

Definition at line 441 of file aiks_dl_unittests.cc.

                                              {
  auto texture = DlImageImpeller::Make(
      CreateTextureForFixture("table_mountain_nx.png",
                              /*enable_mipmapping=*/true));
 
  std::vector<DlPoint> points = {
      {0, 0},      //
      {100, 100},  //
      {100, 0},    //
      {0, 100},    //
      {0, 0},      //
      {48, 48},    //
      {52, 52},    //
  };
 
  auto image_src =
      DlColorSource::MakeImage(texture, DlTileMode::kClamp, DlTileMode::kClamp);
 
  DlPaint paint_round;
  paint_round.setStrokeCap(DlStrokeCap::kRound);
  paint_round.setColorSource(image_src);
  paint_round.setStrokeWidth(200);
 
  DlPaint paint_square;
  paint_square.setStrokeCap(DlStrokeCap::kSquare);
  paint_square.setColorSource(image_src);
  paint_square.setStrokeWidth(200);
 
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.Translate(200, 200);
 
  builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                     paint_round);
  builder.Translate(150, 0);
  builder.DrawPoints(DlPointMode::kPoints, points.size(), points.data(),
                     paint_square);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPoints(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::TRect< Scalar >::MakeSize(), points, flutter::DlPaint::setColorSource(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [30/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawRotatedConvexShadow
	)

Definition at line 1017 of file aiks_dl_shadow_unittests.cc.

                                             {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(-50, -50));
  path_builder.LineTo(DlPoint(50, -50));
  path_builder.LineTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(0, 75));
  path_builder.LineTo(DlPoint(-50, 50));
  path_builder.Close();
  DlPath pentagon_path = path_builder.TakePath();
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen().withAlphaF(0.25f));
 
  DlPaint shadow_paint;
  shadow_paint.setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10.0f));
 
  builder.Translate(500, 380);
 
  for (int degrees = 0; degrees < 360; degrees += 30) {
    builder.Save();
    builder.Rotate(degrees);
    builder.Translate(0, -300);
    builder.DrawPath(pentagon_path, shadow_paint);
    builder.DrawPath(pentagon_path, paint);
    builder.Restore();
  }
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlPathBuilder::MoveTo(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [31/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawScaledPointsLargeScaleSmallRadius
	)

Definition at line 844 of file aiks_dl_unittests.cc.

                                                           {
  std::vector<DlPoint> point = {
      {0, 0},  //
  };
 
  DlPaint paint;
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(100 * 0.000001);
 
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.Translate(200, 200);
  builder.Scale(1000000, 1000000);
 
  builder.DrawPoints(DlPointMode::kPoints, point.size(), point.data(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [32/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanDrawScaledPointsSmallScaleLargeRadius
	)

Definition at line 824 of file aiks_dl_unittests.cc.

                                                           {
  std::vector<DlPoint> point = {
      {0, 0},  //
  };
 
  DlPaint paint;
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(100 * 1000000);
 
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.Translate(200, 200);
  builder.Scale(0.000001, 0.000001);
 
  builder.DrawPoints(DlPointMode::kPoints, point.size(), point.data(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [33/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanEmptyPictureConvertToImage
	)

Definition at line 965 of file aiks_dl_unittests.cc.

                                                {
  DisplayListBuilder recorder_builder;
 
  DisplayListBuilder builder;
  AiksContext renderer(GetContext(), nullptr);
 
  DlPaint paint;
  paint.setColor(DlColor::kTransparent());
  builder.DrawPaint(paint);
 
  auto result_image =
      DisplayListToTexture(builder.Build(), ISize{1000, 1000}, renderer);
  if (result_image) {
    recorder_builder.DrawImage(DlImageImpeller::Make(result_image), DlPoint(),
                               {});
 
    paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 0.2));
    recorder_builder.DrawRect(DlRect::MakeWH(1000, 1000), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(recorder_builder.Build()));
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kTransparent(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeWH(), flutter::DlColor::RGBA(), and flutter::DlPaint::setColor().

◆ TEST_P() [34/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformFullScreenMSAA
	)

Definition at line 1967 of file aiks_dl_basic_unittests.cc.

                                           {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawCircle(DlPoint(250, 250), 125, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kRed(), and flutter::DlPaint::setColor().

◆ TEST_P() [35/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBounds
	)

Definition at line 1988 of file aiks_dl_basic_unittests.cc.

                                                {
  DisplayListBuilder builder;
 
  DlPaint save;
  save.setColor(DlColor::kBlack());
 
  DlRect save_bounds = DlRect::MakeXYWH(0, 0, 50, 50);
  builder.SaveLayer(save_bounds, &save);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), paint);
  paint.setColor(DlColor::kGreen());
  builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100), paint);
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(20, 20, 100, 100), paint);
 
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [36/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSaveLayerWithBoundsAndLargerIntermediateIsNotAllocated
	)

Definition at line 1883 of file aiks_dl_basic_unittests.cc.

                                                                         {
  DisplayListBuilder builder;
 
  DlPaint red;
  red.setColor(DlColor::kRed());
 
  DlPaint green;
  green.setColor(DlColor::kGreen());
 
  DlPaint blue;
  blue.setColor(DlColor::kBlue());
 
  DlPaint save;
  save.setColor(DlColor::kBlack().modulateOpacity(0.5));
 
  DlRect huge_bounds = DlRect::MakeXYWH(0, 0, 100000, 100000);
  builder.SaveLayer(huge_bounds, &save);
 
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
  builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100), green);
  builder.DrawRect(DlRect::MakeXYWH(20, 20, 100, 100), blue);
 
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [37/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanPerformSkew
	)

Definition at line 1977 of file aiks_dl_basic_unittests.cc.

                                 {
  DisplayListBuilder builder;
 
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.Skew(2, 5);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Skew().

◆ TEST_P() [38/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanPictureConvertToImage
	)

Definition at line 938 of file aiks_dl_unittests.cc.

                                           {
  DisplayListBuilder recorder_canvas;
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0));
  recorder_canvas.DrawRect(DlRect::MakeXYWH(100.0, 100.0, 600, 600), paint);
  paint.setColor(DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0));
  recorder_canvas.DrawRect(DlRect::MakeXYWH(200.0, 200.0, 600, 600), paint);
 
  DisplayListBuilder canvas;
  AiksContext renderer(GetContext(), nullptr);
  paint.setColor(DlColor::kTransparent());
  canvas.DrawPaint(paint);
 
  auto image =
      DisplayListToTexture(recorder_canvas.Build(), {1000, 1000}, renderer);
  if (image) {
    canvas.DrawImage(DlImageImpeller::Make(image), DlPoint(), {});
    paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 0.2));
    canvas.DrawRect(DlRect::MakeWH(1000, 1000), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(canvas.Build()));
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), image, flutter::DlColor::kTransparent(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), and flutter::DlPaint::setColor().

◆ TEST_P() [39/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderAdvancedBlendColorFilterWithSaveLayer
	)

Definition at line 61 of file aiks_dl_blend_unittests.cc.

                                                                 {
  DisplayListBuilder builder;
 
  DlRect layer_rect = DlRect::MakeXYWH(0, 0, 500, 500);
  builder.ClipRect(layer_rect);
 
  DlPaint save_paint;
  save_paint.setColorFilter(DlColorFilter::MakeBlend(
      DlColor::RGBA(0, 1, 0, 0.5), DlBlendMode::kDifference));
  builder.SaveLayer(layer_rect, &save_paint);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlack());
  builder.DrawPaint(paint);
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [40/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderAsymmetricRoundSuperellipses
	)

Definition at line 2517 of file aiks_dl_basic_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadii(
          /*rect=*/DlRect::MakeXYWH(50, 50, 440, 440), /*radii=*/
          {
              .top_left = Size(60.0f, 240.0f),
              .top_right = Size(200.0f, 40.0f),
              .bottom_left = Size(180.0f, 20.0f),
              .bottom_right = Size(40.0f, 200.0f),
          }),
      paint);
 
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadii(
          /*rect=*/DlRect::MakeXYWH(550, 50, 440, 440), /*radii=*/
          {
              .top_left = Size(240.0f, 40.0f),
              .top_right = Size(40.0f, 240.0f),
              .bottom_left = Size(40.0f, 240.0f),
              .bottom_right = Size(240.0f, 40.0f),
          }),
      paint);
 
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadii(
          /*rect=*/DlRect::MakeXYWH(50, 550, 400, 400), /*radii=*/
          {
              .top_left = Size(240.0f, 240.0f),
              .top_right = Size(40.0f, 40.0f),
              .bottom_left = Size(40.0f, 40.0f),
              .bottom_right = Size(40.0f, 40.0f),
          }),
      paint);
 
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadii(
          /*rect=*/DlRect::MakeXYWH(550, 550, 400, 400), /*radii=*/
          {
              .top_left = Size(240.0f, 240.0f),
              .top_right = Size(40.0f, 40.0f),
              .bottom_left = Size(40.0f, 40.0f),
              .bottom_right = Size(240.0f, 240.0f),
          }),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [41/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlur
	)

Definition at line 242 of file aiks_dl_blur_unittests.cc.

                                        {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kCornflowerBlue());
  builder.DrawCircle(DlPoint(100, 100), 50, paint);
 
  paint.setColor(DlColor::kGreenYellow());
  builder.DrawCircle(DlPoint(300, 200), 100, paint);
 
  paint.setColor(DlColor::kDarkMagenta());
  builder.DrawCircle(DlPoint(140, 170), 75, paint);
 
  paint.setColor(DlColor::kOrangeRed());
  builder.DrawCircle(DlPoint(180, 120), 100, paint);
 
  DlRoundRect rrect =
      DlRoundRect::MakeRectXY(DlRect::MakeLTRB(75, 50, 375, 275), 20, 20);
  builder.ClipRoundRect(rrect);
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
  auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kCornflowerBlue(), flutter::DlColor::kDarkMagenta(), flutter::DlColor::kGreenYellow(), flutter::DlColor::kOrangeRed(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [42/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurHugeSigma
	)

Definition at line 352 of file aiks_dl_blur_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(400, 400), 300, paint);
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
 
  auto backdrop_filter =
      DlImageFilter::MakeBlur(999999, 999999, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [43/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurInteractive
	)

Definition at line 205 of file aiks_dl_blur_unittests.cc.

                                                   {
  auto callback = [&]() -> sk_sp<DisplayList> {
    static PlaygroundPoint point_a(Point(50, 50), 30, Color::White());
    static PlaygroundPoint point_b(Point(300, 200), 30, Color::White());
    auto [a, b] = DrawPlaygroundLine(point_a, point_b);
 
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::kCornflowerBlue());
    builder.DrawCircle(DlPoint(100, 100), 50, paint);
 
    paint.setColor(DlColor::kGreenYellow());
    builder.DrawCircle(DlPoint(300, 200), 100, paint);
 
    paint.setColor(DlColor::kDarkMagenta());
    builder.DrawCircle(DlPoint(140, 170), 75, paint);
 
    paint.setColor(DlColor::kOrangeRed());
    builder.DrawCircle(DlPoint(180, 120), 100, paint);
 
    DlRoundRect rrect =
        DlRoundRect::MakeRectXY(DlRect::MakeLTRB(a.x, a.y, b.x, b.y), 20, 20);
    builder.ClipRoundRect(rrect);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
 
    auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
    builder.Restore();
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawCircle(), impeller::DrawPlaygroundLine(), flutter::DlColor::kCornflowerBlue(), flutter::DlColor::kDarkMagenta(), flutter::DlColor::kGreenYellow(), flutter::DlColor::kOrangeRed(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and impeller::Color::White().

◆ TEST_P() [44/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBackdropBlurWithSingleBackdropId
	)

Definition at line 271 of file aiks_dl_blur_unittests.cc.

                                                            {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.DrawImage(image, DlPoint(50.0, 50.0),
                    DlImageSampling::kNearestNeighbor, &paint);
 
  DlRoundRect rrect =
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(50, 250, 100, 100), 20, 20);
  builder.Save();
  builder.ClipRoundRect(rrect);
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
  auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                    /*backdrop_id=*/1);
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawImage(), image, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setBlendMode().

◆ TEST_P() [45/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderBoundedBlur
	)

Definition at line 370 of file aiks_dl_blur_unittests.cc.

                                       {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.DrawImage(image, DlPoint(0.0, 0.0), DlImageSampling::kNearestNeighbor,
                    &paint);
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrcOver);
  builder.Save();
 
  // Subcase 1: The 1st branch of downsampling, where the coverage hint is
  // non-null but was ignored during snapshotting.
 
  builder.Scale(1.1, 1.2);
  builder.Rotate(10);
  DlRect rect1 = DlRect::MakeLTRB(70, 70, 313, 170);
  builder.ClipRect(rect1);
  auto backdrop_filter1 =
      DlBlurImageFilter::Make(20, 20, DlTileMode::kDecal, /*bounds=*/rect1);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter1.get());
  builder.Restore();
  builder.Restore();
 
  // Subcase 2: The 2nd branch of downsampling, where the coverage hint is null
  // or was already used during snapshotting.
 
  builder.Scale(1.1, 1.2);
  builder.Rotate(10);
  DlRect rect2 = DlRect::MakeLTRB(55, 190, 298, 290);
  builder.ClipRect(rect2);
  auto backdrop_filter2 =
      DlBlurImageFilter::Make(20, 20, DlTileMode::kDecal, /*bounds=*/rect2);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter2.get());
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlBlurImageFilter::Make(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setBlendMode().

◆ TEST_P() [46/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBackdropFilter
	)

Definition at line 1581 of file aiks_dl_basic_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  // Draw something interesting in the background.
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
  std::vector<Scalar> stops = {
      0.0,
      1.0,
  };
  DlPaint paint;
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/DlPoint(0, 0),     //
      /*end_point=*/DlPoint(100, 100),   //
      /*stop_count=*/2,                  //
      /*colors=*/colors.data(),          //
      /*stops=*/stops.data(),            //
      /*tile_mode=*/DlTileMode::kRepeat  //
      ));
 
  builder.DrawPaint(paint);
 
  DlRect clip_rect = DlRect::MakeLTRB(50, 50, 400, 300);
  DlRoundRect clip_rrect = DlRoundRect::MakeRectXY(clip_rect, 100, 100);
 
  // Draw a clipped SaveLayer, where the clip coverage and SaveLayer size are
  // the same.
  builder.ClipRoundRect(clip_rrect, DlClipOp::kIntersect);
 
  DlPaint save_paint;
  auto backdrop_filter = DlImageFilter::MakeColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kExclusion));
  builder.SaveLayer(clip_rect, &save_paint, backdrop_filter.get());
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), x, and y.

◆ TEST_P() [47/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedBlur
	)

Definition at line 412 of file aiks_dl_blur_unittests.cc.

                                       {
  DisplayListBuilder builder;
  builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
  builder.DrawCircle(DlPoint(400, 400), 200, paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [48/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedLayers
	)

Definition at line 2222 of file aiks_dl_basic_unittests.cc.

                                         {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  // Draw a green circle on the screen.
  {
    // Increase the clip depth for the savelayer to contend with.
    DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 50);
    builder.ClipPath(path);
 
    DlRect bounds = DlRect::MakeXYWH(50, 50, 100, 100);
    DlPaint save_paint;
    builder.SaveLayer(bounds, &save_paint);
 
    // Fill the layer with white.
    paint.setColor(DlColor::kWhite());
    builder.DrawRect(DlRect::MakeSize(DlSize(400, 400)), paint);
    // Fill the layer with green, but do so with a color blend that can't be
    // collapsed into the parent pass.
    paint.setColor(DlColor::kGreen());
    paint.setBlendMode(DlBlendMode::kHardLight);
    builder.DrawRect(DlRect::MakeSize(DlSize(400, 400)), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [49/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClippedRuntimeEffects
	)

Definition at line 54 of file aiks_dl_runtime_effect_unittests.cc.

                                                 {
  // This test used to be excluded on Vulkan for impeller_golden_tests
  // but has been running fine so far with the playground-based golden
  // mechanism, so we will let it run as the underlying problem may
  // have been fixed since the exclusion was added.
  // https://github.com/flutter/flutter/blame/ad80825c24d770a19e33f67800fc0338a3b89ec7/engine/src/flutter/impeller/golden_tests/golden_playground_test_mac.cc#L109
 
  struct FragUniforms {
    Vector2 iResolution;
    Scalar iTime;
  } frag_uniforms = {.iResolution = Vector2(400, 400), .iTime = 100.0};
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  DlPaint paint;
  auto effect =
      MakeRuntimeEffect(this, "runtime_stage_example.frag.iplr", uniform_data);
  ABSL_ASSERT_OK(effect);
  paint.setColorSource(effect.value());
 
  DisplayListBuilder builder;
  builder.Save();
  builder.ClipRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 400, 400), 10.0, 10.0),
      DlClipOp::kIntersect);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawRect(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [50/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderClips
	)

Definition at line 752 of file aiks_dl_path_unittests.cc.

                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kFuchsia());
 
  builder.ClipPath(DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 500, 500)));
  builder.DrawPath(DlPath::MakeCircle(DlPoint(500, 500), 250), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kFuchsia(), flutter::DlPath::MakeCircle(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [51/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColoredRect
	)

Definition at line 32 of file aiks_dl_basic_unittests.cc.

                                       {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawPath(DlPath::MakeRectXYWH(100.0f, 100.0f, 100.0f, 100.0f), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kBlue(), flutter::DlPath::MakeRectXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [52/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColoredRectPrimitive
	)

Definition at line 40 of file aiks_dl_basic_unittests.cc.

                                                {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100.f, 100.f, 100.f, 100.f), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [53/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColors
	)

Definition at line 141 of file aiks_dl_basic_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
  paint.setInvertColors(true);
 
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setInvertColors().

◆ TEST_P() [54/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderColorFilterWithInvertColorsDrawPaint
	)

Definition at line 153 of file aiks_dl_basic_unittests.cc.

                                                                {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
  paint.setInvertColors(true);
 
  builder.DrawPaint(paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlColorFilter::MakeBlend(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setInvertColors().

◆ TEST_P() [55/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradient
	)

Definition at line 675 of file aiks_dl_gradient_unittests.cc.

                                           {
  Scalar size = 256;
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, size * 3, size * 3), paint);
  std::vector<DlColor> colors = {
      DlColor(Color::MakeRGBA8(0xF4, 0x43, 0x36, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0xFF, 0xEB, 0x3B, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0x4c, 0xAF, 0x50, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0x21, 0x96, 0xF3, 0xFF).ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.f / 3.f, 2.f / 3.f, 1.0};
  std::array<std::tuple<DlPoint, float, DlPoint, float>, 8> array{
      std::make_tuple(DlPoint(size / 2.f, size / 2.f), 0.f,
                      DlPoint(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(DlPoint(size / 2.f, size / 2.f), size / 4.f,
                      DlPoint(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(DlPoint(size / 4.f, size / 4.f), 0.f,
                      DlPoint(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 2.f,
                      DlPoint(size / 2.f, size / 2.f), 0),
      std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 4.f,
                      DlPoint(size / 2.f, size / 2.f), size / 2.f),
      std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 16.f,
                      DlPoint(size / 2.f, size / 2.f), size / 8.f),
      std::make_tuple(DlPoint(size / 4.f, size / 4.f), size / 8.f,
                      DlPoint(size / 2.f, size / 2.f), size / 16.f),
      std::make_tuple(DlPoint(size / 8.f, size / 8.f), size / 8.f,
                      DlPoint(size / 2.f, size / 2.f), size / 8.f),
  };
  for (int i = 0; i < 8; i++) {
    builder.Save();
    builder.Translate((i % 3) * size, i / 3 * size);
    paint.setColorSource(DlColorSource::MakeConical(
        /*start_center=*/std::get<2>(array[i]),
        /*start_radius=*/std::get<3>(array[i]),
        /*end_center=*/std::get<0>(array[i]),
        /*end_radius=*/std::get<1>(array[i]),
        /*stop_count=*/stops.size(),
        /*colors=*/colors.data(),
        /*stops=*/stops.data(),
        /*tile_mode=*/DlTileMode::kClamp));
    builder.DrawRect(DlRect::MakeXYWH(0, 0, size, size), paint);
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColor::kWhite(), flutter::DlColorSource::MakeConical(), impeller::Color::MakeRGBA8(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::size, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [56/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradientWithDitheringEnabled
	)

Definition at line 194 of file aiks_dl_gradient_unittests.cc.

                                                               {
  CanRenderConicalGradientWithDithering(this);
}

References CanRenderConicalGradientWithDithering().

◆ TEST_P() [57/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderConicalGradientWithIncompleteStops
	)

Definition at line 336 of file aiks_dl_gradient_unittests.cc.

                                                              {
  CanRenderGradientWithIncompleteStops(this,
                                       DlColorSourceType::kConicalGradient);
}

◆ TEST_P() [58/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderCurvedStrokes
	)

Definition at line 71 of file aiks_dl_path_unittests.cc.

                                         {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(25);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  builder.DrawPath(DlPath::MakeCircle(DlPoint(500, 500), 250), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeCircle(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [59/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDestructiveSaveLayer
	)

Definition at line 383 of file aiks_dl_unittests.cc.

                                                {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawPaint(paint);
  // Draw an empty savelayer with a destructive blend mode, which will replace
  // the entire red screen with fully transparent black, except for the green
  // circle drawn within the layer.
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(300, 300), 100, draw_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [60/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferenceClips
	)

Definition at line 35 of file aiks_dl_clip_unittests.cc.

                                           {
  DisplayListBuilder builder;
  builder.Translate(400, 400);
 
  // Limit drawing to face circle with a clip.
  builder.ClipPath(DlPath::MakeCircle(DlPoint(0, 0), 200));
  builder.Save();
 
  // Cut away eyes/mouth using difference clips.
  builder.ClipPath(DlPath::MakeCircle(DlPoint(-100, -50), 30),
                   DlClipOp::kDifference);
  builder.ClipPath(DlPath::MakeCircle(DlPoint(100, -50), 30),
                   DlClipOp::kDifference);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(-100, 50));
  path_builder.QuadraticCurveTo(DlPoint(0, 150), DlPoint(100, 50));
  builder.ClipPath(path_builder.TakePath(), DlClipOp::kDifference);
 
  // Draw a huge yellow rectangle to prove the clipping works.
  DlPaint paint;
  paint.setColor(DlColor::kYellow());
  builder.DrawRect(DlRect::MakeCircleBounds({0, 0}, 1000), paint);
 
  // Remove the difference clips and draw hair that partially covers the eyes.
  builder.Restore();
  paint.setColor(DlColor::kMaroon());
  DlPathBuilder path_builder_2;
  path_builder_2.MoveTo(DlPoint(200, -200));
  path_builder_2.LineTo(DlPoint(-200, -200));
  path_builder_2.LineTo(DlPoint(-200, -40));
  path_builder_2.CubicCurveTo(DlPoint(0, -40), DlPoint(0, -80),
                              DlPoint(200, -80));
 
  builder.DrawPath(path_builder_2.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kMaroon(), flutter::DlColor::kYellow(), flutter::DlPathBuilder::LineTo(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeCircleBounds(), flutter::DlPathBuilder::MoveTo(), flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [61/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferencePaths
	)

Definition at line 442 of file aiks_dl_path_unittests.cc.

                                           {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
 
  RoundingRadii radii = {
      .top_left = {50, 25},
      .top_right = {25, 50},
      .bottom_left = {25, 50},
      .bottom_right = {50, 25},
  };
  DlPathBuilder path_builder;
  DlRoundRect rrect =
      DlRoundRect::MakeRectRadii(DlRect::MakeXYWH(100, 100, 200, 200), radii);
  // We use the factory method to convert the rrect and circle to a path so
  // that they use the legacy conics for legacy golden output.
  path_builder.AddPath(DlPath::MakeRoundRect(rrect));
  path_builder.AddPath(DlPath::MakeCircle(DlPoint(200, 200), 50));
  path_builder.SetFillType(DlPathFillType::kOdd);
  DlPath path = path_builder.TakePath();
 
  builder.DrawImage(
      DlImageImpeller::Make(CreateTextureForFixture("boston.jpg")),
      DlPoint{10, 10}, {});
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlPathBuilder::AddPath(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), impeller::DlImageImpeller::Make(), flutter::DlPath::MakeCircle(), impeller::RoundRect::MakeRectRadii(), flutter::DlPath::MakeRoundRect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPathBuilder::SetFillType(), flutter::DlPathBuilder::TakePath(), and impeller::RoundingRadii::top_left.

◆ TEST_P() [62/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderDifferentShapesWithSameColorSource
	)

Definition at line 427 of file aiks_dl_basic_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlPaint paint;
 
  DlColor colors[2] = {
      DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
      DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0),
  };
  DlScalar stops[2] = {
      0.0,
      1.0,
  };
 
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/DlPoint(0, 0),     //
      /*end_point=*/DlPoint(100, 100),   //
      /*stop_count=*/2,                  //
      /*colors=*/colors,                 //
      /*stops=*/stops,                   //
      /*tile_mode=*/DlTileMode::kRepeat  //
      ));
 
  builder.Save();
  builder.Translate(100, 100);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
  builder.Restore();
 
  builder.Save();
  builder.Translate(100, 400);
  builder.DrawCircle(DlPoint(100, 100), 100, paint);
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [63/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrame
	)

Definition at line 385 of file aiks_dl_text_unittests.cc.

                                          {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), kFontFixture, RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [64/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithAlpha
	)

Definition at line 413 of file aiks_dl_text_unittests.cc.

                                                   {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
      {.color = DlColor::kBlack().modulateOpacity(0.5)}));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlack(), kFontFixture, flutter::DlColor::modulateOpacity(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [65/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderEmojiTextFrameWithBlur
	)

Definition at line 397 of file aiks_dl_text_unittests.cc.

                                                  {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "😀 😃 😄 😁 😆 😅 😂 🤣 🥲 😊", kFontFixture,
      TextRenderOptions{
          .color = DlColor::kBlue(),
          .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), kFontFixture, flutter::DlBlurMaskFilter::Make(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [66/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderFilledConicPaths
	)

Definition at line 159 of file aiks_dl_path_unittests.cc.

                                            {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kFill);
 
  DlPaint reference_paint;
  reference_paint.setColor(DlColor::kGreen());
  reference_paint.setDrawStyle(DlDrawStyle::kFill);
 
  DlPathBuilder path_builder;
  DlPathBuilder reference_builder;
 
  // weight of 1.0 is just a quadratic bezier
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.ConicCurveTo(DlPoint(150, 150), DlPoint(200, 100), 1.0f);
  reference_builder.MoveTo(DlPoint(300, 100));
  reference_builder.QuadraticCurveTo(DlPoint(350, 150), DlPoint(400, 100));
 
  // weight of sqrt(2)/2 is a circular section
  path_builder.MoveTo(DlPoint(100, 200));
  path_builder.ConicCurveTo(DlPoint(150, 250), DlPoint(200, 200), kSqrt2Over2);
  reference_builder.MoveTo(DlPoint(300, 200));
  auto magic = DlPathBuilder::kArcApproximationMagic;
  reference_builder.CubicCurveTo(DlPoint(300, 200) + DlPoint(50, 50) * magic,
                                 DlPoint(400, 200) + DlPoint(-50, 50) * magic,
                                 DlPoint(400, 200));
 
  // weight of .01 is nearly a straight line
  path_builder.MoveTo(DlPoint(100, 300));
  path_builder.ConicCurveTo(DlPoint(150, 350), DlPoint(200, 300), 0.01f);
  reference_builder.MoveTo(DlPoint(300, 300));
  reference_builder.LineTo(DlPoint(350, 300.5));
  reference_builder.LineTo(DlPoint(400, 300));
 
  // weight of 100.0 is nearly a triangle
  path_builder.MoveTo(DlPoint(100, 400));
  path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 400), 100.0f);
  reference_builder.MoveTo(DlPoint(300, 400));
  reference_builder.LineTo(DlPoint(350, 450));
  reference_builder.LineTo(DlPoint(400, 400));
 
  builder.DrawPath(path_builder.TakePath(), paint);
  builder.DrawPath(reference_builder.TakePath(), reference_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::ConicCurveTo(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DisplayListBuilder::DrawPath(), flutter::DlPathBuilder::kArcApproximationMagic, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::kSqrt2Over2, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [67/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderFilledRoundSuperellipses
	)

Definition at line 2492 of file aiks_dl_basic_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  // Square
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(50, 50, 100, 100), /*radius=*/20),
      paint);
  // Tall
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(200, 50, 60, 140), /*radius=*/20),
      paint);
  // Wide
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(310, 50, 140, 60), /*radius=*/20),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [68/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundAdvancedBlendWithMaskBlur
	)

Definition at line 184 of file aiks_dl_blur_unittests.cc.

                                                               {
  // This case triggers the ForegroundAdvancedBlend path. The color filter
  // should apply to the color only, and respect the alpha mask.
  DisplayListBuilder builder;
  builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
 
  DlPaint paint;
  paint.setColor(
      DlColor::RGBA(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 1.0f));
 
  Sigma sigma = Radius(20);
  paint.setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kColor));
  builder.DrawCircle(DlPoint(400, 400), 200, paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setMaskFilter(), and impeller::Sigma::sigma.

◆ TEST_P() [69/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderForegroundBlendWithMaskBlur
	)

Definition at line 165 of file aiks_dl_blur_unittests.cc.

                                                       {
  // This case triggers the ForegroundPorterDuffBlend path. The color filter
  // should apply to the color only, and respect the alpha mask.
  DisplayListBuilder builder;
  builder.ClipRect(DlRect::MakeXYWH(100, 150, 400, 400));
 
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
 
  Sigma sigma = Radius(20);
  paint.setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kSrc));
  builder.DrawCircle(DlPoint(400, 400), 200, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setMaskFilter(), and impeller::Sigma::sigma.

◆ TEST_P() [70/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGradientDecalWithBackground
	)

Definition at line 723 of file aiks_dl_gradient_unittests.cc.

                                                       {
  std::vector<DlColor> colors = {
      DlColor(Color::MakeRGBA8(0xF4, 0x43, 0x36, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0xFF, 0xEB, 0x3B, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0x4c, 0xAF, 0x50, 0xFF).ToARGB()),
      DlColor(Color::MakeRGBA8(0x21, 0x96, 0xF3, 0xFF).ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.f / 3.f, 2.f / 3.f, 1.0};
 
  std::array<std::shared_ptr<DlColorSource>, 3> color_sources = {
      DlColorSource::MakeLinear({0, 0}, {100, 100}, stops.size(), colors.data(),
                                stops.data(), DlTileMode::kDecal),
      DlColorSource::MakeRadial({100, 100}, 100, stops.size(), colors.data(),
                                stops.data(), DlTileMode::kDecal),
      DlColorSource::MakeSweep({100, 100}, 45, 135, stops.size(), colors.data(),
                               stops.data(), DlTileMode::kDecal),
  };
 
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 605, 205), paint);
  for (int i = 0; i < 3; i++) {
    builder.Save();
    builder.Translate(i * 200.0f, 0);
    paint.setColorSource(color_sources[i]);
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 200, 200), paint);
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorSource::MakeRadial(), impeller::Color::MakeRGBA8(), flutter::DlColorSource::MakeSweep(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [71/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacity
	)

Definition at line 34 of file aiks_dl_opacity_unittests.cc.

                                        {
  DisplayListBuilder builder;
 
  DlPaint red;
  red.setColor(DlColor::kRed());
  DlPaint green;
  green.setColor(DlColor::kGreen().modulateOpacity(0.5));
  DlPaint blue;
  blue.setColor(DlColor::kBlue());
 
  DlPaint alpha;
  alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
 
  builder.SaveLayer(std::nullopt, &alpha);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), red);
  builder.DrawRect(DlRect::MakeXYWH(200, 200, 100, 100), green);
  builder.DrawRect(DlRect::MakeXYWH(400, 400, 100, 100), blue);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [72/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderGroupOpacityToSavelayer
	)

Definition at line 56 of file aiks_dl_opacity_unittests.cc.

                                                   {
  DisplayListBuilder builder;
 
  DlPaint red;
  red.setColor(DlColor::kRed());
 
  DlPaint alpha;
  alpha.setColor(DlColor::kRed().modulateOpacity(0.7));
 
  // Create a saveLayer that will forward its opacity to another
  // saveLayer, to verify that we correctly distribute opacity.
  DlRect bounds = DlRect::MakeLTRB(0, 0, 500, 500);
  builder.SaveLayer(bounds, &alpha);
  builder.SaveLayer(bounds, &alpha);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), red);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 450, 450), red);
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [73/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImage
	)

Definition at line 117 of file aiks_dl_basic_unittests.cc.

                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  builder.DrawImage(image, DlPoint(100.0, 100.0),
                    DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kRed(), impeller::DlImageImpeller::Make(), and flutter::DlPaint::setColor().

◆ TEST_P() [74/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderImageRect
	)

Definition at line 287 of file aiks_dl_basic_unittests.cc.

                                     {
  DisplayListBuilder builder;
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DlISize image_half_size =
      DlISize(image->GetSize().width * 0.5f, image->GetSize().height * 0.5f);
 
  // Render the bottom right quarter of the source image in a stretched rect.
  auto source_rect = DlRect::MakeSize(image_half_size);
  source_rect =
      source_rect.Shift(image_half_size.width, image_half_size.height);
 
  builder.DrawImageRect(image, source_rect,
                        DlRect::MakeXYWH(100, 100, 600, 600),
                        DlImageSampling::kNearestNeighbor);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), impeller::TSize< T >::height, image, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::TSize< T >::width.

◆ TEST_P() [75/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderInvertedImageWithColorFilter
	)

Definition at line 127 of file aiks_dl_basic_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kYellow(), DlBlendMode::kSrcOver));
  paint.setInvertColors(true);
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  builder.DrawImage(image, DlPoint(100.0, 100.0),
                    DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kRed(), flutter::DlColor::kYellow(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setInvertColors().

◆ TEST_P() [76/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderItalicizedText
	)

Definition at line 365 of file aiks_dl_text_unittests.cc.

                                          {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "HomemadeApple.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [77/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientClamp
	)

Definition at line 55 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderLinearGradient(this, DlTileMode::kClamp);
}

◆ TEST_P() [78/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecal
	)

Definition at line 64 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderLinearGradient(this, DlTileMode::kDecal);
}

◆ TEST_P() [79/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientDecalWithColorFilter
	)

Definition at line 68 of file aiks_dl_gradient_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  Point scale = GetContentScale();
  builder.Scale(scale.x, scale.y);
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {
      DlColor(Color{0.9568, 0.2627, 0.2118, 1.0}.ToARGB()),
      DlColor(Color{0.1294, 0.5882, 0.9529, 0.0}.ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear(
      {0, 0}, {200, 200}, 2, colors.data(), stops.data(), DlTileMode::kDecal));
  // Overlay the gradient with 25% green. This should appear as the entire
  // rectangle being drawn with 25% green, including the border area outside the
  // decal gradient.
  paint.setColorFilter(DlColorFilter::MakeBlend(DlColor::kGreen().withAlpha(64),
                                                DlBlendMode::kSrcOver));
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeBlend(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [80/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsClamp
	)

Definition at line 381 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderLinearGradientManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [81/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsDecal
	)

Definition at line 390 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderLinearGradientManyColors(this, DlTileMode::kDecal);
}

◆ TEST_P() [82/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsMirror
	)

Definition at line 387 of file aiks_dl_gradient_unittests.cc.

                                                          {
  CanRenderLinearGradientManyColors(this, DlTileMode::kMirror);
}

◆ TEST_P() [83/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsRepeat
	)

Definition at line 384 of file aiks_dl_gradient_unittests.cc.

                                                          {
  CanRenderLinearGradientManyColors(this, DlTileMode::kRepeat);
}

◆ TEST_P() [84/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientManyColorsUnevenStops
	)

Definition at line 425 of file aiks_dl_gradient_unittests.cc.

                                                               {
  auto callback = [&]() -> sk_sp<DisplayList> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
 
    static int selected_tile_mode = 0;
    static Matrix matrix;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      std::string label = "##1";
      for (int i = 0; i < 4; i++) {
        ImGui::InputScalarN(label.c_str(), ImGuiDataType_Float,
                            &(matrix.vec[i]), 4, NULL, NULL, "%.2f", 0);
        label[2]++;
      }
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    builder.Translate(100.0, 100.0);
    auto tile_mode = tile_modes[selected_tile_mode];
 
    std::vector<DlColor> colors = {
        DlColor(Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}.ToARGB())};
    std::vector<Scalar> stops = {
        0.0, 2.0 / 62.0, 4.0 / 62.0, 8.0 / 62.0, 16.0 / 62.0, 32.0 / 62.0, 1.0,
    };
 
    paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {200, 200},
                                                   stops.size(), colors.data(),
                                                   stops.data(), tile_mode));
 
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), and impeller::Matrix::vec.

◆ TEST_P() [85/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMaskBlur
	)

Definition at line 473 of file aiks_dl_gradient_unittests.cc.

                                                  {
  DisplayListBuilder builder;
 
  std::vector<DlColor> colors = {
      DlColor::kRed(), DlColor::kWhite(), DlColor::kRed(), DlColor::kWhite(),
      DlColor::kRed(), DlColor::kWhite(), DlColor::kRed(), DlColor::kWhite(),
      DlColor::kRed(), DlColor::kWhite(), DlColor::kRed()};
  std::vector<Scalar> stops = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5,
                               0.6, 0.7, 0.8, 0.9, 1.0};
 
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  paint.setColorSource(DlColorSource::MakeLinear(
      {200, 200}, {400, 400}, stops.size(), colors.data(), stops.data(),
      DlTileMode::kClamp));
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
 
  builder.DrawCircle(DlPoint(300, 300), 200, paint);
  builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [86/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientMirror
	)

Definition at line 61 of file aiks_dl_gradient_unittests.cc.

                                                {
  CanRenderLinearGradient(this, DlTileMode::kMirror);
}

◆ TEST_P() [87/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientRepeat
	)

Definition at line 58 of file aiks_dl_gradient_unittests.cc.

                                                {
  CanRenderLinearGradient(this, DlTileMode::kRepeat);
}

◆ TEST_P() [88/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWayManyColorsClamp
	)

Definition at line 421 of file aiks_dl_gradient_unittests.cc.

                                                            {
  CanRenderLinearGradientWayManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [89/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithDitheringEnabled
	)

Definition at line 128 of file aiks_dl_gradient_unittests.cc.

                                                              {
  CanRenderLinearGradientWithDithering(this);
}

References CanRenderLinearGradientWithDithering().

◆ TEST_P() [90/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithImageFilter
	)

Definition at line 92 of file aiks_dl_gradient_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  Point scale = GetContentScale();
  builder.Scale(scale.x, scale.y);
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {
      DlColor(Color{0.9568, 0.2627, 0.2118, 1.0}.ToARGB()),
      DlColor(Color{0.1294, 0.5882, 0.9529, 0.0}.ToARGB())};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear(
      {0, 0}, {200, 200}, 2, colors.data(), stops.data(), DlTileMode::kClamp));
  paint.setImageFilter(DlImageFilter::MakeBlur(20.0, 20.0, DlTileMode::kDecal));
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kWhite(), flutter::DlImageFilter::MakeBlur(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setImageFilter(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [91/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithIncompleteStops
	)

Definition at line 328 of file aiks_dl_gradient_unittests.cc.

                                                             {
  CanRenderGradientWithIncompleteStops(this,
                                       DlColorSourceType::kLinearGradient);
}

◆ TEST_P() [92/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinearGradientWithOverlappingStopsClamp
	)

Definition at line 223 of file aiks_dl_gradient_unittests.cc.

                                                                   {
  CanRenderLinearGradientWithOverlappingStops(this, DlTileMode::kClamp);
}

◆ TEST_P() [93/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderLinesWithCapsAnglesAndAlphas
	)

Definition at line 2777 of file aiks_dl_basic_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kBlack(), DlBlendMode::kSrc);
 
  const float line_length = 30.0f;
  const float stroke_width = 10.0f;
  const float spacing = 50.0f;
 
  const std::vector<flutter::DlStrokeCap> caps = {
      flutter::DlStrokeCap::kButt,
      flutter::DlStrokeCap::kSquare,
      flutter::DlStrokeCap::kRound,
  };
  const std::vector<float> alphas = {1.0f, 0.75f, 0.5f, 0.25f};
  const std::vector<Radians> angles = {
      Degrees(0.0f),  Degrees(3.0f),  Degrees(30.0f), Degrees(45.0f),
      Degrees(60.0f), Degrees(87.0f), Degrees(90.0f),
  };
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(stroke_width);
 
  for (const DlStrokeCap cap : caps) {
    builder.Translate(spacing, 0.0f);
    paint.setStrokeCap(cap);
 
    for (const float alpha : alphas) {
      builder.Translate(spacing, 0.0f);
      paint.setColor(DlColor::kWhite().withAlphaF(alpha));
 
      builder.Save();
      for (const Radians angle : angles) {
        builder.Translate(0.0f, spacing);
        builder.DrawLine(DlPoint(0.0f, 0.0f),
                         DlPoint(cos(angle.radians) * line_length,
                                 sin(angle.radians) * line_length),
                         paint);
      }
      builder.Restore();
    }
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawLine(), flutter::DlColor::kBlack(), flutter::kButt, flutter::kRound, flutter::kSquare, flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), flutter::DisplayListBuilder::Translate(), flutter::DlColor::withAlphaF(), x, and y.

◆ TEST_P() [94/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMaskBlurHugeSigma
	)

Definition at line 153 of file aiks_dl_blur_unittests.cc.

                                             {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 99999));
  builder.DrawCircle(DlPoint(400, 400), 300, paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlBlurMaskFilter::Make(), flutter::DisplayListBuilder::Restore(), flutter::DlPaint::setColor(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [95/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropId
	)

Definition at line 296 of file aiks_dl_blur_unittests.cc.

                                                                    {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.DrawImage(image, DlPoint(50.0, 50.0),
                    DlImageSampling::kNearestNeighbor, &paint);
 
  for (int i = 0; i < 6; i++) {
    DlRoundRect rrect = DlRoundRect::MakeRectXY(
        DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
    builder.Save();
    builder.ClipRoundRect(rrect);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                      /*backdrop_id=*/1);
    builder.Restore();
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawImage(), i, image, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setBlendMode().

◆ TEST_P() [96/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropIdAndDistinctFilters
	)

Definition at line 323 of file aiks_dl_blur_unittests.cc.

                                                                            {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.DrawImage(image, DlPoint(50.0, 50.0),
                    DlImageSampling::kNearestNeighbor, &paint);
 
  for (int i = 0; i < 6; i++) {
    DlRoundRect rrect = DlRoundRect::MakeRectXY(
        DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
    builder.Save();
    builder.ClipRoundRect(rrect);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    auto backdrop_filter =
        DlImageFilter::MakeBlur(30 + i, 30, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                      /*backdrop_id=*/1);
    builder.Restore();
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawImage(), i, image, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setBlendMode().

◆ TEST_P() [97/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderMultipleBackdropBlurWithSingleBackdropIdDifferentLayers
	)

Definition at line 1404 of file aiks_dl_blur_unittests.cc.

                                                                         {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.DrawImage(image, DlPoint(50.0, 50.0),
                    DlImageSampling::kNearestNeighbor, &paint);
 
  for (int i = 0; i < 6; i++) {
    if (i != 0) {
      DlPaint paint;
      paint.setColor(DlColor::kWhite().withAlphaF(0.95));
      builder.SaveLayer(std::nullopt, &paint);
    }
    DlRoundRect rrect = DlRoundRect::MakeRectXY(
        DlRect::MakeXYWH(50 + (i * 100), 250, 100, 100), 20, 20);
    builder.Save();
    builder.ClipRoundRect(rrect);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    auto backdrop_filter = DlImageFilter::MakeBlur(30, 30, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get(),
                      /*backdrop_id=*/1);
    builder.Restore();
    builder.Restore();
    if (i != 0) {
      builder.Restore();
    }
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawImage(), i, image, flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [98/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderNestedBackdropBlur
	)

Definition at line 1468 of file aiks_dl_blur_unittests.cc.

                                              {
  int64_t count = 0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
 
    Scalar freq = 1.0;
    Scalar amp = 50.0;
    Scalar offset = amp * sin(freq * 2.0 * M_PI * count / 60.0);
 
    // Draw some background content to be blurred.
    DlPaint paint;
    paint.setColor(DlColor::kCornflowerBlue());
    builder.DrawCircle(DlPoint(100 + offset, 100), 50, paint);
    paint.setColor(DlColor::kGreenYellow());
    builder.DrawCircle(DlPoint(300, 200 + offset), 100, paint);
    paint.setColor(DlColor::kDarkMagenta());
    builder.DrawCircle(DlPoint(140, 170), 75, paint);
    paint.setColor(DlColor::kOrangeRed());
    builder.DrawCircle(DlPoint(180 + offset, 120 + offset), 100, paint);
 
    // This is the first backdrop blur, simulating the navigation transition.
    auto backdrop_filter1 = DlImageFilter::MakeBlur(15, 15, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, nullptr, backdrop_filter1.get());
 
    // Draw the semi-transparent container from the second screen.
    DlPaint transparent_paint;
    transparent_paint.setColor(DlColor::kWhite().withAlpha(0.1 * 255));
    builder.DrawPaint(transparent_paint);
 
    {
      // This is the second, nested backdrop blur.
      auto backdrop_filter2 =
          DlImageFilter::MakeBlur(10, 10, DlTileMode::kClamp);
      builder.Save();
      builder.ClipRect(DlRect::MakeXYWH(150, 150, 300, 300));
      builder.SaveLayer(std::nullopt, nullptr, backdrop_filter2.get());
      builder.Restore();  // Restore from SaveLayer
      builder.Restore();  // Restore from ClipRect
    }
 
    builder.Restore();  // Restore from the first SaveLayer
 
    count++;
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kCornflowerBlue(), flutter::DlColor::kDarkMagenta(), flutter::DlColor::kGreenYellow(), flutter::DlColor::kOrangeRed(), flutter::DlColor::kWhite(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [99/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderNestedClips
	)

Definition at line 20 of file aiks_dl_clip_unittests.cc.

                                       {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kFuchsia());
 
  builder.Save();
  builder.ClipPath(DlPath::MakeCircle(DlPoint(200, 400), 300));
  builder.Restore();
  builder.ClipPath(DlPath::MakeCircle(DlPoint(600, 400), 300));
  builder.ClipPath(DlPath::MakeCircle(DlPoint(400, 600), 300));
  builder.DrawRect(DlRect::MakeXYWH(200, 200, 400, 400), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kFuchsia(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), and flutter::DlPaint::setColor().

◆ TEST_P() [100/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderOverlappingMultiContourPath
	)

Definition at line 802 of file aiks_dl_path_unittests.cc.

                                                       {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
 
  RoundingRadii radii = {
      .top_left = DlSize(50, 50),
      .top_right = DlSize(50, 50),
      .bottom_left = DlSize(50, 50),
      .bottom_right = DlSize(50, 50),
  };
 
  const Scalar kTriangleHeight = 100;
  DlRoundRect rrect = DlRoundRect::MakeRectRadii(
      DlRect::MakeCircleBounds({0, 0}, kTriangleHeight * 0.5f), radii);
  // We use the factory method to convert the rrect to a path so that it
  // uses the legacy conics for legacy golden output.
  DlPath rrect_path = DlPath::MakeRoundRect(rrect);
 
  builder.Translate(200, 200);
  // Form a path similar to the Material drop slider value indicator. Both
  // shapes should render identically side-by-side.
  {
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(0, kTriangleHeight));
    path_builder.LineTo(DlPoint(-kTriangleHeight / 2.0f, 0));
    path_builder.LineTo(DlPoint(kTriangleHeight / 2.0f, 0));
    path_builder.Close();
    path_builder.AddPath(rrect_path);
 
    builder.DrawPath(path_builder.TakePath(), paint);
  }
  builder.Translate(100, 0);
 
  {
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(0, kTriangleHeight));
    path_builder.LineTo(DlPoint(-kTriangleHeight / 2.0f, 0));
    path_builder.LineTo(DlPoint(0, -10));
    path_builder.LineTo(DlPoint(kTriangleHeight / 2.0f, 0));
    path_builder.Close();
    path_builder.AddPath(rrect_path);
 
    builder.DrawPath(path_builder.TakePath(), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlPathBuilder::AddPath(), flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), impeller::TRect< Scalar >::MakeCircleBounds(), impeller::RoundRect::MakeRectRadii(), flutter::DlPath::MakeRoundRect(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPathBuilder::TakePath(), impeller::RoundingRadii::top_left, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [101/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderQuadraticStrokeWithInstantTurn
	)

Definition at line 139 of file aiks_dl_path_unittests.cc.

                                                          {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(50);
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeCap(DlStrokeCap::kRound);
 
  // Should draw a diagonal pill shape. If flat on either end, the stroke is
  // rendering wrong.
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(250, 250));
  path_builder.QuadraticCurveTo(DlPoint(100, 100), DlPoint(250, 250));
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::MoveTo(), flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [102/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradient
	)

Definition at line 496 of file aiks_dl_gradient_unittests.cc.

                                          {
  auto callback = [&]() -> sk_sp<DisplayList> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
 
    static int selected_tile_mode = 0;
    static Matrix matrix;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      std::string label = "##1";
      for (int i = 0; i < 4; i++) {
        ImGui::InputScalarN(label.c_str(), ImGuiDataType_Float,
                            &(matrix.vec[i]), 4, NULL, NULL, "%.2f", 0);
        label[2]++;
      }
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    builder.Translate(100.0, 100.0);
    auto tile_mode = tile_modes[selected_tile_mode];
 
    std::vector<DlColor> colors = {
        DlColor(Color{0.9568, 0.2627, 0.2118, 1.0}.ToARGB()),
        DlColor(Color{0.1294, 0.5882, 0.9529, 1.0}.ToARGB())};
    std::vector<Scalar> stops = {0.0, 1.0};
 
    paint.setColorSource(DlColorSource::MakeRadial(
        {100, 100}, 100, 2, colors.data(), stops.data(), tile_mode));
 
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColorSource::MakeRadial(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), and impeller::Matrix::vec.

◆ TEST_P() [103/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientManyColors
	)

Definition at line 536 of file aiks_dl_gradient_unittests.cc.

                                                    {
  auto callback = [&]() -> sk_sp<DisplayList> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
 
    static int selected_tile_mode = 0;
    static Matrix matrix = {
        1, 0, 0, 0,  //
        0, 1, 0, 0,  //
        0, 0, 1, 0,  //
        0, 0, 0, 1   //
    };
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      std::string label = "##1";
      for (int i = 0; i < 4; i++) {
        ImGui::InputScalarN(label.c_str(), ImGuiDataType_Float,
                            &(matrix.vec[i]), 4, NULL, NULL, "%.2f", 0);
        label[2]++;
      }
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    builder.Translate(100.0, 100.0);
    auto tile_mode = tile_modes[selected_tile_mode];
 
    std::vector<DlColor> colors = {
        DlColor(Color{0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0}.ToARGB()),
        DlColor(Color{0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0}.ToARGB())};
    std::vector<Scalar> stops = {
        0.0,
        (1.0 / 6.0) * 1,
        (1.0 / 6.0) * 2,
        (1.0 / 6.0) * 3,
        (1.0 / 6.0) * 4,
        (1.0 / 6.0) * 5,
        1.0,
    };
 
    paint.setColorSource(DlColorSource::MakeRadial(
        {100, 100}, 100, stops.size(), colors.data(), stops.data(), tile_mode));
 
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColorSource::MakeRadial(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColorSource(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), and impeller::Matrix::vec.

◆ TEST_P() [104/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientWithDitheringEnabled
	)

Definition at line 148 of file aiks_dl_gradient_unittests.cc.

                                                              {
  CanRenderRadialGradientWithDithering(this);
}

References CanRenderRadialGradientWithDithering().

◆ TEST_P() [105/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRadialGradientWithIncompleteStops
	)

Definition at line 332 of file aiks_dl_gradient_unittests.cc.

                                                             {
  CanRenderGradientWithIncompleteStops(this,
                                       DlColorSourceType::kRadialGradient);
}

◆ TEST_P() [106/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRoundedRectWithNonUniformRadii
	)

Definition at line 461 of file aiks_dl_basic_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
 
  RoundingRadii radii = {
      .top_left = DlSize(50, 25),
      .top_right = DlSize(25, 50),
      .bottom_left = DlSize(25, 50),
      .bottom_right = DlSize(50, 25),
  };
  DlRoundRect rrect =
      DlRoundRect::MakeRectRadii(DlRect::MakeXYWH(100, 100, 500, 500), radii);
 
  builder.DrawRoundRect(rrect, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kRed(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), and impeller::RoundingRadii::top_left.

◆ TEST_P() [107/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRoundedRectWithUniformRadii
	)

Definition at line 480 of file aiks_dl_basic_unittests.cc.

                                                       {
  Scalar top_left = 20.f;
  Scalar top_right = 40.f;
  Scalar bottom_left = 60.f;
  Scalar bottom_right = 80.f;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("top_left", &top_left, 0, 250);
      ImGui::SliderFloat("top_right", &top_right, 0, 250);
      ImGui::SliderFloat("bottom_left", &bottom_left, 0, 250);
      ImGui::SliderFloat("bottom_right", &bottom_right, 0, 250);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::kRed());
 
    RoundingRadii radii = {
        .top_left = DlSize(top_left, top_left),
        .top_right = DlSize(top_right, top_right),
        .bottom_left = DlSize(bottom_left, bottom_left),
        .bottom_right = DlSize(bottom_right, bottom_right),
    };
    DlRoundRect rrect =
        DlRoundRect::MakeRectRadii(DlRect::MakeXYWH(100, 100, 500, 500), radii);
 
    builder.DrawRoundRect(rrect, paint);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kRed(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), and impeller::RoundingRadii::top_left.

◆ TEST_P() [108/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRoundSuperellipseGrid
	)

Definition at line 2649 of file aiks_dl_basic_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  DlScalar radii[] = {10.0f, 30.0f, 50.0f};
 
  for (int row = 0; row < 3; row++) {
    DlScalar y = 50.0f + row * 170.0f;
    DlScalar radius = radii[row];
 
    // Square
    builder.DrawRoundSuperellipse(
        DlRoundSuperellipse::MakeRectRadius(
            /*rect=*/DlRect::MakeXYWH(50, y, 100, 100), /*radius=*/radius),
        paint);
    // Tall
    builder.DrawRoundSuperellipse(
        DlRoundSuperellipse::MakeRectRadius(
            /*rect=*/DlRect::MakeXYWH(200, y, 60, 140), /*radius=*/radius),
        paint);
    // Wide
    builder.DrawRoundSuperellipse(
        DlRoundSuperellipse::MakeRectRadius(
            /*rect=*/DlRect::MakeXYWH(310, y, 140, 60), /*radius=*/radius),
        paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), and y.

◆ TEST_P() [109/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderRuntimeEffectFilter
	)

Definition at line 108 of file aiks_dl_runtime_effect_unittests.cc.

                                               {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_example.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
      nullptr,
  };
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(Vector2));
 
  DlPaint paint;
  paint.setColor(DlColor::kAqua());
  paint.setImageFilter(DlImageFilter::MakeRuntimeEffect(
      DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
      uniform_data));
 
  DisplayListBuilder builder;
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kAqua(), flutter::DlRuntimeEffectImpeller::Make(), flutter::DlImageFilter::MakeRuntimeEffect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [110/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSimpleClips
	)

Definition at line 325 of file aiks_dl_basic_unittests.cc.

                                       {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  auto draw = [&builder](const DlPaint& paint, Scalar x, Scalar y) {
    builder.Save();
    builder.Translate(x, y);
    {
      builder.Save();
      builder.ClipRect(DlRect::MakeLTRB(50, 50, 150, 150));
      builder.DrawPaint(paint);
      builder.Restore();
    }
    {
      builder.Save();
      builder.ClipOval(DlRect::MakeLTRB(200, 50, 300, 150));
      builder.DrawPaint(paint);
      builder.Restore();
    }
    {
      builder.Save();
      builder.ClipRoundRect(
          DlRoundRect::MakeRectXY(DlRect::MakeLTRB(50, 200, 150, 300), 20, 20));
      builder.DrawPaint(paint);
      builder.Restore();
    }
    {
      builder.Save();
      builder.ClipRoundRect(DlRoundRect::MakeRectXY(
          DlRect::MakeLTRB(200, 230, 300, 270), 20, 20));
      builder.DrawPaint(paint);
      builder.Restore();
    }
    {
      builder.Save();
      builder.ClipRoundRect(DlRoundRect::MakeRectXY(
          DlRect::MakeLTRB(230, 200, 270, 300), 20, 20));
      builder.DrawPaint(paint);
      builder.Restore();
    }
    builder.Restore();
  };
 
  paint.setColor(DlColor::kBlue());
  draw(paint, 0, 0);
 
  DlColor gradient_colors[7] = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
  };
  Scalar stops[7] = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
  auto image = DlImageImpeller::Make(texture);
 
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  draw(paint, 0, 300);
 
  paint.setColorSource(
      DlColorSource::MakeImage(image, DlTileMode::kRepeat, DlTileMode::kRepeat,
                               DlImageSampling::kNearestNeighbor));
  draw(paint, 300, 0);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [111/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSkewedCircleHairline
	)

Definition at line 209 of file aiks_dl_primitive_shape_unittests.cc.

                                                {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kBlack(), DlBlendMode::kSrc);
 
  RenderParameters params{
      .render_type = RenderType::kCircle,
      .center = GetWindowBounds().GetCenter(),
      .skew_x = 0.75f,
      .skew_y = 0.75f,
  };
  RenderPrimitiveWithStroke(builder, params);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlack(), params, flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [112/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSmallRadiusRoundSuperellipses
	)

Definition at line 2597 of file aiks_dl_basic_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  // Square
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(50, 50, 100, 100), /*radius=*/2),
      paint);
  // Tall
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(200, 50, 60, 140), /*radius=*/2),
      paint);
  // Wide
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(310, 50, 140, 60), /*radius=*/2),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [113/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedConicPaths
	)

Definition at line 209 of file aiks_dl_path_unittests.cc.

                                             {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(10);
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setStrokeJoin(DlStrokeJoin::kRound);
 
  DlPaint reference_paint;
  reference_paint.setColor(DlColor::kGreen());
  reference_paint.setStrokeWidth(10);
  reference_paint.setDrawStyle(DlDrawStyle::kStroke);
  reference_paint.setStrokeCap(DlStrokeCap::kRound);
  reference_paint.setStrokeJoin(DlStrokeJoin::kRound);
 
  DlPathBuilder path_builder;
  DlPathBuilder reference_builder;
 
  // weight of 1.0 is just a quadratic bezier
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.ConicCurveTo(DlPoint(150, 150), DlPoint(200, 100), 1.0f);
  reference_builder.MoveTo(DlPoint(300, 100));
  reference_builder.QuadraticCurveTo(DlPoint(350, 150), DlPoint(400, 100));
 
  // weight of sqrt(2)/2 is a circular section
  path_builder.MoveTo(DlPoint(100, 200));
  path_builder.ConicCurveTo(DlPoint(150, 250), DlPoint(200, 200), kSqrt2Over2);
  reference_builder.MoveTo(DlPoint(300, 200));
  auto magic = DlPathBuilder::kArcApproximationMagic;
  reference_builder.CubicCurveTo(DlPoint(300, 200) + DlPoint(50, 50) * magic,
                                 DlPoint(400, 200) + DlPoint(-50, 50) * magic,
                                 DlPoint(400, 200));
 
  // weight of .0 is a straight line
  path_builder.MoveTo(DlPoint(100, 300));
  path_builder.ConicCurveTo(DlPoint(150, 350), DlPoint(200, 300), 0.0f);
  reference_builder.MoveTo(DlPoint(300, 300));
  reference_builder.LineTo(DlPoint(400, 300));
 
  // weight of 100.0 is nearly a triangle
  path_builder.MoveTo(DlPoint(100, 400));
  path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 400), 100.0f);
  reference_builder.MoveTo(DlPoint(300, 400));
  reference_builder.LineTo(DlPoint(350, 450));
  reference_builder.LineTo(DlPoint(400, 400));
 
  builder.DrawPath(path_builder.TakePath(), paint);
  builder.DrawPath(reference_builder.TakePath(), reference_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::ConicCurveTo(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DisplayListBuilder::DrawPath(), flutter::DlPathBuilder::kArcApproximationMagic, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::kSqrt2Over2, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [114/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedRoundSuperellipses
	)

Definition at line 2570 of file aiks_dl_basic_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(5.0f);
 
  // Square
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(50, 50, 100, 100), /*radius=*/20),
      paint);
  // Tall
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(200, 50, 60, 140), /*radius=*/20),
      paint);
  // Wide
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(310, 50, 140, 60), /*radius=*/20),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [115/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokedTextFrame
	)

Definition at line 129 of file aiks_dl_text_unittests.cc.

                                            {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf",
      {
          .stroke = true,
      }));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [116/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathThatEndsAtSharpTurn
	)

Definition at line 107 of file aiks_dl_path_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(200);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  DlPath path = DlPath::MakeArc(DlRect::MakeXYWH(100, 100, 200, 200),  //
                                DlDegrees(0), DlDegrees(90), false);
 
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeArc(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [117/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokePathWithCubicLine
	)

Definition at line 122 of file aiks_dl_path_unittests.cc.

                                                   {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(20);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 200));
  path_builder.CubicCurveTo(DlPoint(50, 400), DlPoint(350, 0),
                            DlPoint(400, 200));
 
  builder.DrawPath(path_builder.TakePath(), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [118/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderStrokes
	)

Definition at line 58 of file aiks_dl_path_unittests.cc.

                                   {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(20);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  builder.DrawPath(DlPath::MakeLine(DlPoint(200, 100), DlPoint(800, 100)),
                   paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeLine(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [119/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientClamp
	)

Definition at line 615 of file aiks_dl_gradient_unittests.cc.

                                              {
  CanRenderSweepGradient(this, DlTileMode::kClamp);
}

◆ TEST_P() [120/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientDecal
	)

Definition at line 624 of file aiks_dl_gradient_unittests.cc.

                                              {
  CanRenderSweepGradient(this, DlTileMode::kDecal);
}

◆ TEST_P() [121/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsClamp
	)

Definition at line 662 of file aiks_dl_gradient_unittests.cc.

                                                        {
  CanRenderSweepGradientManyColors(this, DlTileMode::kClamp);
}

◆ TEST_P() [122/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsDecal
	)

Definition at line 671 of file aiks_dl_gradient_unittests.cc.

                                                        {
  CanRenderSweepGradientManyColors(this, DlTileMode::kDecal);
}

◆ TEST_P() [123/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsMirror
	)

Definition at line 668 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderSweepGradientManyColors(this, DlTileMode::kMirror);
}

◆ TEST_P() [124/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientManyColorsRepeat
	)

Definition at line 665 of file aiks_dl_gradient_unittests.cc.

                                                         {
  CanRenderSweepGradientManyColors(this, DlTileMode::kRepeat);
}

◆ TEST_P() [125/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientMirror
	)

Definition at line 621 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderSweepGradient(this, DlTileMode::kMirror);
}

◆ TEST_P() [126/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientRepeat
	)

Definition at line 618 of file aiks_dl_gradient_unittests.cc.

                                               {
  CanRenderSweepGradient(this, DlTileMode::kRepeat);
}

◆ TEST_P() [127/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientWithDitheringEnabled
	)

Definition at line 171 of file aiks_dl_gradient_unittests.cc.

                                                             {
  CanRenderSweepGradientWithDithering(this);
}

References CanRenderSweepGradientWithDithering().

◆ TEST_P() [128/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderSweepGradientWithIncompleteStops
	)

Definition at line 340 of file aiks_dl_gradient_unittests.cc.

                                                            {
  CanRenderGradientWithIncompleteStops(this, DlColorSourceType::kSweepGradient);
}

◆ TEST_P() [129/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrame
	)

Definition at line 100 of file aiks_dl_text_unittests.cc.

                                     {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [130/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithFractionScaling
	)

Definition at line 254 of file aiks_dl_text_unittests.cc.

                                                        {
  Scalar fine_scale = 0.f;
  bool is_subpixel = false;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Fine Scale", &fine_scale, -1, 1);
      ImGui::Checkbox("subpixel", &is_subpixel);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
    builder.DrawPaint(paint);
    Scalar scale = 2.625 + fine_scale;
    builder.Scale(scale, scale);
    RenderTextInCanvasSkia(GetContext(), builder,
                           "the quick brown fox jumped over the lazy dog!.?",
                           "Roboto-Regular.ttf",
                           TextRenderOptions{.is_subpixel = is_subpixel});
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::is_subpixel, is_subpixel, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setColor().

◆ TEST_P() [131/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithHalfScaling
	)

Definition at line 161 of file aiks_dl_text_unittests.cc.

                                                    {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
  builder.Scale(0.5, 0.5);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setColor().

◆ TEST_P() [132/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithInvertedTransform
	)

Definition at line 113 of file aiks_dl_text_unittests.cc.

                                                          {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
  builder.Translate(1000, 0);
  builder.Scale(-1, 1);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [133/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithScalingOverflow
	)

Definition at line 225 of file aiks_dl_text_unittests.cc.

                                                        {
  Scalar scale = 60.0;
  Scalar offsetx = -500.0;
  Scalar offsety = 700.0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("scale", &scale, 1.f, 300.f);
      ImGui::SliderFloat("offsetx", &offsetx, -600.f, 100.f);
      ImGui::SliderFloat("offsety", &offsety, 600.f, 2048.f);
      ImGui::End();
    }
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
    builder.DrawPaint(paint);
    builder.Scale(scale, scale);
 
    RenderTextInCanvasSkia(
        GetContext(), builder, "test", "Roboto-Regular.ttf",
        TextRenderOptions{
            .position = DlPoint(offsetx / scale, offsety / scale),
        });
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::position, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [134/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextFrameWithThinLightAndDarkColors
	)

Definition at line 781 of file aiks_dl_text_unittests.cc.

                                                               {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  auto mapping =
      flutter::testing::OpenFixtureAsSkData("RobotoSlab-VariableFont_wght.ttf");
  ASSERT_TRUE(mapping);
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
 
  // Set the variation axis for weight to 100 (typically "Thin").
  SkFontArguments::VariationPosition::Coordinate weight_coord{
      SkSetFourByteTag('w', 'g', 'h', 't'), 100.0f};
  SkFontArguments args;
  args.setVariationDesignPosition({&weight_coord, 1});
 
  SkFont thin_font(font_mgr->makeFromData(mapping)->makeClone(args), 25);
 
  // Render light text
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "RobotoSlab-VariableFont_wght.ttf",
      TextRenderOptions{.color = DlColor::kWhite(),
                        .position = DlPoint(100, 200)},
      thin_font));
 
  // Render dark text on a light background
  DlPaint dart_text_background_paint;
  dart_text_background_paint.setColor(DlColor::ARGB(1, 0.9, 0.9, 0.9));
  builder.DrawRect(DlRect::MakeXYWH(50, 250, 900, 100),
                   dart_text_background_paint);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "RobotoSlab-VariableFont_wght.ttf",
      TextRenderOptions{.color = DlColor::kDarkGreen(),
                        .position = DlPoint(100, 300)},
      thin_font));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), args, flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), txt::GetDefaultFontManager(), flutter::DlColor::kDarkGreen(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeXYWH(), flutter::testing::OpenFixtureAsSkData(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [135/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextInSaveLayer
	)

Definition at line 426 of file aiks_dl_text_unittests.cc.

                                           {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(0.1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  builder.Translate(100, 100);
  builder.Scale(0.5, 0.5);
 
  // Blend the layer with the parent pass using kClear to expose the coverage.
  paint.setBlendMode(DlBlendMode::kClear);
  builder.SaveLayer(std::nullopt, &paint);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
  builder.Restore();
 
  // Render the text again over the cleared coverage rect.
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [136/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextOutsideBoundaries
	)

Definition at line 452 of file aiks_dl_text_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.Translate(200, 150);
 
  // Construct the text blob.
  auto mapping = flutter::testing::OpenFixtureAsSkData("wtf.otf");
  ASSERT_NE(mapping, nullptr);
 
  Scalar font_size = 80;
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
 
  DlPaint text_paint;
  text_paint.setColor(DlColor::kBlue().withAlpha(255 * 0.8));
 
  struct {
    DlPoint position;
    const char* text;
  } text[] = {{DlPoint(0, 0), "0F0F0F0"},
              {DlPoint(1, 2), "789"},
              {DlPoint(1, 3), "456"},
              {DlPoint(1, 4), "123"},
              {DlPoint(0, 6), "0F0F0F0"}};
  for (auto& t : text) {
    builder.Save();
    builder.Translate(t.position.x * font_size * 2,
                      t.position.y * font_size * 1.1);
    {
      auto blob = SkTextBlob::MakeFromString(t.text, sk_font);
      ASSERT_NE(blob, nullptr);
      auto frame = MakeTextFrameFromTextBlobSkia(blob);
      builder.DrawText(DlTextImpeller::Make(frame), 0, 0, text_paint);
    }
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), font_size, txt::GetDefaultFontManager(), flutter::DlColor::kBlue(), flutter::DlTextImpeller::Make(), impeller::MakeTextFrameFromTextBlobSkia(), flutter::testing::OpenFixtureAsSkData(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), text, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [137/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextStrokeWidth
	)

Definition at line 145 of file aiks_dl_text_unittests.cc.

                                           {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "LMNOP VWXYZ",
                                     "Roboto-Medium.ttf",
                                     {
                                         .stroke = true,
                                         .stroke_width = 4,
                                     }));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), and flutter::DlPaint::setColor().

◆ TEST_P() [138/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextWithLargePerspectiveTransform
	)

Definition at line 559 of file aiks_dl_text_unittests.cc.

                                                             {
  // Verifies that text scales are clamped to work around
  // https://github.com/flutter/flutter/issues/136112 .
 
  DisplayListBuilder builder;
 
  DlPaint save_paint;
  builder.SaveLayer(std::nullopt, &save_paint);
  builder.Transform(Matrix(2000, 0, 0, 0,   //
                           0, 2000, 0, 0,   //
                           0, 0, -1, 9000,  //
                           0, 0, -1, 7000   //
                           ));
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                     "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DisplayListBuilder::Transform().

◆ TEST_P() [139/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTextWithPerspectiveTransformInSublist
	)

Definition at line 578 of file aiks_dl_text_unittests.cc.

                                                                 {
  DisplayListBuilder text_builder;
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), text_builder, "Hello world",
                                     "Roboto-Regular.ttf"));
  auto text_display_list = text_builder.Build();
 
  DisplayListBuilder builder;
 
  Matrix matrix = Matrix::MakeRow(2.0, 0.0, 0.0, 0.0,  //
                                  0.0, 2.0, 0.0, 0.0,  //
                                  0.0, 0.0, 1.0, 0.0,  //
                                  0.0, 0.002, 0.0, 1.0);
 
  DlPaint save_paint;
  DlRect window_bounds =
      DlRect::MakeXYWH(0, 0, GetWindowSize().width, GetWindowSize().height);
  builder.SaveLayer(window_bounds, &save_paint);
  builder.Transform(matrix);
  builder.DrawDisplayList(text_display_list, 1.0f);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawDisplayList(), height, impeller::Matrix::MakeRow(), impeller::TRect< Scalar >::MakeXYWH(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Transform(), and width.

◆ TEST_P() [140/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThickCurvedStrokes
	)

Definition at line 83 of file aiks_dl_path_unittests.cc.

                                              {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(100);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  builder.DrawPath(DlPath::MakeCircle(DlPoint(100, 100), 50), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeCircle(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [141/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThickStrokedRoundSuperellipses
	)

Definition at line 2622 of file aiks_dl_basic_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
  DlPaint paint;
  paint.setColor(DlColor::kBlue().withAlphaF(0.5));
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(40.0f);
 
  // Square
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(50, 50, 100, 100), /*radius=*/30),
      paint);
  // Tall
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(200, 50, 60, 140), /*radius=*/30),
      paint);
  // Wide
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(310, 50, 140, 60), /*radius=*/30),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundSuperellipse(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [142/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderThinCurvedStrokes
	)

Definition at line 95 of file aiks_dl_path_unittests.cc.

                                             {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setStrokeWidth(0.01);
  paint.setDrawStyle(DlDrawStyle::kStroke);
 
  builder.DrawPath(DlPath::MakeCircle(DlPoint(100, 100), 50), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeCircle(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [143/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTightConicPath
	)

Definition at line 393 of file aiks_dl_path_unittests.cc.

                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kFill);
 
  DlPaint reference_paint;
  reference_paint.setColor(DlColor::kGreen());
  reference_paint.setDrawStyle(DlDrawStyle::kFill);
 
  DlPathBuilder path_builder;
 
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.ConicCurveTo(DlPoint(150, 450), DlPoint(200, 100), 5.0f);
 
  DlPathBuilder reference_builder;
  PathTessellator::Conic component{DlPoint(300, 100),  //
                                   DlPoint(350, 450),  //
                                   DlPoint(400, 100),  //
                                   5.0f};
  reference_builder.MoveTo(component.p1);
  constexpr int N = 100;
  for (int i = 1; i < N; i++) {
    reference_builder.LineTo(component.Solve(static_cast<Scalar>(i) / N));
  }
  reference_builder.LineTo(component.p2);
 
  DlPaint line_paint;
  line_paint.setColor(DlColor::kYellow());
  line_paint.setDrawStyle(DlDrawStyle::kStroke);
  line_paint.setStrokeWidth(1.0f);
 
  // Draw some lines to provide a spacial reference for the curvature of
  // the tips of the direct rendering and the manually tessellated versions.
  builder.DrawLine(DlPoint(145, 100), DlPoint(145, 450), line_paint);
  builder.DrawLine(DlPoint(155, 100), DlPoint(155, 450), line_paint);
  builder.DrawLine(DlPoint(345, 100), DlPoint(345, 450), line_paint);
  builder.DrawLine(DlPoint(355, 100), DlPoint(355, 450), line_paint);
  builder.DrawLine(DlPoint(100, 392.5f), DlPoint(400, 392.5f), line_paint);
 
  // Draw the two paths (direct and manually tessellated) on top of the lines.
  builder.DrawPath(path_builder.TakePath(), paint);
  builder.DrawPath(reference_builder.TakePath(), reference_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::ConicCurveTo(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPath(), i, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [144/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClamp
	)

Definition at line 266 of file aiks_dl_basic_unittests.cc.

                                             {
  CanRenderTiledTexture(this, DlTileMode::kClamp);
}

◆ TEST_P() [145/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureClampWithTranslate
	)

Definition at line 282 of file aiks_dl_basic_unittests.cc.

                                                          {
  CanRenderTiledTexture(this, DlTileMode::kClamp,
                        Matrix::MakeTranslation({172.f, 172.f, 0.f}));
}

References impeller::Matrix::MakeTranslation().

◆ TEST_P() [146/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureDecal
	)

Definition at line 278 of file aiks_dl_basic_unittests.cc.

                                             {
  CanRenderTiledTexture(this, DlTileMode::kDecal);
}

◆ TEST_P() [147/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureMirror
	)

Definition at line 274 of file aiks_dl_basic_unittests.cc.

                                              {
  CanRenderTiledTexture(this, DlTileMode::kMirror);
}

◆ TEST_P() [148/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTiledTextureRepeat
	)

Definition at line 270 of file aiks_dl_basic_unittests.cc.

                                              {
  CanRenderTiledTexture(this, DlTileMode::kRepeat);
}

◆ TEST_P() [149/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTinyOverlappingSubpasses
	)

This is a regression check for https://github.com/flutter/engine/pull/41129 The entire screen is green if successful. If failing, no frames will render, or the entire screen will be transparent black.

Definition at line 358 of file aiks_dl_unittests.cc.

                                                    {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawPaint(paint);
 
  // Draw two overlapping subpixel circles.
  builder.SaveLayer(std::nullopt);
 
  DlPaint yellow_paint;
  yellow_paint.setColor(DlColor::kYellow());
  builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
  builder.Restore();
  builder.SaveLayer(std::nullopt);
  builder.DrawCircle(DlPoint(100, 100), 0.1, yellow_paint);
  builder.Restore();
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kGreen());
  builder.DrawPaint(draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [150/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderTransformedRoundSuperellipse
	)

Definition at line 2681 of file aiks_dl_basic_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  builder.Save();
  builder.Translate(200, 200);
  builder.Rotate(45.0f);
  builder.Scale(1.5f, 0.8f);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRoundSuperellipse(
      DlRoundSuperellipse::MakeRectRadius(
          /*rect=*/DlRect::MakeXYWH(-70, -30, 140, 60), /*radius=*/20),
      paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [151/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderWideStrokedRectPathWithoutOverlap
	)

Definition at line 108 of file aiks_dl_basic_unittests.cc.

                                                             {
  ASSERT_TRUE(OpenPlaygroundHere(MakeWideStrokedRects(
      GetContentScale(), [](DisplayListBuilder& builder, const DlRect& rect,
                            const DlPaint& paint) {
        // Draw the rect as a Path
        builder.DrawPath(DlPath::MakeRect(rect), paint);
      })));
}

References flutter::DisplayListBuilder::DrawPath(), and flutter::DlPath::MakeRect().

◆ TEST_P() [152/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderWideStrokedRectWithoutOverlap
	)

Definition at line 99 of file aiks_dl_basic_unittests.cc.

                                                         {
  ASSERT_TRUE(OpenPlaygroundHere(MakeWideStrokedRects(
      GetContentScale(), [](DisplayListBuilder& builder, const DlRect& rect,
                            const DlPaint& paint) {
        // Draw the rect directly
        builder.DrawRect(rect, paint);
      })));
}

References flutter::DisplayListBuilder::DrawRect().

◆ TEST_P() [153/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanRenderWithContiguousClipRestores
	)

Definition at line 74 of file aiks_dl_clip_unittests.cc.

                                                      {
  DisplayListBuilder builder;
 
  // Cover the whole canvas with red.
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawPaint(paint);
 
  builder.Save();
 
  // Append two clips, the second resulting in empty coverage.
  builder.ClipRect(DlRect::MakeXYWH(100, 100, 100, 100));
  builder.ClipRect(DlRect::MakeXYWH(300, 300, 100, 100));
 
  // Restore to no clips.
  builder.Restore();
 
  // Replace the whole canvas with green.
  paint.setColor(DlColor::kGreen());
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), and flutter::DlPaint::setColor().

◆ TEST_P() [154/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanSaveLayerStandalone
	)

Definition at line 409 of file aiks_dl_basic_unittests.cc.

                                         {
  DisplayListBuilder builder;
 
  DlPaint red;
  red.setColor(DlColor::kRed());
 
  DlPaint alpha;
  alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
 
  builder.SaveLayer(std::nullopt, &alpha);
 
  builder.DrawCircle(DlPoint(125, 125), 125, red);
 
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kRed(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [155/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCanPushPopCTM
	)

Definition at line 113 of file canvas_unittests.cc.

                                      {
  ContentContext& context = GetContentContext();
  auto canvas = CreateTestCanvas(context);
 
  ASSERT_EQ(canvas->GetSaveCount(), 1u);
  ASSERT_EQ(canvas->Restore(), false);
 
  canvas->Translate(Size{100, 100});
  canvas->Save(10);
  ASSERT_EQ(canvas->GetSaveCount(), 2u);
  ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                     Matrix::MakeTranslation({100.0, 100.0, 0.0}));
  ASSERT_TRUE(canvas->Restore());
  ASSERT_EQ(canvas->GetSaveCount(), 1u);
  ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                     Matrix::MakeTranslation({100.0, 100.0, 0.0}));
}

References ASSERT_MATRIX_NEAR, context, CreateTestCanvas(), and impeller::Matrix::MakeTranslation().

◆ TEST_P() [156/662]

impeller::testing::TEST_P	(	AiksTest	,
		CanvasCTMCanBeUpdated
	)

Definition at line 131 of file canvas_unittests.cc.

                                        {
  ContentContext& context = GetContentContext();
  auto canvas = CreateTestCanvas(context);
 
  Matrix identity;
  ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(), identity);
  canvas->Translate(Size{100, 100});
  ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(),
                     Matrix::MakeTranslation({100.0, 100.0, 0.0}));
}

References ASSERT_MATRIX_NEAR, context, CreateTestCanvas(), and impeller::Matrix::MakeTranslation().

◆ TEST_P() [157/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlend
	)

Definition at line 494 of file aiks_dl_blend_unittests.cc.

                             {
  DisplayListBuilder builder;
 
  DlPaint blue;
  blue.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600.0, 600.0), blue);
 
  DlPaint clear;
  clear.setBlendMode(DlBlendMode::kClear);
 
  builder.DrawCircle(DlPoint(300.0, 300.0), 200.0, clear);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [158/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClearBlendWithBlur
	)

Definition at line 516 of file aiks_dl_blur_unittests.cc.

                                     {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 600.0, 600.0), paint);
 
  DlPaint clear;
  clear.setBlendMode(DlBlendMode::kClear);
  clear.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 20));
 
  builder.DrawCircle(DlPoint(300.0, 300.0), 200.0, clear);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [159/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClearColorOptimizationWhenSubpassIsBiggerThanParentPass
	)

Definition at line 1827 of file aiks_dl_basic_unittests.cc.

                                                                          {
  SetWindowSize({400, 400});
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeLTRB(200, 200, 300, 300), paint);
 
  paint.setImageFilter(DlImageFilter::MakeMatrix(DlMatrix::MakeScale({2, 2, 1}),
                                                 DlImageSampling::kLinear));
  builder.SaveLayer(std::nullopt, &paint);
  // Draw a rectangle that would fully cover the parent pass size, but not
  // the subpass that it is rendered in.
  paint.setColor(DlColor::kGreen());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
  // Draw a bigger rectangle to force the subpass to be bigger.
 
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 800, 800), paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), x, and y.

◆ TEST_P() [160/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBackdropFilterWithShader
	)

Definition at line 506 of file aiks_dl_runtime_effect_unittests.cc.

                                                  {
  struct FragUniforms {
    Vector2 uSize;
  } frag_uniforms = {.uSize = Vector2(400, 400)};
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_border.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
      nullptr,
  };
 
  auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
      DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
      uniform_data);
 
  DisplayListBuilder builder;
 
  // Draw a background so the backdrop filter has something to affect
  DlPaint background_paint;
  background_paint.setColor(DlColor::kWhite());
  builder.DrawPaint(background_paint);
 
  // Draw some pattern to verify the filter effect
  DlPaint pattern_paint;
  pattern_paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), pattern_paint);
  pattern_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(200, 200, 200, 200), pattern_paint);
 
  builder.Save();
 
  // Replicate the clip rect (inset by 66)
  // Assuming a 400x400 screen, inset 66 gives roughly 66, 66, 268, 268
  builder.ClipRect(DlRect::MakeXYWH(66, 66, 268, 268));
 
  DlPaint save_paint;
  // The Flutter code uses a backdrop filter layer.
  // In DisplayList, this corresponds to SaveLayer with a backdrop filter.
  builder.SaveLayer(std::nullopt, &save_paint, runtime_filter.get());
 
  // The child was empty in the Flutter example, so we don't draw anything
  // inside the SaveLayer
 
  builder.Restore();  // Restore SaveLayer
  builder.Restore();  // Restore Save (Clip)
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlRuntimeEffectImpeller::Make(), flutter::DlImageFilter::MakeRuntimeEffect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [161/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectly
	)

Definition at line 499 of file aiks_dl_blur_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  builder.Translate(0, -400);
  DlPaint paint;
 
  Sigma sigma = Radius{120 * 3};
  paint.setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
  paint.setColor(DlColor::kRed());
 
  DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
  path = path + DlPath::MakeCircle(DlPoint(0, 0), 0.5);
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlBlurMaskFilter::Make(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), impeller::Sigma::sigma, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [162/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedBlurFilterRendersCorrectlyInteractive
	)

Definition at line 475 of file aiks_dl_blur_unittests.cc.

                                                               {
  auto callback = [&]() -> sk_sp<DisplayList> {
    static PlaygroundPoint playground_point(Point(400, 400), 20,
                                            Color::Green());
    auto point = DrawPlaygroundPoint(playground_point);
 
    DisplayListBuilder builder;
    auto location = point - Point(400, 400);
    builder.Translate(location.x, location.y);
 
    DlPaint paint;
    Sigma sigma = Radius{120 * 3};
    paint.setMaskFilter(
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma.sigma));
    paint.setColor(DlColor::kRed());
 
    DlPath path = DlPath::MakeRect(DlRect::MakeLTRB(0, 0, 800, 800));
    path = path + DlPath::MakeCircle(DlPoint(0, 0), 0.5);
    builder.DrawPath(path, paint);
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPath(), impeller::DrawPlaygroundPoint(), impeller::Color::Green(), flutter::DlColor::kRed(), location, flutter::DlBlurMaskFilter::Make(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), impeller::Sigma::sigma, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [163/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClippedComposeBackdropRuntimeOuterBlurInnerSmallSigma
	)

Definition at line 431 of file aiks_dl_runtime_effect_unittests.cc.

                                                                        {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_circle.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
  Scalar sigma = 5.0;
  Vector2 clip_origin = Vector2(20.f, 20.f);
  Vector2 clip_size = Vector2(300, 300);
  Vector2 circle_origin = Vector2(30.f, 30.f);
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("sigma", &sigma, 0, 20);
      ImGui::SliderFloat("clip_x", &clip_origin.x, 0, 2048.f);
      ImGui::SliderFloat("clip_y", &clip_origin.y, 0, 1536.f);
      ImGui::SliderFloat("clip_width", &clip_size.x, 0, 2048.f);
      ImGui::SliderFloat("clip_height", &clip_size.y, 0, 1536.f);
      ImGui::SliderFloat("circle_x", &circle_origin.x, 0.f, 2048.f);
      ImGui::SliderFloat("circle_y", &circle_origin.y, 0.f, 1536.f);
      ImGui::End();
    }
    DisplayListBuilder builder;
    DlPaint background;
    background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background);
 
    auto blur_filter =
        DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
 
    std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
        nullptr,
    };
    struct FragUniforms {
      Vector2 size;
      Vector2 origin;
    } frag_uniforms = {.size = Vector2(1, 1), .origin = circle_origin};
    auto uniform_data = std::make_shared<std::vector<uint8_t>>();
    uniform_data->resize(sizeof(FragUniforms));
    memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
    auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
        DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
        uniform_data);
 
    auto backdrop_filter = DlImageFilter::MakeCompose(/*outer=*/runtime_filter,
                                                      /*inner=*/blur_filter);
 
    builder.ClipRect(DlRect::MakeXYWH(clip_origin.x, clip_origin.y, clip_size.x,
                                      clip_size.y));
 
    DlPaint paint;
    auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
    builder.DrawImage(image, DlPoint(100.0, 100.0),
                      DlImageSampling::kNearestNeighbor, &paint);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
    builder.Restore();
 
    DlPaint green;
    green.setColor(DlColor::kGreen());
    builder.DrawLine({100, 100}, {200, 100}, green);
    builder.DrawLine({100, 100}, {100, 200}, green);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kGreen(), flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeCompose(), flutter::DlImageFilter::MakeRuntimeEffect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::size, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TEST_P() [164/662]

impeller::testing::TEST_P	(	AiksTest	,
		ClipsUseCurrentTransform
	)

Definition at line 98 of file aiks_dl_clip_unittests.cc.

                                           {
  std::array<DlColor, 5> colors = {DlColor::kWhite(), DlColor::kBlack(),
                                   DlColor::kSkyBlue(), DlColor::kRed(),
                                   DlColor::kYellow()};
  DisplayListBuilder builder;
  DlPaint paint;
 
  builder.Translate(300, 300);
  for (int i = 0; i < 15; i++) {
    builder.Scale(0.8, 0.8);
 
    paint.setColor(colors[i % colors.size()]);
    builder.ClipPath(DlPath::MakeCircle(DlPoint(0, 0), 300));
    builder.DrawRect(DlRect::MakeCircleBounds({0, 0}, 300), paint);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawRect(), i, flutter::DlColor::kBlack(), flutter::DlColor::kRed(), flutter::DlColor::kSkyBlue(), flutter::DlColor::kWhite(), flutter::DlColor::kYellow(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeCircleBounds(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [165/662]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpass
	)

Definition at line 41 of file aiks_dl_unittests.cc.

                                              {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kYellow());
  paint.setBlendMode(DlBlendMode::kSrc);
  builder.DrawPaint(paint);
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kMultiply);
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kCornflowerBlue().modulateOpacity(0.75f));
  builder.DrawPaint(draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kCornflowerBlue(), flutter::DlColor::kYellow(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [166/662]

impeller::testing::TEST_P	(	AiksTest	,
		CollapsedDrawPaintInSubpassBackdropFilter
	)

Definition at line 60 of file aiks_dl_unittests.cc.

                                                            {
  // Bug: https://github.com/flutter/flutter/issues/131576
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kYellow());
  paint.setBlendMode(DlBlendMode::kSrc);
  builder.DrawPaint(paint);
 
  auto filter = DlImageFilter::MakeBlur(20.0, 20.0, DlTileMode::kDecal);
  builder.SaveLayer(std::nullopt, nullptr, filter.get());
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kCornflowerBlue());
  builder.DrawPaint(draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kCornflowerBlue(), flutter::DlColor::kYellow(), flutter::DlImageFilter::MakeBlur(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [167/662]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterAdvancedBlend
	)

Definition at line 250 of file aiks_dl_blend_unittests.cc.

                                           {
  bool has_color_filter = true;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Checkbox("has color filter", &has_color_filter);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    auto src_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
    auto dst_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
 
    std::vector<DlBlendMode> blend_modes = {
        DlBlendMode::kScreen,     DlBlendMode::kOverlay,
        DlBlendMode::kDarken,     DlBlendMode::kLighten,
        DlBlendMode::kColorDodge, DlBlendMode::kColorBurn,
        DlBlendMode::kHardLight,  DlBlendMode::kSoftLight,
        DlBlendMode::kDifference, DlBlendMode::kExclusion,
        DlBlendMode::kMultiply,   DlBlendMode::kHue,
        DlBlendMode::kSaturation, DlBlendMode::kColor,
        DlBlendMode::kLuminosity,
    };
 
    for (uint32_t i = 0; i < blend_modes.size(); ++i) {
      builder.Save();
      builder.Translate((i % 5) * 200, (i / 5) * 200);
      builder.Scale(0.4, 0.4);
      {
        DlPaint dstPaint;
        builder.DrawImage(dst_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &dstPaint);
      }
      {
        DlPaint srcPaint;
        srcPaint.setBlendMode(blend_modes[i]);
        if (has_color_filter) {
          std::shared_ptr<const DlColorFilter> color_filter =
              DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                       DlBlendMode::kSrcIn);
          srcPaint.setColorFilter(color_filter);
        }
        builder.DrawImage(src_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &srcPaint);
      }
      builder.Restore();
    }
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), i, impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColorFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [168/662]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterAdvancedBlendNoFbFetch
	)

Definition at line 309 of file aiks_dl_blend_unittests.cc.

                                                    {
  if (GetParam() != PlaygroundBackend::kMetal) {
    GTEST_SKIP()
        << "This backend doesn't yet support setting device capabilities.";
  }
 
  std::shared_ptr<const Capabilities> old_capabilities =
      GetContext()->GetCapabilities();
  auto mock_capabilities = std::make_shared<MockCapabilities>();
  EXPECT_CALL(*mock_capabilities, SupportsFramebufferFetch())
      .Times(::testing::AtLeast(1))
      .WillRepeatedly(::testing::Return(false));
  FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultColorFormat);
  FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultStencilFormat);
  FLT_FORWARD(mock_capabilities, old_capabilities,
              GetDefaultDepthStencilFormat);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsOffscreenMSAA);
  FLT_FORWARD(mock_capabilities, old_capabilities,
              SupportsImplicitResolvingMSAA);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsReadFromResolve);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsSSBO);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsCompute);
  FLT_FORWARD(mock_capabilities, old_capabilities,
              SupportsTextureToTextureBlits);
  FLT_FORWARD(mock_capabilities, old_capabilities, GetDefaultGlyphAtlasFormat);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsTriangleFan);
  FLT_FORWARD(mock_capabilities, old_capabilities,
              SupportsDecalSamplerAddressMode);
  FLT_FORWARD(mock_capabilities, old_capabilities, SupportsPrimitiveRestart);
  FLT_FORWARD(mock_capabilities, old_capabilities, GetMinimumUniformAlignment);
  ASSERT_TRUE(SetCapabilities(mock_capabilities).ok());
 
  bool has_color_filter = true;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Checkbox("has color filter", &has_color_filter);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    auto src_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
    auto dst_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
 
    std::vector<DlBlendMode> blend_modes = {
        DlBlendMode::kScreen,     DlBlendMode::kOverlay,
        DlBlendMode::kDarken,     DlBlendMode::kLighten,
        DlBlendMode::kColorDodge, DlBlendMode::kColorBurn,
        DlBlendMode::kHardLight,  DlBlendMode::kSoftLight,
        DlBlendMode::kDifference, DlBlendMode::kExclusion,
        DlBlendMode::kMultiply,   DlBlendMode::kHue,
        DlBlendMode::kSaturation, DlBlendMode::kColor,
        DlBlendMode::kLuminosity,
    };
 
    for (uint32_t i = 0; i < blend_modes.size(); ++i) {
      builder.Save();
      builder.Translate((i % 5) * 200, (i / 5) * 200);
      builder.Scale(0.4, 0.4);
      {
        DlPaint dstPaint;
        builder.DrawImage(dst_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &dstPaint);
      }
      {
        DlPaint srcPaint;
        srcPaint.setBlendMode(blend_modes[i]);
        if (has_color_filter) {
          std::shared_ptr<const DlColorFilter> color_filter =
              DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                       DlBlendMode::kMultiply);
          srcPaint.setColorFilter(color_filter);
        }
        builder.DrawImage(src_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &srcPaint);
      }
      builder.Restore();
    }
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), FLT_FORWARD, i, impeller::kMetal, impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColorFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [169/662]

impeller::testing::TEST_P	(	AiksTest	,
		ColorFilterBlend
	)

Definition at line 198 of file aiks_dl_blend_unittests.cc.

                                   {
  bool has_color_filter = true;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Checkbox("has color filter", &has_color_filter);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    auto src_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_src.png"));
    auto dst_image =
        DlImageImpeller::Make(CreateTextureForFixture("blend_mode_dst.png"));
 
    std::vector<DlBlendMode> blend_modes = {
        DlBlendMode::kSrc,     DlBlendMode::kSrcATop, DlBlendMode::kSrcOver,
        DlBlendMode::kSrcIn,   DlBlendMode::kSrcOut,  DlBlendMode::kDst,
        DlBlendMode::kDstATop, DlBlendMode::kDstOver, DlBlendMode::kDstIn,
        DlBlendMode::kDstOut,  DlBlendMode::kClear,   DlBlendMode::kXor};
 
    for (uint32_t i = 0; i < blend_modes.size(); ++i) {
      builder.Save();
      builder.Translate((i % 5) * 200, (i / 5) * 200);
      builder.Scale(0.4, 0.4);
      {
        DlPaint dstPaint;
        builder.DrawImage(dst_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &dstPaint);
      }
      {
        DlPaint srcPaint;
        srcPaint.setBlendMode(blend_modes[i]);
        if (has_color_filter) {
          std::shared_ptr<const DlColorFilter> color_filter =
              DlColorFilter::MakeBlend(DlColor::RGBA(0.9, 0.5, 0.0, 1.0),
                                       DlBlendMode::kSrcIn);
          srcPaint.setColorFilter(color_filter);
        }
        builder.DrawImage(src_image, DlPoint(0, 0),
                          DlImageSampling::kMipmapLinear, &srcPaint);
      }
      builder.Restore();
    }
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), i, impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColorFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [170/662]

impeller::testing::TEST_P	(	AiksTest	,
		ColorMatrixFilterSubpassCollapseOptimization
	)

Definition at line 79 of file aiks_dl_unittests.cc.

                                                               {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
 
  const float matrix[20] = {
      -1.0, 0,    0,    1.0, 0,  //
      0,    -1.0, 0,    1.0, 0,  //
      0,    0,    -1.0, 1.0, 0,  //
      1.0,  1.0,  1.0,  1.0, 0   //
  };
  auto filter = DlColorFilter::MakeMatrix(matrix);
 
  DlPaint paint;
  paint.setColorFilter(filter);
  builder.SaveLayer(std::nullopt, &paint);
 
  builder.Translate(500, 300);
  builder.Rotate(120);  // 120 deg
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeMatrix(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [171/662]

impeller::testing::TEST_P	(	AiksTest	,
		ColorWheel
	)

color_wheel_sampler: r=0 -> fuchsia, r=2pi/3 -> yellow, r=4pi/3 -> cyan domain: r >= 0 (because modulo used is non euclidean)

Definition at line 783 of file aiks_dl_blend_unittests.cc.

                             {
  // Compare with https://fiddle.skia.org/c/@BlendModes
 
  BlendModeSelection blend_modes = GetBlendModeSelection();
 
  auto draw_color_wheel = [](DisplayListBuilder& builder) -> void {
    /// color_wheel_sampler: r=0 -> fuchsia, r=2pi/3 -> yellow, r=4pi/3 ->
    /// cyan domain: r >= 0 (because modulo used is non euclidean)
    auto color_wheel_sampler = [](Radians r) {
      Scalar x = r.radians / k2Pi + 1;
 
      // https://www.desmos.com/calculator/6nhjelyoaj
      auto color_cycle = [](Scalar x) {
        Scalar cycle = std::fmod(x, 6.0f);
        return std::max(0.0f, std::min(1.0f, 2 - std::abs(2 - cycle)));
      };
      return Color(color_cycle(6 * x + 1),  //
                   color_cycle(6 * x - 1),  //
                   color_cycle(6 * x - 3),  //
                   1);
    };
 
    DlPaint paint;
    paint.setBlendMode(DlBlendMode::kSrcOver);
 
    // Draw a fancy color wheel for the backdrop.
    // https://www.desmos.com/calculator/xw7kafthwd
    const int max_dist = 900;
    for (int i = 0; i <= 900; i++) {
      Radians r(kPhi / k2Pi * i);
      Scalar distance = r.radians / std::powf(4.12, 0.0026 * r.radians);
      Scalar normalized_distance = static_cast<Scalar>(i) / max_dist;
 
      auto color = color_wheel_sampler(r).WithAlpha(1.0f - normalized_distance);
      paint.setColor(
          DlColor::RGBA(color.red, color.green, color.blue, color.alpha));
      DlPoint position = DlPoint(distance * std::sin(r.radians),
                                 -distance * std::cos(r.radians));
 
      builder.DrawCircle(position, 9 + normalized_distance * 3, paint);
    }
  };
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    // UI state.
    static bool cache_the_wheel = true;
    static int current_blend_index = 3;
    static float dst_alpha = 1;
    static float src_alpha = 1;
    static DlColor color0 = DlColor::kRed();
    static DlColor color1 = DlColor::kGreen();
    static DlColor color2 = DlColor::kBlue();
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Checkbox("Cache the wheel", &cache_the_wheel);
      ImGui::ListBox("Blending mode", &current_blend_index,
                     blend_modes.blend_mode_names.data(),
                     blend_modes.blend_mode_names.size());
      ImGui::SliderFloat("Source alpha", &src_alpha, 0, 1);
      ImGui::ColorEdit4("Color A", reinterpret_cast<float*>(&color0));
      ImGui::ColorEdit4("Color B", reinterpret_cast<float*>(&color1));
      ImGui::ColorEdit4("Color C", reinterpret_cast<float*>(&color2));
      ImGui::SliderFloat("Destination alpha", &dst_alpha, 0, 1);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
 
    DlPaint paint;
    paint.setColor(DlColor::kWhite().withAlpha(dst_alpha * 255));
    paint.setBlendMode(DlBlendMode::kSrc);
    builder.SaveLayer(std::nullopt, &paint);
    {
      DlPaint paint;
      paint.setColor(DlColor::kWhite());
      builder.DrawPaint(paint);
 
      builder.SaveLayer(std::nullopt, nullptr);
      builder.Scale(GetContentScale().x, GetContentScale().y);
      builder.Translate(500, 400);
      builder.Scale(3, 3);
      draw_color_wheel(builder);
      builder.Restore();
    }
    builder.Restore();
 
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.Translate(500, 400);
    builder.Scale(3, 3);
 
    // Draw 3 circles to a subpass and blend it in.
    DlPaint save_paint;
    save_paint.setColor(DlColor::kWhite().withAlpha(src_alpha * 255));
    save_paint.setBlendMode(static_cast<DlBlendMode>(
        blend_modes.blend_mode_values[current_blend_index]));
    builder.SaveLayer(std::nullopt, &save_paint);
    {
      DlPaint paint;
      paint.setBlendMode(DlBlendMode::kPlus);
      const Scalar x = std::sin(k2Pi / 3);
      const Scalar y = -std::cos(k2Pi / 3);
      paint.setColor(color0);
      builder.DrawCircle(DlPoint(-x * 45, y * 45), 65, paint);
      paint.setColor(color1);
      builder.DrawCircle(DlPoint(0, -45), 65, paint);
      paint.setColor(color2);
      builder.DrawCircle(DlPoint(x * 45, y * 45), 65, paint);
    }
    builder.Restore();
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::testing::BlendModeSelection::blend_mode_names, impeller::testing::BlendModeSelection::blend_mode_values, flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), GetBlendModeSelection(), i, impeller::k2Pi, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), impeller::kPhi, flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::Radians::radians, flutter::DisplayListBuilder::Restore(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [172/662]

impeller::testing::TEST_P	(	AiksTest	,
		CompareAntiAliasAndNonAntiAlias
	)

Definition at line 2701 of file aiks_dl_basic_unittests.cc.

                                                  {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kBlack(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
 
  DlRect bounds = DlRect::MakeXYWH(75, 75, 50, 50);
 
  // --- Left Half: Zoom-in on the top-left corner WITH anti-aliasing (SDF) ---
  DlPaint layer_paint_left;
  layer_paint_left.setImageFilter(DlImageFilter::MakeMatrix(
      DlMatrix::MakeTranslation({200, 300}) * DlMatrix::MakeScale({8, 8, 1}) *
          DlMatrix::MakeTranslation({-100, -100}),
      DlImageSampling::kNearestNeighbor));
  builder.SaveLayer(bounds, &layer_paint_left);
 
  paint.setAntiAlias(true);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectRadius(DlRect::MakeXYWH(100, 100, 200, 200), 50.0f),
      paint);
  builder.Restore();
 
  // --- Right Half: Zoom-in on the top-left corner WITHOUT anti-aliasing ---
  DlPaint layer_paint_right;
  layer_paint_right.setImageFilter(DlImageFilter::MakeMatrix(
      DlMatrix::MakeTranslation({600, 300}) * DlMatrix::MakeScale({8, 8, 1}) *
          DlMatrix::MakeTranslation({-100, -100}),
      DlImageSampling::kNearestNeighbor));
  builder.SaveLayer(bounds, &layer_paint_right);
 
  paint.setAntiAlias(false);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectRadius(DlRect::MakeXYWH(100, 100, 200, 200), 50.0f),
      paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlack(), flutter::DlColor::kWhite(), flutter::DlImageFilter::MakeMatrix(), impeller::RoundRect::MakeRectRadius(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setAntiAlias(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [173/662]

impeller::testing::TEST_P	(	AiksTest	,
		CompareDiffRoundRectAndRoundRect
	)

Definition at line 2741 of file aiks_dl_basic_unittests.cc.

                                                   {
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kBlack(), DlBlendMode::kSrc);
 
  DlRect outer_rect = DlRect::MakeXYWH(0, 0, 100, 100);
  DlRoundingRadii outer_radii = {.top_left = DlSize(5.0f),
                                 .top_right = DlSize(10.0f),
                                 .bottom_left = DlSize(20.0f),
                                 .bottom_right = DlSize(50.0f)};
  DlRoundRect outer_rrect = DlRoundRect::MakeRectRadii(outer_rect, outer_radii);
 
  DlScalar inner_inset = 5.0f;
  DlRect inner_rect = outer_rect.Expand(-inner_inset);
  DlRoundingRadii inner_radii = {
      .top_left = DlSize(outer_radii.top_left.width - inner_inset),
      .top_right = DlSize(outer_radii.top_right.width - inner_inset),
      .bottom_left = DlSize(outer_radii.bottom_left.width - inner_inset),
      .bottom_right = DlSize(outer_radii.bottom_right.width - inner_inset)};
  DlRoundRect inner_rrect = DlRoundRect::MakeRectRadii(inner_rect, inner_radii);
 
  builder.Translate(50, 50);
 
  // Draw DiffRoundRect.
  builder.DrawDiffRoundRect(outer_rrect, inner_rrect,
                            DlPaint().setColor(DlColor::kSkyBlue()));
 
  // Draw simalated DiffRoundRect by drawing the outer RoundRect and clearing
  // the inner RoundRect.
  builder.Translate(200, 0);
  builder.DrawRoundRect(outer_rrect, DlPaint().setColor(DlColor::kSkyBlue()));
  builder.DrawRoundRect(inner_rrect,
                        DlPaint().setBlendMode(DlBlendMode::kClear));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::RoundingRadii::bottom_left, impeller::RoundingRadii::bottom_right, flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawDiffRoundRect(), flutter::DisplayListBuilder::DrawRoundRect(), impeller::TRect< T >::Expand(), flutter::DlColor::kBlack(), flutter::DlColor::kSkyBlue(), impeller::RoundRect::MakeRectRadii(), impeller::TRect< Scalar >::MakeXYWH(), impeller::RoundingRadii::top_left, impeller::RoundingRadii::top_right, flutter::DisplayListBuilder::Translate(), and flutter::Size::width().

◆ TEST_P() [174/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposeBackdropRuntimeOuterBlurInner
	)

Definition at line 304 of file aiks_dl_runtime_effect_unittests.cc.

                                                       {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_circle.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
  Scalar sigma = 20.0;
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("sigma", &sigma, 0, 20);
      ImGui::End();
    }
    DisplayListBuilder builder;
    DlPaint background;
    background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background);
 
    auto blur_filter =
        DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
 
    std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
        nullptr,
    };
 
    struct FragUniforms {
      Vector2 size;
      Vector2 origin;
    } frag_uniforms = {.size = Vector2(1, 1), .origin = Vector2(30.f, 30.f)};
    auto uniform_data = std::make_shared<std::vector<uint8_t>>();
    uniform_data->resize(sizeof(FragUniforms));
    memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
    auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
        DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
        uniform_data);
 
    auto backdrop_filter = DlImageFilter::MakeCompose(/*outer=*/runtime_filter,
                                                      /*inner=*/blur_filter);
 
    DlPaint paint;
    auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
    builder.DrawImage(image, DlPoint(100.0, 100.0),
                      DlImageSampling::kNearestNeighbor, &paint);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
    builder.Restore();
 
    DlPaint green;
    green.setColor(DlColor::kGreen());
    builder.DrawLine({100, 100}, {200, 100}, green);
    builder.DrawLine({100, 100}, {100, 200}, green);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kGreen(), flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeCompose(), flutter::DlImageFilter::MakeRuntimeEffect(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::size.

◆ TEST_P() [175/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposeBackdropRuntimeOuterBlurInnerSmallSigma
	)

Definition at line 368 of file aiks_dl_runtime_effect_unittests.cc.

                                                                 {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_circle.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
  Scalar sigma = 5.0;
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("sigma", &sigma, 0, 20);
      ImGui::End();
    }
    DisplayListBuilder builder;
    DlPaint background;
    background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background);
 
    auto blur_filter =
        DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
 
    std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
        nullptr,
    };
    struct FragUniforms {
      Vector2 size;
      Vector2 origin;
    } frag_uniforms = {.size = Vector2(1, 1), .origin = Vector2(30.f, 30.f)};
    auto uniform_data = std::make_shared<std::vector<uint8_t>>();
    uniform_data->resize(sizeof(FragUniforms));
    memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
    auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
        DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
        uniform_data);
 
    auto backdrop_filter = DlImageFilter::MakeCompose(/*outer=*/runtime_filter,
                                                      /*inner=*/blur_filter);
 
    DlPaint paint;
    auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
    builder.DrawImage(image, DlPoint(100.0, 100.0),
                      DlImageSampling::kNearestNeighbor, &paint);
 
    DlPaint save_paint;
    save_paint.setBlendMode(DlBlendMode::kSrc);
    builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
    builder.Restore();
 
    DlPaint green;
    green.setColor(DlColor::kGreen());
    builder.DrawLine({100, 100}, {200, 100}, green);
    builder.DrawLine({100, 100}, {100, 200}, green);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kGreen(), flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeCompose(), flutter::DlImageFilter::MakeRuntimeEffect(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::size.

◆ TEST_P() [176/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposePaintBlurInner
	)

Definition at line 450 of file aiks_dl_blur_unittests.cc.

                                        {
  DisplayListBuilder builder;
 
  DlPaint background;
  background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
  builder.DrawPaint(background);
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  float matrix[] = {
      0, 1, 0, 0, 0,  //
      1, 0, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 1, 0   //
  };
  std::shared_ptr<DlImageFilter> color_filter =
      DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix));
  std::shared_ptr<DlImageFilter> blur =
      DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal);
  paint.setImageFilter(DlImageFilter::MakeCompose(color_filter, blur));
  builder.DrawCircle(DlPoint(400, 400), 200, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlImageFilter::MakeCompose(), flutter::DlColorFilter::MakeMatrix(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [177/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposePaintBlurOuter
	)

Definition at line 425 of file aiks_dl_blur_unittests.cc.

                                        {
  DisplayListBuilder builder;
 
  DlPaint background;
  background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
  builder.DrawPaint(background);
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  float matrix[] = {
      0, 1, 0, 0, 0,  //
      1, 0, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 1, 0   //
  };
  std::shared_ptr<DlImageFilter> color_filter =
      DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix));
  std::shared_ptr<DlImageFilter> blur =
      DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal);
  paint.setImageFilter(DlImageFilter::MakeCompose(blur, color_filter));
  builder.DrawCircle(DlPoint(400, 400), 200, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlImageFilter::MakeCompose(), flutter::DlColorFilter::MakeMatrix(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [178/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposePaintRuntimeInner
	)

Definition at line 217 of file aiks_dl_runtime_effect_unittests.cc.

                                           {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_warp.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
  Scalar xoffset = 50;
  Scalar yoffset = 50;
  Scalar xscale = 0.7;
  Scalar yscale = 0.7;
  bool compare = false;
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("xoffset", &xoffset, -50, 50);
      ImGui::SliderFloat("yoffset", &yoffset, -50, 50);
      ImGui::SliderFloat("xscale", &xscale, 0, 1);
      ImGui::SliderFloat("yscale", &yscale, 0, 1);
      ImGui::Checkbox("compare", &compare);
      ImGui::End();
    }
    DisplayListBuilder builder;
    DlPaint background;
    background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background);
 
    DlPaint paint;
    paint.setColor(DlColor::kGreen());
    float matrix[] = {
        0, 1, 0, 0, 0,  //
        1, 0, 0, 0, 0,  //
        0, 0, 1, 0, 0,  //
        0, 0, 0, 1, 0   //
    };
    std::shared_ptr<DlImageFilter> color_filter =
        DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix));
 
    std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
        nullptr,
    };
    auto uniform_data = std::make_shared<std::vector<uint8_t>>();
    uniform_data->resize(sizeof(Vector2));
 
    auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
        DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
        uniform_data);
 
    builder.Translate(xoffset, yoffset);
    builder.Scale(xscale, yscale);
 
    paint.setImageFilter(
        DlImageFilter::MakeCompose(color_filter, runtime_filter));
    auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
    builder.DrawImage(image, DlPoint(100.0, 100.0),
                      DlImageSampling::kNearestNeighbor, &paint);
 
    if (compare) {
      paint.setImageFilter(
          DlImageFilter::MakeCompose(runtime_filter, color_filter));
      builder.DrawImage(image, DlPoint(800.0, 100.0),
                        DlImageSampling::kNearestNeighbor, &paint);
 
      paint.setImageFilter(runtime_filter);
      builder.DrawImage(image, DlPoint(100.0, 800.0),
                        DlImageSampling::kNearestNeighbor, &paint);
    }
 
    DlPaint green;
    green.setColor(DlColor::kGreen());
    builder.DrawLine({100, 100}, {200, 100}, green);
    builder.DrawLine({100, 100}, {100, 200}, green);
    if (compare) {
      builder.DrawLine({800, 100}, {900, 100}, green);
      builder.DrawLine({800, 100}, {800, 200}, green);
      builder.DrawLine({100, 800}, {200, 800}, green);
      builder.DrawLine({100, 800}, {100, 900}, green);
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kGreen(), flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlImageFilter::MakeCompose(), flutter::DlColorFilter::MakeMatrix(), flutter::DlImageFilter::MakeRuntimeEffect(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [179/662]

impeller::testing::TEST_P	(	AiksTest	,
		ComposePaintRuntimeOuter
	)

Definition at line 165 of file aiks_dl_runtime_effect_unittests.cc.

                                           {
  DisplayListBuilder builder;
  DlPaint background;
  background.setColor(DlColor(1.0, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
  builder.DrawPaint(background);
 
  DlPaint paint;
  paint.setColor(DlColor::kGreen());
  float matrix[] = {
      0, 1, 0, 0, 0,  //
      1, 0, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 1, 0   //
  };
  std::shared_ptr<DlImageFilter> color_filter =
      DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix));
 
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_filter_warp.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
      nullptr,
  };
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(Vector2));
 
  auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
      DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
      uniform_data);
 
  builder.Translate(50, 50);
  builder.Scale(0.7, 0.7);
 
  paint.setImageFilter(
      DlImageFilter::MakeCompose(runtime_filter, color_filter));
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  builder.DrawImage(image, DlPoint(100.0, 100.0),
                    DlImageSampling::kNearestNeighbor, &paint);
 
  DlPaint green;
  green.setColor(DlColor::kGreen());
  builder.DrawLine({100, 100}, {200, 100}, green);
  builder.DrawLine({100, 100}, {100, 200}, green);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kGreen(), flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlImageFilter::MakeCompose(), flutter::DlColorFilter::MakeMatrix(), flutter::DlImageFilter::MakeRuntimeEffect(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [180/662]

impeller::testing::TEST_P	(	AiksTest	,
		CoordinateConversionsAreCorrect
	)

Definition at line 1931 of file aiks_dl_basic_unittests.cc.

                                                  {
  DisplayListBuilder builder;
 
  // Render a texture directly.
  {
    auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
    builder.Save();
    builder.Translate(100, 200);
    builder.Scale(0.5, 0.5);
    builder.DrawImage(image, DlPoint(100.0, 100.0),
                      DlImageSampling::kNearestNeighbor);
    builder.Restore();
  }
 
  // Render an offscreen rendered texture.
  {
    DlPaint alpha;
    alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
 
    builder.SaveLayer(std::nullopt, &alpha);
 
    DlPaint paint;
    paint.setColor(DlColor::kRed());
    builder.DrawRect(DlRect::MakeXYWH(000, 000, 100, 100), paint);
    paint.setColor(DlColor::kGreen());
    builder.DrawRect(DlRect::MakeXYWH(020, 020, 100, 100), paint);
    paint.setColor(DlColor::kBlue());
    builder.DrawRect(DlRect::MakeXYWH(040, 040, 100, 100), paint);
 
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [181/662]

impeller::testing::TEST_P	(	AiksTest	,
		CoverageOriginShouldBeAccountedForInSubpasses
	)

Definition at line 2112 of file aiks_dl_basic_unittests.cc.

                                                                {
  auto callback = [&]() -> sk_sp<DisplayList> {
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    DlPaint alpha;
    alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
 
    auto current = Point{25, 25};
    const auto offset = Point{25, 25};
    const auto size = Size(100, 100);
 
    static PlaygroundPoint point_a(Point(40, 40), 10, Color::White());
    static PlaygroundPoint point_b(Point(160, 160), 10, Color::White());
    auto [b0, b1] = DrawPlaygroundLine(point_a, point_b);
    DlRect bounds = DlRect::MakeLTRB(b0.x, b0.y, b1.x, b1.y);
 
    DlPaint stroke_paint;
    stroke_paint.setColor(DlColor::kYellow());
    stroke_paint.setStrokeWidth(5);
    stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
    builder.DrawRect(bounds, stroke_paint);
 
    builder.SaveLayer(bounds, &alpha);
 
    DlPaint paint;
    paint.setColor(DlColor::kRed());
    builder.DrawRect(
        DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
 
    paint.setColor(DlColor::kGreen());
    current += offset;
    builder.DrawRect(
        DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
 
    paint.setColor(DlColor::kBlue());
    current += offset;
    builder.DrawRect(
        DlRect::MakeXYWH(current.x, current.y, size.width, size.height), paint);
 
    builder.Restore();
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, impeller::DrawPlaygroundLine(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::modulateOpacity(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), flutter::size, and impeller::Color::White().

◆ TEST_P() [182/662]

impeller::testing::TEST_P	(	AiksTest	,
		DepthValuesForLineMode
	)

Definition at line 988 of file aiks_dl_unittests.cc.

                                         {
  // Ensures that the additional draws created by line/polygon mode all
  // have the same depth values.
  DisplayListBuilder builder;
 
  DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 100);
 
  builder.DrawPath(path, DlPaint()
                             .setColor(DlColor::kRed())
                             .setDrawStyle(DlDrawStyle::kStroke)
                             .setStrokeWidth(5));
  builder.Save();
  builder.ClipPath(path);
 
  std::vector<DlPoint> points = {
      DlPoint::MakeXY(0, -200), DlPoint::MakeXY(400, 200),
      DlPoint::MakeXY(0, -100), DlPoint::MakeXY(400, 300),
      DlPoint::MakeXY(0, 0),    DlPoint::MakeXY(400, 400),
      DlPoint::MakeXY(0, 100),  DlPoint::MakeXY(400, 500),
      DlPoint::MakeXY(0, 150),  DlPoint::MakeXY(400, 600)};
 
  builder.DrawPoints(DlPointMode::kLines, points.size(), points.data(),
                     DlPaint().setColor(DlColor::kBlue()).setStrokeWidth(10));
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlPath::MakeCircle(), impeller::TPoint< Scalar >::MakeXY(), flutter::path, points, flutter::DisplayListBuilder::Restore(), and flutter::DisplayListBuilder::Save().

◆ TEST_P() [183/662]

impeller::testing::TEST_P	(	AiksTest	,
		DepthValuesForPolygonMode
	)

Definition at line 1016 of file aiks_dl_unittests.cc.

                                            {
  // Ensures that the additional draws created by line/polygon mode all
  // have the same depth values.
  DisplayListBuilder builder;
 
  DlPath path = DlPath::MakeCircle(DlPoint(100, 100), 100);
 
  builder.DrawPath(path, DlPaint()
                             .setColor(DlColor::kRed())
                             .setDrawStyle(DlDrawStyle::kStroke)
                             .setStrokeWidth(5));
  builder.Save();
  builder.ClipPath(path);
 
  std::vector<DlPoint> points = {
      DlPoint::MakeXY(0, -200), DlPoint::MakeXY(400, 200),
      DlPoint::MakeXY(0, -100), DlPoint::MakeXY(400, 300),
      DlPoint::MakeXY(0, 0),    DlPoint::MakeXY(400, 400),
      DlPoint::MakeXY(0, 100),  DlPoint::MakeXY(400, 500),
      DlPoint::MakeXY(0, 150),  DlPoint::MakeXY(400, 600)};
 
  builder.DrawPoints(DlPointMode::kPolygon, points.size(), points.data(),
                     DlPaint().setColor(DlColor::kBlue()).setStrokeWidth(10));
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawPoints(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlPath::MakeCircle(), impeller::TPoint< Scalar >::MakeXY(), flutter::path, points, flutter::DisplayListBuilder::Restore(), and flutter::DisplayListBuilder::Save().

◆ TEST_P() [184/662]

impeller::testing::TEST_P	(	AiksTest	,
		DestructiveBlendColorFilterFloodsClip
	)

Definition at line 900 of file aiks_dl_blend_unittests.cc.

                                                        {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawPaint(paint);
 
  DlPaint save_paint;
  save_paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kSrc));
  builder.SaveLayer(std::nullopt, &save_paint);
  builder.Restore();
 
  // Should be solid red as the destructive color filter floods the clip.
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [185/662]

impeller::testing::TEST_P	(	AiksTest	,
		DifferenceClipsMustRenderIdenticallyAcrossBackends
	)

Definition at line 644 of file aiks_dl_text_unittests.cc.

                                                                     {
  DisplayListBuilder builder;
 
  DlPaint paint;
  DlColor clear_color(1.0, 0.5, 0.5, 0.5, DlColorSpace::kSRGB);
  paint.setColor(clear_color);
  builder.DrawPaint(paint);
 
  DlMatrix identity = {
      1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
      0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
  };
  builder.Save();
  builder.Transform(identity);
 
  DlRect frame = DlRect::MakeLTRB(1.0, 1.0, 1278.0, 763.0);
  DlColor white(1.0, 1.0, 1.0, 1.0, DlColorSpace::kSRGB);
  paint.setColor(white);
  builder.DrawRect(frame, paint);
 
  builder.Save();
  builder.ClipRect(frame, DlClipOp::kIntersect);
 
  DlMatrix rect_xform = {
      0.8241262, 0.56640625, 0.0, 0.0, -0.56640625, 0.8241262, 0.0, 0.0,
      0.0,       0.0,        1.0, 0.0, 271.1137,    489.4733,  0.0, 1.0,
  };
  builder.Save();
  builder.Transform(rect_xform);
 
  DlRect rect = DlRect::MakeLTRB(0.0, 0.0, 100.0, 100.0);
  DlColor bluish(1.0, 0.184, 0.501, 0.929, DlColorSpace::kSRGB);
  paint.setColor(bluish);
  DlRoundRect rrect = DlRoundRect::MakeRectRadius(rect, 18.0);
  builder.DrawRoundRect(rrect, paint);
 
  builder.Save();
  builder.ClipRect(rect, DlClipOp::kIntersect);
  builder.Restore();
 
  builder.Restore();
 
  DlMatrix path_xform = {
      1.0, 0.0, 0.0, 0.0, 0.0,   1.0,   0.0, 0.0,
      0.0, 0.0, 1.0, 0.0, 675.0, 279.5, 0.0, 1.0,
  };
  builder.Save();
  builder.Transform(path_xform);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(87.5, 349.5));
  path_builder.LineTo(DlPoint(25.0, 29.5));
  path_builder.LineTo(DlPoint(150.0, 118.0));
  path_builder.LineTo(DlPoint(25.0, 118.0));
  path_builder.LineTo(DlPoint(150.0, 29.5));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DlColor fill_color(1.0, 1.0, 0.0, 0.0, DlColorSpace::kSRGB);
  DlColor stroke_color(1.0, 0.0, 0.0, 0.0, DlColorSpace::kSRGB);
  paint.setColor(fill_color);
  paint.setDrawStyle(DlDrawStyle::kFill);
  builder.DrawPath(path, paint);
 
  paint.setColor(stroke_color);
  paint.setStrokeWidth(2.0);
  paint.setDrawStyle(DlDrawStyle::kStroke);
  builder.DrawPath(path, paint);
 
  builder.Restore();
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [186/662]

impeller::testing::TEST_P	(	AiksTest	,
		DispatcherDoesNotCullPerspectiveTransformedChildDisplayLists
	)

Definition at line 875 of file aiks_dl_unittests.cc.

                                                                               {
  flutter::DisplayListBuilder sub_builder(true);
  sub_builder.DrawRect(DlRect::MakeXYWH(0, 0, 50, 50),
                       flutter::DlPaint(flutter::DlColor::kRed()));
  auto display_list = sub_builder.Build();
 
  AiksContext context(GetContext(), nullptr);
  RenderTarget render_target =
      context.GetContentContext().GetRenderTargetCache()->CreateOffscreen(
          *context.GetContext(), {2400, 1800}, 1);
 
  DisplayListBuilder builder;
 
  builder.Scale(2.0, 2.0);
  builder.Translate(-93.0, 0.0);
 
  // clang-format off
  builder.TransformFullPerspective(
     0.8, -0.2, -0.1, -0.0,
     0.0,  1.0,  0.0,  0.0,
     1.4,  1.3,  1.0,  0.0,
    63.2, 65.3, 48.6,  1.1
  );
  // clang-format on
  builder.Translate(35.0, 75.0);
  builder.DrawDisplayList(display_list, 1.0f);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), context, flutter::DisplayListBuilder::DrawDisplayList(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DisplayListBuilder::TransformFullPerspective(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [187/662]

impeller::testing::TEST_P	(	AiksTest	,
		DisplayListToTextureAllocationFailure
	)

Definition at line 1116 of file aiks_dl_unittests.cc.

                                                        {
  ScopedValidationDisable disable_validations;
  DisplayListBuilder builder;
 
  AiksContext aiks_context(GetContext(), nullptr);
  // Use intentionally invalid dimensions that would trigger an allocation
  // failure.
  auto texture =
      DisplayListToTexture(builder.Build(), ISize{0, 0}, aiks_context);
 
  EXPECT_EQ(texture, nullptr);
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), and texture.

◆ TEST_P() [188/662]

impeller::testing::TEST_P	(	AiksTest	,
		DisplayListToTextureWithMipGeneration
	)

Definition at line 1129 of file aiks_dl_unittests.cc.

                                                        {
  DisplayListBuilder builder;
 
  std::shared_ptr<DlImageFilter> filter =
      DlImageFilter::MakeBlur(8, 8, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, nullptr, filter.get());
  builder.Restore();
 
  AiksContext aiks_context(GetContext(), nullptr);
  // Use intentionally invalid dimensions that would trigger an allocation
  // failure.
  auto texture =
      DisplayListToTexture(builder.Build(), ISize{10, 10}, aiks_context,
                           /*reset_host_buffer=*/true, /*generate_mips=*/true);
 
  EXPECT_FALSE(texture->NeedsMipmapGeneration());
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DlImageFilter::MakeBlur(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and texture.

◆ TEST_P() [189/662]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryBlend
	)

Definition at line 208 of file aiks_dl_atlas_unittests.cc.

                                       {
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors;
  colors.reserve(texture_coordinates.size());
  for (auto i = 0u; i < texture_coordinates.size(); i++) {
    colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
  }
  DlAtlasGeometry geom(atlas->GetImpellerTexture(GetContext()),
                       transforms.data(), texture_coordinates.data(),
                       colors.data(), transforms.size(), BlendMode::kSrcOver,
                       {}, std::nullopt);
 
  EXPECT_TRUE(geom.ShouldUseBlend());
  EXPECT_FALSE(geom.ShouldSkip());
 
  ContentContext context(GetContext(), nullptr);
  auto vertex_buffer =
      geom.CreateBlendVertexBuffer(context.GetTransientsDataBuffer());
 
  EXPECT_EQ(vertex_buffer.index_type, IndexType::kNone);
  EXPECT_EQ(vertex_buffer.vertex_count, texture_coordinates.size() * 6);
}

References flutter::DlColor::ARGB(), context, impeller::DlAtlasGeometry::CreateBlendVertexBuffer(), i, impeller::kNone, impeller::kSrcOver, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [190/662]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryColorButNoBlend
	)

Definition at line 232 of file aiks_dl_atlas_unittests.cc.

                                                 {
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors;
  colors.reserve(texture_coordinates.size());
  for (auto i = 0u; i < texture_coordinates.size(); i++) {
    colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
  }
  DlAtlasGeometry geom(atlas->GetImpellerTexture(GetContext()),
                       transforms.data(), texture_coordinates.data(),
                       colors.data(), transforms.size(), BlendMode::kSrc, {},
                       std::nullopt);
 
  // Src blend mode means that colors would be ignored, even if provided.
  EXPECT_FALSE(geom.ShouldUseBlend());
  EXPECT_FALSE(geom.ShouldSkip());
}

References flutter::DlColor::ARGB(), i, impeller::kSrc, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [191/662]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometryNoBlendRenamed
	)

Definition at line 189 of file aiks_dl_atlas_unittests.cc.

                                                {
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  DlAtlasGeometry geom(atlas->GetImpellerTexture(GetContext()),
                       transforms.data(), texture_coordinates.data(), nullptr,
                       transforms.size(), BlendMode::kSrcOver, {},
                       std::nullopt);
 
  EXPECT_FALSE(geom.ShouldUseBlend());
  EXPECT_FALSE(geom.ShouldSkip());
 
  ContentContext context(GetContext(), nullptr);
  auto vertex_buffer =
      geom.CreateSimpleVertexBuffer(context.GetTransientsDataBuffer());
 
  EXPECT_EQ(vertex_buffer.index_type, IndexType::kNone);
  EXPECT_EQ(vertex_buffer.vertex_count, texture_coordinates.size() * 6);
}

References context, impeller::DlAtlasGeometry::CreateSimpleVertexBuffer(), impeller::kNone, impeller::kSrcOver, impeller::DlAtlasGeometry::ShouldSkip(), and impeller::DlAtlasGeometry::ShouldUseBlend().

◆ TEST_P() [192/662]

impeller::testing::TEST_P	(	AiksTest	,
		DlAtlasGeometrySkip
	)

Definition at line 250 of file aiks_dl_atlas_unittests.cc.

                                      {
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors;
  colors.reserve(texture_coordinates.size());
  for (auto i = 0u; i < texture_coordinates.size(); i++) {
    colors.push_back(DlColor::ARGB(0.5, 1, 1, 1));
  }
  DlAtlasGeometry geom(atlas->GetImpellerTexture(GetContext()),
                       transforms.data(), texture_coordinates.data(),
                       colors.data(), transforms.size(), BlendMode::kClear, {},
                       std::nullopt);
  EXPECT_TRUE(geom.ShouldSkip());
}

References flutter::DlColor::ARGB(), i, impeller::kClear, and impeller::DlAtlasGeometry::ShouldSkip().

◆ TEST_P() [193/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAdvancedBlendPartlyOffscreen
	)

Definition at line 142 of file aiks_dl_blend_unittests.cc.

                                                   {
  DisplayListBuilder builder;
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawPaint(draw_paint);
  builder.Scale(2, 2);
  builder.ClipRect(DlRect::MakeLTRB(0, 0, 200, 200));
 
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  DlPaint paint;
  DlMatrix matrix = DlMatrix::MakeScale({0.3, 0.3, 1.0});
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/{0, 0},             //
      /*end_point=*/{100, 100},           //
      /*stop_count=*/colors.size(),       //
      /*colors=*/colors.data(),           //
      /*stops=*/stops.data(),             //
      /*tile_mode=*/DlTileMode::kRepeat,  //
      /*matrix=*/&matrix                  //
      ));
  paint.setBlendMode(DlBlendMode::kLighten);
 
  builder.DrawCircle(DlPoint(100, 100), 100, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [194/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasAdvancedAndTransform
	)

Definition at line 137 of file aiks_dl_atlas_unittests.cc.

                                                {
  DisplayListBuilder builder;
  // Draws the image as four squares stiched together.
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  builder.Scale(0.25, 0.25);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    /*colors=*/nullptr, /*count=*/4, DlBlendMode::kModulate,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [195/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColor
	)

Definition at line 60 of file aiks_dl_atlas_unittests.cc.

                                   {
  DisplayListBuilder builder;
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    /*colors=*/nullptr, /*count=*/4, DlBlendMode::kSrcOver,
                    DlImageSampling::kNearestNeighbor, nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [196/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasNoColorFullSize
	)

Definition at line 120 of file aiks_dl_atlas_unittests.cc.

                                           {
  auto atlas = DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
  auto size = atlas->GetImpellerTexture(GetContext())->GetSize();
  std::vector<DlRect> texture_coordinates = {
      DlRect::MakeLTRB(0, 0, size.width, size.height)};
  std::vector<RSTransform> transforms = {MakeTranslation(0, 0)};
 
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    /*colors=*/nullptr, /*count=*/1, DlBlendMode::kSrcOver,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Scale(), flutter::size, x, and y.

◆ TEST_P() [197/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasPlusWideGamut
	)

Definition at line 166 of file aiks_dl_atlas_unittests.cc.

                                         {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with wide gamut support.
  if (!EnsureContextSupportsWideGamut()) {
    GTEST_SKIP() << "This backend doesn't yet support wide gamut.";
  }
 
  DisplayListBuilder builder;
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
 
  // Draws the image as four squares stiched together.
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                 DlColor::kBlue(), DlColor::kYellow()};
 
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    colors.data(), /*count=*/4, DlBlendMode::kPlus,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), impeller::kB10G10R10A10XR, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), and flutter::DlColor::kYellow().

◆ TEST_P() [198/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvanced
	)

Definition at line 72 of file aiks_dl_atlas_unittests.cc.

                                             {
  DisplayListBuilder builder;
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                 DlColor::kBlue(), DlColor::kYellow()};
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    colors.data(), /*count=*/4, DlBlendMode::kModulate,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [199/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorAdvancedAndTransform
	)

Definition at line 151 of file aiks_dl_atlas_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  // Draws the image as four squares stiched together.
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                 DlColor::kBlue(), DlColor::kYellow()};
 
  builder.Scale(0.25, 0.25);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    colors.data(), /*count=*/4, DlBlendMode::kModulate,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [200/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorBurn
	)

Definition at line 330 of file aiks_dl_atlas_unittests.cc.

                                         {
  DisplayListBuilder builder;
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors = {DlColor::kDarkGrey(), DlColor::kBlack(),
                                 DlColor::kLightGrey(), DlColor::kWhite()};
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    colors.data(), /*count=*/4, DlBlendMode::kColorBurn,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DlColor::kBlack(), flutter::DlColor::kDarkGrey(), flutter::DlColor::kLightGrey(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [201/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithColorSimple
	)

Definition at line 87 of file aiks_dl_atlas_unittests.cc.

                                           {
  DisplayListBuilder builder;
  // Draws the image as four squares stiched together.
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kGreen(),
                                 DlColor::kBlue(), DlColor::kYellow()};
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    colors.data(), /*count=*/4, DlBlendMode::kSrcATop,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [202/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawAtlasWithOpacity
	)

Definition at line 103 of file aiks_dl_atlas_unittests.cc.

                                       {
  DisplayListBuilder builder;
  // Draws the image as four squares stiched together slightly
  // opaque
  auto [texture_coordinates, transforms, atlas] = CreateTestData(this);
 
  DlPaint paint;
  paint.setAlpha(128);
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawAtlas(atlas, transforms.data(), texture_coordinates.data(),
                    /*colors=*/nullptr, 4, DlBlendMode::kSrcOver,
                    DlImageSampling::kNearestNeighbor, /*cullRect=*/nullptr,
                    &paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawAtlas(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setAlpha(), x, and y.

◆ TEST_P() [203/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectSrcOutsideBounds
	)

Definition at line 305 of file aiks_dl_basic_unittests.cc.

                                                {
  DisplayListBuilder builder;
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
 
  // Use a source rect that is partially outside the bounds of the image.
  auto source_rect = DlRect::MakeXYWH(
      image->GetSize().width * 0.25f, image->GetSize().height * 0.4f,
      image->GetSize().width, image->GetSize().height);
 
  auto dest_rect = DlRect::MakeXYWH(100, 100, 600, 600);
 
  DlPaint paint;
  paint.setColor(DlColor::kMidGrey());
  builder.DrawRect(dest_rect, paint);
 
  builder.DrawImageRect(image, source_rect, dest_rect,
                        DlImageSampling::kNearestNeighbor);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawRect(), image, flutter::DlColor::kMidGrey(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColor().

◆ TEST_P() [204/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectWithBlendColorFilter
	)

Definition at line 265 of file aiks_dl_atlas_unittests.cc.

                                                    {
  sk_sp<DlImageImpeller> texture =
      DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
 
  DisplayListBuilder builder;
  DlPaint paint = DlPaint().setColorFilter(DlColorFilter::MakeBlend(
      DlColor::kRed().withAlphaF(0.4), DlBlendMode::kSrcOver));
 
  DlMatrix filter_matrix = DlMatrix();
  auto filter = flutter::DlMatrixImageFilter(filter_matrix,
                                             flutter::DlImageSampling::kLinear);
  DlPaint paint_with_filter = paint;
  paint_with_filter.setImageFilter(&filter);
 
  // Compare porter-duff blend modes.
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  // Uses image filter to disable atlas conversion.
  builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                        DlRect::MakeLTRB(0, 0, 500, 500), {},
                        &paint_with_filter);
 
  // Uses atlas conversion.
  builder.Translate(600, 0);
  builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                        DlRect::MakeLTRB(0, 0, 500, 500), {}, &paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::kLinear, flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setImageFilter(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [205/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawImageRectWithMatrixColorFilter
	)

Definition at line 294 of file aiks_dl_atlas_unittests.cc.

                                                     {
  sk_sp<DlImageImpeller> texture =
      DlImageImpeller::Make(CreateTextureForFixture("bay_bridge.jpg"));
 
  DisplayListBuilder builder;
  static const constexpr ColorMatrix kColorInversion = {
      .array = {
          -1.0, 0,    0,    1.0, 0,  //
          0,    -1.0, 0,    1.0, 0,  //
          0,    0,    -1.0, 1.0, 0,  //
          1.0,  1.0,  1.0,  1.0, 0   //
      }};
  DlPaint paint = DlPaint().setColorFilter(
      DlColorFilter::MakeMatrix(kColorInversion.array));
 
  DlMatrix filter_matrix = DlMatrix();
  auto filter = flutter::DlMatrixImageFilter(filter_matrix,
                                             flutter::DlImageSampling::kLinear);
  DlPaint paint_with_filter = paint;
  paint_with_filter.setImageFilter(&filter);
 
  // Compare inverting color matrix filter.
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
  // Uses image filter to disable atlas conversion.
  builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                        DlRect::MakeLTRB(0, 0, 500, 500), {},
                        &paint_with_filter);
 
  // Uses atlas conversion.
  builder.Translate(600, 0);
  builder.DrawImageRect(texture, DlRect::MakeSize(texture->GetSize()),
                        DlRect::MakeLTRB(0, 0, 500, 500), {}, &paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::ColorMatrix::array, flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawPaint(), impeller::kColorInversion, flutter::kLinear, flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorFilter::MakeMatrix(), impeller::TRect< Scalar >::MakeSize(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setImageFilter(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [206/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesRenderCorrectly
	)

Definition at line 600 of file aiks_dl_path_unittests.cc.

                                           {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  paint.setStrokeWidth(10);
 
  auto draw = [&builder](DlPaint& paint) {
    for (auto cap :
         {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
      paint.setStrokeCap(cap);
      DlPoint origin = {100, 100};
      builder.DrawLine(DlPoint(150, 100), DlPoint(250, 100), paint);
      for (int d = 15; d < 90; d += 15) {
        Matrix m = Matrix::MakeRotationZ(Degrees(d));
        Point origin = {100, 100};
        Point p0 = {50, 0};
        Point p1 = {150, 0};
        auto a = origin + m * p0;
        auto b = origin + m * p1;
 
        builder.DrawLine(a, b, paint);
      }
      builder.DrawLine(DlPoint(100, 150), DlPoint(100, 250), paint);
      builder.DrawCircle(origin, 35, paint);
 
      builder.DrawLine(DlPoint(250, 250), DlPoint(250, 250), paint);
 
      builder.Translate(250, 0);
    }
    builder.Translate(-750, 250);
  };
 
  std::vector<DlColor> colors = {
      DlColor::ARGB(1, 0x1f / 255.0, 0.0, 0x5c / 255.0),
      DlColor::ARGB(1, 0x5b / 255.0, 0.0, 0x60 / 255.0),
      DlColor::ARGB(1, 0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0),
      DlColor::ARGB(1, 0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0),
      DlColor::ARGB(1, 0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0),
      DlColor::ARGB(1, 0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0),
      DlColor::ARGB(1, 0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0)};
  std::vector<Scalar> stops = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
 
  auto texture = DlImageImpeller::Make(
      CreateTextureForFixture("airplane.jpg",
                              /*enable_mipmapping=*/true));
 
  draw(paint);
 
  paint.setColorSource(DlColorSource::MakeRadial({100, 100}, 200, stops.size(),
                                                 colors.data(), stops.data(),
                                                 DlTileMode::kMirror));
  draw(paint);
 
  DlMatrix matrix = DlMatrix::MakeTranslation({-150, 75});
  paint.setColorSource(DlColorSource::MakeImage(
      texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kMipmapLinear, &matrix));
  draw(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), d, flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawLine(), flutter::DlColor::kBlue(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeRadial(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), p1, flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), texture, flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [207/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesWithDrawLine
	)

Definition at line 355 of file aiks_dl_path_unittests.cc.

                                        {
  DrawLinesTest(this, [](DisplayListBuilder& builder, const DlPaint& paint,
                         Point p0, Point p1, Scalar width) {
    DlPaint stroke_paint = paint;
    stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
    stroke_paint.setStrokeWidth(width);
    builder.DrawLine(p0, p1, stroke_paint);
  });
}

References flutter::DisplayListBuilder::DrawLine(), p1, flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and width.

◆ TEST_P() [208/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesWithFilledRects
	)

Definition at line 365 of file aiks_dl_path_unittests.cc.

                                           {
  DrawLinesTest(this, [](DisplayListBuilder& builder, const DlPaint& paint,
                         Point p0, Point p1, Scalar width) {
    DlPaint fill_paint = paint;
    fill_paint.setDrawStyle(DlDrawStyle::kFill);
    Scalar length = p0.GetDistance(p1);
    Point center = {(p0.x + p1.x) * 0.5f, (p0.y + p1.y) * 0.5f};
    builder.DrawRect(
        DlRect::MakeEllipseBounds(center, Size(length, width) * 0.5f),
        fill_paint);
  });
}

References flutter::DisplayListBuilder::DrawRect(), length, impeller::TRect< Scalar >::MakeEllipseBounds(), p1, flutter::DlPaint::setDrawStyle(), width, flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [209/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesWithFilledRoundRects
	)

Definition at line 378 of file aiks_dl_path_unittests.cc.

                                                {
  DrawLinesTest(this, [](DisplayListBuilder& builder, const DlPaint& paint,
                         Point p0, Point p1, Scalar width) {
    DlPaint fill_paint = paint;
    fill_paint.setDrawStyle(DlDrawStyle::kFill);
    Scalar length = p0.GetDistance(p1);
    Point center = {(p0.x + p1.x) * 0.5f, (p0.y + p1.y) * 0.5f};
    builder.DrawRoundRect(
        DlRoundRect::MakeRectRadius(
            DlRect::MakeEllipseBounds(center, Size(length, width) * 0.5f),
            width * 0.5f),
        fill_paint);
  });
}

References flutter::DisplayListBuilder::DrawRoundRect(), length, impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::RoundRect::MakeRectRadius(), p1, flutter::DlPaint::setDrawStyle(), width, flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [210/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawLinesWithPath
	)

Definition at line 342 of file aiks_dl_path_unittests.cc.

                                    {
  DrawLinesTest(this, [](DisplayListBuilder& builder, const DlPaint& paint,
                         Point p0, Point p1, Scalar width) {
    DlPaint stroke_paint = paint;
    stroke_paint.setDrawStyle(DlDrawStyle::kStroke);
    stroke_paint.setStrokeWidth(width);
    DlPathBuilder path_builder;
    path_builder.MoveTo(p0);
    path_builder.LineTo(p1);
    builder.DrawPath(path_builder.TakePath(), stroke_paint);
  });
}

References flutter::DisplayListBuilder::DrawPath(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), p1, flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and width.

◆ TEST_P() [211/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawOpacityPeephole
	)

Definition at line 18 of file aiks_dl_opacity_unittests.cc.

                                      {
  DisplayListBuilder builder;
 
  DlPaint green;
  green.setColor(DlColor::kGreen().modulateOpacity(0.5));
 
  DlPaint alpha;
  alpha.setColor(DlColor::kRed().modulateOpacity(0.5));
 
  builder.SaveLayer(std::nullopt, &alpha);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), green);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [212/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintTransformsBounds
	)

Definition at line 86 of file aiks_dl_runtime_effect_unittests.cc.

                                            {
  struct FragUniforms {
    Size size;
  } frag_uniforms = {.size = Size::MakeWH(400, 400)};
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  DlPaint paint;
  auto effect = MakeRuntimeEffect(this, "gradient.frag.iplr", uniform_data);
  ABSL_ASSERT_OK(effect);
  paint.setColorSource(effect.value());
 
  DisplayListBuilder builder;
  builder.Save();
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawPaint(paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), impeller::TSize< Scalar >::MakeWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), flutter::size, x, and y.

◆ TEST_P() [213/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawPaintWithAdvancedBlendOverFilter
	)

Definition at line 125 of file aiks_dl_blend_unittests.cc.

                                                       {
  DlPaint paint;
  paint.setColor(DlColor::kBlack());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 60));
 
  DisplayListBuilder builder;
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
  paint.setColor(DlColor::kBlack());
  builder.DrawCircle(DlPoint(300, 300), 200, paint);
  paint.setColor(DlColor::kGreen());
  paint.setBlendMode(DlBlendMode::kScreen);
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [214/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesRenderCorrectly
	)

Definition at line 672 of file aiks_dl_path_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(10);
 
  builder.Translate(100, 100);
  builder.DrawPath(DlPath::MakeRect(DlRect::MakeSize(DlSize(100, 100))), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeSize(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [215/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawRectStrokesWithBevelJoinRenderCorrectly
	)

Definition at line 685 of file aiks_dl_path_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(10);
  paint.setStrokeJoin(DlStrokeJoin::kBevel);
 
  builder.Translate(100, 100);
  builder.DrawPath(DlPath::MakeRect(DlRect::MakeSize(DlSize(100, 100))), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeSize(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [216/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveNoSaveLayer
	)

Definition at line 520 of file aiks_dl_text_unittests.cc.

                                                           {
  DisplayListBuilder builder;
 
  Matrix matrix = Matrix(1.0, 0.0, 0.0, 0.0,    //
                         0.0, 1.0, 0.0, 0.0,    //
                         0.0, 0.0, 1.0, 0.01,   //
                         0.0, 0.0, 0.0, 1.0) *  //
                  Matrix::MakeRotationY({Degrees{10}});
 
  builder.Transform(matrix);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                     "Roboto-Regular.ttf"));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), impeller::Matrix::MakeRotationY(), RenderTextInCanvasSkia(), and flutter::DisplayListBuilder::Transform().

◆ TEST_P() [217/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawScaledTextWithPerspectiveSaveLayer
	)

Definition at line 536 of file aiks_dl_text_unittests.cc.

                                                         {
  DisplayListBuilder builder;
 
  Matrix matrix = Matrix(1.0, 0.0, 0.0, 0.0,    //
                         0.0, 1.0, 0.0, 0.0,    //
                         0.0, 0.0, 1.0, 0.01,   //
                         0.0, 0.0, 0.0, 1.0) *  //
                  Matrix::MakeRotationY({Degrees{10}});
 
  DlPaint save_paint;
  DlRect window_bounds =
      DlRect::MakeXYWH(0, 0, GetWindowSize().width, GetWindowSize().height);
  // Note: bounds were not needed by the AIKS version, which may indicate a bug.
  builder.SaveLayer(window_bounds, &save_paint);
  builder.Transform(matrix);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(GetContext(), builder, "Hello world",
                                     "Roboto-Regular.ttf"));
 
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), height, impeller::Matrix::MakeRotationY(), impeller::TRect< Scalar >::MakeXYWH(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Transform(), and width.

◆ TEST_P() [218/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseCircle
	)

Definition at line 429 of file aiks_dl_shadow_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  // A weight of sqrt(2) is how you really perform conic circular sections,
  // but by tweaking it slightly the path will not be recognized as an oval
  // and accelerated.
  constexpr Scalar kWeight = kSqrt2Over2 - 0.0005f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.ConicCurveTo(DlPoint(300, 100), DlPoint(300, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 300), DlPoint(200, 300), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 300), DlPoint(100, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 100), DlPoint(200, 100), kWeight);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeCircle(DlPoint(200, 200), 100);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), impeller::kSqrt2Over2, flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [219/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseConic
	)

Definition at line 715 of file aiks_dl_shadow_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.ConicCurveTo(DlPoint(300, 100), DlPoint(300, 200), 0.4f);
  path_builder.ConicCurveTo(DlPoint(300, 300), DlPoint(200, 300), 0.4f);
  path_builder.ConicCurveTo(DlPoint(100, 300), DlPoint(100, 200), 0.4f);
  path_builder.ConicCurveTo(DlPoint(100, 100), DlPoint(200, 100), 0.4f);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [220/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseCubic
	)

Definition at line 759 of file aiks_dl_shadow_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.CubicCurveTo(DlPoint(280, 100), DlPoint(300, 120),
                            DlPoint(300, 200));
  path_builder.CubicCurveTo(DlPoint(300, 280), DlPoint(280, 300),
                            DlPoint(200, 300));
  path_builder.CubicCurveTo(DlPoint(120, 300), DlPoint(100, 280),
                            DlPoint(100, 200));
  path_builder.CubicCurveTo(DlPoint(100, 120), DlPoint(120, 100),
                            DlPoint(200, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [221/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseMultiRadiiRoundRect
	)

Definition at line 615 of file aiks_dl_shadow_unittests.cc.

                                                                    {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlRoundingRadii radii = DlRoundingRadii{
      .top_left = {80, 60},
      .top_right = {20, 25},
      .bottom_left = {60, 80},
      .bottom_right = {25, 20},
  };
  DlPath path = MakeAlmostRoundRectPath(DlRect::MakeLTRB(100, 100, 300, 300),
                                        radii, true);
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, flutter::DisplayListBuilder::Scale(), impeller::RoundingRadii::top_left, x, and y.

◆ TEST_P() [222/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseOctagon
	)

Definition at line 811 of file aiks_dl_shadow_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 125));
  path_builder.LineTo(DlPoint(125, 100));
  path_builder.LineTo(DlPoint(275, 100));
  path_builder.LineTo(DlPoint(300, 125));
  path_builder.LineTo(DlPoint(300, 275));
  path_builder.LineTo(DlPoint(275, 300));
  path_builder.LineTo(DlPoint(125, 300));
  path_builder.LineTo(DlPoint(100, 275));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [223/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseOval
	)

Definition at line 497 of file aiks_dl_shadow_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  // A weight of sqrt(2) is how you really perform conic circular sections,
  // but by tweaking it slightly the path will not be recognized as an oval
  // and accelerated.
  constexpr Scalar kWeight = kSqrt2Over2 - 0.0005f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 120));
  path_builder.ConicCurveTo(DlPoint(300, 120), DlPoint(300, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 280), DlPoint(200, 280), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 280), DlPoint(100, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 120), DlPoint(200, 120), kWeight);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeOvalLTRB(100, 120, 300, 280);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), impeller::kSqrt2Over2, flutter::DlColor::kWhite(), flutter::DlPath::MakeOvalLTRB(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [224/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseQuadratic
	)

Definition at line 671 of file aiks_dl_shadow_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.QuadraticCurveTo(DlPoint(300, 100), DlPoint(300, 200));
  path_builder.QuadraticCurveTo(DlPoint(300, 300), DlPoint(200, 300));
  path_builder.QuadraticCurveTo(DlPoint(100, 300), DlPoint(100, 200));
  path_builder.QuadraticCurveTo(DlPoint(100, 100), DlPoint(200, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [225/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseRect
	)

Definition at line 369 of file aiks_dl_shadow_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  // Tweak one corner by a sub-pixel amount to prevent recognition as
  // a rectangle, but still generating a rectangular shadow.
  path_builder.LineTo(DlPoint(299.9, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeRectLTRB(100, 100, 300, 300);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPath::MakeRectLTRB(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [226/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseTriangle
	)

Definition at line 329 of file aiks_dl_shadow_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [227/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseUniformRoundRect
	)

Definition at line 565 of file aiks_dl_shadow_unittests.cc.

                                                                 {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPath path = MakeAlmostRoundRectPath(DlRect::MakeLTRB(100, 100, 300, 300),
                                        DlRoundingRadii::MakeRadius(30), true);
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const RoundRect round_rect =
      RoundRect::MakeRectRadius(Rect::MakeLTRB(100, 100, 300, 300), 30);
  const DlPath simple_path = DlPath::MakeRoundRect(round_rect);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadius(), impeller::RoundRect::MakeRectRadius(), flutter::DlPath::MakeRoundRect(), flutter::path, flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [228/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeClockwiseWithExtraColinearVertices
	)

Definition at line 886 of file aiks_dl_shadow_unittests.cc.

                                                                          {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(250, 200));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.LineTo(DlPoint(150, 200));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [229/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseCircle
	)

Definition at line 463 of file aiks_dl_shadow_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  // A weight of sqrt(2)/2 is how you really perform conic circular sections,
  // but by tweaking it slightly the path will not be recognized as an oval
  // and accelerated.
  constexpr Scalar kWeight = kSqrt2Over2 - 0.0005f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.ConicCurveTo(DlPoint(100, 100), DlPoint(100, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 300), DlPoint(200, 300), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 300), DlPoint(300, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 100), DlPoint(200, 100), kWeight);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeCircle(DlPoint(200, 200), 100);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), impeller::kSqrt2Over2, flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [230/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseConic
	)

Definition at line 737 of file aiks_dl_shadow_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.ConicCurveTo(DlPoint(100, 100), DlPoint(100, 200), 0.4f);
  path_builder.ConicCurveTo(DlPoint(100, 300), DlPoint(200, 300), 0.4f);
  path_builder.ConicCurveTo(DlPoint(300, 300), DlPoint(300, 200), 0.4f);
  path_builder.ConicCurveTo(DlPoint(300, 100), DlPoint(200, 100), 0.4f);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [231/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseCubic
	)

Definition at line 785 of file aiks_dl_shadow_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.CubicCurveTo(DlPoint(120, 100), DlPoint(100, 120),
                            DlPoint(100, 200));
  path_builder.CubicCurveTo(DlPoint(100, 280), DlPoint(120, 300),
                            DlPoint(200, 300));
  path_builder.CubicCurveTo(DlPoint(280, 300), DlPoint(300, 280),
                            DlPoint(300, 200));
  path_builder.CubicCurveTo(DlPoint(300, 120), DlPoint(280, 100),
                            DlPoint(200, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::CubicCurveTo(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [232/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseMultiRadiiRoundRect
	)

Definition at line 643 of file aiks_dl_shadow_unittests.cc.

                                                                           {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlRoundingRadii radii = DlRoundingRadii{
      .top_left = {80, 60},
      .top_right = {20, 25},
      .bottom_left = {60, 80},
      .bottom_right = {25, 20},
  };
  DlPath path = MakeAlmostRoundRectPath(DlRect::MakeLTRB(100, 100, 300, 300),
                                        radii, false);
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, flutter::DisplayListBuilder::Scale(), impeller::RoundingRadii::top_left, x, and y.

◆ TEST_P() [233/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseOctagon
	)

Definition at line 836 of file aiks_dl_shadow_unittests.cc.

                                                               {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 125));
  path_builder.LineTo(DlPoint(100, 275));
  path_builder.LineTo(DlPoint(125, 300));
  path_builder.LineTo(DlPoint(275, 300));
  path_builder.LineTo(DlPoint(300, 275));
  path_builder.LineTo(DlPoint(300, 125));
  path_builder.LineTo(DlPoint(275, 100));
  path_builder.LineTo(DlPoint(125, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [234/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseOval
	)

Definition at line 531 of file aiks_dl_shadow_unittests.cc.

                                                            {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  // A weight of sqrt(2)/2 is how you really perform conic circular sections,
  // but by tweaking it slightly the path will not be recognized as an oval
  // and accelerated.
  constexpr Scalar kWeight = kSqrt2Over2 - 0.0005f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 120));
  path_builder.ConicCurveTo(DlPoint(100, 120), DlPoint(100, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(100, 280), DlPoint(200, 280), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 280), DlPoint(300, 200), kWeight);
  path_builder.ConicCurveTo(DlPoint(300, 120), DlPoint(200, 120), kWeight);
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeOvalLTRB(100, 120, 300, 280);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlPathBuilder::ConicCurveTo(), impeller::kSqrt2Over2, flutter::DlColor::kWhite(), flutter::DlPath::MakeOvalLTRB(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [235/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseQuadratic
	)

Definition at line 693 of file aiks_dl_shadow_unittests.cc.

                                                                 {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.QuadraticCurveTo(DlPoint(100, 100), DlPoint(100, 200));
  path_builder.QuadraticCurveTo(DlPoint(100, 300), DlPoint(200, 300));
  path_builder.QuadraticCurveTo(DlPoint(300, 300), DlPoint(300, 200));
  path_builder.QuadraticCurveTo(DlPoint(300, 100), DlPoint(200, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [236/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseRect
	)

Definition at line 399 of file aiks_dl_shadow_unittests.cc.

                                                            {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.LineTo(DlPoint(300, 300));
  // Tweak one corner by a sub-pixel amount to prevent recognition as
  // a rectangle, but still generating a rectangular shadow.
  path_builder.LineTo(DlPoint(299.9, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const DlPath simple_path = DlPath::MakeRectLTRB(100, 100, 300, 300);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPath::MakeRectLTRB(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [237/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseTriangle
	)

Definition at line 349 of file aiks_dl_shadow_unittests.cc.

                                                                {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [238/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseUniformRoundRect
	)

Definition at line 590 of file aiks_dl_shadow_unittests.cc.

                                                                        {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPath path = MakeAlmostRoundRectPath(DlRect::MakeLTRB(100, 100, 300, 300),
                                        DlRoundingRadii::MakeRadius(30), false);
 
  // Path must be convex, but unrecognizable as a simple shape.
  ASSERT_TRUE(path.IsConvex());
  ASSERT_FALSE(path.IsRect());
  ASSERT_FALSE(path.IsOval());
  ASSERT_FALSE(path.IsRoundRect());
 
  const RoundRect round_rect =
      RoundRect::MakeRectRadius(Rect::MakeLTRB(100, 100, 300, 300), 30);
  const DlPath simple_path = DlPath::MakeRoundRect(round_rect);
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr, &simple_path);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundingRadii::MakeRadius(), impeller::RoundRect::MakeRectRadius(), flutter::DlPath::MakeRoundRect(), flutter::path, flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [239/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeCounterClockwiseWithExtraColinearVertices
	)

Definition at line 909 of file aiks_dl_shadow_unittests.cc.

                                                                       {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(150, 200));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(250, 200));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [240/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowCanOptimizeWithExtraneousMoveTos
	)

Definition at line 861 of file aiks_dl_shadow_unittests.cc.

                                                             {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 0));
  path_builder.MoveTo(DlPoint(1000, 1000));
  path_builder.MoveTo(DlPoint(100, 50));
  path_builder.MoveTo(DlPoint(200, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.Close();
  path_builder.MoveTo(DlPoint(1000, 1000));
  path_builder.MoveTo(DlPoint(500, 300));
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [241/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowDoesNotOptimizeHourglass
	)

Definition at line 234 of file aiks_dl_shadow_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.LineTo(DlPoint(300, 100));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [242/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowDoesNotOptimizeInnerOuterSpiral
	)

Definition at line 255 of file aiks_dl_shadow_unittests.cc.

                                                            {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(300, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = (k2Pi * i) / step_count;
    Scalar radius = 80.0f + std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), i, impeller::k2Pi, flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [243/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowDoesNotOptimizeMultipleContours
	)

Definition at line 305 of file aiks_dl_shadow_unittests.cc.

                                                            {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(150, 100));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.LineTo(DlPoint(100, 300));
  path_builder.Close();
  path_builder.MoveTo(DlPoint(250, 100));
  path_builder.LineTo(DlPoint(300, 300));
  path_builder.LineTo(DlPoint(200, 300));
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [244/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawShadowDoesNotOptimizeOuterInnerSpiral
	)

Definition at line 280 of file aiks_dl_shadow_unittests.cc.

                                                            {
  DisplayListBuilder builder;
  builder.Clear(DlColor::kWhite());
  builder.Scale(GetContentScale().x, GetContentScale().y);
  Scalar dpr = std::max(GetContentScale().x, GetContentScale().y);
  Scalar elevation = 30.0f;
  int step_count = 20;
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(280, 200));
  for (int i = 1; i < step_count * 2; i++) {
    Scalar angle = (k2Pi * i) / step_count;
    Scalar radius = 100.0f - std::abs(i - step_count);
    path_builder.LineTo(DlPoint(200, 200) + DlPoint(std::cos(angle) * radius,
                                                    std::sin(angle) * radius));
  }
  path_builder.Close();
  DlPath path = path_builder.TakePath();
 
  DrawShadowAndCompareMeshes(builder, path, elevation, dpr);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DlPathBuilder::Close(), i, impeller::k2Pi, flutter::DlColor::kWhite(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [245/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawThinStrokedCircle
	)

Definition at line 734 of file aiks_dl_basic_unittests.cc.

                                        {
  auto callback = [&]() {
    static float stroked_radius = 100.0;
    static float stroke_width = 0.0;
    static float stroke_width_fine = 2.0;
    static float stroked_alpha = 255.0;
    static float stroked_scale[2] = {1.0, 1.0};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Stroked Radius", &stroked_radius, 0, 500);
      ImGui::SliderFloat("Stroked Width", &stroke_width, 0, 500);
      ImGui::SliderFloat("Stroked Width Fine", &stroke_width_fine, 0, 5);
      ImGui::SliderFloat("Stroked Alpha", &stroked_alpha, 0, 10.0);
      ImGui::SliderFloat2("Stroked Scale", stroked_scale, 0, 10.0);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
 
    DlPaint background_paint;
    background_paint.setColor(DlColor(1, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background_paint);
 
    flutter::DlPaint paint;
 
    paint.setColor(flutter::DlColor::kRed().withAlpha(stroked_alpha));
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setStrokeWidth(stroke_width + stroke_width_fine);
    builder.Save();
    builder.Translate(250, 250);
    builder.Scale(stroked_scale[0], stroked_scale[1]);
    builder.Translate(-250, -250);
    builder.DrawCircle(DlPoint(250, 250), stroked_radius, paint);
    builder.Restore();
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kRed(), flutter::kStroke, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [246/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinates
	)

Definition at line 273 of file aiks_dl_vertices_unittests.cc.

                                                                {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  auto dl_image = DlImageImpeller::Make(texture);
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
  };
  std::vector<DlPoint> texture_coordinates = {
      DlPoint(0, 0),
      DlPoint(100, 200),
      DlPoint(200, 100),
  };
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, 3, positions.data(),
      texture_coordinates.data(), /*colors=*/nullptr);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  auto image_source = flutter::DlColorSource::MakeImage(
      dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
 
  paint.setColorSource(image_source);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::kRepeat, flutter::kTriangles, flutter::DlVertices::Make(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlPaint::setColorSource(), and texture.

◆ TEST_P() [247/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesImageSourceWithTextureCoordinatesAndColorBlending
	)

Definition at line 303 of file aiks_dl_vertices_unittests.cc.

                                                                      {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  auto dl_image = DlImageImpeller::Make(texture);
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
  };
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kWhite(),
                                          flutter::DlColor::kGreen(),
                                          flutter::DlColor::kWhite()};
  std::vector<DlPoint> texture_coordinates = {
      DlPoint(0, 0),
      DlPoint(100, 200),
      DlPoint(200, 100),
  };
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, 3, positions.data(),
      texture_coordinates.data(), colors.data());
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  auto image_source = flutter::DlColorSource::MakeImage(
      dl_image, flutter::DlTileMode::kRepeat, flutter::DlTileMode::kRepeat);
 
  paint.setColorSource(image_source);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kModulate, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kGreen(), flutter::kRepeat, flutter::kTriangles, flutter::DlColor::kWhite(), flutter::DlVertices::Make(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlPaint::setColorSource(), and texture.

◆ TEST_P() [248/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithEmptySize
	)

Definition at line 286 of file canvas_unittests.cc.

                                                          {
  RenderCallback callback = [&](RenderTarget& render_target) {
    ContentContext& context = GetContentContext();
    Canvas canvas(context, render_target, true, false);
 
    std::vector<flutter::DlPoint> vertex_coordinates = {
        flutter::DlPoint(0, 0),
        flutter::DlPoint(600, 0),
        flutter::DlPoint(0, 600),
    };
    std::vector<flutter::DlPoint> texture_coordinates = {
        flutter::DlPoint(0, 0),
        flutter::DlPoint(500, 0),
        flutter::DlPoint(0, 500),
    };
    std::vector<uint16_t> indices = {0, 1, 2};
    flutter::DlVertices::Builder vertices_builder(
        flutter::DlVertexMode::kTriangleStrip, vertex_coordinates.size(),
        flutter::DlVertices::Builder::kHasTextureCoordinates, indices.size());
    vertices_builder.store_vertices(vertex_coordinates.data());
    vertices_builder.store_indices(indices.data());
    vertices_builder.store_texture_coordinates(texture_coordinates.data());
    auto vertices = vertices_builder.build();
 
    // The start and end points of the gradient form an empty rectangle.
    std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                            flutter::DlColor::kRed()};
    std::vector<Scalar> stops = {0.0, 1.0};
    auto gradient = flutter::DlColorSource::MakeLinear(
        {0, 0}, {0, 600}, 2, colors.data(), stops.data(),
        flutter::DlTileMode::kClamp);
 
    Paint paint;
    paint.color_source = gradient.get();
    canvas.DrawVertices(std::make_shared<DlVerticesGeometry>(vertices, context),
                        BlendMode::kSrcOver, paint);
 
    canvas.EndReplay();
    return true;
  };
 
  ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
}

References flutter::DlVertices::Builder::build(), callback, impeller::Paint::color_source, context, impeller::Canvas::DrawVertices(), impeller::Canvas::EndReplay(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlVertices::Builder::kHasTextureCoordinates, flutter::DlColor::kRed(), impeller::kSrcOver, flutter::kTriangleStrip, flutter::DlColorSource::MakeLinear(), impeller::Playground::OpenPlaygroundHere(), flutter::DlVertices::Builder::store_indices(), flutter::DlVertices::Builder::store_texture_coordinates(), and flutter::DlVertices::Builder::store_vertices().

◆ TEST_P() [249/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithoutIndices
	)

Definition at line 212 of file aiks_dl_vertices_unittests.cc.

                                                           {
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
  };
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, 3, positions.data(),
      /*texture_coordinates=*/nullptr, /*colors=*/nullptr);
 
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  const float stops[2] = {0.0, 1.0};
 
  auto linear = flutter::DlColorSource::MakeLinear(
      {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
      flutter::DlTileMode::kRepeat);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColorSource(linear);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::kRepeat, flutter::kTriangles, flutter::DlVertices::Make(), flutter::DlColorSource::MakeLinear(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [250/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesLinearGradientWithTextureCoordinates
	)

Definition at line 240 of file aiks_dl_vertices_unittests.cc.

                                                                   {
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
  };
  std::vector<DlPoint> texture_coordinates = {
      DlPoint(300, 100),
      DlPoint(100, 200),
      DlPoint(300, 300),
  };
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, 3, positions.data(),
      texture_coordinates.data(), /*colors=*/nullptr);
 
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  const float stops[2] = {0.0, 1.0};
 
  auto linear = flutter::DlColorSource::MakeLinear(
      {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
      flutter::DlTileMode::kRepeat);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColorSource(linear);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::kRepeat, flutter::kTriangles, flutter::DlVertices::Make(), flutter::DlColorSource::MakeLinear(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [251/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesPremultipliesColors
	)

Definition at line 360 of file aiks_dl_vertices_unittests.cc.

                                                  {
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
      DlPoint(200, 500),
  };
  auto color = flutter::DlColor::kBlue().withAlpha(0x99);
  std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3};
  std::vector<flutter::DlColor> colors = {color, color, color, color};
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
      /*texture_coordinates=*/nullptr, colors.data(), indices.size(),
      indices.data());
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
  paint.setColor(flutter::DlColor::kRed());
 
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kDst, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::kTriangles, flutter::DlVertices::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DlColor::withAlpha().

◆ TEST_P() [252/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithIndices
	)

Definition at line 337 of file aiks_dl_vertices_unittests.cc.

                                                             {
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
      DlPoint(200, 500),
  };
  std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3};
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
      /*texture_coordinates=*/nullptr, /*colors=*/nullptr, indices.size(),
      indices.data());
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColor(flutter::DlColor::kRed());
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kRed(), flutter::kTriangles, flutter::DlVertices::Make(), and flutter::DlPaint::setColor().

◆ TEST_P() [253/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesSolidColorTrianglesWithoutIndices
	)

Definition at line 186 of file aiks_dl_vertices_unittests.cc.

                                                                {
  // Use negative coordinates and then scale the transform by -1, -1 to make
  // sure coverage is taking the transform into account.
  std::vector<DlPoint> positions = {
      DlPoint(-100, -300),
      DlPoint(-200, -100),
      DlPoint(-300, -300),
  };
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kWhite(),
                                          flutter::DlColor::kGreen(),
                                          flutter::DlColor::kWhite()};
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, 3, positions.data(),
      /*texture_coordinates=*/nullptr, colors.data());
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColor(flutter::DlColor::kRed().modulateOpacity(0.5));
  builder.Scale(-1, -1);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::kTriangles, flutter::DlColor::kWhite(), flutter::DlVertices::Make(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setColor().

◆ TEST_P() [254/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesTextureCoordinatesWithFragmentShader
	)

Definition at line 419 of file aiks_dl_vertices_unittests.cc.

                                                                   {
  std::vector<DlPoint> positions_lt = {
      DlPoint(0, 0),    //
      DlPoint(50, 0),   //
      DlPoint(0, 50),   //
      DlPoint(50, 50),  //
  };
 
  auto vertices_lt = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleStrip, positions_lt.size(),
      positions_lt.data(),
      /*texture_coordinates=*/positions_lt.data(), /*colors=*/nullptr,
      /*index_count=*/0,
      /*indices=*/nullptr);
 
  std::vector<DlPoint> positions_rt = {
      DlPoint(50, 0),    //
      DlPoint(100, 0),   //
      DlPoint(50, 50),   //
      DlPoint(100, 50),  //
  };
 
  auto vertices_rt = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleStrip, positions_rt.size(),
      positions_rt.data(),
      /*texture_coordinates=*/positions_rt.data(), /*colors=*/nullptr,
      /*index_count=*/0,
      /*indices=*/nullptr);
 
  std::vector<DlPoint> positions_lb = {
      DlPoint(0, 50),    //
      DlPoint(50, 50),   //
      DlPoint(0, 100),   //
      DlPoint(50, 100),  //
  };
 
  auto vertices_lb = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleStrip, positions_lb.size(),
      positions_lb.data(),
      /*texture_coordinates=*/positions_lb.data(), /*colors=*/nullptr,
      /*index_count=*/0,
      /*indices=*/nullptr);
 
  std::vector<DlPoint> positions_rb = {
      DlPoint(50, 50),    //
      DlPoint(100, 50),   //
      DlPoint(50, 100),   //
      DlPoint(100, 100),  //
  };
 
  auto vertices_rb = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleStrip, positions_rb.size(),
      positions_rb.data(),
      /*texture_coordinates=*/positions_rb.data(), /*colors=*/nullptr,
      /*index_count=*/0,
      /*indices=*/nullptr);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  flutter::DlPaint rect_paint;
  rect_paint.setColor(DlColor::kBlue());
 
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_simple.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
 
  auto runtime_effect = DlRuntimeEffectImpeller::Make(runtime_stage);
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
      runtime_effect, {}, uniform_data);
 
  paint.setColorSource(color_source);
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Save();
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), rect_paint);
  builder.DrawVertices(vertices_lt, flutter::DlBlendMode::kSrcOver, paint);
  builder.DrawVertices(vertices_rt, flutter::DlBlendMode::kSrcOver, paint);
  builder.DrawVertices(vertices_lb, flutter::DlBlendMode::kSrcOver, paint);
  builder.DrawVertices(vertices_rb, flutter::DlBlendMode::kSrcOver, paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kBlue(), flutter::kTriangleStrip, flutter::DlVertices::Make(), flutter::DlRuntimeEffectImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorSource::MakeRuntimeEffect(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), x, and y.

◆ TEST_P() [255/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesTextureCoordinatesWithFragmentShaderNonZeroOrigin
	)

Definition at line 509 of file aiks_dl_vertices_unittests.cc.

                                                                      {
  std::vector<DlPoint> positions_lt = {
      DlPoint(200, 200),  //
      DlPoint(250, 200),  //
      DlPoint(200, 250),  //
      DlPoint(250, 250),  //
  };
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangleStrip, positions_lt.size(),
      positions_lt.data(),
      /*texture_coordinates=*/positions_lt.data(), /*colors=*/nullptr,
      /*index_count=*/0,
      /*indices=*/nullptr);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  flutter::DlPaint rect_paint;
  rect_paint.setColor(DlColor::kBlue());
 
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_position.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
 
  auto runtime_effect = DlRuntimeEffectImpeller::Make(runtime_stage);
  auto rect_data = std::vector<Rect>{Rect::MakeLTRB(200, 200, 250, 250)};
 
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(rect_data.size() * sizeof(Rect));
  memcpy(uniform_data->data(), rect_data.data(), uniform_data->size());
 
  auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
      runtime_effect, {}, uniform_data);
 
  paint.setColorSource(color_source);
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawRect(DlRect::MakeLTRB(200, 200, 250, 250), rect_paint);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrcOver, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlColor::kBlue(), flutter::kTriangleStrip, flutter::DlVertices::Make(), flutter::DlRuntimeEffectImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorSource::MakeRuntimeEffect(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), x, and y.

◆ TEST_P() [256/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesWithEmptyTextureCoordinates
	)

Definition at line 330 of file canvas_unittests.cc.

                                                          {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_simple.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
 
  auto runtime_effect = flutter::DlRuntimeEffectImpeller::Make(runtime_stage);
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  auto color_source = flutter::DlColorSource::MakeRuntimeEffect(
      runtime_effect, {}, uniform_data);
 
  RenderCallback callback = [&](RenderTarget& render_target) {
    ContentContext& context = GetContentContext();
    Canvas canvas(context, render_target, true, false);
 
    std::vector<flutter::DlPoint> vertex_coordinates = {
        flutter::DlPoint(100, 100),
        flutter::DlPoint(300, 100),
        flutter::DlPoint(100, 300),
    };
    // The bounding box of the texture coordinates is empty.
    std::vector<flutter::DlPoint> texture_coordinates = {
        flutter::DlPoint(0, 0),
        flutter::DlPoint(0, 100),
        flutter::DlPoint(0, 0),
    };
    std::vector<uint16_t> indices = {0, 1, 2};
    flutter::DlVertices::Builder vertices_builder(
        flutter::DlVertexMode::kTriangleStrip, vertex_coordinates.size(),
        flutter::DlVertices::Builder::kHasTextureCoordinates, indices.size());
    vertices_builder.store_vertices(vertex_coordinates.data());
    vertices_builder.store_indices(indices.data());
    vertices_builder.store_texture_coordinates(texture_coordinates.data());
    auto vertices = vertices_builder.build();
 
    Paint paint;
    paint.color_source = color_source.get();
    canvas.DrawVertices(std::make_shared<DlVerticesGeometry>(vertices, context),
                        BlendMode::kSrcOver, paint);
 
    canvas.EndReplay();
    return true;
  };
 
  ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
}

References flutter::DlVertices::Builder::build(), callback, impeller::Paint::color_source, context, impeller::Canvas::DrawVertices(), impeller::Canvas::EndReplay(), flutter::DlVertices::Builder::kHasTextureCoordinates, impeller::kSrcOver, flutter::kTriangleStrip, flutter::DlRuntimeEffectImpeller::Make(), flutter::DlColorSource::MakeRuntimeEffect(), impeller::Playground::OpenPlaygroundHere(), flutter::DlVertices::Builder::store_indices(), flutter::DlVertices::Builder::store_texture_coordinates(), and flutter::DlVertices::Builder::store_vertices().

◆ TEST_P() [257/662]

impeller::testing::TEST_P	(	AiksTest	,
		DrawVerticesWithInvalidIndices
	)

Definition at line 387 of file aiks_dl_vertices_unittests.cc.

                                                 {
  std::vector<DlPoint> positions = {
      DlPoint(100, 300),
      DlPoint(200, 100),
      DlPoint(300, 300),
      DlPoint(200, 500),
  };
  std::vector<uint16_t> indices = {0, 1, 2, 0, 2, 3, 99, 100, 101};
 
  auto vertices = flutter::DlVertices::Make(
      flutter::DlVertexMode::kTriangles, positions.size(), positions.data(),
      /*texture_coordinates=*/nullptr, /*colors=*/nullptr, indices.size(),
      indices.data());
 
  EXPECT_EQ(vertices->GetBounds(), DlRect::MakeLTRB(100, 100, 300, 500));
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
  paint.setColor(flutter::DlColor::kRed());
 
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 400), paint);
  builder.DrawVertices(vertices, flutter::DlBlendMode::kSrc, paint);
 
  AiksContext renderer(GetContext(), nullptr);
  std::shared_ptr<Texture> image =
      DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
  EXPECT_TRUE(image);
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawVertices(), image, flutter::DlColor::kRed(), flutter::kTriangles, flutter::DlVertices::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [258/662]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerIgnoresPaint
	)

Definition at line 1853 of file aiks_dl_basic_unittests.cc.

                                             {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawPaint(paint);
  builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
  paint.setColor(DlColor::kBlue());
  builder.SaveLayer(std::nullopt, &paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [259/662]

impeller::testing::TEST_P	(	AiksTest	,
		EmptySaveLayerRendersWithClear
	)

Definition at line 1868 of file aiks_dl_basic_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  builder.DrawImage(image, DlPoint(10, 10), {});
  builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
 
  DlPaint paint;
  paint.setBlendMode(DlBlendMode::kClear);
  builder.SaveLayer(std::nullopt, &paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImage(), image, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), x, and y.

◆ TEST_P() [260/662]

impeller::testing::TEST_P	(	AiksTest	,
		EmulatedAdvancedBlendRestore
	)

Definition at line 937 of file aiks_dl_blend_unittests.cc.

                                               {
  DisplayListBuilder builder;
 
  builder.DrawPaint(DlPaint(DlColor::kWhite()));
  builder.Save();
  builder.ClipRect(DlRect::MakeLTRB(100, 100, 400, 300));
 
  // Draw should apply the clip, even though it is an advanced blend.
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 300),
                   DlPaint()
                       .setColor(DlColor::kRed())
                       .setBlendMode(DlBlendMode::kDifference));
  // This color should not show if clip is still functional.
  builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100),
                   DlPaint().setColor(DlColor::kBlue()));
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Restore(), and flutter::DisplayListBuilder::Save().

◆ TEST_P() [261/662]

impeller::testing::TEST_P	(	AiksTest	,
		FastEllipticalRRectMaskBlursRenderCorrectly
	)

Definition at line 2276 of file aiks_dl_basic_unittests.cc.

                                                              {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1));
 
  DlPaint save_paint;
  save_paint.setColor(DlColor::kWhite());
  builder.DrawPaint(save_paint);
 
  paint.setColor(DlColor::kBlue());
  for (int i = 0; i < 5; i++) {
    Scalar y = i * 125;
    Scalar y_radius = i * 15;
    for (int j = 0; j < 5; j++) {
      Scalar x = j * 125;
      Scalar x_radius = j * 15;
      builder.DrawRoundRect(
          DlRoundRect::MakeRectXY(
              DlRect::MakeXYWH(x + 50, y + 50, 100.0f, 100.0f),  //
              x_radius, y_radius),
          paint);
    }
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRoundRect(), i, flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), x, and y.

◆ TEST_P() [262/662]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontal
	)

Definition at line 845 of file aiks_dl_gradient_unittests.cc.

                                             {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                 DlColor::kGreen()};
  std::vector<Scalar> stops = {0.0, 0.1, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {300, 0}, stops.size(),
                                                 colors.data(), stops.data(),
                                                 DlTileMode::kClamp));
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [263/662]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestHorizontalReversed
	)

Definition at line 891 of file aiks_dl_gradient_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                 DlColor::kGreen()};
  std::vector<Scalar> stops = {0.0, 0.1, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear({300, 0}, {0, 0}, stops.size(),
                                                 colors.data(), stops.data(),
                                                 DlTileMode::kClamp));
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [264/662]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVertical
	)

Definition at line 868 of file aiks_dl_gradient_unittests.cc.

                                           {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                 DlColor::kGreen()};
  std::vector<Scalar> stops = {0.0, 0.1, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {0, 300}, stops.size(),
                                                 colors.data(), stops.data(),
                                                 DlTileMode::kClamp));
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [265/662]

impeller::testing::TEST_P	(	AiksTest	,
		FastGradientTestVerticalReversed
	)

Definition at line 914 of file aiks_dl_gradient_unittests.cc.

                                                   {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                 DlColor::kGreen()};
  std::vector<Scalar> stops = {0.0, 0.1, 1.0};
 
  paint.setColorSource(DlColorSource::MakeLinear({0, 300}, {0, 0}, stops.size(),
                                                 colors.data(), stops.data(),
                                                 DlTileMode::kClamp));
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [266/662]

impeller::testing::TEST_P	(	AiksTest	,
		FatStrokeArc
	)

Definition at line 763 of file aiks_dl_path_unittests.cc.

                               {
  DlScalar stroke_width = 300;
  DlScalar aspect = 1.0;
  DlScalar start_angle = 0;
  DlScalar end_angle = 90;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Stroke Width", &stroke_width, 1, 300);
      ImGui::SliderFloat("Aspect", &aspect, 0.5, 2.0);
      ImGui::SliderFloat("Start Angle", &start_angle, 0, 360);
      ImGui::SliderFloat("End Angle", &end_angle, 0, 360);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint grey_paint;
    grey_paint.setColor(DlColor(0xff111111));
    builder.DrawPaint(grey_paint);
 
    DlPaint white_paint;
    white_paint.setColor(DlColor::kWhite());
    white_paint.setStrokeWidth(stroke_width);
    white_paint.setDrawStyle(DlDrawStyle::kStroke);
    DlPaint red_paint;
    red_paint.setColor(DlColor::kRed());
 
    Rect rect = Rect::MakeXYWH(100, 100, 100, aspect * 100);
    builder.DrawRect(rect, red_paint);
    builder.DrawArc(rect, start_angle, end_angle,
                    /*useCenter=*/false, white_paint);
    DlScalar frontier = rect.GetRight() + stroke_width / 2.0;
    builder.DrawLine(Point(frontier, 0), Point(frontier, 150), red_paint);
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawArc(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [267/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledArcsRenderCorrectly
	)

Definition at line 1057 of file aiks_dl_basic_unittests.cc.

                                            {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [268/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledArcsRenderCorrectlyWithCenter
	)

Definition at line 1091 of file aiks_dl_basic_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = true,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [269/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledCirclesRenderCorrectly
	)

Definition at line 673 of file aiks_dl_basic_unittests.cc.

                                               {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  const int color_count = 3;
  DlColor colors[color_count] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
  };
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  int c_index = 0;
  int radius = 600;
  while (radius > 0) {
    paint.setColor(colors[(c_index++) % color_count]);
    builder.DrawCircle(DlPoint(10, 10), radius, paint);
    if (radius > 30) {
      radius -= 10;
    } else {
      radius -= 2;
    }
  }
 
  DlColor gradient_colors[7] = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
  };
  DlScalar stops[7] = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
  auto image = DlImageImpeller::Make(texture);
 
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  builder.DrawCircle(DlPoint(500, 600), 100, paint);
 
  DlMatrix local_matrix = DlMatrix::MakeTranslation({700, 200});
  paint.setColorSource(DlColorSource::MakeImage(
      image, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kNearestNeighbor, &local_matrix));
  builder.DrawCircle(DlPoint(800, 300), 100, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeRadial(), impeller::Matrix::MakeTranslation(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), texture, x, and y.

◆ TEST_P() [270/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledEllipsesRenderCorrectly
	)

Definition at line 936 of file aiks_dl_basic_unittests.cc.

                                                {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  const int color_count = 3;
  DlColor colors[color_count] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
  };
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  int c_index = 0;
  int long_radius = 600;
  int short_radius = 600;
  while (long_radius > 0 && short_radius > 0) {
    paint.setColor(colors[(c_index++) % color_count]);
    builder.DrawOval(
        DlRect::MakeEllipseBounds({10, 10}, Size(long_radius, short_radius)),
        paint);
    builder.DrawOval(
        DlRect::MakeEllipseBounds({1000, 750}, Size(short_radius, long_radius)),
        paint);
    if (short_radius > 30) {
      short_radius -= 10;
      long_radius -= 5;
    } else {
      short_radius -= 2;
      long_radius -= 1;
    }
  }
 
  DlColor gradient_colors[7] = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
  };
  DlScalar stops[7] = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
  auto image = DlImageImpeller::Make(texture);
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
 
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(300, 650), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  builder.DrawOval(DlRect::MakeXYWH(200, 625, 200, 50), paint);
  builder.DrawOval(DlRect::MakeXYWH(275, 550, 50, 200), paint);
 
  DlMatrix local_matrix = DlMatrix::MakeTranslation({610, 15});
  paint.setColorSource(DlColorSource::MakeImage(
      image, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kNearestNeighbor, &local_matrix));
  builder.DrawOval(DlRect::MakeXYWH(610, 90, 200, 50), paint);
  builder.DrawOval(DlRect::MakeXYWH(685, 15, 50, 200), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawOval(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeEllipseBounds(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeRadial(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), texture, x, and y.

◆ TEST_P() [271/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectPathsRenderCorrectly
	)

Definition at line 2010 of file aiks_dl_basic_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  const int color_count = 3;
  DlColor colors[color_count] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::ARGB(1.0, 220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f),
  };
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  auto draw_rrect_as_path = [&builder](const DlRect& rect, Scalar x, Scalar y,
                                       const DlPaint& paint) {
    builder.DrawPath(DlPath::MakeRoundRectXY(rect, x, y), paint);
  };
 
  int c_index = 0;
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      paint.setColor(colors[(c_index++) % color_count]);
      draw_rrect_as_path(DlRect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),
                         i * 5 + 10, j * 5 + 10, paint);
    }
  }
  paint.setColor(colors[(c_index++) % color_count]);
  draw_rrect_as_path(DlRect::MakeXYWH(10, 420, 380, 80), 40, 40, paint);
  paint.setColor(colors[(c_index++) % color_count]);
  draw_rrect_as_path(DlRect::MakeXYWH(410, 20, 80, 380), 40, 40, paint);
 
  std::vector<DlColor> gradient_colors = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0)};
  std::vector<Scalar> stops = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = DlImageImpeller::Make(
      CreateTextureForFixture("airplane.jpg",
                              /*enable_mipmapping=*/true));
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
  paint.setColorSource(DlColorSource::MakeRadial(
      /*center=*/DlPoint(550, 550),
      /*radius=*/75,
      /*stop_count=*/gradient_colors.size(),
      /*colors=*/gradient_colors.data(),
      /*stops=*/stops.data(),
      /*tile_mode=*/DlTileMode::kMirror));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    draw_rrect_as_path(DlRect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                        550 + i * 20, 550 + j * 20),
                       i * 10, j * 10, paint);
  }
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  paint.setColorSource(DlColorSource::MakeRadial(
      /*center=*/DlPoint(200, 650),
      /*radius=*/75,
      /*stop_count=*/gradient_colors.size(),
      /*colors=*/gradient_colors.data(),
      /*stops=*/stops.data(),
      /*tile_mode=*/DlTileMode::kMirror));
  draw_rrect_as_path(DlRect::MakeLTRB(100, 610, 300, 690), 40, 40, paint);
  draw_rrect_as_path(DlRect::MakeLTRB(160, 550, 240, 750), 40, 40, paint);
 
  auto matrix = DlMatrix::MakeTranslation({520, 20});
  paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
  paint.setColorSource(DlColorSource::MakeImage(
      texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kMipmapLinear, &matrix));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    draw_rrect_as_path(DlRect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                        720 + i * 20, 220 + j * 20),
                       i * 10, j * 10, paint);
  }
  matrix = DlMatrix::MakeTranslation({800, 300});
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  paint.setColorSource(DlColorSource::MakeImage(
      texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kMipmapLinear, &matrix));
 
  draw_rrect_as_path(DlRect::MakeLTRB(800, 410, 1000, 490), 40, 40, paint);
  draw_rrect_as_path(DlRect::MakeLTRB(860, 350, 940, 550), 40, 40, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), i, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorSource::MakeRadial(), flutter::DlPath::MakeRoundRectXY(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), texture, x, and y.

◆ TEST_P() [272/662]

impeller::testing::TEST_P	(	AiksTest	,
		FilledRoundRectsRenderCorrectly
	)

Definition at line 1408 of file aiks_dl_basic_unittests.cc.

                                                  {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  const int color_count = 3;
  DlColor colors[color_count] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
  };
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  int c_index = 0;
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      paint.setColor(colors[(c_index++) % color_count]);
      builder.DrawRoundRect(
          DlRoundRect::MakeRectXY(
              DlRect::MakeXYWH(i * 100 + 10, j * 100 + 20, 80, 80),  //
              i * 5 + 10, j * 5 + 10),
          paint);
    }
  }
  paint.setColor(colors[(c_index++) % color_count]);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 420, 380, 80), 40, 40),
      paint);
  paint.setColor(colors[(c_index++) % color_count]);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(410, 20, 80, 380), 40, 40),
      paint);
 
  DlColor gradient_colors[7] = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
  };
  DlScalar stops[7] = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
  auto image = DlImageImpeller::Make(texture);
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(550, 550), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeLTRB(550 - i * 20, 550 - j * 20,  //
                                                 550 + i * 20, 550 + j * 20),
                                i * 10, j * 10),
        paint);
  }
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(200, 650), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeLTRB(100, 610, 300, 690), 40, 40),
      paint);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeLTRB(160, 550, 240, 750), 40, 40),
      paint);
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.1));
  DlMatrix local_matrix = DlMatrix::MakeTranslation({520, 20});
  paint.setColorSource(DlColorSource::MakeImage(
      image, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kNearestNeighbor, &local_matrix));
  for (int i = 1; i <= 10; i++) {
    int j = 11 - i;
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeLTRB(720 - i * 20, 220 - j * 20,  //
                                                 720 + i * 20, 220 + j * 20),
                                i * 10, j * 10),
        paint);
  }
 
  paint.setColor(DlColor::kWhite().modulateOpacity(0.5));
  local_matrix = DlMatrix::MakeTranslation({800, 300});
  paint.setColorSource(DlColorSource::MakeImage(
      image, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kNearestNeighbor, &local_matrix));
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeLTRB(800, 410, 1000, 490), 40, 40),
      paint);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeLTRB(860, 350, 940, 550), 40, 40),
      paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRoundRect(), i, image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorSource::MakeRadial(), impeller::RoundRect::MakeRectXY(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), texture, x, and y.

◆ TEST_P() [273/662]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundAdvancedBlendAppliesTransformCorrectly
	)

Definition at line 742 of file aiks_dl_blend_unittests.cc.

                                                                   {
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  DisplayListBuilder builder;
  builder.Rotate(30);
 
  DlPaint image_paint;
  image_paint.setColorFilter(DlColorFilter::MakeBlend(
      DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f),
      DlBlendMode::kColorDodge));
 
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                    DlImageSampling::kMipmapLinear, &image_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Rotate(), flutter::DlPaint::setColorFilter(), and texture.

◆ TEST_P() [274/662]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundBlendSubpassCollapseOptimization
	)

Definition at line 476 of file aiks_dl_blend_unittests.cc.

                                                             {
  DisplayListBuilder builder;
 
  DlPaint save_paint;
  save_paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kColorDodge));
  builder.SaveLayer(std::nullopt, &save_paint);
 
  builder.Translate(500, 300);
  builder.Rotate(120);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [275/662]

impeller::testing::TEST_P	(	AiksTest	,
		ForegroundPipelineBlendAppliesTransformCorrectly
	)

Definition at line 724 of file aiks_dl_blend_unittests.cc.

                                                                   {
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  DisplayListBuilder builder;
  builder.Rotate(30);
 
  DlPaint image_paint;
  image_paint.setColorFilter(DlColorFilter::MakeBlend(
      DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f),
      DlBlendMode::kSrcIn));
 
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                    DlImageSampling::kMipmapLinear, &image_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Rotate(), flutter::DlPaint::setColorFilter(), and texture.

◆ TEST_P() [276/662]

impeller::testing::TEST_P	(	AiksTest	,
		FormatSRGB
	)

Definition at line 1923 of file aiks_dl_basic_unittests.cc.

                             {
  PixelFormat pixel_format =
      GetContext()->GetCapabilities()->GetDefaultColorFormat();
  EXPECT_TRUE(pixel_format == PixelFormat::kR8G8B8A8UNormInt ||
              pixel_format == PixelFormat::kB8G8R8A8UNormInt)
      << "pixel format: " << PixelFormatToString(pixel_format);
}

References impeller::kB8G8R8A8UNormInt, impeller::kR8G8B8A8UNormInt, and impeller::PixelFormatToString().

◆ TEST_P() [277/662]

impeller::testing::TEST_P	(	AiksTest	,
		FormatWideGamut
	)

Definition at line 1912 of file aiks_dl_basic_unittests.cc.

                                  {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with wide gamut support.
  if (!EnsureContextSupportsWideGamut()) {
    GTEST_SKIP() << "This backend doesn't yet support wide gamut.";
  }
 
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
}

References impeller::kB10G10R10A10XR.

◆ TEST_P() [278/662]

impeller::testing::TEST_P	(	AiksTest	,
		FramebufferAdvancedBlendCoverage
	)

Definition at line 760 of file aiks_dl_blend_unittests.cc.

                                                   {
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
 
  // Draw with an advanced blend that can use FramebufferBlendContents and
  // verify that the scale transform is correctly applied to the image.
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(
      DlColor::RGBA(169.0f / 255.0f, 169.0f / 255.0f, 169.0f / 255.0f, 1.0f));
  builder.DrawPaint(paint);
  builder.Scale(0.4, 0.4);
 
  DlPaint image_paint;
  image_paint.setBlendMode(DlBlendMode::kMultiply);
 
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(20, 20),
                    DlImageSampling::kMipmapLinear, &image_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawPaint(), impeller::DlImageImpeller::Make(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and texture.

◆ TEST_P() [279/662]

impeller::testing::TEST_P	(	AiksTest	,
		FramebufferBlendsRespectClips
	)

If correct, this test should draw a green circle. If any red is visible, there is a depth bug.

Definition at line 118 of file aiks_dl_clip_unittests.cc.

                                                {
  DisplayListBuilder builder;
 
  // Clear the whole canvas with white.
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  builder.ClipPath(DlPath::MakeCircle(DlPoint(150, 150), 50),
                   DlClipOp::kIntersect);
 
  // Draw a red rectangle that should not show through the circle clip.
  paint.setColor(DlColor::kRed());
  paint.setBlendMode(DlBlendMode::kMultiply);
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 100, 100), paint);
 
  // Draw a green circle that shows through the clip.
  paint.setColor(DlColor::kGreen());
  paint.setBlendMode(DlBlendMode::kSrcOver);
  builder.DrawCircle(DlPoint(150, 150), 50, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipPath(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [280/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAnimatedBackdrop
	)

Definition at line 949 of file aiks_dl_blur_unittests.cc.

                                               {
  // This test is for checking out how stable rendering is when content is
  // translated underneath a blur.  Animating under a blur can cause
  // *shimmering* to happen as a result of pixel alignment.
  // See also: https://github.com/flutter/flutter/issues/140193
  auto boston =
      CreateTextureForFixture("boston.jpg", /*enable_mipmapping=*/true);
  ASSERT_TRUE(boston);
  int64_t count = 0;
  Scalar sigma = 20.0;
  Scalar freq = 0.1;
  Scalar amp = 50.0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Sigma", &sigma, 0, 200);
      ImGui::SliderFloat("Frequency", &freq, 0.01, 2.0);
      ImGui::SliderFloat("Amplitude", &amp, 1, 100);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    Scalar y = amp * sin(freq * 2.0 * M_PI * count / 60);
    builder.DrawImage(DlImageImpeller::Make(boston),
                      DlPoint(1024 / 2 - boston->GetSize().width / 2,
                              (768 / 2 - boston->GetSize().height / 2) + y),
                      DlImageSampling::kMipmapLinear);
    static PlaygroundPoint point_a(Point(100, 100), 20, Color::Red());
    static PlaygroundPoint point_b(Point(900, 700), 20, Color::Red());
    auto [handle_a, handle_b] = DrawPlaygroundLine(point_a, point_b);
 
    builder.ClipRect(
        DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
    builder.ClipRect(DlRect::MakeLTRB(100, 100, 900, 700));
 
    DlPaint paint;
    paint.setBlendMode(DlBlendMode::kSrc);
 
    auto backdrop_filter =
        DlImageFilter::MakeBlur(sigma, sigma, DlTileMode::kClamp);
    builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
    count += 1;
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImage(), impeller::DrawPlaygroundLine(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Color::Red(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), x, and y.

◆ TEST_P() [281/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryHorizontal
	)

Definition at line 920 of file aiks_dl_blur_unittests.cc.

                                                    {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  builder.DrawImageRect(
      DlImageImpeller::Make(boston),
      DlRect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height),
      DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100),
      DlImageSampling::kNearestNeighbor);
 
  DlPaint paint;
  paint.setColor(DlColor::kMagenta());
 
  DlRoundRect rrect = DlRoundRect::MakeRectXY(
      DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
  builder.DrawRoundRect(rrect, paint);
  builder.ClipRect(DlRect::MakeLTRB(0, 50, GetWindowSize().width, 150));
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
 
  auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
 
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImageRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kMagenta(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), width, x, and y.

◆ TEST_P() [282/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurAtPeripheryVertical
	)

Definition at line 892 of file aiks_dl_blur_unittests.cc.

                                                  {
  DisplayListBuilder builder;
 
  DlPaint paint;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  paint.setColor(DlColor::kLimeGreen());
  DlRoundRect rrect = DlRoundRect::MakeRectXY(
      DlRect::MakeLTRB(0, 0, GetWindowSize().width, 100), 10, 10);
  builder.DrawRoundRect(rrect, paint);
 
  paint.setColor(DlColor::kMagenta());
  rrect = DlRoundRect::MakeRectXY(
      DlRect::MakeLTRB(0, 110, GetWindowSize().width, 210), 10, 10);
  builder.DrawRoundRect(rrect, paint);
  builder.ClipRect(DlRect::MakeLTRB(100, 0, 200, GetWindowSize().height));
 
  DlPaint save_paint;
  save_paint.setBlendMode(DlBlendMode::kSrc);
 
  auto backdrop_filter = DlImageFilter::MakeBlur(20, 20, DlTileMode::kClamp);
 
  builder.SaveLayer(std::nullopt, &save_paint, backdrop_filter.get());
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawRoundRect(), height, flutter::DlColor::kLimeGreen(), flutter::DlColor::kMagenta(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundRect::MakeRectXY(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), width, x, and y.

◆ TEST_P() [283/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurBackdropTinyMipMap
	)

Definition at line 1381 of file aiks_dl_blur_unittests.cc.

                                                 {
  AiksContext renderer(GetContext(), nullptr);
  for (int32_t i = 1; i < 5; ++i) {
    DisplayListBuilder builder;
 
    ISize clip_size = ISize(i, i);
    builder.Save();
    builder.ClipRect(
        DlRect::MakeXYWH(400, 400, clip_size.width, clip_size.height));
 
    DlPaint paint;
    paint.setColor(DlColor::kGreen());
    auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kDecal);
    paint.setImageFilter(blur_filter);
 
    builder.DrawCircle(DlPoint(400, 400), 200, paint);
    builder.Restore();
 
    auto image = DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
    EXPECT_TRUE(image) << " length " << i;
  }
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawCircle(), impeller::TSize< T >::height, i, image, flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and impeller::TSize< T >::width.

◆ TEST_P() [284/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurFlipped
	)

Definition at line 1516 of file aiks_dl_blur_unittests.cc.

                                      {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 350, 350),
                   DlPaint().setColor(DlColor::kWhite()));
 
  builder.Save();
  builder.Scale(-1, 1);
  DlPaint paint;
  paint.setImageFilter(DlBlurImageFilter::Make(10, 10, DlTileMode::kDecal));
  builder.SaveLayer(DlRect::MakeLTRB(-150, 100, 150, 200), &paint);
  builder.DrawRect(DlRect::MakeLTRB(-150, 0, 150, 300),
                   DlPaint().setColor(DlColor::kRed()));
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlBlurImageFilter::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setImageFilter(), x, and y.

◆ TEST_P() [285/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurOneDimension
	)

Definition at line 1194 of file aiks_dl_blur_unittests.cc.

                                           {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Scale(0.5, 0.5);
 
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  builder.DrawImage(DlImageImpeller::Make(boston), DlPoint(100, 100), {});
 
  DlPaint paint;
  paint.setBlendMode(DlBlendMode::kSrc);
 
  auto backdrop_filter = DlImageFilter::MakeBlur(50, 0, DlTileMode::kClamp);
  builder.SaveLayer(std::nullopt, &paint, backdrop_filter.get());
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setBlendMode(), x, and y.

◆ TEST_P() [286/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClipped
	)

Definition at line 1216 of file aiks_dl_blur_unittests.cc.

                                                {
  DisplayListBuilder builder;
 
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  Rect bounds =
      Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
 
  DlPaint paint;
  paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
 
  Vector2 image_center = Vector2(bounds.GetSize() / 2);
  Vector2 clip_size = {150, 75};
  Vector2 center = Vector2(1024, 768) / 2;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  auto clip_bounds = Rect::MakeEllipseBounds(center, clip_size);
  builder.ClipRect(DlRect::MakeLTRB(clip_bounds.GetLeft(), clip_bounds.GetTop(),
                                    clip_bounds.GetRight(),
                                    clip_bounds.GetBottom()));
  builder.Translate(center.x, center.y);
  builder.Scale(0.6, 0.6);
  builder.Rotate(25);
 
  auto dst_rect = bounds.Shift(-image_center);
  builder.DrawImageRect(
      DlImageImpeller::Make(boston), /*src=*/
      DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(), bounds.GetRight(),
                       bounds.GetBottom()),
      /*dst=*/
      DlRect::MakeLTRB(dst_rect.GetLeft(), dst_rect.GetTop(),
                       dst_rect.GetRight(), dst_rect.GetBottom()),
      DlImageSampling::kMipmapLinear, &paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImageRect(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [287/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedAndClippedInteractive
	)

Definition at line 1139 of file aiks_dl_blur_unittests.cc.

                                                           {
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
 
    static float rotation = 0;
    static float scale = 0.6;
    static int selected_tile_mode = 3;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Rotation (degrees)", &rotation, -180, 180);
      ImGui::SliderFloat("Scale", &scale, 0, 2.0);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    Rect bounds =
        Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
    Vector2 image_center = Vector2(bounds.GetSize() / 2);
    DlPaint paint;
    paint.setImageFilter(
        DlImageFilter::MakeBlur(20, 20, tile_modes[selected_tile_mode]));
 
    static PlaygroundPoint point_a(Point(362, 309), 20, Color::Red());
    static PlaygroundPoint point_b(Point(662, 459), 20, Color::Red());
    auto [handle_a, handle_b] = DrawPlaygroundLine(point_a, point_b);
    Vector2 center = Vector2(1024, 768) / 2;
 
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.ClipRect(
        DlRect::MakeLTRB(handle_a.x, handle_a.y, handle_b.x, handle_b.y));
    builder.Translate(center.x, center.y);
    builder.Scale(scale, scale);
    builder.Rotate(rotation);
 
    DlRect sk_bounds = DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(),
                                        bounds.GetRight(), bounds.GetBottom());
    Rect dest = bounds.Shift(-image_center);
    DlRect sk_dst = DlRect::MakeLTRB(dest.GetLeft(), dest.GetTop(),
                                     dest.GetRight(), dest.GetBottom());
    builder.DrawImageRect(DlImageImpeller::Make(boston), /*src=*/sk_bounds,
                          /*dst=*/sk_dst, DlImageSampling::kNearestNeighbor,
                          &paint);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImageRect(), impeller::DrawPlaygroundLine(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::Red(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [288/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurRotatedNonUniform
	)

Definition at line 1252 of file aiks_dl_blur_unittests.cc.

                                                {
  auto callback = [&]() -> sk_sp<DisplayList> {
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
 
    static float rotation = 45;
    static float scale = 0.6;
    static int selected_tile_mode = 3;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Rotation (degrees)", &rotation, -180, 180);
      ImGui::SliderFloat("Scale", &scale, 0, 2.0);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      ImGui::End();
    }
 
    DisplayListBuilder builder;
 
    DlPaint paint;
    paint.setColor(DlColor::kGreen());
    paint.setImageFilter(
        DlImageFilter::MakeBlur(50, 0, tile_modes[selected_tile_mode]));
 
    Vector2 center = Vector2(1024, 768) / 2;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.Translate(center.x, center.y);
    builder.Scale(scale, scale);
    builder.Rotate(rotation);
 
    DlRoundRect rrect =
        DlRoundRect::MakeRectXY(DlRect::MakeCircleBounds({0, 0}, 100), 10, 10);
    builder.DrawRoundRect(rrect, paint);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeCircleBounds(), impeller::RoundRect::MakeRectXY(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [289/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurScaledAndClipped
	)

Definition at line 1107 of file aiks_dl_blur_unittests.cc.

                                               {
  DisplayListBuilder builder;
  std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
  Rect bounds =
      Rect::MakeXYWH(0, 0, boston->GetSize().width, boston->GetSize().height);
  Vector2 image_center = Vector2(bounds.GetSize() / 2);
 
  DlPaint paint;
  paint.setImageFilter(DlImageFilter::MakeBlur(20, 20, DlTileMode::kDecal));
 
  Vector2 clip_size = {150, 75};
  Vector2 center = Vector2(1024, 768) / 2;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  auto rect = Rect::MakeEllipseBounds(center, clip_size);
  builder.ClipRect(DlRect::MakeLTRB(rect.GetLeft(), rect.GetTop(),
                                    rect.GetRight(), rect.GetBottom()));
  builder.Translate(center.x, center.y);
  builder.Scale(0.6, 0.6);
 
  DlRect sk_bounds = DlRect::MakeLTRB(bounds.GetLeft(), bounds.GetTop(),
                                      bounds.GetRight(), bounds.GetBottom());
  Rect dest = bounds.Shift(-image_center);
  DlRect sk_dst = DlRect::MakeLTRB(dest.GetLeft(), dest.GetTop(),
                                   dest.GetRight(), dest.GetBottom());
  builder.DrawImageRect(DlImageImpeller::Make(boston), /*src=*/sk_bounds,
                        /*dst=*/sk_dst, DlImageSampling::kNearestNeighbor,
                        &paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawImageRect(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [290/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurSolidColorTinyMipMap
	)

Definition at line 1356 of file aiks_dl_blur_unittests.cc.

                                                   {
  AiksContext renderer(GetContext(), nullptr);
 
  for (int32_t i = 1; i < 5; ++i) {
    DisplayListBuilder builder;
    Scalar fi = i;
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(100, 100));
    path_builder.LineTo(DlPoint(100 + fi, 100 + fi));
 
    DlPaint paint;
    paint.setColor(DlColor::kChartreuse());
    auto blur_filter = DlImageFilter::MakeBlur(0.1, 0.1, DlTileMode::kClamp);
    paint.setImageFilter(blur_filter);
 
    builder.DrawPath(path_builder.TakePath(), paint);
 
    auto image = DisplayListToTexture(builder.Build(), {1024, 768}, renderer);
    EXPECT_TRUE(image) << " length " << i;
  }
}

References flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPath(), i, image, flutter::DlColor::kChartreuse(), flutter::DlPathBuilder::LineTo(), flutter::DlImageFilter::MakeBlur(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [291/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInner
	)

Definition at line 747 of file aiks_dl_blur_unittests.cc.

                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1));
  builder.DrawPaint(paint);
 
  paint.setColor(DlColor::kGreen());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [292/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleInnerGradient
	)

Definition at line 997 of file aiks_dl_blur_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint = DlPaint{};
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/{0, 0},
      /*end_point=*/{200, 200},
      /*stop_count=*/colors.size(),
      /*colors=*/colors.data(),
      /*stops=*/stops.data(),
      /*tile_mode=*/DlTileMode::kMirror));
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kInner, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [293/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuter
	)

Definition at line 774 of file aiks_dl_blur_unittests.cc.

                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  paint.setColor(DlColor::kGreen());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [294/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleOuterGradient
	)

Definition at line 1071 of file aiks_dl_blur_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint = DlPaint{};
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/{0, 0},
      /*end_point=*/{200, 200},
      /*stop_count=*/colors.size(),
      /*colors=*/colors.data(),
      /*stops=*/stops.data(),
      /*tile_mode=*/DlTileMode::kMirror));
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kOuter, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [295/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolid
	)

Definition at line 801 of file aiks_dl_blur_unittests.cc.

                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  paint.setColor(DlColor::kGreen());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [296/662]

impeller::testing::TEST_P	(	AiksTest	,
		GaussianBlurStyleSolidGradient
	)

Definition at line 1035 of file aiks_dl_blur_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.7568, 0.2627, 0.2118, 1.0)};
  std::vector<Scalar> stops = {0.0, 1.0};
 
  paint = DlPaint{};
  paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/{0, 0},
      /*end_point=*/{200, 200},
      /*stop_count=*/colors.size(),
      /*colors=*/colors.data(),
      /*stops=*/stops.data(),
      /*tile_mode=*/DlTileMode::kMirror));
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kSolid, 30));
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(300, 400));
  path_builder.LineTo(DlPoint(100, 400));
  path_builder.Close();
  builder.DrawPath(path_builder.TakePath(), paint);
 
  // Draw another thing to make sure the clip area is reset.
  DlPaint red;
  red.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlBlurMaskFilter::Make(), flutter::DlColorSource::MakeLinear(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DlPathBuilder::TakePath(), x, and y.

◆ TEST_P() [297/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlur
	)

Definition at line 104 of file aiks_dl_blur_unittests.cc.

                                             {
  ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
      GetContentScale(), /*sigma=*/10, DlBlurStyle::kNormal)));
}

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [298/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurInner
	)

Definition at line 119 of file aiks_dl_blur_unittests.cc.

                                                  {
  ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
      GetContentScale(), /*sigma=*/10, DlBlurStyle::kInner)));
}

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [299/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurOuter
	)

Definition at line 114 of file aiks_dl_blur_unittests.cc.

                                                  {
  ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
      GetContentScale(), /*sigma=*/10, DlBlurStyle::kOuter)));
}

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [300/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurSigmaZero
	)

Definition at line 109 of file aiks_dl_blur_unittests.cc.

                                                      {
  ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
      GetContentScale(), /*sigma=*/0, DlBlurStyle::kNormal)));
}

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [301/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientOvalStrokeMaskBlurSolid
	)

Definition at line 124 of file aiks_dl_blur_unittests.cc.

                                                  {
  ASSERT_TRUE(OpenPlaygroundHere(DoGradientOvalStrokeMaskBlur(
      GetContentScale(), /*sigma=*/10, DlBlurStyle::kSolid)));
}

References DoGradientOvalStrokeMaskBlur().

◆ TEST_P() [302/662]

impeller::testing::TEST_P	(	AiksTest	,
		GradientStrokesRenderCorrectly
	)

Definition at line 754 of file aiks_dl_gradient_unittests.cc.

                                                 {
  // Compare with https://fiddle.skia.org/c/027392122bec8ac2b5d5de00a4b9bbe2
  auto callback = [&]() -> sk_sp<DisplayList> {
    static float scale = 3;
    static bool add_circle_clip = true;
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const DlTileMode tile_modes[] = {DlTileMode::kClamp, DlTileMode::kRepeat,
                                     DlTileMode::kMirror, DlTileMode::kDecal};
    static int selected_tile_mode = 0;
    static float alpha = 1;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Scale", &scale, 0, 6);
      ImGui::Checkbox("Circle clip", &add_circle_clip);
      ImGui::SliderFloat("Alpha", &alpha, 0, 1);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    DlPaint paint;
    paint.setColor(DlColor::kWhite());
    builder.DrawPaint(paint);
 
    paint.setDrawStyle(DlDrawStyle::kStroke);
    paint.setColor(DlColor::kWhite().withAlpha(alpha * 255));
    paint.setStrokeWidth(10);
    auto tile_mode = tile_modes[selected_tile_mode];
 
    std::vector<DlColor> colors = {
        DlColor(Color{0.9568, 0.2627, 0.2118, 1.0}.ToARGB()),
        DlColor(Color{0.1294, 0.5882, 0.9529, 1.0}.ToARGB())};
    std::vector<Scalar> stops = {0.0, 1.0};
 
    paint.setColorSource(DlColorSource::MakeLinear({0, 0}, {50, 50},
                                                   stops.size(), colors.data(),
                                                   stops.data(), tile_mode));
 
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(20, 20));
    path_builder.QuadraticCurveTo(DlPoint(60, 20), DlPoint(60, 60));
    path_builder.Close();
    path_builder.MoveTo(DlPoint(60, 20));
    path_builder.QuadraticCurveTo(DlPoint(60, 60), DlPoint(20, 60));
    DlPath path = path_builder.TakePath();
 
    builder.Scale(scale, scale);
 
    if (add_circle_clip) {
      static PlaygroundPoint circle_clip_point_a(Point(60, 300), 20,
                                                 Color::Red());
      static PlaygroundPoint circle_clip_point_b(Point(600, 300), 20,
                                                 Color::Red());
      auto [handle_a, handle_b] =
          DrawPlaygroundLine(circle_clip_point_a, circle_clip_point_b);
 
      Matrix ip_matrix = builder.GetMatrix();
      if (!ip_matrix.IsInvertible()) {
        return nullptr;
      }
      ip_matrix = ip_matrix.Invert();
      Point point_a = ip_matrix * handle_a * GetContentScale();
      Point point_b = ip_matrix * handle_b * GetContentScale();
 
      Point middle = (point_a + point_b) / 2;
      auto radius = point_a.GetDistance(middle);
      builder.ClipPath(DlPath::MakeCircle(middle, radius));
    }
 
    for (auto join :
         {DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
      paint.setStrokeJoin(join);
      for (auto cap :
           {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
        paint.setStrokeCap(cap);
        builder.DrawPath(path, paint);
        builder.Translate(80, 0);
      }
      builder.Translate(-240, 60);
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipPath(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), impeller::DrawPlaygroundLine(), flutter::DisplayListBuilder::GetMatrix(), impeller::Matrix::Invert(), impeller::Matrix::IsInvertible(), flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), flutter::DlColorSource::MakeLinear(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), impeller::Color::Red(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), impeller::Color::ToARGB(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [303/662]

impeller::testing::TEST_P	(	AiksTest	,
		ImageColorSourceEffectTransform
	)

Definition at line 1681 of file aiks_dl_basic_unittests.cc.

                                                  {
  // Compare with https://fiddle.skia.org/c/6cdc5aefb291fda3833b806ca347a885
 
  DisplayListBuilder builder;
  auto texture = DlImageImpeller::Make(CreateTextureForFixture("monkey.png"));
 
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  // Translation
  {
    DlMatrix matrix = DlMatrix::MakeTranslation({50, 50});
    DlPaint paint;
    paint.setColorSource(DlColorSource::MakeImage(
        texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
        DlImageSampling::kNearestNeighbor, &matrix));
 
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 100, 100), paint);
  }
 
  // Rotation/skew
  {
    builder.Save();
    builder.Rotate(45);
    DlPaint paint;
 
    Matrix matrix(1, -1, 0, 0,  //
                  1, 1, 0, 0,   //
                  0, 0, 1, 0,   //
                  0, 0, 0, 1);
    paint.setColorSource(DlColorSource::MakeImage(
        texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
        DlImageSampling::kNearestNeighbor, &matrix));
    builder.DrawRect(DlRect::MakeLTRB(100, 0, 200, 100), paint);
    builder.Restore();
  }
 
  // Scale
  {
    builder.Save();
    builder.Translate(100, 0);
    builder.Scale(100, 100);
    DlPaint paint;
 
    DlMatrix matrix = DlMatrix::MakeScale({0.005, 0.005, 1});
    paint.setColorSource(DlColorSource::MakeImage(
        texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
        DlImageSampling::kNearestNeighbor, &matrix));
 
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 1, 1), paint);
    builder.Restore();
  }
 
  // Perspective
  {
    builder.Save();
    builder.Translate(150, 150);
    DlPaint paint;
 
    DlMatrix matrix =
        DlMatrix::MakePerspective(Radians{0.5}, ISize{200, 200}, 0.05, 1);
    paint.setColorSource(DlColorSource::MakeImage(
        texture, DlTileMode::kRepeat, DlTileMode::kRepeat,
        DlImageSampling::kNearestNeighbor, &matrix));
 
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 200, 200), paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

◆ TEST_P() [304/662]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredSaveLayerWithUnboundedContents
	)

Definition at line 665 of file aiks_dl_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  auto test = [&builder](const std::shared_ptr<DlImageFilter>& filter) {
    auto DrawLine = [&builder](const DlPoint& p0, const DlPoint& p1,
                               const DlPaint& p) {
      DlPaint paint = p;
      paint.setDrawStyle(DlDrawStyle::kStroke);
      builder.DrawPath(DlPath::MakeLine(p0, p1), paint);
    };
    // Registration marks for the edge of the SaveLayer
    DlPaint paint;
    paint.setColor(DlColor::kWhite());
    DrawLine(DlPoint(75, 100), DlPoint(225, 100), paint);
    DrawLine(DlPoint(75, 200), DlPoint(225, 200), paint);
    DrawLine(DlPoint(100, 75), DlPoint(100, 225), paint);
    DrawLine(DlPoint(200, 75), DlPoint(200, 225), paint);
 
    DlPaint save_paint;
    save_paint.setImageFilter(filter);
    DlRect bounds = DlRect::MakeLTRB(100, 100, 200, 200);
    builder.SaveLayer(bounds, &save_paint);
 
    {
      // DrawPaint to verify correct behavior when the contents are unbounded.
      DlPaint paint;
      paint.setColor(DlColor::kYellow());
      builder.DrawPaint(paint);
 
      // Contrasting rectangle to see interior blurring
      paint.setColor(DlColor::kBlue());
      builder.DrawRect(DlRect::MakeLTRB(125, 125, 175, 175), paint);
    }
    builder.Restore();
  };
 
  test(DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal));
 
  builder.Translate(200.0, 0.0);
 
  test(DlImageFilter::MakeDilate(10.0, 10.0));
 
  builder.Translate(200.0, 0.0);
 
  test(DlImageFilter::MakeErode(10.0, 10.0));
 
  builder.Translate(-400.0, 200.0);
 
  DlMatrix matrix = DlMatrix::MakeRotationZ(DlDegrees(10));
 
  auto rotate_filter =
      DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear);
  test(rotate_filter);
 
  builder.Translate(200.0, 0.0);
 
  const float m[20] = {
      0, 1, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      1, 0, 0, 0, 0,  //
      0, 0, 0, 1, 0   //
  };
  auto rgb_swap_filter =
      DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(m));
  test(rgb_swap_filter);
 
  builder.Translate(200.0, 0.0);
 
  test(DlImageFilter::MakeCompose(rotate_filter, rgb_swap_filter));
 
  builder.Translate(-400.0, 200.0);
 
  test(rotate_filter->makeWithLocalMatrix(
      DlMatrix::MakeTranslation({25.0, 25.0})));
 
  builder.Translate(200.0, 0.0);
 
  test(rgb_swap_filter->makeWithLocalMatrix(
      DlMatrix::MakeTranslation({25.0, 25.0})));
 
  builder.Translate(200.0, 0.0);
 
  test(DlImageFilter::MakeCompose(rotate_filter, rgb_swap_filter)
           ->makeWithLocalMatrix(DlMatrix::MakeTranslation({25.0, 25.0})));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DlColor::kYellow(), flutter::DlImageFilter::MakeBlur(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlImageFilter::MakeCompose(), flutter::DlImageFilter::MakeDilate(), flutter::DlImageFilter::MakeErode(), flutter::DlPath::MakeLine(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlImageFilter::MakeMatrix(), flutter::DlColorFilter::MakeMatrix(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), p1, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [305/662]

impeller::testing::TEST_P	(	AiksTest	,
		ImageFilteredUnboundedSaveLayerWithUnboundedContents
	)

Definition at line 225 of file aiks_dl_unittests.cc.

                                                                       {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint save_paint;
  save_paint.setImageFilter(
      DlImageFilter::MakeBlur(10.0, 10.0, DlTileMode::kDecal));
  builder.SaveLayer(std::nullopt, &save_paint);
 
  {
    // DrawPaint to verify correct behavior when the contents are unbounded.
    DlPaint draw_paint;
    draw_paint.setColor(DlColor::kYellow());
    builder.DrawPaint(draw_paint);
 
    // Contrasting rectangle to see interior blurring
    DlPaint draw_rect;
    draw_rect.setColor(DlColor::kBlue());
    builder.DrawRect(DlRect::MakeLTRB(125, 125, 175, 175), draw_rect);
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kYellow(), flutter::DlImageFilter::MakeBlur(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), x, and y.

◆ TEST_P() [306/662]

impeller::testing::TEST_P	(	AiksTest	,
		ImageTextureCacheBehavesCorrectly
	)

Definition at line 461 of file canvas_unittests.cc.

                                                    {
  ContentContext& context = GetContentContext();
 
  TextureDescriptor desc;
  desc.size = {100, 100};
  desc.format = context.GetDeviceCapabilities().GetDefaultColorFormat();
  desc.usage = TextureUsage::kRenderTarget;
  auto texture =
      context.GetContext()->GetResourceAllocator()->CreateTexture(desc);
 
  auto dl_image = impeller::DlImageImpeller::Make(texture);
 
  context.SetTextureCachingEnabled(true);
  auto cached_tex1 = dl_image->GetCachedTexture(context);
  ASSERT_EQ(cached_tex1, texture);
 
  auto cached_tex2 = context.GetCachedTexture(dl_image.get());
  ASSERT_EQ(cached_tex2, texture);
 
  context.RemoveCachedTexture(dl_image.get());
  auto cached_tex3 = context.GetCachedTexture(dl_image.get());
  ASSERT_EQ(cached_tex3, nullptr);
 
  auto cached_tex4 = dl_image->GetCachedTexture(context);
  ASSERT_EQ(cached_tex4, texture);
 
  context.ClearCachedTextures();
  auto cached_tex5 = context.GetCachedTexture(dl_image.get());
  ASSERT_EQ(cached_tex5, nullptr);
 
  context.SetTextureCachingEnabled(false);
}

References context, impeller::TextureDescriptor::format, impeller::kRenderTarget, impeller::DlImageImpeller::Make(), impeller::TextureDescriptor::size, texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [307/662]

impeller::testing::TEST_P	(	AiksTest	,
		LinearToSrgbFilterSubpassCollapseOptimization
	)

Definition at line 105 of file aiks_dl_unittests.cc.

                                                                {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
  builder.SaveLayer(std::nullopt, &paint);
 
  builder.Translate(500, 300);
  builder.Rotate(120);  // 120 deg.
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColorFilter::MakeLinearToSrgbGamma(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [308/662]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurDoesntStretchContents
	)

Definition at line 857 of file aiks_dl_blur_unittests.cc.

                                                {
  Scalar sigma = 70;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Sigma", &sigma, 0, 500);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    DlPaint paint;
    paint.setColor(DlColor::RGBA(0.1, 0.1, 0.1, 1.0));
    builder.DrawPaint(paint);
 
    std::shared_ptr<Texture> boston = CreateTextureForFixture("boston.jpg");
 
    builder.Transform(Matrix::MakeTranslation({100, 100}) *
                      Matrix::MakeScale({0.5, 0.5, 1.0f}));
 
    paint.setColorSource(DlColorSource::MakeImage(
        DlImageImpeller::Make(boston), DlTileMode::kRepeat, DlTileMode::kRepeat,
        DlImageSampling::kMipmapLinear));
    paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
 
    builder.DrawRect(DlRect::MakeXYWH(0, 0, boston->GetSize().width,
                                      boston->GetSize().height),
                     paint);
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DlBlurMaskFilter::Make(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setMaskFilter(), flutter::DisplayListBuilder::Transform(), x, and y.

◆ TEST_P() [309/662]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurOnZeroDimensionIsSkippedWideGamut
	)

Definition at line 567 of file aiks_dl_blur_unittests.cc.

                                                            {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with wide gamut support.
  if (!EnsureContextSupportsWideGamut()) {
    GTEST_SKIP() << "This backend doesn't yet support wide gamut.";
  }
 
  // Making sure this test is run on a wide gamut enabled backend
  EXPECT_EQ(GetContext()->GetCapabilities()->GetDefaultColorFormat(),
            PixelFormat::kB10G10R10A10XR);
 
  DisplayListBuilder builder;
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10));
 
  // Zero height above
  builder.DrawRect(DlRect::MakeLTRB(100, 250, 500, 250), paint);
  // Regular rect
  builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
  // Zero width to the right
  builder.DrawRect(DlRect::MakeLTRB(550, 300, 550, 600), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRect(), impeller::kB10G10R10A10XR, flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setColor(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [310/662]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurTexture
	)

Definition at line 828 of file aiks_dl_blur_unittests.cc.

                                  {
  Scalar sigma = 30;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Sigma", &sigma, 0, 500);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    DlPaint paint;
    paint.setColor(DlColor::kGreen());
    paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigma));
 
    builder.DrawImage(
        DlImageImpeller::Make(CreateTextureForFixture("boston.jpg")),
        DlPoint(200, 200), DlImageSampling::kNearestNeighbor, &paint);
 
    DlPaint red;
    red.setColor(DlColor::kRed());
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), red);
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlBlurMaskFilter::Make(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), x, and y.

◆ TEST_P() [311/662]

impeller::testing::TEST_P	(	AiksTest	,
		MaskBlurWithZeroSigmaIsSkipped
	)

Definition at line 554 of file aiks_dl_blur_unittests.cc.

                                                 {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 0));
 
  builder.DrawCircle(DlPoint(300, 300), 200, paint);
  builder.DrawRect(DlRect::MakeLTRB(100, 300, 500, 600), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlBlurMaskFilter::Make(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setColor(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [312/662]

impeller::testing::TEST_P	(	AiksTest	,
		MassiveScaleConvertToPath
	)

Definition at line 198 of file aiks_dl_text_unittests.cc.

                                            {
  Scalar scale = 16.0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Scale", &scale, 4, 20);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    DlPaint paint;
    paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
    builder.DrawPaint(paint);
 
    builder.Scale(scale, scale);
    RenderTextInCanvasSkia(
        GetContext(), builder, "HELLO", "Roboto-Regular.ttf",
        TextRenderOptions{.font_size = 16,
                          .color = (16 * scale >= 250) ? DlColor::kYellow()
                                                       : DlColor::kOrange(),
                          .position = DlPoint(0, 20)});
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::font_size, flutter::DlColor::kOrange(), flutter::DlColor::kYellow(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setColor().

◆ TEST_P() [313/662]

impeller::testing::TEST_P	(	AiksTest	,
		MassiveScalingMatrixImageFilter
	)

Definition at line 2331 of file aiks_dl_basic_unittests.cc.

                                                  {
  switch (GetBackend()) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
      break;
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
    case PlaygroundBackend::kVulkan:
      GTEST_SKIP() << "Platform is running out of memory on this example "
                   << "(see https://github.com/flutter/flutter/issues/189286).";
  }
 
  DisplayListBuilder builder(DlRect::MakeSize(DlSize(1000, 1000)));
 
  auto filter = DlImageFilter::MakeMatrix(
      DlMatrix::MakeScale({0.001, 0.001, 1}), DlImageSampling::kLinear);
 
  DlPaint paint;
  paint.setImageFilter(filter);
  builder.SaveLayer(std::nullopt, &paint);
  {
    DlPaint paint;
    paint.setColor(DlColor::kRed());
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 100000, 100000), paint);
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, flutter::DlColor::kRed(), impeller::kVulkan, impeller::TRect< Scalar >::MakeLTRB(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [314/662]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixBackdropFilter
	)

Definition at line 754 of file aiks_dl_unittests.cc.

                                       {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kBlack());
  builder.DrawPaint(paint);
  builder.SaveLayer(std::nullopt, nullptr);
  {
    DlPaint paint;
    paint.setColor(DlColor::kGreen().withAlpha(0.5 * 255));
    paint.setBlendMode(DlBlendMode::kPlus);
 
    DlPaint rect_paint;
    rect_paint.setColor(DlColor::kRed());
    rect_paint.setStrokeWidth(4);
    rect_paint.setDrawStyle(DlDrawStyle::kStroke);
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 300, 300), rect_paint);
    builder.DrawCircle(DlPoint(200, 200), 100, paint);
    // Should render a second circle, centered on the bottom-right-most edge of
    // the circle.
    DlMatrix matrix = DlMatrix::MakeTranslation({(100 + 100 * k1OverSqrt2),
                                                 (100 + 100 * k1OverSqrt2)}) *
                      DlMatrix::MakeScale({0.5, 0.5, 1}) *
                      DlMatrix::MakeTranslation({-100, -100});
    auto backdrop_filter =
        DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear);
    builder.SaveLayer(std::nullopt, nullptr, backdrop_filter.get());
    builder.Restore();
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), impeller::k1OverSqrt2, flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [315/662]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenScaledAndTranslatedFromOffscreen
	)

Definition at line 1804 of file aiks_dl_basic_unittests.cc.

                                                                        {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Translate(100, 100);
  // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
  // +300 translation applied by a SaveLayer image filter.
 
  DlPaint paint;
  paint.setImageFilter(DlImageFilter::MakeMatrix(
      DlMatrix::MakeTranslation({300, 0}) * DlMatrix::MakeScale({2, 2, 1}),
      DlImageSampling::kNearestNeighbor));
  builder.SaveLayer(std::nullopt, &paint);
 
  DlPaint circle_paint;
  circle_paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(-150, 0), 50, circle_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [316/662]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterDoesntCullWhenTranslatedFromOffscreen
	)

Definition at line 1783 of file aiks_dl_basic_unittests.cc.

                                                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Translate(100, 100);
  // Draw a circle in a SaveLayer at -300, but move it back on-screen with a
  // +300 translation applied by a SaveLayer image filter.
  DlPaint paint;
  DlMatrix translate = DlMatrix::MakeTranslation({300, 0});
  paint.setImageFilter(
      DlImageFilter::MakeMatrix(translate, DlImageSampling::kLinear));
  builder.SaveLayer(std::nullopt, &paint);
 
  DlPaint circle_paint;
  circle_paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(-300, 0), 100, circle_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeTranslation(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [317/662]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixImageFilterMagnify
	)

Definition at line 633 of file aiks_dl_unittests.cc.

                                           {
  Scalar scale = 2.0;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Scale", &scale, 1, 2);
      ImGui::End();
    }
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
 
    builder.Translate(600, -200);
 
    DlMatrix matrix = DlMatrix::MakeScale({scale, scale, 1});
    DlPaint paint;
    paint.setImageFilter(
        DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
    builder.SaveLayer(std::nullopt, &paint);
 
    DlPaint rect_paint;
    rect_paint.setAlpha(0.5 * 255);
    builder.DrawImage(image, DlPoint(0, 0), DlImageSampling::kLinear,
                      &rect_paint);
    builder.Restore();
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), image, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setAlpha(), flutter::DlPaint::setImageFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [318/662]

impeller::testing::TEST_P	(	AiksTest	,
		MatrixSaveLayerFilter
	)

Definition at line 788 of file aiks_dl_unittests.cc.

                                        {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kBlack());
  builder.DrawPaint(paint);
  builder.SaveLayer(std::nullopt, nullptr);
  {
    paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
    paint.setBlendMode(DlBlendMode::kPlus);
    builder.DrawCircle(DlPoint(200, 200), 100, paint);
    // Should render a second circle, centered on the bottom-right-most edge of
    // the circle.
 
    DlMatrix matrix = DlMatrix::MakeTranslation({(200 + 100 * k1OverSqrt2),
                                                 (200 + 100 * k1OverSqrt2)}) *
                      DlMatrix::MakeScale({0.5, 0.5, 1}) *
                      DlMatrix::MakeTranslation({-200, -200});
    DlPaint save_paint;
    save_paint.setImageFilter(
        DlImageFilter::MakeMatrix(matrix, DlImageSampling::kLinear));
 
    builder.SaveLayer(std::nullopt, &save_paint);
 
    DlPaint circle_paint;
    circle_paint.setColor(DlColor::kGreen().withAlpha(255 * 0.5));
    circle_paint.setBlendMode(DlBlendMode::kPlus);
    builder.DrawCircle(DlPoint(200, 200), 100, circle_paint);
    builder.Restore();
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), impeller::k1OverSqrt2, flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), flutter::DlImageFilter::MakeMatrix(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and flutter::DlColor::withAlpha().

◆ TEST_P() [319/662]

impeller::testing::TEST_P	(	AiksTest	,
		MipmapGenerationWorksCorrectly
	)

Definition at line 481 of file aiks_dl_unittests.cc.

                                                 {
  TextureDescriptor texture_descriptor;
  texture_descriptor.size = ISize{1024, 1024};
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.mip_count = texture_descriptor.size.MipCount();
 
  std::vector<uint8_t> bytes(4194304);
  bool alternate = false;
  for (auto i = 0u; i < 4194304; i += 4) {
    if (alternate) {
      bytes[i] = 255;
      bytes[i + 1] = 0;
      bytes[i + 2] = 0;
      bytes[i + 3] = 255;
    } else {
      bytes[i] = 0;
      bytes[i + 1] = 255;
      bytes[i + 2] = 0;
      bytes[i + 3] = 255;
    }
    alternate = !alternate;
  }
 
  ASSERT_EQ(texture_descriptor.GetByteSizeOfBaseMipLevel(), bytes.size());
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      bytes.data(),                                   // data
      texture_descriptor.GetByteSizeOfBaseMipLevel()  // size
  );
  auto texture =
      GetContext()->GetResourceAllocator()->CreateTexture(texture_descriptor);
 
  auto device_buffer =
      GetContext()->GetResourceAllocator()->CreateBufferWithCopy(*mapping);
  auto command_buffer = GetContext()->CreateCommandBuffer();
  auto blit_pass = command_buffer->CreateBlitPass();
 
  blit_pass->AddCopy(DeviceBuffer::AsBufferView(std::move(device_buffer)),
                     texture);
  blit_pass->GenerateMipmap(texture);
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({command_buffer}).ok());
 
  auto image = DlImageImpeller::Make(texture);
 
  DisplayListBuilder builder;
  builder.DrawImageRect(
      image,
      DlRect::MakeWH(texture->GetSize().width, texture->GetSize().height),
      DlRect::MakeLTRB(0, 0, 100, 100), DlImageSampling::kMipmapLinear);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::DeviceBuffer::AsBufferView(), flutter::DisplayListBuilder::Build(), command_buffer, flutter::DisplayListBuilder::DrawImageRect(), impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), i, image, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeWH(), impeller::TextureDescriptor::mip_count, impeller::TSize< T >::MipCount(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and texture.

◆ TEST_P() [320/662]

impeller::testing::TEST_P	(	AiksTest	,
		MultipleColorWithShadowCache
	)

Definition at line 886 of file aiks_dl_text_unittests.cc.

                                               {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  AiksContext aiks_context(GetContext(),
                           std::make_shared<TypographerContextSkia>());
  // Cache empty
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            0u);
 
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
 
  std::array<DlColor, 4> colors{DlColor::kRed(), DlColor::kGreen(),
                                DlColor::kBlue(), DlColor::kRed()};
  for (const auto& color : colors) {
    ASSERT_TRUE(RenderTextInCanvasSkia(
        GetContext(), builder, "A", kFontFixture,
        TextRenderOptions{
            .color = color,
            .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)},
        sk_font));
  }
 
  DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
 
  // The count of cache entries should match the number of distinct colors
  // in the list.  Repeated usage of a color should not add to the cache.
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            3u);
}

References flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, flutter::testing::CreateTestFontOfSize(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPaint(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), flutter::DlColor::kBlue(), kFontFixture, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [321/662]

impeller::testing::TEST_P	(	AiksTest	,
		MultipleTextWithShadowCache
	)

Definition at line 853 of file aiks_dl_text_unittests.cc.

                                              {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  AiksContext aiks_context(GetContext(),
                           std::make_shared<TypographerContextSkia>());
  // Cache empty
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            0u);
 
  for (auto i = 0; i < 5; i++) {
    ASSERT_TRUE(RenderTextInCanvasSkia(
        GetContext(), builder, "Hello World", kFontFixture,
        TextRenderOptions{
            .color = DlColor::kBlue(),
            .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
  }
 
  DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
 
  // Text should be cached. Each text gets its own entry as we don't analyze the
  // strings.
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            5u);
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPaint(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), i, flutter::DlColor::kBlue(), kFontFixture, flutter::DlBlurMaskFilter::Make(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [322/662]

impeller::testing::TEST_P	(	AiksTest	,
		NoDimplesInRRectPath
	)

Definition at line 2361 of file aiks_dl_basic_unittests.cc.

                                       {
  Scalar width = 200.f;
  Scalar height = 60.f;
  Scalar corner = 1.f;
  bool stroked = true;
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("width", &width, 0, 200);
      ImGui::SliderFloat("height", &height, 0, 200);
      ImGui::SliderFloat("corner", &corner, 0, 1);
      ImGui::Checkbox("stroked", &stroked);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    DlPaint background_paint;
    background_paint.setColor(DlColor(1, 0.1, 0.1, 0.1, DlColorSpace::kSRGB));
    builder.DrawPaint(background_paint);
 
    std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue()};
    std::vector<Scalar> stops = {0.0, 1.0};
 
    DlPaint paint;
    auto gradient = DlColorSource::MakeLinear(DlPoint(0, 0), DlPoint(200, 200),
                                              2, colors.data(), stops.data(),
                                              DlTileMode::kClamp);
    paint.setColorSource(gradient);
    paint.setColor(DlColor::kWhite());
    if (stroked) {
      paint.setDrawStyle(DlDrawStyle::kStroke);
      paint.setStrokeWidth(20);
    } else {
      paint.setDrawStyle(DlDrawStyle::kFill);
    }
 
    builder.Save();
    builder.Translate(100, 100);
 
    Scalar corner_x = ((1 - corner) * 50) + 50;
    Scalar corner_y = corner * 50 + 50;
    DlRoundRect rrect = DlRoundRect::MakeRectXY(
        DlRect::MakeXYWH(0, 0, width, height), corner_x, corner_y);
    builder.DrawRoundRect(rrect, paint);
    builder.Restore();
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRoundRect(), height, flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), flutter::DisplayListBuilder::Translate(), width, x, and y.

◆ TEST_P() [323/662]

impeller::testing::TEST_P	(	AiksTest	,
		NonSquareFilledArcsRenderCorrectly
	)

Definition at line 1108 of file aiks_dl_basic_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                    .vertical_scale = 0.8f,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [324/662]

impeller::testing::TEST_P	(	AiksTest	,
		NonSquareFilledArcsRenderCorrectlyWithCenter
	)

Definition at line 1126 of file aiks_dl_basic_unittests.cc.

                                                               {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = true,
                    .full_circles = false,
                    .vertical_scale = 0.8f,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [325/662]

impeller::testing::TEST_P	(	AiksTest	,
		PaintBlendModeIsRespected
	)

Definition at line 172 of file aiks_dl_blend_unittests.cc.

                                            {
  DlPaint paint;
  DisplayListBuilder builder;
  // Default is kSourceOver.
 
  paint.setColor(DlColor::RGBA(1, 0, 0, 0.5));
  builder.DrawCircle(DlPoint(150, 200), 100, paint);
 
  paint.setColor(DlColor::RGBA(0, 1, 0, 0.5));
  builder.DrawCircle(DlPoint(250, 200), 100, paint);
 
  paint.setBlendMode(DlBlendMode::kPlus);
 
  paint.setColor(DlColor::kRed());
  builder.DrawCircle(DlPoint(450, 250), 100, paint);
 
  paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(550, 250), 100, paint);
 
  paint.setColor(DlColor::kBlue());
  builder.DrawCircle(DlPoint(500, 150), 100, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::RGBA(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [326/662]

impeller::testing::TEST_P	(	AiksTest	,
		PerspectiveRectangle
	)

Definition at line 2441 of file aiks_dl_basic_unittests.cc.

                                       {
  int perspective = 58;
  bool use_clip = true;
  bool diff_clip = false;
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderInt("perspective%", &perspective, 0, 100);
      ImGui::Checkbox("use clip", &use_clip);
      if (use_clip) {
        ImGui::Checkbox("diff clip", &diff_clip);
      }
      ImGui::SetWindowPos("Controls", ImVec2(500, 100));
      ImGui::End();
    }
 
    DisplayListBuilder builder;
 
    Scalar val = perspective * -0.00005f;
    builder.TransformFullPerspective(
        // clang-format off
        1.0f,  0.0f, 0.0f, 400.0f,
        0.0f,  1.0f, 0.0f, 400.0f,
        0.0f,  0.0f, 1.0f, 0.0f,
        0.0f,  val,  0.0f, 2.2f
        // clang-format on
    );
 
    if (use_clip) {
      Rect clip = DlRect::MakeLTRB(0, 0, 400, 800);
      DlClipOp clip_op = DlClipOp::kIntersect;
      if (diff_clip) {
        clip = clip.Expand(-20);
        clip_op = DlClipOp::kDifference;
      }
      builder.ClipRect(clip, clip_op);
    }
 
    DlPaint paint;
    paint.setColor(DlColor::kBlue());
    builder.DrawRect(DlRect::MakeLTRB(0, 0, 400, 800), paint);
 
    builder.DrawColor(DlColor::kWhite().withAlphaF(0.5f),
                      DlBlendMode::kSrcOver);
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::TransformFullPerspective().

◆ TEST_P() [327/662]

impeller::testing::TEST_P	(	AiksTest	,
		PipelineBlendSingleParameter
	)

Definition at line 2305 of file aiks_dl_basic_unittests.cc.

                                               {
  DisplayListBuilder builder;
 
  // Should render a green square in the middle of a blue circle.
  DlPaint paint;
  builder.SaveLayer(std::nullopt, &paint);
  {
    builder.Translate(100, 100);
    paint.setColor(DlColor::kBlue());
    builder.DrawCircle(DlPoint(200, 200), 200, paint);
    builder.ClipRect(DlRect::MakeXYWH(100, 100, 200, 200));
 
    paint.setColor(DlColor::kGreen());
    paint.setBlendMode(DlBlendMode::kSrcOver);
    paint.setImageFilter(DlImageFilter::MakeColorFilter(
        DlColorFilter::MakeBlend(DlColor::kWhite(), DlBlendMode::kDst)));
    builder.DrawCircle(DlPoint(200, 200), 200, paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlColorFilter::MakeBlend(), flutter::DlImageFilter::MakeColorFilter(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [328/662]

impeller::testing::TEST_P	(	AiksTest	,
		PrimitiveShapePlayground
	)

Definition at line 147 of file aiks_dl_primitive_shape_unittests.cc.

                                           {
  if (!IsPlaygroundEnabled()) {
    GTEST_SKIP() << "PrimitiveShapePlayground is only for on-screen use";
  }
  // In the odd case that we are being run with a playground and the
  // golden flag set, we don't want to write out the golden either.
  // Just do the playground part...
  SetEnableWriteGolden(false);
 
  RenderParameters params{
      .render_type = RenderType::kRectangle,
      .center = GetWindowBounds().GetCenter(),
  };
  // The ImGui controls need a pointer to an int and casting a pointer to
  // an enum field to an int pointer is frowned upon, so we instead create
  // an int variable and then fill in the params enum from it later.
  int render_type_index = static_cast<int>(RenderType::kRectangle);
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    FML_CHECK(IsPlaygroundEnabled());
    ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
    ImGui::SliderFloat("Stroke", &params.stroke_width, 0.0f, 30.0f);
    ImGui::SliderFloat("X Scale", &params.scale_x, 1.0f, 3.0f);
    ImGui::SliderFloat("Y Scale", &params.scale_y, 1.0f, 3.0f);
    ImGui::SliderFloat("X Skew", &params.skew_x, 0.0f, 1.0f);
    ImGui::SliderFloat("Y Skew", &params.skew_y, 0.0f, 1.0f);
    ImGui::SliderFloat("Rotation", &params.degrees, 0.0f, 360.0f);
    ImGui::ListBox(
        "Shape Type", &render_type_index,
        [](void* data, int index) {
          switch (static_cast<RenderType>(index)) {
            case RenderType::kSquare:
              return "Square";
            case RenderType::kRectangle:
              return "Rectangle";
            case RenderType::kCircle:
              return "Circle";
            case RenderType::kOval:
              return "Oval";
            case RenderType::kLine:
              return "Line";
            case RenderType::kValidCount:
            case RenderType::kInvalid:
              FML_UNREACHABLE();
          }
        },
        nullptr, static_cast<int>(RenderType::kValidCount), -1);
    ImGui::End();
 
    // Translate our "Gui int variable" to the appropriate enum field value.
    params.render_type = static_cast<RenderType>(render_type_index);
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.DrawColor(DlColor::kBlack(), DlBlendMode::kSrc);
    RenderPrimitiveWithStroke(builder, params);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::data, flutter::DisplayListBuilder::DrawColor(), FML_CHECK, FML_UNREACHABLE, flutter::DlColor::kBlack(), params, and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [329/662]

impeller::testing::TEST_P	(	AiksTest	,
		ReleasesTextureOnTeardown
	)

Definition at line 594 of file aiks_dl_unittests.cc.

                                            {
  // Must be called before any methods that use the context to ensure that
  // this test is always run with its own unique context.
  EnsureContextIsUnique();
 
  auto context = MakeContext();
  std::weak_ptr<Texture> weak_texture;
 
  {
    auto texture = CreateTextureForFixture("table_mountain_nx.png");
    weak_texture = texture;
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.Translate(100.0f, 100.0f);
 
    DlPaint paint;
    paint.setColorSource(DlColorSource::MakeImage(
        DlImageImpeller::Make(texture), DlTileMode::kClamp, DlTileMode::kClamp,
        DlImageSampling::kLinear, nullptr));
 
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 600, 600), paint);
 
    ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
  }
 
  // See https://github.com/flutter/flutter/issues/134751.
  //
  // If the fence waiter was working this may not be released by the end of the
  // scope above. Adding a manual shutdown so that future changes to the fence
  // waiter will not flake this test.
  context->Shutdown();
 
  // The texture should be released by now.
  ASSERT_TRUE(weak_texture.expired()) << "When the texture is no longer in use "
                                         "by the backend, it should be "
                                         "released.";
}

References flutter::DisplayListBuilder::Build(), context, flutter::DisplayListBuilder::DrawRect(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColorSource(), texture, flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [330/662]

impeller::testing::TEST_P	(	AiksTest	,
		RotateColorFilteredPath
	)

Definition at line 27 of file aiks_dl_path_unittests.cc.

                                          {
  DisplayListBuilder builder;
  builder.Transform(DlMatrix::MakeTranslation(DlPoint(300, 300)) *
                    DlMatrix::MakeRotationZ(DlDegrees(90)));
 
  DlPathBuilder arrow_stem;
  DlPathBuilder arrow_head;
 
  arrow_stem.MoveTo(DlPoint(120, 190)).LineTo(DlPoint(120, 50));
  arrow_head.MoveTo(DlPoint(50, 120))
      .LineTo(DlPoint(120, 190))
      .LineTo(DlPoint(190, 120));
 
  auto filter =
      DlColorFilter::MakeBlend(DlColor::kAliceBlue(), DlBlendMode::kSrcIn);
 
  DlPaint paint;
  paint.setStrokeWidth(15.0);
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setStrokeJoin(DlStrokeJoin::kRound);
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setColorFilter(filter);
  paint.setColor(DlColor::kBlack());
 
  builder.DrawPath(arrow_stem.TakePath(), paint);
  builder.DrawPath(arrow_head.TakePath(), paint);
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kAliceBlue(), flutter::DlColor::kBlack(), flutter::DlPathBuilder::LineTo(), flutter::DlColorFilter::MakeBlend(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Transform().

◆ TEST_P() [331/662]

impeller::testing::TEST_P	(	AiksTest	,
		RoundSuperellipseShadowComparison
	)

Definition at line 392 of file canvas_unittests.cc.

                                                    {
  // Config
  Size default_size(600, 400);
  Point left_center(400, 700);
  Point right_center(1300, 700);
  Color color = Color::Red();
 
  // Convert `color` to a `color_source`. This forces
  // `canvas.DrawRoundSuperellipse` to use the regular shadow algorithm
  // (blurring) instead of the fast shadow algorithm.
  std::shared_ptr<flutter::DlColorSource> color_source;
  {
    flutter::DlColor dl_color = flutter::DlColor(color.ToARGB());
    std::vector<flutter::DlColor> colors = {dl_color, dl_color};
    std::vector<Scalar> stops = {0.0, 1.0};
    color_source = flutter::DlColorSource::MakeLinear(
        {0, 0}, {1000, 1000}, 2, colors.data(), stops.data(),
        flutter::DlTileMode::kClamp);
  }
 
  RenderCallback callback = [&](RenderTarget& render_target) {
    ContentContext& context = GetContentContext();
    Canvas canvas(context, render_target, true, false);
    // Somehow there's a scaling factor between PlaygroundPoint and Canvas.
    Matrix ctm = Matrix::MakeScale(Vector2(1, 1) * 0.5);
    Matrix i_ctm = ctm.Invert();
 
    static Scalar sigma = 0.05;
    static Scalar radius = 200;
 
    // Define the ImGui
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Shadow", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Sigma", &sigma, 0, 100);
      ImGui::SliderFloat("Radius", &radius, 0, 1000);
      ImGui::End();
    }
 
    static PlaygroundPoint right_reference_var(
        ctm * (right_center + default_size / 2), 30, Color::White());
    Point right_reference = i_ctm * DrawPlaygroundPoint(right_reference_var);
    Point half_size = (right_reference - right_center).Abs();
    Rect left_bounds = Rect::MakeEllipseBounds(left_center, half_size);
    Rect right_bounds = Rect::MakeEllipseBounds(right_center, half_size);
 
    Paint paint{
        .color = color,
        .mask_blur_descriptor =
            Paint::MaskBlurDescriptor{
                .sigma = Sigma(sigma),
            },
    };
 
    // Left: Draw with canvas
    canvas.DrawRoundSuperellipse(
        RoundSuperellipse::MakeRectRadius(left_bounds, radius), paint);
 
    // Right: Direct draw
    paint.color_source = color_source.get();
    canvas.DrawRoundSuperellipse(
        RoundSuperellipse::MakeRectRadius(right_bounds, radius), paint);
 
    canvas.EndReplay();
    return true;
  };
 
  ASSERT_TRUE(Playground::OpenPlaygroundHere(callback));
}

References callback, impeller::Paint::color, context, impeller::DrawPlaygroundPoint(), impeller::Canvas::DrawRoundSuperellipse(), impeller::Canvas::EndReplay(), impeller::Matrix::Invert(), flutter::kClamp, impeller::TRect< Scalar >::MakeEllipseBounds(), flutter::DlColorSource::MakeLinear(), impeller::RoundSuperellipse::MakeRectRadius(), impeller::Matrix::MakeScale(), impeller::Playground::OpenPlaygroundHere(), impeller::Color::Red(), impeller::Paint::MaskBlurDescriptor::sigma, impeller::Color::ToARGB(), and impeller::Color::White().

◆ TEST_P() [332/662]

impeller::testing::TEST_P	(	AiksTest	,
		RuntimeEffectImageFilterRotated
	)

Definition at line 564 of file aiks_dl_runtime_effect_unittests.cc.

                                                  {
  auto image = DlImageImpeller::Make(CreateTextureForFixture("kalimba.jpg"));
  auto size = image->GetBounds().GetSize();
 
  struct FragUniforms {
    Size size;
  } frag_uniforms = {.size = Size(size.width, size.height)};
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  auto runtime_stages_result = OpenAssetAsRuntimeStage("gradient.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
      nullptr,
  };
 
  auto runtime_filter = DlImageFilter::MakeRuntimeEffect(
      DlRuntimeEffectImpeller::Make(runtime_stage), sampler_inputs,
      uniform_data);
 
  Scalar rotation = 45;
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("rotation", &rotation, 0, 360);
      ImGui::End();
    }
    DisplayListBuilder builder;
    builder.Translate(size.width * 0.5, size.height * 0.5);
    builder.Rotate(rotation);
    builder.Translate(-size.width * 0.5, -size.height * 0.5);
 
    DlPaint paint;
    paint.setImageFilter(runtime_filter);
    builder.DrawImage(image, DlPoint(0.0, 0.0),
                      DlImageSampling::kNearestNeighbor, &paint);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), image, flutter::DlRuntimeEffectImpeller::Make(), impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeRuntimeEffect(), flutter::DisplayListBuilder::Rotate(), flutter::DlPaint::setImageFilter(), flutter::size, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [333/662]

impeller::testing::TEST_P	(	AiksTest	,
		RuntimeEffectVectorArray
	)

Definition at line 614 of file aiks_dl_runtime_effect_unittests.cc.

                                           {
  constexpr float kDimension = 400.0f;
  struct FragUniforms {
    Vector2 iResolution;
    Vector4 iValues;
  } frag_uniforms = {.iResolution = Vector2(kDimension, kDimension),
                     .iValues = Vector4(0.25, 0.50, 0.75, 1.0)};
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  DlPaint paint;
  auto effect = MakeRuntimeEffect(this, "runtime_stage_vector_array.frag.iplr",
                                  uniform_data);
  ABSL_ASSERT_OK(effect);
  paint.setColorSource(effect.value());
 
  DisplayListBuilder builder;
  builder.DrawRect(DlRect::MakeXYWH(0, 0, kDimension, kDimension), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::TRect< Scalar >::MakeXYWH(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [334/662]

impeller::testing::TEST_P	(	AiksTest	,
		RuntimeEffectWithInvalidSamplerDoesNotCrash
	)

Definition at line 135 of file aiks_dl_runtime_effect_unittests.cc.

                                                              {
  ScopedValidationDisable disable_validation;
 
  // Create a sampler that is not usable as an input to the runtime effect.
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  const float stops[2] = {0.0, 1.0};
  auto linear = flutter::DlColorSource::MakeLinear({0.0, 0.0}, {300.0, 300.0},
                                                   2, colors.data(), stops,
                                                   flutter::DlTileMode::kClamp);
  std::vector<std::shared_ptr<DlColorSource>> sampler_inputs = {
      linear,
  };
 
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(Vector2));
 
  DlPaint paint;
  auto effect =
      MakeRuntimeEffect(this, "runtime_stage_filter_example.frag.iplr",
                        uniform_data, sampler_inputs);
  ABSL_ASSERT_OK(effect);
  paint.setColorSource(effect.value());
 
  DisplayListBuilder builder;
  builder.DrawPaint(paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::DlColor::kRed(), flutter::DlColorSource::MakeLinear(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [335/662]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerDrawsBehindSubsequentEntities
	)

Definition at line 2160 of file aiks_dl_basic_unittests.cc.

                                                         {
  // Compare with https://fiddle.skia.org/c/9e03de8567ffb49e7e83f53b64bcf636
  DisplayListBuilder builder;
  DlPaint paint;
 
  paint.setColor(DlColor::kBlack());
  DlRect rect = DlRect::MakeXYWH(25, 25, 25, 25);
  builder.DrawRect(rect, paint);
 
  builder.Translate(10, 10);
 
  DlPaint save_paint;
  builder.SaveLayer(std::nullopt, &save_paint);
 
  paint.setColor(DlColor::kGreen());
  builder.DrawRect(rect, paint);
 
  builder.Restore();
 
  builder.Translate(10, 10);
  paint.setColor(DlColor::kRed());
  builder.DrawRect(rect, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [336/662]

impeller::testing::TEST_P	(	AiksTest	,
		SaveLayerFiltersScaleWithTransform
	)

Definition at line 2252 of file aiks_dl_basic_unittests.cc.

                                                     {
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Translate(100, 100);
 
  auto texture = DlImageImpeller::Make(CreateTextureForFixture("boston.jpg"));
  auto draw_image_layer = [&builder, &texture](const DlPaint& paint) {
    builder.SaveLayer(std::nullopt, &paint);
    builder.DrawImage(texture, DlPoint(), DlImageSampling::kLinear);
    builder.Restore();
  };
 
  DlPaint effect_paint;
  effect_paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 6));
  draw_image_layer(effect_paint);
 
  builder.Translate(300, 300);
  builder.Scale(3, 3);
  draw_image_layer(effect_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::DlBlurMaskFilter::Make(), impeller::DlImageImpeller::Make(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setMaskFilter(), texture, flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [337/662]

impeller::testing::TEST_P	(	AiksTest	,
		ScaledK
	)

Definition at line 176 of file aiks_dl_text_unittests.cc.

                          {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
  for (int i = 0; i < 6; ++i) {
    builder.Save();
    builder.Translate(300 * i, 0);
    Scalar scale = 0.445 - (i / 1000.f);
    builder.Scale(scale, scale);
    RenderTextInCanvasSkia(
        GetContext(), builder, "k", "Roboto-Regular.ttf",
        TextRenderOptions{.font_size = 600, .position = DlPoint(10, 500)});
    RenderTextInCanvasSkia(
        GetContext(), builder, "k", "Roboto-Regular.ttf",
        TextRenderOptions{.font_size = 300, .position = DlPoint(10, 800)});
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::font_size, i, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [338/662]

impeller::testing::TEST_P	(	AiksTest	,
		SetContentsWithRegion
	)

Definition at line 560 of file aiks_dl_unittests.cc.

                                        {
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
 
  // Replace part of the texture with a red rectangle.
  std::vector<uint8_t> bytes(100 * 100 * 4);
  for (auto i = 0u; i < bytes.size(); i += 4) {
    bytes[i] = 255;
    bytes[i + 1] = 0;
    bytes[i + 2] = 0;
    bytes[i + 3] = 255;
  }
  auto mapping =
      std::make_shared<fml::NonOwnedMapping>(bytes.data(), bytes.size());
  auto device_buffer =
      GetContext()->GetResourceAllocator()->CreateBufferWithCopy(*mapping);
  auto cmd_buffer = GetContext()->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
  blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer), bridge,
                     IRect::MakeLTRB(50, 50, 150, 150));
 
  auto did_submit =
      blit_pass->EncodeCommands() &&
      GetContext()->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok();
  ASSERT_TRUE(did_submit);
 
  auto image = DlImageImpeller::Make(bridge);
 
  DisplayListBuilder builder;
  builder.DrawImage(image, DlPoint(0, 0), {});
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References impeller::DeviceBuffer::AsBufferView(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), i, image, impeller::DlImageImpeller::Make(), and impeller::TRect< T >::MakeLTRB().

◆ TEST_P() [339/662]

impeller::testing::TEST_P	(	AiksTest	,
		SiblingSaveLayerBoundsAreRespected
	)

Definition at line 2186 of file aiks_dl_basic_unittests.cc.

                                                     {
  DisplayListBuilder builder;
  DlPaint paint;
  DlRect rect = DlRect::MakeXYWH(0, 0, 1000, 1000);
 
  // Black, green, and red squares offset by [10, 10].
  {
    DlPaint save_paint;
    DlRect bounds = DlRect::MakeXYWH(25, 25, 25, 25);
    builder.SaveLayer(bounds, &save_paint);
    paint.setColor(DlColor::kBlack());
    builder.DrawRect(rect, paint);
    builder.Restore();
  }
 
  {
    DlPaint save_paint;
    DlRect bounds = DlRect::MakeXYWH(35, 35, 25, 25);
    builder.SaveLayer(bounds, &save_paint);
    paint.setColor(DlColor::kGreen());
    builder.DrawRect(rect, paint);
    builder.Restore();
  }
 
  {
    DlPaint save_paint;
    DlRect bounds = DlRect::MakeXYWH(45, 45, 25, 25);
    builder.SaveLayer(bounds, &save_paint);
    paint.setColor(DlColor::kRed());
    builder.DrawRect(rect, paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [340/662]

impeller::testing::TEST_P	(	AiksTest	,
		SingleIconShadowTest
	)

Definition at line 924 of file aiks_dl_text_unittests.cc.

                                       {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  AiksContext aiks_context(GetContext(),
                           std::make_shared<TypographerContextSkia>());
  // Cache empty
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            0u);
 
  // Create font instance outside loop so all draws use identical font instance.
  auto c_font_fixture = std::string(kFontFixture);
  auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
  ASSERT_TRUE(mapping);
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont sk_font(font_mgr->makeFromData(mapping), 50);
 
  for (auto i = 0; i < 10; i++) {
    ASSERT_TRUE(RenderTextInCanvasSkia(
        GetContext(), builder, "A", kFontFixture,
        TextRenderOptions{
            .color = DlColor::kBlue(),
            .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)},
        sk_font));
  }
 
  DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
 
  // Text should be cached. All 10 glyphs use the same cache entry.
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            1u);
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPaint(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), txt::GetDefaultFontManager(), impeller::ContentContext::GetTextShadowCache(), i, flutter::DlColor::kBlue(), kFontFixture, flutter::DlBlurMaskFilter::Make(), flutter::testing::OpenFixtureAsSkData(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [341/662]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorCircleMaskBlurTinySigma
	)

Definition at line 129 of file aiks_dl_blur_unittests.cc.

                                                    {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  std::vector<float> sigmas = {0.0, 0.01, 1.0};
  std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
                                 DlColor::kRed()};
  for (uint32_t i = 0; i < sigmas.size(); ++i) {
    DlPaint paint;
    paint.setColor(colors[i]);
    paint.setMaskFilter(
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
 
    builder.Save();
    builder.Translate(100 + (i * 100), 100);
    DlRoundRect rrect = DlRoundRect::MakeRectXY(
        DlRect::MakeXYWH(0, 0, 100.0f, 100.0f), 100, 100);
    builder.DrawRoundRect(rrect, paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRoundRect(), i, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlBlurMaskFilter::Make(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [342/662]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorCirclesOvalsRRectsMaskBlurCorrectly
	)

Definition at line 1516 of file aiks_dl_basic_unittests.cc.

                                                                {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 1.0f));
 
  builder.DrawPaint(DlPaint().setColor(DlColor::kWhite()));
 
  paint.setColor(
      DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f));
  Scalar y = 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    builder.DrawRect(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                      radius, 60.0f - radius),
                     paint);
  }
 
  paint.setColor(DlColor::kBlue());
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    builder.DrawCircle(DlPoint(x + 25, y + 25), radius, paint);
  }
 
  paint.setColor(DlColor::kGreen());
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 10.0f;
    builder.DrawOval(DlRect::MakeXYWH(x + 25 - radius / 2, y + radius / 2,  //
                                      radius, 60.0f - radius),
                     paint);
  }
 
  paint.setColor(
      DlColor::RGBA(128.0f / 255.0f, 0.0f / 255.0f, 128.0f / 255.0f, 1.0f));
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 20.0f;
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                                radius, radius),
        paint);
  }
 
  paint.setColor(
      DlColor::RGBA(255.0f / 255.0f, 165.0f / 255.0f, 0.0f / 255.0f, 1.0f));
  y += 100.0f;
  for (int i = 0; i < 5; i++) {
    Scalar x = (i + 1) * 100;
    Scalar radius = x / 20.0f;
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(x, y, 60.0f, 60.0f),  //
                                radius, 5.0f),
        paint);
  }
 
  auto dl = builder.Build();
  ASSERT_TRUE(OpenPlaygroundHere(dl));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawOval(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), i, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), flutter::DlBlurMaskFilter::Make(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), x, and y.

◆ TEST_P() [343/662]

impeller::testing::TEST_P	(	AiksTest	,
		SolidColorOvalsMaskBlurTinySigma
	)

Definition at line 39 of file aiks_dl_blur_unittests.cc.

                                                   {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  std::vector<float> sigmas = {0.0, 0.01, 1.0};
  std::vector<DlColor> colors = {DlColor::kGreen(), DlColor::kYellow(),
                                 DlColor::kRed()};
  for (uint32_t i = 0; i < sigmas.size(); ++i) {
    DlPaint paint;
    paint.setColor(colors[i]);
    paint.setMaskFilter(
        DlBlurMaskFilter::Make(DlBlurStyle::kNormal, sigmas[i]));
 
    builder.Save();
    builder.Translate(100 + (i * 100), 100);
    DlRoundRect rrect =
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 60.0f, 160.0f), 50, 100);
    builder.DrawRoundRect(rrect, paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRoundRect(), i, flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlBlurMaskFilter::Make(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [344/662]

impeller::testing::TEST_P	(	AiksTest	,
		SolidStrokesRenderCorrectly
	)

Definition at line 520 of file aiks_dl_path_unittests.cc.

                                              {
  // Compare with https://fiddle.skia.org/c/027392122bec8ac2b5d5de00a4b9bbe2
  auto callback = [&]() -> sk_sp<DisplayList> {
    static Color color = Color::Black().WithAlpha(0.5);
    static float scale = 3;
    static bool add_circle_clip = true;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&color));
      ImGui::SliderFloat("Scale", &scale, 0, 6);
      ImGui::Checkbox("Circle clip", &add_circle_clip);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    DlPaint paint;
 
    paint.setColor(DlColor::kWhite());
    builder.DrawPaint(paint);
 
    paint.setColor(
        DlColor::ARGB(color.alpha, color.red, color.green, color.blue));
    paint.setDrawStyle(DlDrawStyle::kStroke);
    paint.setStrokeWidth(10);
 
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(20, 20));
    path_builder.QuadraticCurveTo(DlPoint(60, 20), DlPoint(60, 60));
    path_builder.Close();
    path_builder.MoveTo(DlPoint(60, 20));
    path_builder.QuadraticCurveTo(DlPoint(60, 60), DlPoint(20, 60));
    DlPath path = path_builder.TakePath();
 
    builder.Scale(scale, scale);
 
    if (add_circle_clip) {
      static PlaygroundPoint circle_clip_point_a(Point(60, 300), 20,
                                                 Color::Red());
      static PlaygroundPoint circle_clip_point_b(Point(600, 300), 20,
                                                 Color::Red());
      auto [handle_a, handle_b] =
          DrawPlaygroundLine(circle_clip_point_a, circle_clip_point_b);
 
      Matrix screen_to_canvas = builder.GetMatrix();
      if (!screen_to_canvas.IsInvertible()) {
        return nullptr;
      }
      screen_to_canvas = screen_to_canvas.Invert();
 
      Point point_a = screen_to_canvas * handle_a;
      Point point_b = screen_to_canvas * handle_b;
 
      Point middle = point_a + point_b;
      middle *= GetContentScale().x / 2;
 
      auto radius = point_a.GetDistance(middle);
 
      builder.ClipPath(DlPath::MakeCircle(middle, radius));
    }
 
    for (auto join :
         {DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
      paint.setStrokeJoin(join);
      for (auto cap :
           {DlStrokeCap::kButt, DlStrokeCap::kSquare, DlStrokeCap::kRound}) {
        paint.setStrokeCap(cap);
        builder.DrawPath(path, paint);
        builder.Translate(80, 0);
      }
      builder.Translate(-240, 60);
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::Color::alpha, flutter::DlColor::ARGB(), impeller::Color::Black(), impeller::Color::blue, flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipPath(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), impeller::DrawPlaygroundLine(), flutter::DisplayListBuilder::GetMatrix(), impeller::Color::green, impeller::Matrix::Invert(), impeller::Matrix::IsInvertible(), flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::QuadraticCurveTo(), impeller::Color::red, impeller::Color::Red(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), flutter::DisplayListBuilder::Translate(), impeller::Color::WithAlpha(), x, flutter::Point::x(), and y.

◆ TEST_P() [345/662]

impeller::testing::TEST_P	(	AiksTest	,
		SrgbToLinearFilterSubpassCollapseOptimization
	)

Definition at line 122 of file aiks_dl_unittests.cc.

                                                                {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColorFilter(DlColorFilter::MakeLinearToSrgbGamma());
  builder.SaveLayer(std::nullopt, &paint);
 
  builder.Translate(500, 300);
  builder.Rotate(120);  // 120 deg
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 200, 200), draw_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColorFilter::MakeLinearToSrgbGamma(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [346/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokeCapsAndJoins
	)

Definition at line 898 of file aiks_dl_path_unittests.cc.

                                     {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  builder.Translate(100, 0);
 
  builder.Save();
  for (auto cap : std::vector<DlStrokeCap>{
           DlStrokeCap::kButt, DlStrokeCap::kRound, DlStrokeCap::kSquare}) {
    DlPathBuilder path_builder;
    path_builder.MoveTo({20, 50});
    path_builder.LineTo({50, 50});
    path_builder.MoveTo({120, 50});
    path_builder.LineTo({120, 80});
    path_builder.MoveTo({180, 50});
    path_builder.LineTo({180, 50});
    DlPath path = path_builder.TakePath();
 
    DlPaint paint;
    paint.setColor(DlColor::kRed());
    paint.setDrawStyle(DlDrawStyle::kStroke);
    paint.setStrokeWidth(20.0f);
    paint.setStrokeCap(cap);
    paint.setStrokeJoin(DlStrokeJoin::kBevel);
 
    builder.DrawPath(path, paint);
 
    paint.setColor(DlColor::kYellow());
    paint.setStrokeWidth(1.0f);
    paint.setStrokeCap(DlStrokeCap::kButt);
 
    builder.DrawPath(path, paint);
 
    builder.Translate(250, 0);
  }
  builder.Restore();
 
  builder.Translate(0, 100);
 
  builder.Save();
  for (auto join : std::vector<DlStrokeJoin>{
           DlStrokeJoin::kBevel, DlStrokeJoin::kRound, DlStrokeJoin::kMiter}) {
    DlPathBuilder path_builder;
    path_builder.MoveTo({20, 50});  // 0 degree right turn
    path_builder.LineTo({50, 50});
    path_builder.LineTo({80, 50});
    path_builder.MoveTo({20, 150});  // 90 degree right turn
    path_builder.LineTo({50, 150});
    path_builder.LineTo({50, 180});
    path_builder.MoveTo({20, 250});  // 45 degree right turn
    path_builder.LineTo({50, 250});
    path_builder.LineTo({70, 270});
    path_builder.MoveTo({20, 350});  // 135 degree right turn
    path_builder.LineTo({50, 350});
    path_builder.LineTo({30, 370});
    path_builder.MoveTo({20, 450});  // 180 degree right turn
    path_builder.LineTo({50, 450});
    path_builder.LineTo({20, 450});
    path_builder.MoveTo({120, 80});  // 0 degree left turn
    path_builder.LineTo({150, 80});
    path_builder.LineTo({180, 80});
    path_builder.MoveTo({120, 180});  // 90 degree left turn
    path_builder.LineTo({150, 180});
    path_builder.LineTo({150, 150});
    path_builder.MoveTo({120, 280});  // 45 degree left turn
    path_builder.LineTo({150, 280});
    path_builder.LineTo({170, 260});
    path_builder.MoveTo({120, 380});  // 135 degree left turn
    path_builder.LineTo({150, 380});
    path_builder.LineTo({130, 360});
    path_builder.MoveTo({120, 480});  // 180 degree left turn
    path_builder.LineTo({150, 480});
    path_builder.LineTo({120, 480});
    DlPath path = path_builder.TakePath();
 
    DlPaint paint;
 
    paint.setColor(DlColor::kRed());
    paint.setDrawStyle(DlDrawStyle::kStroke);
    paint.setStrokeWidth(20.0f);
    paint.setStrokeCap(DlStrokeCap::kSquare);
    paint.setStrokeJoin(join);
    builder.DrawPath(path, paint);
 
    paint.setColor(DlColor::kYellow());
    paint.setStrokeWidth(1.0f);
    paint.setStrokeCap(DlStrokeCap::kButt);
    builder.DrawPath(path, paint);
 
    builder.Translate(250, 0);
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlColor::kYellow(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [347/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsCoverFullArcWithButtEnds
	)

Definition at line 1367 of file aiks_dl_basic_unittests.cc.

                                                      {
  // This test compares the rendering of a full circle arc against a partial
  // arc by drawing a one over the other in high contrast. If the partial
  // arc misses any pixels that were drawn by the full arc, there will be
  // some "pixel dirt" around the missing "erased" parts of the arcs. This
  // case arises while rendering a CircularProgressIndicator with a background
  // color where we want the rendering of the background full arc to hit the
  // same pixels around the edges as the partial arc that covers it.
  //
  // In this case we draw a full blue circle and then draw a partial arc
  // over it in the background color (white).
 
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeCap(DlStrokeCap::kButt);
  paint.setColor(DlColor::kBlue());
 
  // First draw full circles in blue to establish the pixels to be erased
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = true,
                });
 
  paint.setColor(DlColor::kWhite());
 
  // Then draw partial arcs in white over the circles to "erase" them
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [348/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithBevelJoinsAndCenter
	)

Definition at line 1234 of file aiks_dl_basic_unittests.cc.

                                                                    {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeJoin(DlStrokeJoin::kBevel);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = true,
                    .full_circles = false,
                    .sweeps_over_360 = true,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [349/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithButtEnds
	)

Definition at line 1144 of file aiks_dl_basic_unittests.cc.

                                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeCap(DlStrokeCap::kButt);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [350/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithMiterJoinsAndCenter
	)

Definition at line 1255 of file aiks_dl_basic_unittests.cc.

                                                                    {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeJoin(DlStrokeJoin::kMiter);
  // Default miter of 4.0 does a miter on all of the centers, but
  // using 3.0 will show some bevels on the widest interior angles...
  paint.setStrokeMiter(3.0f);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = true,
                    .full_circles = false,
                    .sweeps_over_360 = true,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeMiter(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [351/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithRoundEnds
	)

Definition at line 1199 of file aiks_dl_basic_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [352/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithRoundJoinsAndCenter
	)

Definition at line 1279 of file aiks_dl_basic_unittests.cc.

                                                                    {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeJoin(DlStrokeJoin::kRound);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = true,
                    .full_circles = false,
                    .sweeps_over_360 = true,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [353/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareAndButtAndRoundEnds
	)

Definition at line 1329 of file aiks_dl_basic_unittests.cc.

                                                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(8.0f);
  paint.setStrokeCap(DlStrokeCap::kSquare);
  paint.setColor(DlColor::kRed());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setColor(DlColor::kGreen());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  paint.setStrokeCap(DlStrokeCap::kButt);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [354/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareAndButtEnds
	)

Definition at line 1300 of file aiks_dl_basic_unittests.cc.

                                                                  {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(8.0f);
  paint.setStrokeCap(DlStrokeCap::kSquare);
  paint.setColor(DlColor::kRed());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  paint.setStrokeCap(DlStrokeCap::kButt);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [355/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithSquareEnds
	)

Definition at line 1164 of file aiks_dl_basic_unittests.cc.

                                                           {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(6.0f);
  paint.setStrokeCap(DlStrokeCap::kSquare);
  paint.setColor(DlColor::kBlue());
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), x, and y.

◆ TEST_P() [356/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithTranslucencyAndRoundEnds
	)

Definition at line 1219 of file aiks_dl_basic_unittests.cc.

                                                                         {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
 
  RenderArcFarmForOverlappingCapsTest(builder, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), x, and y.

◆ TEST_P() [357/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedArcsRenderCorrectlyWithTranslucencyAndSquareEnds
	)

Definition at line 1184 of file aiks_dl_basic_unittests.cc.

                                                                          {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeCap(DlStrokeCap::kSquare);
  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
 
  RenderArcFarmForOverlappingCapsTest(builder, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), x, and y.

◆ TEST_P() [358/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedCirclesRenderCorrectly
	)

Definition at line 775 of file aiks_dl_basic_unittests.cc.

                                                {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  const int color_count = 3;
  DlColor colors[color_count] = {
      DlColor::kBlue(),
      DlColor::kGreen(),
      DlColor::RGBA(220.0f / 255.0f, 20.0f / 255.0f, 60.0f / 255.0f, 1.0f),
  };
 
  paint.setColor(DlColor::kWhite());
  builder.DrawPaint(paint);
 
  int c_index = 0;
 
  auto draw = [&paint, &colors, &c_index](DlCanvas& canvas, DlPoint center,
                                          Scalar r, Scalar dr, int n) {
    for (int i = 0; i < n; i++) {
      paint.setColor(colors[(c_index++) % color_count]);
      canvas.DrawCircle(center, r, paint);
      r += dr;
    }
  };
 
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(1);
  draw(builder, DlPoint(10, 10), 2, 2, 14);  // r = [2, 28], covers [1,29]
  paint.setStrokeWidth(5);
  draw(builder, DlPoint(10, 10), 35, 10, 56);  // r = [35, 585], covers [30,590]
 
  DlColor gradient_colors[7] = {
      DlColor::RGBA(0x1f / 255.0, 0.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0x5b / 255.0, 0.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0x87 / 255.0, 0x01 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xac / 255.0, 0x25 / 255.0, 0x53 / 255.0, 1.0),
      DlColor::RGBA(0xe1 / 255.0, 0x6b / 255.0, 0x5c / 255.0, 1.0),
      DlColor::RGBA(0xf3 / 255.0, 0x90 / 255.0, 0x60 / 255.0, 1.0),
      DlColor::RGBA(0xff / 255.0, 0xb5 / 255.0, 0x6b / 250.0, 1.0),
  };
  DlScalar stops[7] = {
      0.0,
      (1.0 / 6.0) * 1,
      (1.0 / 6.0) * 2,
      (1.0 / 6.0) * 3,
      (1.0 / 6.0) * 4,
      (1.0 / 6.0) * 5,
      1.0,
  };
  auto texture = CreateTextureForFixture("airplane.jpg",
                                         /*enable_mipmapping=*/true);
  auto image = DlImageImpeller::Make(texture);
 
  paint.setColorSource(DlColorSource::MakeRadial(
      DlPoint(500, 600), 75, 7, gradient_colors, stops, DlTileMode::kMirror));
  draw(builder, DlPoint(500, 600), 5, 10, 10);
 
  DlMatrix local_matrix = DlMatrix::MakeTranslation({700, 200});
  paint.setColorSource(DlColorSource::MakeImage(
      image, DlTileMode::kRepeat, DlTileMode::kRepeat,
      DlImageSampling::kNearestNeighbor, &local_matrix));
  draw(builder, DlPoint(800, 300), 5, 10, 10);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), i, image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kWhite(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeRadial(), impeller::Matrix::MakeTranslation(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), texture, x, and y.

◆ TEST_P() [359/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedPathWithLargeStrokeWidthRendersCorrectly
	)

Definition at line 931 of file aiks_dl_basic_unittests.cc.

                                                                  {
  DrawStrokedAndFilledCirclesWithZoom(this, /*zoom=*/1.0f, /*radius=*/1.0f,
                                      /*stroke_width=*/5.0f);
}

◆ TEST_P() [360/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedPathWithMoveToThenCloseDrawnCorrectly
	)

Definition at line 536 of file aiks_dl_unittests.cc.

                                                               {
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(0, 400))
      .LineTo(DlPoint(0, 0))
      .LineTo(DlPoint(400, 0))
      // MoveTo implicitly adds a contour, ensure that close doesn't
      // add another nearly-empty contour.
      .MoveTo(DlPoint(0, 400))
      .Close();
  DlPath path = path_builder.TakePath();
 
  DisplayListBuilder builder;
  builder.Translate(50, 50);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  paint.setStrokeCap(DlStrokeCap::kRound);
  paint.setStrokeWidth(10);
  paint.setDrawStyle(DlDrawStyle::kStroke);
  builder.DrawPath(path, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlPathBuilder::Close(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kBlue(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [361/662]

impeller::testing::TEST_P	(	AiksTest	,
		StrokedRectsRenderCorrectly
	)

Definition at line 538 of file aiks_dl_basic_unittests.cc.

                                              {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  DlPaint paint;
  paint.setColor(DlColor::kPurple());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(20.0f);
 
  DlPaint thin_paint = paint;
  thin_paint.setColor(DlColor::kYellow());
  thin_paint.setStrokeWidth(0.0f);
 
  DlRect rect = DlRect::MakeLTRB(10, 10, 90, 90);
  DlRect thin_tall_rect = DlRect::MakeLTRB(120, 10, 120, 90);
  DlRect thin_wide_rect = DlRect::MakeLTRB(10, 120, 90, 120);
  DlRect empty_rect = DlRect::MakeLTRB(120, 120, 120, 120);
 
  // We draw the following sets of rectangles:
  //
  //      A     E     X
  //                  X
  //      B     F     X
  //                  X
  //      C  D  G  H  X
  //
  // Purple A,B,C,D are all drawn with stroke width 20 (non-overflowing).
  // Each of those sets has 4 rectangles of dimension 80x80, 80x0, 0x80,
  // and 0,0 to demonstrate the basic behavior and also the behavior of
  // empty dimensions.
  //
  // Blue E,F,G,H are the same 80x80 rectangles, but with an overflowing
  // stroke width of 120 to show the behavior with degenerately large
  // stroke widths.
  //
  // A,E are drawn with Bevel joins.
  // B,F are drawn with Round joins.
  // C,G are drawn with Miter joins and a large enough miter limit.
  // D,H are drawn with Miter joins and a too small miter limit (== Bevel).
  //
  // All orange X rectangles are drawn with round joins and increasing stroke
  // widths to demonstrate fidelity of the rounding code at various arc sizes.
  // These X rectangles also help test that the variable sizing estimates in
  // the round join code are accurate.
 
  // rects (A)
  paint.setStrokeJoin(DlStrokeJoin::kBevel);
  builder.DrawRect(rect.Shift({100, 100}), paint);
  builder.DrawRect(rect.Shift({100, 100}), thin_paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 100}), paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 100}), thin_paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 100}), paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 100}), thin_paint);
  builder.DrawRect(empty_rect.Shift({100, 100}), paint);
  builder.DrawRect(empty_rect.Shift({100, 100}), thin_paint);
 
  // rects (B)
  paint.setStrokeJoin(DlStrokeJoin::kRound);
  builder.DrawRect(rect.Shift({100, 300}), paint);
  builder.DrawRect(rect.Shift({100, 300}), thin_paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 300}), paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 300}), thin_paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 300}), paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 300}), thin_paint);
  builder.DrawRect(empty_rect.Shift({100, 300}), paint);
  builder.DrawRect(empty_rect.Shift({100, 300}), thin_paint);
 
  // rects (C)
  paint.setStrokeJoin(DlStrokeJoin::kMiter);
  paint.setStrokeMiter(kSqrt2 + flutter::kEhCloseEnough);
  builder.DrawRect(rect.Shift({100, 500}), paint);
  builder.DrawRect(rect.Shift({100, 500}), thin_paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 500}), paint);
  builder.DrawRect(thin_tall_rect.Shift({100, 500}), thin_paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 500}), paint);
  builder.DrawRect(thin_wide_rect.Shift({100, 500}), thin_paint);
  builder.DrawRect(empty_rect.Shift({100, 500}), paint);
  builder.DrawRect(empty_rect.Shift({100, 500}), thin_paint);
 
  // rects (D)
  paint.setStrokeJoin(DlStrokeJoin::kMiter);
  paint.setStrokeMiter(kSqrt2 - flutter::kEhCloseEnough);
  builder.DrawRect(rect.Shift({300, 500}), paint);
  builder.DrawRect(rect.Shift({300, 500}), thin_paint);
  builder.DrawRect(thin_tall_rect.Shift({300, 500}), paint);
  builder.DrawRect(thin_tall_rect.Shift({300, 500}), thin_paint);
  builder.DrawRect(thin_wide_rect.Shift({300, 500}), paint);
  builder.DrawRect(thin_wide_rect.Shift({300, 500}), thin_paint);
  builder.DrawRect(empty_rect.Shift({300, 500}), paint);
  builder.DrawRect(empty_rect.Shift({300, 500}), thin_paint);
 
  paint.setStrokeWidth(120.0f);
  paint.setColor(DlColor::kBlue());
  rect = rect.Expand(-20);
 
  // rect (E)
  paint.setStrokeJoin(DlStrokeJoin::kBevel);
  builder.DrawRect(rect.Shift({500, 100}), paint);
  builder.DrawRect(rect.Shift({500, 100}), thin_paint);
 
  // rect (F)
  paint.setStrokeJoin(DlStrokeJoin::kRound);
  builder.DrawRect(rect.Shift({500, 300}), paint);
  builder.DrawRect(rect.Shift({500, 300}), thin_paint);
 
  // rect (G)
  paint.setStrokeJoin(DlStrokeJoin::kMiter);
  paint.setStrokeMiter(kSqrt2 + flutter::kEhCloseEnough);
  builder.DrawRect(rect.Shift({500, 500}), paint);
  builder.DrawRect(rect.Shift({500, 500}), thin_paint);
 
  // rect (H)
  paint.setStrokeJoin(DlStrokeJoin::kMiter);
  paint.setStrokeMiter(kSqrt2 - flutter::kEhCloseEnough);
  builder.DrawRect(rect.Shift({700, 500}), paint);
  builder.DrawRect(rect.Shift({700, 500}), thin_paint);
 
  DlPaint round_mock_paint;
  round_mock_paint.setColor(DlColor::kGreen());
  round_mock_paint.setDrawStyle(DlDrawStyle::kFill);
 
  // array of rects (X)
  Scalar x = 900;
  Scalar y = 50;
  for (int i = 0; i < 15; i++) {
    paint.setStrokeWidth(i);
    paint.setColor(DlColor::kOrange());
    paint.setStrokeJoin(DlStrokeJoin::kRound);
    builder.DrawRect(DlRect::MakeXYWH(x, y, 30, 30), paint);
    y += 32 + i;
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), impeller::TRect< T >::Expand(), i, flutter::DlColor::kBlue(), flutter::kEhCloseEnough, flutter::DlColor::kGreen(), flutter::DlColor::kOrange(), flutter::DlColor::kPurple(), impeller::kSqrt2, flutter::DlColor::kYellow(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeMiter(), flutter::DlPaint::setStrokeWidth(), impeller::TRect< T >::Shift(), x, and y.

◆ TEST_P() [362/662]

impeller::testing::TEST_P	(	AiksTest	,
		SubpassWithClearColorOptimization
	)

Definition at line 1754 of file aiks_dl_basic_unittests.cc.

                                                    {
  DisplayListBuilder builder;
 
  // Use a non-srcOver blend mode to ensure that we don't detect this as an
  // opacity peephole optimization.
  DlPaint paint;
  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
  paint.setBlendMode(DlBlendMode::kSrc);
 
  DlRect bounds = DlRect::MakeLTRB(0, 0, 200, 200);
  builder.SaveLayer(bounds, &paint);
 
  paint.setColor(DlColor::kTransparent());
  paint.setBlendMode(DlBlendMode::kSrc);
  builder.DrawPaint(paint);
  builder.Restore();
 
  paint.setColor(DlColor::kBlue());
  paint.setBlendMode(DlBlendMode::kDstOver);
  builder.SaveLayer(std::nullopt, &paint);
  builder.Restore();
 
  // This playground should appear blank on CI since we are only drawing
  // transparent black. If the clear color optimization is broken, the texture
  // will be filled with NaNs and may produce a magenta texture on macOS or iOS.
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlue(), flutter::DlColor::kTransparent(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [363/662]

impeller::testing::TEST_P	(	AiksTest	,
		SupportsBlitToOnscreen
	)

Definition at line 379 of file canvas_unittests.cc.

                                         {
  ContentContext& context = GetContentContext();
  auto canvas = CreateTestCanvas(context, Rect::MakeLTRB(0, 0, 100, 100),
                                 /*requires_readback=*/true);
 
  if (GetBackend() != PlaygroundBackend::kMetal &&
      GetBackend() != PlaygroundBackend::kMetalSDF) {
    EXPECT_FALSE(canvas->SupportsBlitToOnscreen());
  } else {
    EXPECT_TRUE(canvas->SupportsBlitToOnscreen());
  }
}

References context, CreateTestCanvas(), impeller::kMetal, impeller::kMetalSDF, and impeller::TRect< Scalar >::MakeLTRB().

◆ TEST_P() [364/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextContentsMismatchedTransformTest
	)

Definition at line 720 of file aiks_dl_text_unittests.cc.

                                                      {
  AiksContext aiks_context(GetContext(),
                           std::make_shared<TypographerContextSkia>());
 
  // Verifies that TextContents only use the scale/transform that is
  // computed during preroll.
  constexpr const char* font_fixture = "Roboto-Regular.ttf";
 
  // Construct the text blob.
  auto c_font_fixture = std::string(font_fixture);
  auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
  ASSERT_TRUE(mapping);
 
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont sk_font(font_mgr->makeFromData(mapping), 16);
 
  auto blob = SkTextBlob::MakeFromString("Hello World", sk_font);
  ASSERT_TRUE(blob);
 
  auto text_frame = MakeTextFrameFromTextBlobSkia(blob);
 
  // Simulate recording the text frame during preroll.
  Matrix preroll_matrix =
      Matrix::MakeTranslateScale({1.5, 1.5, 1}, {100, 50, 0});
  Point preroll_point = Point{23, 45};
  {
    aiks_context.GetContentContext().GetLazyGlyphAtlas()->AddTextFrame(
        text_frame,        //
        preroll_point,     //
        preroll_matrix,    //
        GlyphProperties{}  //
    );
  }
 
  // Now simulate rendering with a slightly different scale factor.
  RenderTarget render_target =
      aiks_context.GetContentContext()
          .GetRenderTargetCache()
          ->CreateOffscreenMSAA(*aiks_context.GetContext(), {100, 100}, 1);
 
  TextContents text_contents;
  text_contents.SetTextFrame(text_frame);
  text_contents.SetPosition(preroll_point);
  text_contents.SetScreenTransform(preroll_matrix);
  text_contents.SetColor(Color::Aqua());
 
  Matrix not_preroll_matrix =
      preroll_matrix * Matrix::MakeScale({2.0f, 2.0f, 1.0f});
 
  Entity entity;
  entity.SetTransform(not_preroll_matrix);
 
  std::shared_ptr<CommandBuffer> command_buffer =
      aiks_context.GetContext()->CreateCommandBuffer();
  std::shared_ptr<RenderPass> render_pass =
      command_buffer->CreateRenderPass(render_target);
 
  EXPECT_TRUE(text_contents.Render(aiks_context.GetContentContext(), entity,
                                   *render_pass));
}

References impeller::Color::Aqua(), command_buffer, impeller::AiksContext::GetContentContext(), impeller::AiksContext::GetContext(), txt::GetDefaultFontManager(), impeller::ContentContext::GetLazyGlyphAtlas(), impeller::ContentContext::GetRenderTargetCache(), impeller::Matrix::MakeScale(), impeller::MakeTextFrameFromTextBlobSkia(), impeller::Matrix::MakeTranslateScale(), flutter::testing::OpenFixtureAsSkData(), impeller::TextContents::Render(), render_pass, impeller::TextContents::SetColor(), impeller::TextContents::SetPosition(), impeller::TextContents::SetScreenTransform(), impeller::TextContents::SetTextFrame(), and impeller::Entity::SetTransform().

◆ TEST_P() [365/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextForegroundShaderWithTransform
	)

Definition at line 605 of file aiks_dl_text_unittests.cc.

                                                    {
  auto mapping = flutter::testing::OpenFixtureAsSkData("Roboto-Regular.ttf");
  ASSERT_NE(mapping, nullptr);
 
  Scalar font_size = 100;
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont sk_font(font_mgr->makeFromData(mapping), font_size);
 
  DlPaint text_paint;
  text_paint.setColor(DlColor::kBlue());
 
  std::vector<DlColor> colors = {DlColor::RGBA(0.9568, 0.2627, 0.2118, 1.0),
                                 DlColor::RGBA(0.1294, 0.5882, 0.9529, 1.0)};
  std::vector<Scalar> stops = {
      0.0,
      1.0,
  };
  text_paint.setColorSource(DlColorSource::MakeLinear(
      /*start_point=*/DlPoint(0, 0),     //
      /*end_point=*/DlPoint(100, 100),   //
      /*stop_count=*/2,                  //
      /*colors=*/colors.data(),          //
      /*stops=*/stops.data(),            //
      /*tile_mode=*/DlTileMode::kRepeat  //
      ));
 
  DisplayListBuilder builder;
  builder.Translate(100, 100);
  builder.Rotate(45);
 
  auto blob = SkTextBlob::MakeFromString("Hello", sk_font);
  ASSERT_NE(blob, nullptr);
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
  builder.DrawText(DlTextImpeller::Make(frame), 0, 0, text_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), font_size, txt::GetDefaultFontManager(), flutter::DlColor::kBlue(), flutter::DlTextImpeller::Make(), flutter::DlColorSource::MakeLinear(), impeller::MakeTextFrameFromTextBlobSkia(), flutter::testing::OpenFixtureAsSkData(), flutter::DlColor::RGBA(), flutter::DisplayListBuilder::Rotate(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [366/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextFramesDoNotShareRenderDataBigSmall
	)

Definition at line 1054 of file aiks_dl_text_unittests.cc.

                                                         {
  DrawTextFramesMultipleScalesWithReuse(this,                  //
                                        /*first_scale=*/4.0f,  //
                                        /*second_scale=*/0.5f);
}

◆ TEST_P() [367/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextFramesDoNotShareRenderDataSmallBig
	)

Definition at line 1060 of file aiks_dl_text_unittests.cc.

                                                         {
  DrawTextFramesMultipleScalesWithReuse(this,                  //
                                        /*first_scale=*/0.5f,  //
                                        /*second_scale=*/4.0f);
}

◆ TEST_P() [368/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextFrameSubpixelAlignment
	)

Definition at line 319 of file aiks_dl_text_unittests.cc.

                                             {
  // "Random" numbers between 0 and 1. Hardcoded to avoid flakiness in goldens.
  std::array<Scalar, 20> phase_offsets = {
      7.82637e-06, 0.131538,  0.755605,   0.45865,   0.532767,
      0.218959,    0.0470446, 0.678865,   0.679296,  0.934693,
      0.383502,    0.519416,  0.830965,   0.0345721, 0.0534616,
      0.5297,      0.671149,  0.00769819, 0.383416,  0.0668422};
  auto callback = [&]() -> sk_sp<DisplayList> {
    static float font_size = 20;
    static float phase_variation = 0.2;
    static float speed = 0.5;
    static float magnitude = 100;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Font size", &font_size, 5, 50);
      ImGui::SliderFloat("Phase variation", &phase_variation, 0, 1);
      ImGui::SliderFloat("Oscillation speed", &speed, 0, 2);
      ImGui::SliderFloat("Oscillation magnitude", &magnitude, 0, 300);
      ImGui::End();
    }
 
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
 
    for (size_t i = 0; i < phase_offsets.size(); i++) {
      DlPoint position = DlPoint(
          200 +
              magnitude * std::sin((-phase_offsets[i] * k2Pi * phase_variation +
                                    GetSecondsElapsed() * speed)),  //
          200 + i * font_size * 1.1                                 //
      );
      if (!RenderTextInCanvasSkia(
              GetContext(), builder,
              "the quick brown fox jumped over "
              "the lazy dog!.?",
              "Roboto-Regular.ttf",
              {.font_size = font_size, .position = position})) {
        return nullptr;
      }
    }
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, font_size, i, impeller::k2Pi, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), x, and y.

◆ TEST_P() [369/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextGammaCorrectionGoldenTest
	)

Definition at line 1111 of file aiks_dl_text_unittests.cc.

                                                {
  constexpr const char* font_fixture = "Roboto-Regular.ttf";
  auto c_font_fixture = std::string(font_fixture);
  auto mapping = flutter::testing::OpenFixtureAsSkData(c_font_fixture.c_str());
  ASSERT_TRUE(mapping);
 
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont sk_font(/*typeface=*/font_mgr->makeFromData(mapping), /*size=*/60);
  sk_font.setSubpixel(true);
 
  auto blob_corrected =
      SkTextBlob::MakeFromString("Gamma Corrected (true)", sk_font);
  ASSERT_TRUE(blob_corrected);
  auto text_frame_corrected = MakeTextFrameFromTextBlobSkia(blob_corrected);
  text_frame_corrected->SetEnableGammaCorrection(true);
 
  auto blob_uncorrected =
      SkTextBlob::MakeFromString("Gamma Corrected (false)", sk_font);
  ASSERT_TRUE(blob_uncorrected);
  auto text_frame_uncorrected = MakeTextFrameFromTextBlobSkia(blob_uncorrected);
  text_frame_uncorrected->SetEnableGammaCorrection(false);
 
  auto callback = [&]() -> sk_sp<flutter::DisplayList> {
    DisplayListBuilder builder;
 
    DlPaint bg_paint;
    bg_paint.setColor(DlColor::ARGB(1.0, 0.1, 0.1, 0.1));
    builder.DrawPaint(bg_paint);
 
    DlPaint text_paint;
    text_paint.setColor(DlColor::kWhite());
 
    builder.DrawText(/*text=*/DlTextImpeller::Make(text_frame_corrected),
                     /*x=*/50, /*y=*/100, /*paint=*/text_paint);
    builder.DrawText(/*text=*/DlTextImpeller::Make(text_frame_uncorrected),
                     /*x=*/50, /*y=*/200, /*paint=*/text_paint);
 
    builder.DrawText(/*text=*/DlTextImpeller::Make(text_frame_corrected),
                     /*x=*/50, /*y=*/300, /*paint=*/text_paint);
    DlPaint diff_paint = text_paint;
    diff_paint.setBlendMode(DlBlendMode::kDifference);
    builder.DrawText(/*text=*/DlTextImpeller::Make(text_frame_uncorrected),
                     /*x=*/50, /*y=*/300, /*paint=*/diff_paint);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawText(), txt::GetDefaultFontManager(), flutter::DlColor::kWhite(), flutter::DlTextImpeller::Make(), impeller::MakeTextFrameFromTextBlobSkia(), flutter::testing::OpenFixtureAsSkData(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [370/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextRotated
	)

Definition at line 491 of file aiks_dl_text_unittests.cc.

                              {
  // This test used to be intentionally excluded for impeller_golden_tests
  // but when the SDF backend variants were added, the explicit exclusions
  // for those backends were not added to the exclusion list. So it has
  // actually been running just fine for a while now generating goldens
  // for the SDF backends.
  // We will let it run on all backends now in the playground-based golden
  // mechanism as the underlying flakiness may have been resolved since the
  // exclusion was added.
  // https://github.com/flutter/flutter/blame/ad80825c24d770a19e33f67800fc0338a3b89ec7/engine/src/flutter/impeller/golden_tests/golden_playground_test_mac.cc#L107
 
  DisplayListBuilder builder;
 
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::ARGB(0.1, 0.1, 0.1, 1.0));
  builder.DrawPaint(paint);
 
  builder.Transform(Matrix(0.25, -0.3, 0, -0.002,  //
                           0, 0.5, 0, 0,           //
                           0, 0, 0.3, 0,           //
                           100, 100, 0, 1.3));
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "the quick brown fox jumped over the lazy dog!.?",
      "Roboto-Regular.ttf"));
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DisplayListBuilder::Transform(), x, and y.

◆ TEST_P() [371/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextRotated180Degrees
	)

Definition at line 282 of file aiks_dl_text_unittests.cc.

                                        {
  float fpivot[2] = {200 + 30, 200 - 20};
  float rotation = 180;
  float foffset[2] = {200, 200};
 
  auto callback = [&]() -> sk_sp<DisplayList> {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("pivotx", &fpivot[0], 0, 300);
      ImGui::SliderFloat("pivoty", &fpivot[1], 0, 300);
      ImGui::SliderFloat("rotation", &rotation, 0, 360);
      ImGui::SliderFloat("foffsetx", &foffset[0], 0, 300);
      ImGui::SliderFloat("foffsety", &foffset[1], 0, 300);
      ImGui::End();
    }
    DisplayListBuilder builder;
    builder.Scale(GetContentScale().x, GetContentScale().y);
    builder.DrawPaint(DlPaint().setColor(DlColor(0xffffeeff)));
 
    builder.Save();
    DlPoint pivot = Point(fpivot[0], fpivot[1]);
    builder.Translate(pivot.x, pivot.y);
    builder.Rotate(rotation);
    builder.Translate(-pivot.x, -pivot.y);
 
    RenderTextInCanvasSkia(GetContext(), builder, "test", "Roboto-Regular.ttf",
                           TextRenderOptions{
                               .color = DlColor::kBlack(),
                               .position = DlPoint(foffset[0], foffset[1]),
                           });
 
    builder.Restore();
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, impeller::testing::TextRenderOptions::color, flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kBlack(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Rotate(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DisplayListBuilder::Translate(), x, impeller::TPoint< T >::x, impeller::TPoint< T >::y, and y.

◆ TEST_P() [372/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextWithNonUniformScale
	)

Definition at line 1069 of file aiks_dl_text_unittests.cc.

                                          {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  // Row 1: Uniform scale (should use nearest-neighbor, pixel-perfect).
  builder.Save();
  builder.Scale(2, 2);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "Uniform 2x2", "Roboto-Regular.ttf",
      TextRenderOptions{.font_size = 30, .position = DlPoint(20, 40)}));
  builder.Restore();
 
  // Row 2: Non-uniform scale Y-only (ratio 2.0, triggers bilinear).
  builder.Save();
  builder.Scale(1, 2);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "ScaleY 1x2", "Roboto-Regular.ttf",
      TextRenderOptions{.font_size = 30, .position = DlPoint(20, 140)}));
  builder.Restore();
 
  // Row 3: Non-uniform scale X-only (ratio 3.0, triggers bilinear).
  builder.Save();
  builder.Scale(3, 1);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "ScaleX 3x1", "Roboto-Regular.ttf",
      TextRenderOptions{.font_size = 30, .position = DlPoint(20, 300)}));
  builder.Restore();
 
  // Row 4: Slightly non-uniform (ratio 1.1, below threshold, nearest).
  builder.Save();
  builder.Scale(2, 2.2);
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "Near-uniform 2x2.2", "Roboto-Regular.ttf",
      TextRenderOptions{.font_size = 30, .position = DlPoint(20, 200)}));
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::font_size, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), and flutter::DlPaint::setColor().

◆ TEST_P() [373/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextWithShadowAndPosition
	)

Definition at line 1161 of file aiks_dl_text_unittests.cc.

                                            {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.Clear(DlColor::kWhite());
 
  auto frame = MakeDefaultTextFrame("Hello", 25.0f);
  auto text = DlTextImpeller::Make(frame);
  DlPaint paint = DlPaint().setColor(DlColor::kMagenta());
  DlPaint shadow_paint_ctm = DlPaint().setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 5.0f, true));
  DlPaint shadow_paint_no_ctm = DlPaint().setMaskFilter(
      DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 5.0f, false));
 
  builder.Translate(100, 100);
  builder.Scale(4, 4);
  for (int x = 10; x <= 100; x += 30) {
    builder.DrawText(text, x, 20, shadow_paint_ctm);
    builder.DrawText(text, x, 20, paint);
 
    builder.DrawText(text, x, 50, shadow_paint_no_ctm);
    builder.DrawText(text, x, 50, paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DlCanvas::Clear(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kMagenta(), flutter::DlColor::kWhite(), flutter::DlTextImpeller::Make(), flutter::DlBlurMaskFilter::Make(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), text, flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [374/662]

impeller::testing::TEST_P	(	AiksTest	,
		TextWithShadowCache
	)

Definition at line 823 of file aiks_dl_text_unittests.cc.

                                      {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
 
  AiksContext aiks_context(GetContext(),
                           std::make_shared<TypographerContextSkia>());
  // Cache empty
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            0u);
 
  ASSERT_TRUE(RenderTextInCanvasSkia(
      GetContext(), builder, "Hello World", kFontFixture,
      TextRenderOptions{
          .color = DlColor::kBlue(),
          .filter = DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 4)}));
 
  DisplayListToTexture(builder.Build(), {400, 400}, aiks_context);
 
  // Text should be cached.
  EXPECT_EQ(aiks_context.GetContentContext()
                .GetTextShadowCache()
                .GetCacheSizeForTesting(),
            1u);
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), impeller::testing::TextRenderOptions::color, impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawPaint(), impeller::TextShadowCache::GetCacheSizeForTesting(), impeller::AiksContext::GetContentContext(), impeller::ContentContext::GetTextShadowCache(), flutter::DlColor::kBlue(), kFontFixture, flutter::DlBlurMaskFilter::Make(), RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [375/662]

impeller::testing::TEST_P	(	AiksTest	,
		ToImageFromImage
	)

Definition at line 1046 of file aiks_dl_unittests.cc.

                                   {
  DisplayListBuilder builder;
  DlPath path = DlPath::MakeArc(DlRect::MakeLTRB(0, 0, 100, 100), DlDegrees(0),
                                DlDegrees(90),
                                /*use_center=*/true);
 
  builder.DrawPath(path, DlPaint().setColor(DlColor::kRed()));
 
  AiksContext renderer(GetContext(), nullptr);
  auto texture =
      DisplayListToTexture(builder.Build(), ISize(100, 100), renderer);
 
  // First, Readback the texture data into a host buffer.
  impeller::DeviceBufferDescriptor desc;
  desc.size = texture->GetTextureDescriptor().GetByteSizeOfBaseMipLevel();
  desc.readback = true;
  desc.storage_mode = StorageMode::kHostVisible;
 
  auto device_buffer = GetContext()->GetResourceAllocator()->CreateBuffer(desc);
  {
    auto cmd_buffer = GetContext()->CreateCommandBuffer();
    auto blit_pass = cmd_buffer->CreateBlitPass();
 
    blit_pass->AddCopy(texture, device_buffer);
    blit_pass->EncodeCommands();
 
    auto latch = std::make_shared<fml::CountDownLatch>(1u);
    GetContext()->GetCommandQueue()->Submit(
        {cmd_buffer},
        [latch](CommandBuffer::Status status) { latch->CountDown(); });
    latch->Wait();
  }
 
  impeller::TextureDescriptor tex_desc = texture->GetTextureDescriptor();
  auto reupload_texture =
      GetContext()->GetResourceAllocator()->CreateTexture(tex_desc);
 
  // Next, Re-upload the data into a new texture.
  {
    auto cmd_buffer = GetContext()->CreateCommandBuffer();
    auto blit_pass = cmd_buffer->CreateBlitPass();
    blit_pass->AddCopy(DeviceBuffer::AsBufferView(device_buffer),
                       reupload_texture);
    blit_pass->ConvertTextureToShaderRead(texture);
    blit_pass->EncodeCommands();
 
    auto latch = std::make_shared<fml::CountDownLatch>(1u);
    GetContext()->GetCommandQueue()->Submit(
        {cmd_buffer},
        [latch](CommandBuffer::Status status) { latch->CountDown(); });
    latch->Wait();
  }
 
  // Draw the results side by side. These should look the same.
  DisplayListBuilder canvas;
  DlPaint paint = DlPaint();
  canvas.DrawRect(
      DlRect::MakeLTRB(0, 0, 100, 100),
      DlPaint().setColor(DlColor::kBlue()).setDrawStyle(DlDrawStyle::kStroke));
  canvas.DrawImage(DlImageImpeller::Make(texture), DlPoint(0, 0),
                   DlImageSampling::kNearestNeighbor, &paint);
 
  canvas.DrawRect(
      DlRect::MakeLTRB(0, 100, 100, 200),
      DlPaint().setColor(DlColor::kRed()).setDrawStyle(DlDrawStyle::kStroke));
  canvas.DrawImage(DlImageImpeller::Make(reupload_texture), DlPoint(0, 100),
                   DlImageSampling::kNearestNeighbor, &paint);
  OpenPlaygroundHere(canvas.Build());
}

References impeller::DeviceBuffer::AsBufferView(), flutter::DisplayListBuilder::Build(), impeller::DisplayListToTexture(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), impeller::kHostVisible, flutter::DlColor::kRed(), impeller::DlImageImpeller::Make(), flutter::DlPath::MakeArc(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, impeller::DeviceBufferDescriptor::readback, impeller::DeviceBufferDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and texture.

◆ TEST_P() [376/662]

impeller::testing::TEST_P	(	AiksTest	,
		TransformMultipliesCorrectly
	)

Definition at line 72 of file canvas_unittests.cc.

                                               {
  ContentContext& context = GetContentContext();
  auto canvas = CreateTestCanvas(context);
 
  ASSERT_MATRIX_NEAR(canvas->GetCurrentTransform(), Matrix());
 
  // clang-format off
  canvas->Translate(Vector3(100, 200));
  ASSERT_MATRIX_NEAR(
    canvas->GetCurrentTransform(),
    Matrix(  1,   0,   0,   0,
             0,   1,   0,   0,
             0,   0,   1,   0,
           100, 200,   0,   1));
 
  canvas->Rotate(Radians(kPiOver2));
  ASSERT_MATRIX_NEAR(
    canvas->GetCurrentTransform(),
    Matrix(  0,   1,   0,   0,
            -1,   0,   0,   0,
             0,   0,   1,   0,
           100, 200,   0,   1));
 
  canvas->Scale(Vector3(2, 3));
  ASSERT_MATRIX_NEAR(
    canvas->GetCurrentTransform(),
    Matrix(  0,   2,   0,   0,
            -3,   0,   0,   0,
             0,   0,   0,   0,
           100, 200,   0,   1));
 
  canvas->Translate(Vector3(100, 200));
  ASSERT_MATRIX_NEAR(
    canvas->GetCurrentTransform(),
    Matrix(   0,   2,   0,   0,
             -3,   0,   0,   0,
              0,   0,   0,   0,
           -500, 400,   0,   1));
  // clang-format on
}

References ASSERT_MATRIX_NEAR, context, CreateTestCanvas(), and impeller::kPiOver2.

◆ TEST_P() [377/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentFilledArcsRenderCorrectly
	)

Definition at line 1074 of file aiks_dl_basic_unittests.cc.

                                                       {
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  builder.DrawColor(DlColor::kWhite(), DlBlendMode::kSrc);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue().modulateOpacity(0.5));
 
  RenderArcFarm(builder, paint,
                {
                    .use_center = false,
                    .full_circles = false,
                });
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DlColor::kBlue(), flutter::DlColor::kWhite(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [378/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerDrawsCorrectly
	)

Definition at line 139 of file aiks_dl_unittests.cc.

                                                     {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
 
  DlPaint save_paint;
  save_paint.setColor(DlColor::kBlack().withAlpha(128));
  builder.SaveLayer(std::nullopt, &save_paint);
  builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [379/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerImageDrawsCorrectly
	)

Definition at line 250 of file aiks_dl_unittests.cc.

                                                          {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  builder.DrawImage(image, DlPoint(100, 100), DlImageSampling::kMipmapLinear);
 
  DlPaint paint;
  paint.setColor(DlColor::kBlack().withAlpha(128));
  builder.SaveLayer(std::nullopt, &paint);
  builder.DrawImage(image, DlPoint(100, 500), DlImageSampling::kMipmapLinear);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kBlack(), impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setColor().

◆ TEST_P() [380/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithAdvancedBlendModeDrawsCorrectly
	)

Definition at line 335 of file aiks_dl_unittests.cc.

                                                                          {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 400, 400), paint);
 
  DlPaint save_paint;
  save_paint.setAlpha(128);
  save_paint.setBlendMode(DlBlendMode::kLighten);
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kGreen());
  builder.DrawCircle(DlPoint(200, 200), 100, draw_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setAlpha(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColor().

◆ TEST_P() [381/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendColorFilterDrawsCorrectly
	)

Definition at line 155 of file aiks_dl_unittests.cc.

                                                                         {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
 
  DlPaint save_paint;
  paint.setColor(DlColor::kBlack().withAlpha(128));
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
  builder.Save();
  builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
  builder.SaveLayer(std::nullopt, &paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [382/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithBlendImageFilterDrawsCorrectly
	)

Definition at line 179 of file aiks_dl_unittests.cc.

                                                                         {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
 
  DlPaint save_paint;
  save_paint.setColor(DlColor::kBlack().withAlpha(128));
  save_paint.setImageFilter(DlImageFilter::MakeColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver)));
 
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), flutter::DlImageFilter::MakeColorFilter(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [383/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorAndImageFilterDrawsCorrectly
	)

Definition at line 201 of file aiks_dl_unittests.cc.

                                                                            {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  DlPaint paint;
  paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 100, 300, 300), paint);
 
  DlPaint save_paint;
  save_paint.setColor(DlColor::kBlack().withAlpha(128));
  save_paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kRed(), DlBlendMode::kDstOver));
  builder.Save();
  builder.ClipRect(DlRect::MakeXYWH(100, 500, 300, 300));
  builder.SaveLayer(std::nullopt, &save_paint);
 
  DlPaint draw_paint;
  draw_paint.setColor(DlColor::kBlue());
  builder.DrawRect(DlRect::MakeXYWH(100, 500, 300, 300), draw_paint);
  builder.Restore();
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [384/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorFilterAndImageFilterDrawsCorrectly
	)

Definition at line 309 of file aiks_dl_unittests.cc.

                                                                        {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  builder.DrawImage(image, DlPoint(100, 100), {});
 
  const float matrix[20] = {
      1, 0,   0, 0,   0,  //
      0, 1,   0, 0,   0,  //
      0, 0.2, 1, 0,   0,  //
      0, 0,   0, 0.5, 0   //
  };
  DlPaint paint;
  paint.setColor(DlColor::kBlack().withAlpha(128));
  paint.setImageFilter(
      DlImageFilter::MakeColorFilter(DlColorFilter::MakeMatrix(matrix)));
  paint.setColorFilter(
      DlColorFilter::MakeBlend(DlColor::kGreen(), DlBlendMode::kModulate));
  builder.SaveLayer(std::nullopt, &paint);
  builder.DrawImage(image, DlPoint(100, 500), {});
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kBlack(), flutter::DlColor::kGreen(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlColorFilter::MakeMatrix(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [385/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixColorFilterDrawsCorrectly
	)

Definition at line 265 of file aiks_dl_unittests.cc.

                                                                               {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  builder.DrawImage(image, DlPoint(100, 100), {});
 
  const float matrix[20] = {
      1, 0, 0, 0, 0,  //
      0, 1, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 2, 0   //
  };
  DlPaint paint;
  paint.setColor(DlColor::kBlack().withAlpha(128));
  paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
  builder.SaveLayer(std::nullopt, &paint);
  builder.DrawImage(image, DlPoint(100, 500), {});
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kBlack(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeMatrix(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [386/662]

impeller::testing::TEST_P	(	AiksTest	,
		TranslucentSaveLayerWithColorMatrixImageFilterDrawsCorrectly
	)

Definition at line 287 of file aiks_dl_unittests.cc.

                                                                               {
  DisplayListBuilder builder(DlRect::MakeSize(GetWindowSize()));
 
  auto image = DlImageImpeller::Make(CreateTextureForFixture("airplane.jpg"));
  builder.DrawImage(image, DlPoint(100, 100), {});
 
  const float matrix[20] = {
      1, 0, 0, 0, 0,  //
      0, 1, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 2, 0   //
  };
  DlPaint paint;
  paint.setColor(DlColor::kBlack().withAlpha(128));
  paint.setColorFilter(DlColorFilter::MakeMatrix(matrix));
  builder.SaveLayer(std::nullopt, &paint);
  builder.DrawImage(image, DlPoint(100, 500), {});
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), image, flutter::DlColor::kBlack(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeMatrix(), impeller::TRect< Scalar >::MakeSize(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setColor(), and flutter::DlPaint::setColorFilter().

◆ TEST_P() [387/662]

impeller::testing::TEST_P	(	AiksTest	,
		TransparentShadowProducesCorrectColor
	)

Definition at line 862 of file aiks_dl_unittests.cc.

                                                        {
  DisplayListBuilder builder;
  builder.Save();
  builder.Scale(1.618, 1.618);
  DlPath path = DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 200, 100));
 
  builder.DrawShadow(path, flutter::DlColor::kTransparent(), 15, false, 1);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawShadow(), flutter::DlColor::kTransparent(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), and flutter::DisplayListBuilder::Scale().

◆ TEST_P() [388/662]

impeller::testing::TEST_P	(	AiksTest	,
		TwoContourPathWithConnectingLines
	)

Definition at line 872 of file aiks_dl_path_unittests.cc.

                                                    {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(15.0);
 
  builder.Translate(100, 0);
  for (auto join : std::vector<DlStrokeJoin>{
           DlStrokeJoin::kMiter, DlStrokeJoin::kRound, DlStrokeJoin::kBevel}) {
    builder.Translate(0, 100);
    paint.setStrokeJoin(join);
 
    DlPathBuilder path_builder;
    path_builder.MoveTo(DlPoint(0, 0));
    path_builder.LineTo(DlPoint(50, 50));
    path_builder.MoveTo(DlPoint(50, 50));
    path_builder.LineTo(DlPoint(100, 0));
 
    builder.DrawPath(path_builder.TakePath(), paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [389/662]

impeller::testing::TEST_P	(	AiksTest	,
		TwoContourPathWithSinglePointContour
	)

Definition at line 852 of file aiks_dl_path_unittests.cc.

                                                       {
  DisplayListBuilder builder;
 
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  paint.setDrawStyle(DlDrawStyle::kStroke);
  paint.setStrokeWidth(15.0);
  paint.setStrokeCap(DlStrokeCap::kRound);
 
  DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(150, 150));
  path_builder.MoveTo(DlPoint(200, 200));
  path_builder.LineTo(DlPoint(200, 200));
 
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [390/662]

impeller::testing::TEST_P	(	AiksTest	,
		VarietyOfTextScalesShowingRasterAndPath
	)

Definition at line 964 of file aiks_dl_text_unittests.cc.

                                                          {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setColor(DlColor::ARGB(1, 0.1, 0.1, 0.1));
  builder.DrawPaint(paint);
  builder.Scale(GetContentScale().x, GetContentScale().y);
 
  std::vector<Scalar> scales = {4, 8, 16, 24, 32};
  std::vector<Scalar> spacing = {8, 8, 8, 8, 8};
  Scalar space = 16;
  Scalar x = 0;
  for (auto i = 0u; i < scales.size(); i++) {
    builder.Save();
    builder.Scale(scales[i], scales[i]);
    RenderTextInCanvasSkia(
        GetContext(), builder, "lo", "Roboto-Regular.ttf",
        TextRenderOptions{.font_size = 16, .position = DlPoint(x, space)});
    space += spacing[i];
    if (i == 3) {
      x = 10;
      space = 16;
    }
    builder.Restore();
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlColor::ARGB(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), impeller::testing::TextRenderOptions::font_size, i, RenderTextInCanvasSkia(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), x, and y.

◆ TEST_P() [391/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerifyNonOptimizedGradient
	)

Definition at line 936 of file aiks_dl_gradient_unittests.cc.

                                             {
  DisplayListBuilder builder;
  DlPaint paint;
  builder.Translate(100.0f, 0);
 
  std::vector<DlColor> colors = {DlColor::kRed(), DlColor::kBlue(),
                                 DlColor::kGreen()};
  std::vector<Scalar> stops = {0.0, 0.1, 1.0};
 
  // Inset the start and end point to verify that we do not apply
  // the fast gradient condition.
  paint.setColorSource(
      DlColorSource::MakeLinear({0, 150}, {0, 100}, stops.size(), colors.data(),
                                stops.data(), DlTileMode::kRepeat));
 
  paint.setColor(DlColor::kWhite());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 300, 300), paint);
  builder.Translate(400, 0);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(0, 0, 300, 300), 4, 4), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorSource(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [392/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionData
	)

Definition at line 99 of file aiks_dl_vertices_unittests.cc.

                                                      {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->GetImpellerTexture(GetContext())->GetSize();
 
  paint.setColorSource(
      DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<DlPoint> positions = {
      DlPoint(0, 0),           DlPoint(size.width, 0),
      DlPoint(0, size.height), DlPoint(size.width, 0),
      DlPoint(0, 0),           DlPoint(size.width, size.height),
  };
  std::vector<DlColor> colors = {
      DlColor::kRed().withAlpha(128),   DlColor::kBlue().withAlpha(128),
      DlColor::kGreen().withAlpha(128), DlColor::kRed().withAlpha(128),
      DlColor::kBlue().withAlpha(128),  DlColor::kGreen().withAlpha(128),
  };
 
  auto vertices =
      MakeVertices(DlVertexMode::kTriangles, positions, {}, {}, colors);
 
  builder.DrawVertices(vertices, DlBlendMode::kDstOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlPaint::setColorSource(), flutter::size, and flutter::DlColor::withAlpha().

◆ TEST_P() [393/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryColorUVPositionDataAdvancedBlend
	)

Definition at line 127 of file aiks_dl_vertices_unittests.cc.

                                                                   {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->GetImpellerTexture(GetContext())->GetSize();
 
  paint.setColorSource(
      DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<DlPoint> positions = {
      DlPoint(0, 0),           DlPoint(size.width, 0),
      DlPoint(0, size.height), DlPoint(size.width, 0),
      DlPoint(0, 0),           DlPoint(size.width, size.height),
  };
  std::vector<DlColor> colors = {
      DlColor::kRed().modulateOpacity(0.5),
      DlColor::kBlue().modulateOpacity(0.5),
      DlColor::kGreen().modulateOpacity(0.5),
      DlColor::kRed().modulateOpacity(0.5),
      DlColor::kBlue().modulateOpacity(0.5),
      DlColor::kGreen().modulateOpacity(0.5),
  };
 
  auto vertices =
      MakeVertices(DlVertexMode::kTriangles, positions, {}, {}, colors);
 
  builder.DrawVertices(vertices, DlBlendMode::kColorBurn, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), image, flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::DlColor::kRed(), impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColor::modulateOpacity(), flutter::DlPaint::setColorSource(), and flutter::size.

◆ TEST_P() [394/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionData
	)

Definition at line 51 of file aiks_dl_vertices_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->GetImpellerTexture(GetContext())->GetSize();
 
  paint.setColorSource(
      DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp));
 
  std::vector<DlPoint> vertex_coordinates = {
      DlPoint(0, 0),
      DlPoint(size.width, 0),
      DlPoint(0, size.height),
  };
  auto vertices = MakeVertices(DlVertexMode::kTriangleStrip, vertex_coordinates,
                               {0, 1, 2}, {}, {});
 
  builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), image, impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlPaint::setColorSource(), and flutter::size.

◆ TEST_P() [395/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryUVPositionDataWithTranslate
	)

Definition at line 74 of file aiks_dl_vertices_unittests.cc.

                                                              {
  DisplayListBuilder builder;
  DlPaint paint;
  auto image =
      DlImageImpeller::Make(CreateTextureForFixture("table_mountain_nx.png"));
  auto size = image->GetImpellerTexture(GetContext())->GetSize();
 
  DlMatrix matrix = DlMatrix::MakeTranslation({100, 100});
  paint.setColorSource(
      DlColorSource::MakeImage(image, DlTileMode::kClamp, DlTileMode::kClamp,
                               DlImageSampling::kLinear, &matrix));
 
  std::vector<DlPoint> positions = {
      DlPoint(0, 0),
      DlPoint(size.width, 0),
      DlPoint(0, size.height),
  };
  auto vertices =
      MakeVertices(DlVertexMode::kTriangleStrip, positions, {0, 1, 2}, {}, {});
 
  builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), image, impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), impeller::Matrix::MakeTranslation(), flutter::DlPaint::setColorSource(), and flutter::size.

◆ TEST_P() [396/662]

impeller::testing::TEST_P	(	AiksTest	,
		VerticesGeometryWithMaskFilter
	)

Definition at line 557 of file aiks_dl_vertices_unittests.cc.

                                                 {
  DisplayListBuilder builder;
  DlPaint paint;
  paint.setMaskFilter(DlBlurMaskFilter::Make(DlBlurStyle::kNormal, 10));
 
  std::vector<DlPoint> vertex_coordinates = {
      DlPoint(0, 0),
      DlPoint(400, 0),
      DlPoint(0, 400),
  };
  auto vertices = MakeVertices(DlVertexMode::kTriangleStrip, vertex_coordinates,
                               {0, 1, 2}, {}, {});
 
  builder.DrawVertices(vertices, DlBlendMode::kSrcOver, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawVertices(), flutter::DlBlurMaskFilter::Make(), and flutter::DlPaint::setMaskFilter().

◆ TEST_P() [397/662]

impeller::testing::TEST_P	(	AiksTest	,
		ZoomedStrokedPathRendersCorrectly
	)

Definition at line 926 of file aiks_dl_basic_unittests.cc.

                                                    {
  DrawStrokedAndFilledCirclesWithZoom(this, /*zoom=*/80.0f, /*radius=*/2.0f,
                                      /*stroke_width=*/0.05f);
}

◆ TEST_P() [398/662]

impeller::testing::TEST_P	(	AllocatorMTLTest	,
		DebugTraceMemoryStatistics
	)

Definition at line 28 of file allocator_mtl_unittests.mm.

                                                     {
  auto& context_mtl = ContextMTL::Cast(*GetContext());
  const auto& allocator = context_mtl.GetResourceAllocator();
 
  EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
            0u);
 
  // Memoryless texture does not increase allocated size.
  {
    TextureDescriptor desc;
    desc.format = PixelFormat::kR8G8B8A8UNormInt;
    desc.storage_mode = StorageMode::kDeviceTransient;
    desc.size = {1024, 1024};
    auto texture_1 = allocator->CreateTexture(desc);
 
    // Private storage texture increases allocated size.
    desc.storage_mode = StorageMode::kDevicePrivate;
    auto texture_2 = allocator->CreateTexture(desc);
 
#ifdef IMPELLER_DEBUG
    EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
              4u);
#else
    EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
              0u);
#endif  // IMPELLER_DEBUG
 
    // Host storage texture increases allocated size.
    desc.storage_mode = StorageMode::kHostVisible;
    auto texture_3 = allocator->CreateTexture(desc);
 
#ifdef IMPELLER_DEBUG
    EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
              8u);
#else
    EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
              0u);
#endif  // IMPELLER_DEBUG
  }
 
  // After all textures are out of scope, memory has been decremented.
  EXPECT_EQ(allocator->DebugGetHeapUsage().ConvertTo<MebiBytes>().GetSize(),
            0u);
}

References allocator, impeller::BackendCast< ContextMTL, Context >::Cast(), impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kDeviceTransient, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [399/662]

impeller::testing::TEST_P	(	AllocatorMTLTest	,
		ManagedMemory
	)

Definition at line 73 of file allocator_mtl_unittests.mm.

                                        {
  auto& context_mtl = ContextMTL::Cast(*GetContext());
  auto allocator = std::make_unique<AllocatorMTL>(context_mtl.GetMTLDevice(),
                                                  "test-allocator");
  allocator->DebugSetSupportsUMA(false);
 
  DeviceBufferDescriptor desc;
  desc.size = 100;
  desc.storage_mode = StorageMode::kHostVisible;
 
  auto buffer = allocator->CreateBuffer(desc);
  ASSERT_TRUE(buffer);
 
  EXPECT_NE(buffer->OnGetContents(), nullptr);
}

References allocator, flutter::buffer, impeller::BackendCast< ContextMTL, Context >::Cast(), impeller::kHostVisible, impeller::DeviceBufferDescriptor::size, and impeller::DeviceBufferDescriptor::storage_mode.

◆ TEST_P() [400/662]

impeller::testing::TEST_P	(	BlendFilterContentsTest	,
		AdvancedBlendColorAlignsColorTo4
	)

Definition at line 45 of file blend_filter_contents_unittests.cc.

                                                                  {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  BlendFilterContents filter_contents;
  filter_contents.SetInputs({FilterInput::Make(texture)});
  filter_contents.SetForegroundColor(Color(1.0, 0.0, 0.0, 1.0));
  filter_contents.SetBlendMode(BlendMode::kColorDodge);
 
  ContentContext& renderer = GetContentContext();
  // Add random byte to get the HostBuffer in a bad alignment.
  uint8_t byte = 0xff;
  BufferView buffer_view = renderer.GetTransientsDataBuffer().Emplace(
      &byte, /*length=*/1, /*align=*/1);
  EXPECT_EQ(buffer_view.GetRange().offset, 4u);
  EXPECT_EQ(buffer_view.GetRange().length, 1u);
  Entity entity;
 
  std::optional<Entity> result = filter_contents.GetEntity(
      renderer, entity, /*coverage_hint=*/std::nullopt);
 
  EXPECT_TRUE(result.has_value());
}

References impeller::HostBuffer::Emplace(), impeller::FilterContents::GetEntity(), impeller::BufferView::GetRange(), impeller::ContentContext::GetTransientsDataBuffer(), impeller::kColorDodge, impeller::Range::length, impeller::FilterInput::Make(), impeller::Range::offset, impeller::BlendFilterContents::SetBlendMode(), impeller::BlendFilterContents::SetForegroundColor(), impeller::FilterContents::SetInputs(), and texture.

◆ TEST_P() [401/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentPixelFormatsFails
	)

Definition at line 30 of file blit_pass_unittests.cc.

                                                           {
  ScopedValidationDisable scope;  // avoid noise in output.
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor src_desc;
  src_desc.format = PixelFormat::kA8UNormInt;
  src_desc.size = {100, 100};
  src_desc.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
 
  TextureDescriptor dst_format;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {100, 100};
  dst_format.storage_mode = StorageMode::kHostVisible;
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  EXPECT_FALSE(blit_pass->AddCopy(src, dst));
}

References context, impeller::TextureDescriptor::format, impeller::kA8UNormInt, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [402/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitAcrossDifferentSampleCountsFails
	)

Definition at line 51 of file blit_pass_unittests.cc.

                                                           {
  ScopedValidationDisable scope;  // avoid noise in output.
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor src_desc;
  src_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  src_desc.sample_count = SampleCount::kCount4;
  src_desc.size = {100, 100};
  auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
 
  TextureDescriptor dst_format;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {100, 100};
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  EXPECT_FALSE(blit_pass->AddCopy(src, dst));
}

References context, impeller::TextureDescriptor::format, impeller::kCount4, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::sample_count, and impeller::TextureDescriptor::size.

◆ TEST_P() [403/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		BlitPassesForMatchingFormats
	)

Definition at line 71 of file blit_pass_unittests.cc.

                                                   {
  ScopedValidationDisable scope;  // avoid noise in output.
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor src_desc;
  src_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  src_desc.size = {100, 100};
  src_desc.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateTexture(src_desc);
 
  TextureDescriptor dst_format;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {100, 100};
  dst_format.storage_mode = StorageMode::kHostVisible;
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  EXPECT_TRUE(blit_pass->AddCopy(src, dst));
}

References context, impeller::TextureDescriptor::format, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TextureDescriptor::size, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [404/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanBlitSmallRegionToUninitializedTexture
	)

Definition at line 123 of file blit_pass_unittests.cc.

                                                               {
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {1000, 1000};
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  DeviceBufferDescriptor src_format;
  src_format.size = 4;
  src_format.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
 
  ASSERT_TRUE(dst);
 
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                 IRect::MakeLTRB(0, 0, 1, 1), "",
                                 /*mip_level=*/0, /*slice=*/0));
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
}

References impeller::DeviceBuffer::AsBufferView(), context, impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [405/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanBlitToHigherTextureMipLevels
	)

Definition at line 176 of file blit_pass_unittests.cc.

                                                      {
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {1000, 1000};
  dst_format.mip_count = 4;
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  DeviceBufferDescriptor src_format;
  src_format.size = 4;
  src_format.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
 
  ASSERT_TRUE(dst);
 
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                 IRect::MakeLTRB(0, 0, 1, 1), "",
                                 /*mip_level=*/1, /*slice=*/0));
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
}

References impeller::DeviceBuffer::AsBufferView(), context, impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::TextureDescriptor::mip_count, impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [406/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanResizeTextures
	)

Definition at line 202 of file blit_pass_unittests.cc.

                                        {
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {10, 10};
  dst_format.usage = TextureUsage::kShaderRead | TextureUsage::kShaderWrite;
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  TextureDescriptor src_format;
  src_format.storage_mode = StorageMode::kDevicePrivate;
  src_format.format = PixelFormat::kR8G8B8A8UNormInt;
  src_format.size = {100, 100};
  auto src = context->GetResourceAllocator()->CreateTexture(src_format);
 
  std::vector<uint8_t> bytes(src_format.GetByteSizeOfBaseMipLevel());
  for (auto i = 0u; i < src_format.GetByteSizeOfBaseMipLevel(); i += 4) {
    // RGBA
    bytes[i + 0] = 255;
    bytes[i + 1] = 0;
    bytes[i + 2] = 0;
    bytes[i + 3] = 255;
  }
  auto mapping = fml::DataMapping(bytes);
  auto staging = context->GetResourceAllocator()->CreateBufferWithCopy(mapping);
 
  ASSERT_TRUE(dst);
  ASSERT_TRUE(src);
  ASSERT_TRUE(staging);
 
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(staging), src));
  EXPECT_TRUE(blit_pass->ResizeTexture(src, dst));
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
}

References impeller::DeviceBuffer::AsBufferView(), context, impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), i, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kShaderRead, impeller::kShaderWrite, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and impeller::TextureDescriptor::usage.

◆ TEST_P() [407/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		CanResizeTexturesPlayground
	)

Definition at line 241 of file blit_pass_unittests.cc.

                                                  {
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  std::shared_ptr<Texture> src = CreateTextureForFixture("kalimba.jpg");
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {src->GetSize().width / 2, src->GetSize().height};
  dst_format.usage = TextureUsage::kShaderRead | TextureUsage::kShaderWrite;
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  ASSERT_TRUE(dst);
  ASSERT_TRUE(src);
 
  EXPECT_TRUE(blit_pass->ResizeTexture(src, dst));
  EXPECT_TRUE(blit_pass->EncodeCommands());
  EXPECT_TRUE(context->GetCommandQueue()->Submit({std::move(cmd_buffer)}).ok());
 
  DisplayListBuilder builder;
  builder.Scale(GetContentScale().x, GetContentScale().y);
  DlPaint paint;
  paint.setColor(DlColor::kRed());
  auto image = DlImageImpeller::Make(dst);
  builder.DrawImage(image, flutter::DlPoint(100.0, 100.0),
                    DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), context, flutter::DisplayListBuilder::DrawImage(), impeller::TextureDescriptor::format, image, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, flutter::DlColor::kRed(), impeller::kShaderRead, impeller::kShaderWrite, impeller::DlImageImpeller::Make(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::TextureDescriptor::usage, impeller::TSize< T >::width, x, and y.

◆ TEST_P() [408/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		ChecksInvalidMipLevelParameter
	)

Definition at line 148 of file blit_pass_unittests.cc.

                                                     {
  ScopedValidationDisable scope;
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {1000, 1000};
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  DeviceBufferDescriptor src_format;
  src_format.size = 4;
  src_format.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
 
  ASSERT_TRUE(dst);
 
  EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  IRect::MakeLTRB(0, 0, 1, 1), "",
                                  /*mip_level=*/1, /*slice=*/0));
 
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                 IRect::MakeLTRB(0, 0, 1, 1), "",
                                 /*mip_level=*/0, /*slice=*/0));
}

References impeller::DeviceBuffer::AsBufferView(), context, impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::TRect< T >::MakeLTRB(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [409/662]

impeller::testing::TEST_P	(	BlitPassTest	,
		ChecksInvalidSliceParameters
	)

Definition at line 92 of file blit_pass_unittests.cc.

                                                   {
  ScopedValidationDisable scope;  // avoid noise in output.
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto blit_pass = cmd_buffer->CreateBlitPass();
 
  TextureDescriptor dst_format;
  dst_format.storage_mode = StorageMode::kDevicePrivate;
  dst_format.format = PixelFormat::kR8G8B8A8UNormInt;
  dst_format.size = {100, 100};
  auto dst = context->GetResourceAllocator()->CreateTexture(dst_format);
 
  DeviceBufferDescriptor src_format;
  src_format.size = 40000;
  src_format.storage_mode = StorageMode::kHostVisible;
  auto src = context->GetResourceAllocator()->CreateBuffer(src_format);
 
  ASSERT_TRUE(dst);
  ASSERT_TRUE(src);
 
  EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  std::nullopt, "", /*mip_level=*/0,
                                  /*slice=*/25));
  EXPECT_FALSE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                  std::nullopt, "", /*mip_level=*/0,
                                  /*slice=*/6));
  EXPECT_TRUE(blit_pass->AddCopy(DeviceBuffer::AsBufferView(src), dst,
                                 std::nullopt, "", /*mip_level=*/0,
                                 /*slice=*/0));
}

References impeller::DeviceBuffer::AsBufferView(), context, impeller::TextureDescriptor::format, impeller::kDevicePrivate, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, and impeller::TextureDescriptor::storage_mode.

◆ TEST_P() [410/662]

impeller::testing::TEST_P	(	ComputeTest	,
		1DThreadgroupSizingIsCorrect
	)

Definition at line 200 of file compute_unittests.cc.

                                                  {
  using CS = ThreadgroupSizingTestComputeShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc =
      SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount = 2048;
 
  pass->SetPipeline(compute_pipeline);
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::OutputData<kCount>>(
      context, "Output Buffer");
 
  CS::BindOutputData(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  ASSERT_TRUE(
      pass->Compute({WorkgroupCount(kCount, CS::kWorkgroupSize[0]), 1, 1})
          .ok());
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit({cmd_buffer},
                   [&latch, output_buffer](CommandBuffer::Status status) {
                     EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                     auto view = DeviceBuffer::AsBufferView(output_buffer);
                     EXPECT_EQ(view.GetRange().length,
                               sizeof(CS::OutputData<kCount>));
 
                     CS::OutputData<kCount>* output =
                         reinterpret_cast<CS::OutputData<kCount>*>(
                             output_buffer->OnGetContents());
                     EXPECT_TRUE(output);
                     EXPECT_EQ(output->data[kCount - 1], kCount - 1);
                     latch.Signal();
                   })
          .ok());
 
  latch.Wait();
}

References context, and fml::AutoResetWaitableEvent::Wait().

◆ TEST_P() [411/662]

impeller::testing::TEST_P	(	ComputeTest	,
		3DWorkgroupDispatchIsCorrect
	)

Definition at line 255 of file compute_unittests.cc.

                                                  {
  using CS = Compute3dTestComputeShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using PipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc = PipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  // The shader's local size is (2, 3, 4). Dispatching (3, 2, 1) workgroups
  // covers a (6, 6, 4) invocation grid, which exercises all three dimensions
  // and confirms the reflected local size is honored on every axis.
  static_assert(CS::kWorkgroupSize[0] == 2 && CS::kWorkgroupSize[1] == 3 &&
                CS::kWorkgroupSize[2] == 4);
  constexpr std::array<uint32_t, 3> kWorkgroups = {3, 2, 1};
  constexpr uint32_t kWidth = kWorkgroups[0] * CS::kWorkgroupSize[0];
  constexpr uint32_t kHeight = kWorkgroups[1] * CS::kWorkgroupSize[1];
  constexpr uint32_t kDepth = kWorkgroups[2] * CS::kWorkgroupSize[2];
  constexpr size_t kCount = kWidth * kHeight * kDepth;
 
  pass->SetPipeline(compute_pipeline);
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::OutputData<kCount>>(
      context, "Output Buffer");
  CS::BindOutputData(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  ASSERT_TRUE(pass->Compute(kWorkgroups).ok());
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit({cmd_buffer},
                   [&latch, output_buffer](CommandBuffer::Status status) {
                     EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                     CS::OutputData<kCount>* output =
                         reinterpret_cast<CS::OutputData<kCount>*>(
                             output_buffer->OnGetContents());
                     EXPECT_TRUE(output);
                     for (uint32_t i = 0; i < kCount; i++) {
                       EXPECT_EQ(output->data[i], i);
                     }
                     latch.Signal();
                   })
          .ok());
 
  latch.Wait();
}

References context, and fml::AutoResetWaitableEvent::Signal().

◆ TEST_P() [412/662]

impeller::testing::TEST_P	(	ComputeTest	,
		CanCompute1DimensionalData
	)

Definition at line 463 of file compute_unittests.cc.

                                                {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc =
      SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount = 5;
 
  pass->SetPipeline(compute_pipeline);
 
  CS::Info info{.count = kCount};
  CS::Input0<kCount> input_0;
  CS::Input1<kCount> input_1;
  for (size_t i = 0; i < kCount; i++) {
    input_0.elements[i] = Vector4(2.0 + i, 3.0 + i, 4.0 + i, 5.0 * i);
    input_1.elements[i] = Vector4(6.0, 7.0, 8.0, 9.0);
  }
 
  input_0.fixed_array[1] = IPoint32(2, 2);
  input_1.fixed_array[0] = UintPoint32(3, 3);
  input_0.some_int = 5;
  input_1.some_struct = CS::SomeStruct{.vf = Point(3, 4), .i = 42};
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::Output<kCount>>(
      context, "Output Buffer");
 
  CS::BindInfo(*pass, host_buffer->EmplaceUniform(info));
  CS::BindInput0(*pass, host_buffer->EmplaceStorageBuffer(input_0));
  CS::BindInput1(*pass, host_buffer->EmplaceStorageBuffer(input_1));
  CS::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  ASSERT_TRUE(
      pass->Compute({WorkgroupCount(kCount, CS::kWorkgroupSize[0]), 1, 1})
          .ok());
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit(
              {cmd_buffer},
              [&latch, output_buffer, &input_0,
               &input_1](CommandBuffer::Status status) {
                EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                auto view = DeviceBuffer::AsBufferView(output_buffer);
                EXPECT_EQ(view.GetRange().length, sizeof(CS::Output<kCount>));
 
                CS::Output<kCount>* output =
                    reinterpret_cast<CS::Output<kCount>*>(
                        output_buffer->OnGetContents());
                EXPECT_TRUE(output);
                for (size_t i = 0; i < kCount; i++) {
                  Vector4 vector = output->elements[i];
                  Vector4 computed = input_0.elements[i] * input_1.elements[i];
                  EXPECT_EQ(vector,
                            Vector4(computed.x + 2 + input_1.some_struct.i,
                                    computed.y + 3 + input_1.some_struct.vf.x,
                                    computed.z + 5 + input_1.some_struct.vf.y,
                                    computed.w));
                }
                latch.Signal();
              })
          .ok());
 
  latch.Wait();
}

References context, i, and fml::AutoResetWaitableEvent::Signal().

◆ TEST_P() [413/662]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSum
	)

Definition at line 132 of file compute_unittests.cc.

                                         {
  using CS = PrefixSumTestComputeShader;
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc =
      SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount = 5;
 
  pass->SetPipeline(compute_pipeline);
 
  CS::InputData<kCount> input_data;
  input_data.count = kCount;
  for (size_t i = 0; i < kCount; i++) {
    input_data.data[i] = 1 + i;
  }
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::OutputData<kCount>>(
      context, "Output Buffer");
 
  CS::BindInputData(*pass, host_buffer->EmplaceStorageBuffer(input_data));
  CS::BindOutputData(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  // The prefix sum is computed within a single workgroup whose size is sized to
  // the device (a specialization constant), so dispatch exactly one.
  ASSERT_TRUE(pass->Compute({1, 1, 1}).ok());
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit({cmd_buffer},
                   [&latch, output_buffer](CommandBuffer::Status status) {
                     EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                     auto view = DeviceBuffer::AsBufferView(output_buffer);
                     EXPECT_EQ(view.GetRange().length,
                               sizeof(CS::OutputData<kCount>));
 
                     CS::OutputData<kCount>* output =
                         reinterpret_cast<CS::OutputData<kCount>*>(
                             output_buffer->OnGetContents());
                     EXPECT_TRUE(output);
 
                     constexpr uint32_t expected[kCount] = {1, 3, 6, 10, 15};
                     for (size_t i = 0; i < kCount; i++) {
                       auto computed_sum = output->data[i];
                       EXPECT_EQ(computed_sum, expected[i]);
                     }
                     latch.Signal();
                   })
          .ok());
 
  latch.Wait();
}

References impeller::DeviceBuffer::AsBufferView(), context, i, and fml::AutoResetWaitableEvent::Signal().

◆ TEST_P() [414/662]

impeller::testing::TEST_P	(	ComputeTest	,
		CanComputePrefixSumLargeInteractive
	)

Definition at line 313 of file compute_unittests.cc.

                                                         {
  using CS = PrefixSumTestComputeShader;
 
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
 
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  auto callback = [&](RenderPass& render_pass) -> bool {
    using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
    auto pipeline_desc =
        SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
    auto compute_pipeline =
        context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
 
    auto cmd_buffer = context->CreateCommandBuffer();
    auto pass = cmd_buffer->CreateComputePass();
 
    static constexpr size_t kCount = 1023;
 
    pass->SetPipeline(compute_pipeline);
 
    CS::InputData<kCount> input_data;
    input_data.count = kCount;
    for (size_t i = 0; i < kCount; i++) {
      input_data.data[i] = 1 + i;
    }
 
    auto output_buffer = CreateHostVisibleDeviceBuffer<CS::OutputData<kCount>>(
        context, "Output Buffer");
 
    CS::BindInputData(*pass, host_buffer->EmplaceStorageBuffer(input_data));
    CS::BindOutputData(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
    // Single workgroup; see CanComputePrefixSum.
    pass->Compute({1, 1, 1});
    pass->EncodeCommands();
    host_buffer->Reset();
    return context->GetCommandQueue()->Submit({cmd_buffer}).ok();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, i, and render_pass.

◆ TEST_P() [415/662]

impeller::testing::TEST_P	(	ComputeTest	,
		CanCreateComputePass
	)

Definition at line 51 of file compute_unittests.cc.

                                          {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc =
      SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount = 5;
 
  pass->SetPipeline(compute_pipeline);
 
  CS::Info info{.count = kCount};
  CS::Input0<kCount> input_0;
  CS::Input1<kCount> input_1;
  for (size_t i = 0; i < kCount; i++) {
    input_0.elements[i] = Vector4(2.0 + i, 3.0 + i, 4.0 + i, 5.0 * i);
    input_1.elements[i] = Vector4(6.0, 7.0, 8.0, 9.0);
  }
 
  input_0.fixed_array[1] = IPoint32(2, 2);
  input_1.fixed_array[0] = UintPoint32(3, 3);
  input_0.some_int = 5;
  input_1.some_struct = CS::SomeStruct{.vf = Point(3, 4), .i = 42};
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::Output<kCount>>(
      context, "Output Buffer");
 
  CS::BindInfo(*pass, host_buffer->EmplaceUniform(info));
  CS::BindInput0(*pass, host_buffer->EmplaceStorageBuffer(input_0));
  CS::BindInput1(*pass, host_buffer->EmplaceStorageBuffer(input_1));
  CS::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  ASSERT_TRUE(
      pass->Compute({WorkgroupCount(kCount, CS::kWorkgroupSize[0]), 1, 1})
          .ok());
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit(
              {cmd_buffer},
              [&latch, output_buffer, &input_0,
               &input_1](CommandBuffer::Status status) {
                EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                auto view = DeviceBuffer::AsBufferView(output_buffer);
                EXPECT_EQ(view.GetRange().length, sizeof(CS::Output<kCount>));
 
                CS::Output<kCount>* output =
                    reinterpret_cast<CS::Output<kCount>*>(
                        output_buffer->OnGetContents());
                EXPECT_TRUE(output);
                for (size_t i = 0; i < kCount; i++) {
                  Vector4 vector = output->elements[i];
                  Vector4 computed = input_0.elements[i] * input_1.elements[i];
                  EXPECT_EQ(vector,
                            Vector4(computed.x + 2 + input_1.some_struct.i,
                                    computed.y + 3 + input_1.some_struct.vf.x,
                                    computed.z + 5 + input_1.some_struct.vf.y,
                                    computed.w));
                }
                latch.Signal();
              })
          .ok());
 
  latch.Wait();
}

References impeller::DeviceBuffer::AsBufferView(), context, i, and fml::AutoResetWaitableEvent::Signal().

◆ TEST_P() [416/662]

impeller::testing::TEST_P	(	ComputeTest	,
		CapabilitiesReportSupport
	)

Definition at line 45 of file compute_unittests.cc.

                                               {
  auto context = GetContext();
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
}

References context.

◆ TEST_P() [417/662]

impeller::testing::TEST_P	(	ComputeTest	,
		MultiStageInputAndOutput
	)

Definition at line 357 of file compute_unittests.cc.

                                              {
  using CS1 = Stage1ComputeShader;
  using Stage1PipelineBuilder = ComputePipelineBuilder<CS1>;
  using CS2 = Stage2ComputeShader;
  using Stage2PipelineBuilder = ComputePipelineBuilder<CS2>;
 
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  auto pipeline_desc_1 =
      Stage1PipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc_1.has_value());
  auto compute_pipeline_1 =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc_1).Get();
  ASSERT_TRUE(compute_pipeline_1);
 
  auto pipeline_desc_2 =
      Stage2PipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc_2.has_value());
  auto compute_pipeline_2 =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc_2).Get();
  ASSERT_TRUE(compute_pipeline_2);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount1 = 5;
  static constexpr size_t kCount2 = kCount1 * 2;
 
  CS1::Input<kCount1> input_1;
  input_1.count = kCount1;
  for (size_t i = 0; i < kCount1; i++) {
    input_1.elements[i] = i;
  }
 
  CS2::Input<kCount2> input_2;
  input_2.count = kCount2;
  for (size_t i = 0; i < kCount2; i++) {
    input_2.elements[i] = i;
  }
 
  auto output_buffer_1 = CreateHostVisibleDeviceBuffer<CS1::Output<kCount2>>(
      context, "Output Buffer Stage 1");
  auto output_buffer_2 = CreateHostVisibleDeviceBuffer<CS2::Output<kCount2>>(
      context, "Output Buffer Stage 2");
 
  {
    pass->SetPipeline(compute_pipeline_1);
 
    CS1::BindInput(*pass, host_buffer->EmplaceStorageBuffer(input_1));
    CS1::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer_1));
 
    ASSERT_TRUE(
        pass->Compute({WorkgroupCount(kCount1, CS1::kWorkgroupSize[0]), 1, 1})
            .ok());
    pass->AddBufferMemoryBarrier();
  }
 
  {
    pass->SetPipeline(compute_pipeline_2);
 
    CS1::BindInput(*pass, DeviceBuffer::AsBufferView(output_buffer_1));
    CS2::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer_2));
    ASSERT_TRUE(
        pass->Compute({WorkgroupCount(kCount2, CS2::kWorkgroupSize[0]), 1, 1})
            .ok());
  }
 
  ASSERT_TRUE(pass->EncodeCommands());
 
  fml::AutoResetWaitableEvent latch;
  ASSERT_TRUE(
      context->GetCommandQueue()
          ->Submit({cmd_buffer},
                   [&latch, &output_buffer_1,
                    &output_buffer_2](CommandBuffer::Status status) {
                     EXPECT_EQ(status, CommandBuffer::Status::kCompleted);
 
                     CS1::Output<kCount2>* output_1 =
                         reinterpret_cast<CS1::Output<kCount2>*>(
                             output_buffer_1->OnGetContents());
                     EXPECT_TRUE(output_1);
                     EXPECT_EQ(output_1->count, 10u);
                     EXPECT_THAT(
                         output_1->elements,
                         ::testing::ElementsAre(0, 0, 2, 3, 4, 6, 6, 9, 8, 12));
 
                     CS2::Output<kCount2>* output_2 =
                         reinterpret_cast<CS2::Output<kCount2>*>(
                             output_buffer_2->OnGetContents());
                     EXPECT_TRUE(output_2);
                     EXPECT_EQ(output_2->count, 10u);
                     EXPECT_THAT(output_2->elements,
                                 ::testing::ElementsAre(0, 0, 4, 6, 8, 12, 12,
                                                        18, 16, 24));
 
                     latch.Signal();
                   })
          .ok());
 
  latch.Wait();
}

References context, i, impeller::kCount1, and fml::AutoResetWaitableEvent::Wait().

◆ TEST_P() [418/662]

impeller::testing::TEST_P	(	ComputeTest	,
		ReturnsEarlyWhenAnyGridDimensionIsZero
	)

Definition at line 544 of file compute_unittests.cc.

                                                            {
  using CS = SampleComputeShader;
  auto context = GetContext();
  auto host_buffer = CreateHostBufferFromContext(context);
  ASSERT_TRUE(context);
  ASSERT_TRUE(context->GetCapabilities()->SupportsCompute());
 
  using SamplePipelineBuilder = ComputePipelineBuilder<CS>;
  auto pipeline_desc =
      SamplePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_desc.has_value());
  auto compute_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(compute_pipeline);
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  ASSERT_TRUE(pass && pass->IsValid());
 
  static constexpr size_t kCount = 5;
 
  pass->SetPipeline(compute_pipeline);
 
  CS::Info info{.count = kCount};
  CS::Input0<kCount> input_0;
  CS::Input1<kCount> input_1;
  for (size_t i = 0; i < kCount; i++) {
    input_0.elements[i] = Vector4(2.0 + i, 3.0 + i, 4.0 + i, 5.0 * i);
    input_1.elements[i] = Vector4(6.0, 7.0, 8.0, 9.0);
  }
 
  input_0.fixed_array[1] = IPoint32(2, 2);
  input_1.fixed_array[0] = UintPoint32(3, 3);
  input_0.some_int = 5;
  input_1.some_struct = CS::SomeStruct{.vf = Point(3, 4), .i = 42};
 
  auto output_buffer = CreateHostVisibleDeviceBuffer<CS::Output<kCount>>(
      context, "Output Buffer");
 
  CS::BindInfo(*pass, host_buffer->EmplaceUniform(info));
  CS::BindInput0(*pass, host_buffer->EmplaceStorageBuffer(input_0));
  CS::BindInput1(*pass, host_buffer->EmplaceStorageBuffer(input_1));
  CS::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer));
 
  // Intentionally making the workgroup count zero in one dimension. No GPU will
  // tolerate this.
  auto status = pass->Compute({0, 1, 1});
  EXPECT_FALSE(status.ok());
  EXPECT_EQ(status.code(), fml::StatusCode::kCancelled);
  pass->EncodeCommands();
}

References context, i, and fml::kCancelled.

◆ TEST_P() [419/662]

impeller::testing::TEST_P	(	ContextMTLTest	,
		FlushTask
	)

Definition at line 28 of file context_mtl_unittests.mm.

                                  {
  auto& context_mtl = ContextMTL::Cast(*GetContext());
 
  int executed = 0;
  int failed = 0;
  context_mtl.StoreTaskForGPU([&]() { executed++; }, [&]() { failed++; });
 
  context_mtl.FlushTasksAwaitingGPU();
 
  EXPECT_EQ(executed, 1);
  EXPECT_EQ(failed, 0);
}

References impeller::BackendCast< ContextMTL, Context >::Cast().

◆ TEST_P() [420/662]

impeller::testing::TEST_P	(	ContextMTLTest	,
		FlushTaskWithGPULoss
	)

Definition at line 41 of file context_mtl_unittests.mm.

                                             {
  auto& context_mtl = ContextMTL::Cast(*GetContext());
 
  int executed = 0;
  int failed = 0;
  context_mtl.StoreTaskForGPU([&]() { executed++; }, [&]() { failed++; });
 
  // If tasks are flushed while the GPU is disabled, then
  // they should not be executed.
  SetGPUDisabled(/*disabled=*/true);
  context_mtl.FlushTasksAwaitingGPU();
 
  EXPECT_EQ(executed, 0);
  EXPECT_EQ(failed, 0);
 
  // Toggling availibility should flush tasks.
  SetGPUDisabled(/*disabled=*/false);
 
  EXPECT_EQ(executed, 1);
  EXPECT_EQ(failed, 0);
}

References impeller::BackendCast< ContextMTL, Context >::Cast().

◆ TEST_P() [421/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanBlendDstOverAndDstCorrectly
	)

Definition at line 1288 of file dl_unittests.cc.

                                                        {
  flutter::DisplayListBuilder builder;
 
  {
    builder.SaveLayer(std::nullopt, nullptr);
    builder.Translate(100, 100);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kRed());
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(std::nullopt, nullptr);
    builder.Translate(300, 100);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    paint.setColor(flutter::DlColor::kRed());
    paint.setBlendMode(flutter::DlBlendMode::kDstOver);
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(std::nullopt, nullptr);
    builder.Translate(100, 300);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kRed());
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    paint.setBlendMode(flutter::DlBlendMode::kSrc);
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    builder.Restore();
  }
  {
    builder.SaveLayer(std::nullopt, nullptr);
    builder.Translate(300, 300);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kBlue().withAlpha(127));
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    paint.setColor(flutter::DlColor::kRed());
    paint.setBlendMode(flutter::DlBlendMode::kDst);
    builder.DrawRect(DlRect::MakeWH(200, 200), paint);
    builder.Restore();
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kRed(), impeller::TRect< Scalar >::MakeWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setBlendMode(), flutter::DlPaint::setColor(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [422/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanClampTheResultingColorOfColorMatrixFilter
	)

Definition at line 637 of file dl_unittests.cc.

                                                                      {
  auto texture = CreateTextureForFixture("boston.jpg");
  const float inner_color_matrix[20] = {
      1, 0, 0, 0, 0,  //
      0, 1, 0, 0, 0,  //
      0, 0, 1, 0, 0,  //
      0, 0, 0, 2, 0,  //
  };
  const float outer_color_matrix[20] = {
      1, 0, 0, 0,   0,  //
      0, 1, 0, 0,   0,  //
      0, 0, 1, 0,   0,  //
      0, 0, 0, 0.5, 0,  //
  };
  auto inner_color_filter =
      flutter::DlColorFilter::MakeMatrix(inner_color_matrix);
  auto outer_color_filter =
      flutter::DlColorFilter::MakeMatrix(outer_color_matrix);
  auto inner = flutter::DlImageFilter::MakeColorFilter(inner_color_filter);
  auto outer = flutter::DlImageFilter::MakeColorFilter(outer_color_filter);
  auto compose = std::make_shared<flutter::DlComposeImageFilter>(outer, inner);
 
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  paint.setImageFilter(compose.get());
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlColorFilter::MakeMatrix(), flutter::DlPaint::setImageFilter(), and texture.

◆ TEST_P() [423/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawAnOpenPath
	)

Definition at line 424 of file dl_unittests.cc.

                                           {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColor(flutter::DlColor::kRed());
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setStrokeWidth(10);
 
  builder.Translate(300, 300);
 
  // Move to (50, 50) and draw lines from:
  // 1. (50, height)
  // 2. (width, height)
  // 3. (width, 50)
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(50, 50));
  path_builder.LineTo(DlPoint(50, 100));
  path_builder.LineTo(DlPoint(100, 100));
  path_builder.LineTo(DlPoint(100, 50));
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::DlColor::kRed(), flutter::kStroke, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [424/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawArc
	)

Definition at line 158 of file dl_unittests.cc.

                                    {
  auto callback = [&]() {
    static float start_angle = 45;
    static float sweep_angle = 270;
    static float stroke_width = 10;
    static bool use_center = true;
 
    static int selected_cap = 0;
    const char* cap_names[] = {"Butt", "Round", "Square"};
    flutter::DlStrokeCap cap;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Start angle", &start_angle, -360, 360);
      ImGui::SliderFloat("Sweep angle", &sweep_angle, -360, 360);
      ImGui::SliderFloat("Stroke width", &stroke_width, 0, 300);
      ImGui::Combo("Cap", &selected_cap, cap_names,
                   sizeof(cap_names) / sizeof(char*));
      ImGui::Checkbox("Use center", &use_center);
      ImGui::End();
    }
 
    switch (selected_cap) {
      case 0:
        cap = flutter::DlStrokeCap::kButt;
        break;
      case 1:
        cap = flutter::DlStrokeCap::kRound;
        break;
      case 2:
        cap = flutter::DlStrokeCap::kSquare;
        break;
      default:
        cap = flutter::DlStrokeCap::kButt;
        break;
    }
 
    static PlaygroundPoint point_a(Point(200, 200), 20, Color::White());
    static PlaygroundPoint point_b(Point(400, 400), 20, Color::White());
    auto [p1, p2] = DrawPlaygroundLine(point_a, point_b);
 
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    Vector2 scale = GetContentScale();
    builder.Scale(scale.x, scale.y);
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setStrokeCap(cap);
    paint.setStrokeJoin(flutter::DlStrokeJoin::kMiter);
    paint.setStrokeMiter(10);
    auto rect = DlRect::MakeLTRB(p1.x, p1.y, p2.x, p2.y);
    paint.setColor(flutter::DlColor::kGreen());
    paint.setStrokeWidth(2);
    builder.DrawRect(rect, paint);
    paint.setColor(flutter::DlColor::kRed());
    paint.setStrokeWidth(stroke_width);
    builder.DrawArc(rect, start_angle, sweep_angle, use_center, paint);
 
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawArc(), impeller::DrawPlaygroundLine(), flutter::DisplayListBuilder::DrawRect(), flutter::kButt, flutter::DlColor::kGreen(), flutter::kMiter, flutter::DlColor::kRed(), flutter::kRound, flutter::kSquare, flutter::kStroke, impeller::TRect< Scalar >::MakeLTRB(), p1, p2, flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeMiter(), flutter::DlPaint::setStrokeWidth(), use_center, impeller::Color::White(), impeller::TPoint< T >::x, flutter::Point::x(), impeller::TPoint< T >::y, and flutter::Point::y().

◆ TEST_P() [425/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawBackdropFilter
	)

Definition at line 667 of file dl_unittests.cc.

                                               {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
 
  auto callback = [&]() {
    static float sigma[] = {10, 10};
    static float ctm_scale = 1;
    static bool use_bounds = true;
    static bool draw_circle = true;
    static bool add_clip = true;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat2("Sigma", sigma, 0, 100);
      ImGui::SliderFloat("Scale", &ctm_scale, 0, 10);
      ImGui::NewLine();
      ImGui::TextWrapped(
          "If everything is working correctly, none of the options below "
          "should impact the filter's appearance.");
      ImGui::Checkbox("Use SaveLayer bounds", &use_bounds);
      ImGui::Checkbox("Draw child element", &draw_circle);
      ImGui::Checkbox("Add pre-clip", &add_clip);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
 
    Vector2 scale = ctm_scale * GetContentScale();
    builder.Scale(scale.x, scale.y);
 
    auto filter = flutter::DlBlurImageFilter(sigma[0], sigma[1],
                                             flutter::DlTileMode::kClamp);
 
    std::optional<DlRect> bounds;
    if (use_bounds) {
      static PlaygroundPoint point_a(Point(350, 150), 20, Color::White());
      static PlaygroundPoint point_b(Point(800, 600), 20, Color::White());
      auto [p1, p2] = DrawPlaygroundLine(point_a, point_b);
      bounds = DlRect::MakeLTRB(p1.x, p1.y, p2.x, p2.y);
    }
 
    // Insert a clip to test that the backdrop filter handles stencil depths > 0
    // correctly.
    if (add_clip) {
      builder.ClipRect(DlRect::MakeLTRB(0, 0, 99999, 99999),
                       flutter::DlClipOp::kIntersect, true);
    }
 
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                      flutter::DlImageSampling::kNearestNeighbor, nullptr);
    builder.SaveLayer(bounds, nullptr, &filter);
 
    if (draw_circle) {
      static PlaygroundPoint center_point(Point(500, 400), 20, Color::Red());
      auto circle_center = DrawPlaygroundPoint(center_point);
 
      flutter::DlPaint paint;
      paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
      paint.setStrokeCap(flutter::DlStrokeCap::kButt);
      paint.setStrokeJoin(flutter::DlStrokeJoin::kBevel);
      paint.setStrokeWidth(10);
      paint.setColor(flutter::DlColor::kRed().withAlpha(100));
      builder.DrawCircle(DlPoint(circle_center.x, circle_center.y), 100, paint);
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawImage(), impeller::DrawPlaygroundLine(), impeller::DrawPlaygroundPoint(), flutter::kBevel, flutter::kButt, flutter::kClamp, flutter::kIntersect, flutter::kNearestNeighbor, flutter::DlColor::kRed(), flutter::kStroke, impeller::DlImageImpeller::Make(), impeller::TRect< Scalar >::MakeLTRB(), p1, p2, impeller::Color::Red(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), texture, impeller::Color::White(), impeller::TPoint< T >::x, flutter::Point::x(), impeller::TPoint< T >::y, and flutter::Point::y().

◆ TEST_P() [426/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawBoundedBlur
	)

Definition at line 737 of file dl_unittests.cc.

                                            {
  auto texture = CreateTextureForFixture("kalimba.jpg");
  const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
  const flutter::DlTileMode tile_modes[] = {
      flutter::DlTileMode::kClamp, flutter::DlTileMode::kRepeat,
      flutter::DlTileMode::kMirror, flutter::DlTileMode::kDecal};
 
  auto callback = [&]() {
    static float sigma = 20;
    static float bg_scale = 2.1;
    static float rotate_degree = 0;
    static float bounds_scale = 1.0;
    static bool use_bounds = true;
    static int selected_tile_mode = 0;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Background scale", &bg_scale, 0, 10);
      ImGui::SliderFloat("Sigma", &sigma, 0, 100);
      ImGui::SliderFloat("Bounds rotate", &rotate_degree, -200, 200);
      ImGui::SliderFloat("Bounds scale", &bounds_scale, 0.5f, 2.0f);
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      ImGui::NewLine();
      ImGui::Checkbox("Bounded blur", &use_bounds);
      ImGui::End();
    }
 
    // Draw from top right to bottom left.
    static PlaygroundPoint blur_point_a(Point(410, 30), 10, Color::White());
    static PlaygroundPoint blur_point_b(Point(150, 320), 10, Color::White());
    auto [p1_raw, p2_raw] = DrawPlaygroundLine(blur_point_a, blur_point_b);
    Matrix content_scale_transform = Matrix::MakeScale(GetContentScale());
    Point p1_global = content_scale_transform * p1_raw;
    Point p2_global = content_scale_transform * p2_raw;
 
    flutter::DisplayListBuilder builder;
 
    builder.Save();
    builder.Scale(bg_scale, bg_scale);
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(0, 0),
                      flutter::DlImageSampling::kNearestNeighbor, nullptr);
    builder.Restore();
 
    Matrix transform =
        Matrix::MakeRotationZ(Radians(rotate_degree / 180.0f * kPi));
    Matrix inverse_transform = transform.Invert();
 
    builder.Transform(transform);
 
    Point p1 = inverse_transform * p1_global;
    Point p2 = inverse_transform * p2_global;
    DlRect bounds =
        DlRect::MakeLTRB(p2.x, p1.y, p1.x, p2.y).Scale(bounds_scale);
 
    builder.ClipRect(bounds);
    builder.Save();
 
    flutter::DlPaint save_paint;
    save_paint.setBlendMode(flutter::DlBlendMode::kSrcOver);
 
    std::optional<DlRect> blur_bounds;
    if (use_bounds) {
      blur_bounds = bounds;
    }
    auto filter = flutter::DlBlurImageFilter(
        sigma, sigma, tile_modes[selected_tile_mode], blur_bounds);
    builder.SaveLayer(std::nullopt, &save_paint, &filter);
    builder.Restore();
    builder.Restore();
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

◆ TEST_P() [427/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCapsAndJoins
	)

Definition at line 109 of file dl_unittests.cc.

                                             {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setStrokeWidth(30);
  paint.setColor(flutter::DlColor::kRed());
 
  flutter::DlPathBuilder path_builder;
  path_builder.MoveTo(DlPoint(-50, 0));
  path_builder.LineTo(DlPoint(0, -50));
  path_builder.LineTo(DlPoint(50, 0));
  flutter::DlPath path = path_builder.TakePath();
 
  builder.Translate(100, 100);
  {
    paint.setStrokeCap(flutter::DlStrokeCap::kButt);
    paint.setStrokeJoin(flutter::DlStrokeJoin::kMiter);
    paint.setStrokeMiter(4);
    builder.DrawPath(path, paint);
  }
 
  {
    builder.Save();
    builder.Translate(0, 100);
    // The joint in the path is 45 degrees. A miter length of 1 convert to a
    // bevel in this case.
    paint.setStrokeMiter(1);
    builder.DrawPath(path, paint);
    builder.Restore();
  }
 
  builder.Translate(150, 0);
  {
    paint.setStrokeCap(flutter::DlStrokeCap::kSquare);
    paint.setStrokeJoin(flutter::DlStrokeJoin::kBevel);
    builder.DrawPath(path, paint);
  }
 
  builder.Translate(150, 0);
  {
    paint.setStrokeCap(flutter::DlStrokeCap::kRound);
    paint.setStrokeJoin(flutter::DlStrokeJoin::kRound);
    builder.DrawPath(path, paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::kBevel, flutter::kButt, flutter::kMiter, flutter::DlColor::kRed(), flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::DlPathBuilder::LineTo(), flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeMiter(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [428/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawCorrectlyWithColorFilterAndImageFilter
	)

Definition at line 1339 of file dl_unittests.cc.

                                                                       {
  flutter::DisplayListBuilder builder;
  const float green_color_matrix[20] = {
      0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 1,  //
      0, 0, 0, 0, 0,  //
      0, 0, 0, 1, 0,  //
  };
  const float blue_color_matrix[20] = {
      0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 0,  //
      0, 0, 0, 0, 1,  //
      0, 0, 0, 1, 0,  //
  };
  auto green_color_filter =
      flutter::DlColorFilter::MakeMatrix(green_color_matrix);
  auto blue_color_filter =
      flutter::DlColorFilter::MakeMatrix(blue_color_matrix);
  auto blue_image_filter =
      flutter::DlImageFilter::MakeColorFilter(blue_color_filter);
 
  flutter::DlPaint paint;
  paint.setColor(flutter::DlColor::kRed());
  paint.setColorFilter(green_color_filter);
  paint.setImageFilter(blue_image_filter);
  builder.DrawRect(DlRect::MakeLTRB(100, 100, 500, 500), paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kRed(), flutter::DlImageFilter::MakeColorFilter(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlColorFilter::MakeMatrix(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DlPaint::setImageFilter().

◆ TEST_P() [429/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawImage
	)

Definition at line 101 of file dl_unittests.cc.

                                      {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, impeller::DlImageImpeller::Make(), and texture.

◆ TEST_P() [430/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImage
	)

Definition at line 814 of file dl_unittests.cc.

                                               {
  // Image is drawn with corners to scale and center pieces stretched to fit.
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto size = texture->GetSize();
  builder.DrawImageNine(
      DlImageImpeller::Make(texture),
      DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      DlRect::MakeLTRB(0, 0, size.width * 2, size.height * 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::size, and texture.

◆ TEST_P() [431/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterBiggerThanDest
	)

Definition at line 860 of file dl_unittests.cc.

                                                                   {
  // Edge case, the width and height of the corners does not leave any
  // room for the center slices. Only the corners are displayed.
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto size = texture->GetSize();
  builder.DrawImageNine(
      DlImageImpeller::Make(texture),
      DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      DlRect::MakeLTRB(0, 0, size.width / 2, size.height / 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::size, and texture.

◆ TEST_P() [432/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterHeightBiggerThanDest
	)

Definition at line 844 of file dl_unittests.cc.

                                                                         {
  // Edge case, the height of the corners does not leave any room for the
  // center slice. The center (across the horizontal axis) is folded out of the
  // resulting image.
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto size = texture->GetSize();
  builder.DrawImageNine(
      DlImageImpeller::Make(texture),
      DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      DlRect::MakeLTRB(0, 0, size.width, size.height / 2),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::size, and texture.

◆ TEST_P() [433/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCenterWidthBiggerThanDest
	)

Definition at line 828 of file dl_unittests.cc.

                                                                        {
  // Edge case, the width of the corners does not leave any room for the
  // center slice. The center (across the vertical axis) is folded out of the
  // resulting image.
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto size = texture->GetSize();
  builder.DrawImageNine(
      DlImageImpeller::Make(texture),
      DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      DlRect::MakeLTRB(0, 0, size.width / 2, size.height),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::size, and texture.

◆ TEST_P() [434/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawNinePatchImageCornersScaledDown
	)

Definition at line 875 of file dl_unittests.cc.

                                                                {
  // Edge case, there is not enough room for the corners to be drawn
  // without scaling them down.
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto size = texture->GetSize();
  builder.DrawImageNine(
      DlImageImpeller::Make(texture),
      DlIRect::MakeLTRB(size.width / 4, size.height / 4, size.width * 3 / 4,
                        size.height * 3 / 4),
      DlRect::MakeLTRB(0, 0, size.width / 4, size.height / 4),
      flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeLTRB(), impeller::TRect< Scalar >::MakeLTRB(), flutter::size, and texture.

◆ TEST_P() [435/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPaintWithColorSource
	)

Definition at line 1236 of file dl_unittests.cc.

                                                     {
  const flutter::DlColor colors[2] = {
      flutter::DlColor(0xFFF44336),
      flutter::DlColor(0xFF2196F3),
  };
  const float stops[2] = {0.0, 1.0};
  flutter::DlPaint paint;
  flutter::DisplayListBuilder builder;
  auto clip_bounds = DlRect::MakeWH(300.0, 300.0);
  builder.Save();
  builder.Translate(100, 100);
  builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
  auto linear =
      flutter::DlColorSource::MakeLinear({0.0, 0.0}, {100.0, 100.0}, 2, colors,
                                         stops, flutter::DlTileMode::kRepeat);
  paint.setColorSource(linear);
  builder.DrawPaint(paint);
  builder.Restore();
 
  builder.Save();
  builder.Translate(500, 100);
  builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
  auto radial = flutter::DlColorSource::MakeRadial(
      {100.0, 100.0}, 100.0, 2, colors, stops, flutter::DlTileMode::kRepeat);
  paint.setColorSource(radial);
  builder.DrawPaint(paint);
  builder.Restore();
 
  builder.Save();
  builder.Translate(100, 500);
  builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
  auto sweep =
      flutter::DlColorSource::MakeSweep({100.0, 100.0}, 180.0, 270.0, 2, colors,
                                        stops, flutter::DlTileMode::kRepeat);
  paint.setColorSource(sweep);
  builder.DrawPaint(paint);
  builder.Restore();
 
  builder.Save();
  builder.Translate(500, 500);
  builder.ClipRect(clip_bounds, flutter::DlClipOp::kIntersect, false);
  auto texture = CreateTextureForFixture("table_mountain_nx.png");
  auto image = flutter::DlColorSource::MakeImage(DlImageImpeller::Make(texture),
                                                 flutter::DlTileMode::kRepeat,
                                                 flutter::DlTileMode::kRepeat);
  paint.setColorSource(image);
  builder.DrawPaint(paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRect(), flutter::DisplayListBuilder::DrawPaint(), image, flutter::kIntersect, flutter::kRepeat, impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeLinear(), flutter::DlColorSource::MakeRadial(), flutter::DlColorSource::MakeSweep(), impeller::TRect< Scalar >::MakeWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColorSource(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [436/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawPoints
	)

Definition at line 918 of file dl_unittests.cc.

                                       {
  flutter::DisplayListBuilder builder;
  DlPoint points[7] = {
      {0, 0},      //
      {100, 100},  //
      {100, 0},    //
      {0, 100},    //
      {0, 0},      //
      {48, 48},    //
      {52, 52},    //
  };
  std::vector<flutter::DlStrokeCap> caps = {
      flutter::DlStrokeCap::kButt,
      flutter::DlStrokeCap::kRound,
      flutter::DlStrokeCap::kSquare,
  };
  flutter::DlPaint paint =
      flutter::DlPaint()                                         //
          .setColor(flutter::DlColor::kYellow().withAlpha(127))  //
          .setStrokeWidth(20);
  builder.Translate(50, 50);
  for (auto cap : caps) {
    paint.setStrokeCap(cap);
    builder.Save();
    builder.DrawPoints(flutter::DlPointMode::kPoints, 7, points, paint);
    builder.Translate(150, 0);
    builder.DrawPoints(flutter::DlPointMode::kLines, 5, points, paint);
    builder.Translate(150, 0);
    builder.DrawPoints(flutter::DlPointMode::kPolygon, 5, points, paint);
    builder.Restore();
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPoints(), flutter::kButt, flutter::kLines, flutter::kPoints, flutter::kPolygon, flutter::kRound, flutter::kSquare, flutter::DlColor::kYellow(), points, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [437/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRect
	)

Definition at line 48 of file dl_unittests.cc.

                                     {
  flutter::DisplayListBuilder builder;
  builder.DrawRect(DlRect::MakeXYWH(10, 10, 100, 100),
                   flutter::DlPaint(flutter::DlColor::kBlue()));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [438/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawRectWithLinearToSrgbColorFilter
	)

Definition at line 1222 of file dl_unittests.cc.

                                                                {
  flutter::DlPaint paint;
  paint.setColor(flutter::DlColor(0xFF2196F3).withAlpha(128));
  flutter::DisplayListBuilder builder;
  paint.setColorFilter(flutter::DlColorFilter::MakeLinearToSrgbGamma());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
  builder.Translate(0, 200);
 
  paint.setColorFilter(flutter::DlColorFilter::MakeSrgbToLinearGamma());
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 200, 200), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColorFilter::MakeLinearToSrgbGamma(), flutter::DlColorFilter::MakeSrgbToLinearGamma(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setColorFilter(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [439/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawShadow
	)

Definition at line 976 of file dl_unittests.cc.

                                       {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  auto content_scale = GetContentScale() * 0.8;
  builder.Scale(content_scale.x, content_scale.y);
 
  constexpr size_t star_spikes = 5;
  constexpr DlScalar half_spike_rotation = kPi / star_spikes;
  constexpr DlScalar radius = 40;
  constexpr DlScalar spike_size = 10;
  constexpr DlScalar outer_radius = radius + spike_size;
  constexpr DlScalar inner_radius = radius - spike_size;
  std::array<DlPoint, star_spikes * 2> star;
  for (size_t i = 0; i < star_spikes; i++) {
    const DlScalar rotation = half_spike_rotation * i * 2;
    star[i * 2] = DlPoint(50 + std::sin(rotation) * outer_radius,
                          50 - std::cos(rotation) * outer_radius);
    star[i * 2 + 1] =
        DlPoint(50 + std::sin(rotation + half_spike_rotation) * inner_radius,
                50 - std::cos(rotation + half_spike_rotation) * inner_radius);
  }
 
  std::array<DlPath, 4> paths = {
      DlPath::MakeRect(DlRect::MakeXYWH(0, 0, 200, 100)),
      DlPath::MakeRoundRectXY(DlRect::MakeXYWH(20, 0, 200, 100), 30, 30),
      DlPath::MakeCircle(DlPoint(100, 50), 50),
      DlPath::MakePoly(star.data(), star.size(), true),
  };
  paint.setColor(flutter::DlColor::kWhite());
  builder.DrawPaint(paint);
  paint.setColor(flutter::DlColor::kCyan());
  builder.Translate(100, 50);
  for (size_t x = 0; x < paths.size(); x++) {
    builder.Save();
    for (size_t y = 0; y < 6; y++) {
      builder.DrawShadow(paths[x], flutter::DlColor::kBlack(), 3 + y * 8, false,
                         1);
      builder.DrawPath(paths[x], paint);
      builder.Translate(0, 150);
    }
    builder.Restore();
    builder.Translate(250, 0);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawShadow(), i, flutter::DlColor::kBlack(), flutter::DlColor::kCyan(), flutter::kPi, flutter::DlColor::kWhite(), flutter::DlPath::MakeCircle(), flutter::DlPath::MakePoly(), flutter::DlPath::MakeRect(), flutter::DlPath::MakeRoundRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DisplayListBuilder::Translate(), x, and y.

◆ TEST_P() [440/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawStrokedText
	)

Definition at line 485 of file dl_unittests.cc.

                                            {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setColor(flutter::DlColor::kRed());
  builder.DrawText(
      flutter::DlTextImpeller::MakeFromBlob(SkTextBlob::MakeFromString(
          "stoked about stroked text", CreateTestFont())),
      250, 250, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kRed(), flutter::kStroke, flutter::DlTextImpeller::MakeFromBlob(), flutter::DlPaint::setColor(), and flutter::DlPaint::setDrawStyle().

◆ TEST_P() [441/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextBlob
	)

Definition at line 55 of file dl_unittests.cc.

                                         {
  flutter::DisplayListBuilder builder;
  builder.DrawText(flutter::DlTextImpeller::MakeFromBlob(
                       SkTextBlob::MakeFromString("Hello", CreateTestFont())),
                   100, 100, flutter::DlPaint(flutter::DlColor::kBlue()));
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kBlue(), and flutter::DlTextImpeller::MakeFromBlob().

◆ TEST_P() [442/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextBlobWithGradient
	)

Definition at line 63 of file dl_unittests.cc.

                                                     {
  flutter::DisplayListBuilder builder;
 
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kBlue(),
                                          flutter::DlColor::kRed()};
  const float stops[2] = {0.0, 1.0};
 
  auto linear = flutter::DlColorSource::MakeLinear(
      {0.0, 0.0}, {300.0, 300.0}, 2, colors.data(), stops,
      flutter::DlTileMode::kMirror);
  flutter::DlPaint paint;
  paint.setColorSource(linear);
 
  builder.DrawText(
      flutter::DlTextImpeller::MakeFromBlob(
          SkTextBlob::MakeFromString("Hello World", CreateTestFont())),
      100, 100, paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kBlue(), flutter::kMirror, flutter::DlColor::kRed(), flutter::DlTextImpeller::MakeFromBlob(), flutter::DlColorSource::MakeLinear(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [443/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawTextWithSaveLayer
	)

Definition at line 83 of file dl_unittests.cc.

                                                  {
  flutter::DisplayListBuilder builder;
  builder.DrawText(flutter::DlTextImpeller::MakeFromBlob(
                       SkTextBlob::MakeFromString("Hello", CreateTestFont())),
                   100, 100, flutter::DlPaint(flutter::DlColor::kRed()));
 
  flutter::DlPaint save_paint;
  float alpha = 0.5;
  save_paint.setAlpha(static_cast<uint8_t>(255 * alpha));
  builder.SaveLayer(std::nullopt, &save_paint);
  builder.DrawText(
      flutter::DlTextImpeller::MakeFromBlob(SkTextBlob::MakeFromString(
          "Hello with half alpha", CreateTestFontOfSize(100))),
      100, 300, flutter::DlPaint(flutter::DlColor::kRed()));
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kRed(), flutter::DlTextImpeller::MakeFromBlob(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), and flutter::DlPaint::setAlpha().

◆ TEST_P() [444/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithBlendColorFilter
	)

Definition at line 539 of file dl_unittests.cc.

                                                     {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  // Pipeline blended image.
  {
    auto filter = flutter::DlColorFilter::MakeBlend(
        flutter::DlColor::kYellow(), flutter::DlBlendMode::kModulate);
    paint.setColorFilter(filter);
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
  }
 
  // Advanced blended image.
  {
    auto filter = flutter::DlColorFilter::MakeBlend(
        flutter::DlColor::kRed(), flutter::DlBlendMode::kScreen);
    paint.setColorFilter(filter);
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(250, 250),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, flutter::DlColor::kRed(), flutter::DlColor::kYellow(), impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), flutter::DlPaint::setColorFilter(), and texture.

◆ TEST_P() [445/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithColorFilterImageFilter
	)

Definition at line 565 of file dl_unittests.cc.

                                                           {
  const float invert_color_matrix[20] = {
      -1, 0,  0,  0, 1,  //
      0,  -1, 0,  0, 1,  //
      0,  0,  -1, 0, 1,  //
      0,  0,  0,  1, 0,  //
  };
  auto texture = CreateTextureForFixture("boston.jpg");
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  auto color_filter = flutter::DlColorFilter::MakeMatrix(invert_color_matrix);
  auto image_filter = flutter::DlImageFilter::MakeColorFilter(color_filter);
 
  paint.setImageFilter(image_filter);
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
 
  builder.Translate(0, 700);
  paint.setColorFilter(color_filter);
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, impeller::DlImageImpeller::Make(), flutter::DlImageFilter::MakeColorFilter(), flutter::DlColorFilter::MakeMatrix(), flutter::DlPaint::setColorFilter(), flutter::DlPaint::setImageFilter(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [446/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithComposeImageFilter
	)

Definition at line 617 of file dl_unittests.cc.

                                                       {
  auto texture = CreateTextureForFixture("boston.jpg");
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  auto dilate = std::make_shared<flutter::DlDilateImageFilter>(10.0, 10.0);
  auto erode = std::make_shared<flutter::DlErodeImageFilter>(10.0, 10.0);
  auto open = std::make_shared<flutter::DlComposeImageFilter>(dilate, erode);
  auto close = std::make_shared<flutter::DlComposeImageFilter>(erode, dilate);
 
  paint.setImageFilter(open.get());
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  builder.Translate(0, 700);
  paint.setImageFilter(close.get());
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, impeller::DlImageImpeller::Make(), flutter::DlPaint::setImageFilter(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [447/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithImageBlurFilter
	)

Definition at line 590 of file dl_unittests.cc.

                                                    {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
 
  auto callback = [&]() {
    static float sigma[] = {10, 10};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat2("Sigma", sigma, 0, 100);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    auto filter = flutter::DlBlurImageFilter(sigma[0], sigma[1],
                                             flutter::DlTileMode::kClamp);
    paint.setImageFilter(&filter);
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(200, 200),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::kClamp, flutter::kNearestNeighbor, impeller::DlImageImpeller::Make(), flutter::DlPaint::setImageFilter(), and texture.

◆ TEST_P() [448/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMaskBlur
	)

Definition at line 448 of file dl_unittests.cc.

                                             {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  // Mask blurred image.
  {
    auto filter =
        flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
    paint.setMaskFilter(&filter);
    builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                      flutter::DlImageSampling::kNearestNeighbor, &paint);
  }
 
  // Mask blurred filled path.
  {
    paint.setColor(flutter::DlColor::kYellow());
    auto filter =
        flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kOuter, 10.0f);
    paint.setMaskFilter(&filter);
    builder.DrawArc(DlRect::MakeXYWH(410, 110, 100, 100), 45, 270, true, paint);
  }
 
  // Mask blurred text.
  {
    auto filter =
        flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kSolid, 10.0f);
    paint.setMaskFilter(&filter);
    builder.DrawText(
        flutter::DlTextImpeller::MakeFromBlob(
            SkTextBlob::MakeFromString("Testing", CreateTestFont())),
        220, 170, paint);
  }
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawArc(), flutter::DisplayListBuilder::DrawImage(), flutter::DisplayListBuilder::DrawText(), flutter::kNearestNeighbor, flutter::kNormal, flutter::kOuter, flutter::kSolid, flutter::DlColor::kYellow(), impeller::DlImageImpeller::Make(), flutter::DlTextImpeller::MakeFromBlob(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setMaskFilter(), and texture.

◆ TEST_P() [449/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilter
	)

Definition at line 1058 of file dl_unittests.cc.

                                                 {
  auto boston = CreateTextureForFixture("boston.jpg");
 
  auto callback = [&]() {
    static int selected_matrix_type = 0;
    const char* matrix_type_names[] = {"Matrix", "Local Matrix"};
 
    static float ctm_translation[2] = {200, 200};
    static float ctm_scale[2] = {0.65, 0.65};
    static float ctm_skew[2] = {0, 0};
 
    static bool enable = true;
    static float translation[2] = {100, 100};
    static float scale[2] = {0.8, 0.8};
    static float skew[2] = {0.2, 0.2};
 
    static bool enable_savelayer = true;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Filter type", &selected_matrix_type, matrix_type_names,
                   sizeof(matrix_type_names) / sizeof(char*));
 
      ImGui::TextWrapped("Current Transform");
      ImGui::SliderFloat2("CTM Translation", ctm_translation, 0, 1000);
      ImGui::SliderFloat2("CTM Scale", ctm_scale, 0, 3);
      ImGui::SliderFloat2("CTM Skew", ctm_skew, -3, 3);
 
      ImGui::TextWrapped(
          "MatrixFilter and LocalMatrixFilter modify the CTM in the same way. "
          "The only difference is that MatrixFilter doesn't affect the effect "
          "transform, whereas LocalMatrixFilter does.");
      // Note: See this behavior in:
      //       https://fiddle.skia.org/c/6cbb551ab36d06f163db8693972be954
      ImGui::Checkbox("Enable", &enable);
      ImGui::SliderFloat2("Filter Translation", translation, 0, 1000);
      ImGui::SliderFloat2("Filter Scale", scale, 0, 3);
      ImGui::SliderFloat2("Filter Skew", skew, -3, 3);
 
      ImGui::TextWrapped(
          "Rendering the filtered image within a layer can expose bounds "
          "issues. If the rendered image gets cut off when this setting is "
          "enabled, there's a coverage bug in the filter.");
      ImGui::Checkbox("Render in layer", &enable_savelayer);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    if (enable_savelayer) {
      builder.SaveLayer(std::nullopt, nullptr);
    }
    {
      auto content_scale = GetContentScale();
      builder.Scale(content_scale.x, content_scale.y);
 
      // Set the current transform
      auto ctm_matrix = Matrix::MakeRow(
          ctm_scale[0], ctm_skew[0], 0.0f, ctm_translation[0],  //
          ctm_skew[1], ctm_scale[1], 0.0f, ctm_translation[1],  //
          0, 0, 1, 0,                                           //
          0, 0, 0, 1);
      builder.Transform(ctm_matrix);
 
      // Set the matrix filter
      auto filter_matrix =
          Matrix::MakeRow(scale[0], skew[0], 0.0f, translation[0],  //
                          skew[1], scale[1], 0.0f, translation[1],  //
                          0.0f, 0.0f, 1.0f, 0.0f,                   //
                          0.0f, 0.0f, 0.0f, 1.0f);
 
      if (enable) {
        switch (selected_matrix_type) {
          case 0: {
            auto filter = flutter::DlMatrixImageFilter(
                filter_matrix, flutter::DlImageSampling::kLinear);
            paint.setImageFilter(&filter);
            break;
          }
          case 1: {
            auto internal_filter =
                flutter::DlBlurImageFilter(10, 10, flutter::DlTileMode::kDecal)
                    .shared();
            auto filter = flutter::DlLocalMatrixImageFilter(filter_matrix,
                                                            internal_filter);
            paint.setImageFilter(&filter);
            break;
          }
        }
      }
 
      builder.DrawImage(DlImageImpeller::Make(boston), DlPoint(),
                        flutter::DlImageSampling::kLinear, &paint);
    }
    if (enable_savelayer) {
      builder.Restore();
    }
 
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawImage(), flutter::kDecal, flutter::kLinear, impeller::DlImageImpeller::Make(), impeller::Matrix::MakeRow(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setImageFilter(), flutter::DlBlurImageFilter::shared(), and flutter::DisplayListBuilder::Transform().

◆ TEST_P() [450/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithMatrixFilterWhenSavingLayer
	)

Definition at line 1163 of file dl_unittests.cc.

                                                                {
  auto callback = [&]() {
    static float translation[2] = {0, 0};
    static bool enable_save_layer = true;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat2("Translation", translation, -130, 130);
      ImGui::Checkbox("Enable save layer", &enable_save_layer);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
    builder.Save();
    builder.Scale(2.0, 2.0);
    flutter::DlPaint paint;
    paint.setColor(flutter::DlColor::kYellow());
    builder.DrawRect(DlRect::MakeWH(300, 300), paint);
    paint.setStrokeWidth(1.0);
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setColor(flutter::DlColor::kBlack().withAlpha(0x80));
    builder.DrawLine(DlPoint(150, 0), DlPoint(150, 300), paint);
    builder.DrawLine(DlPoint(0, 150), DlPoint(300, 150), paint);
 
    flutter::DlPaint save_paint;
    DlRect bounds = DlRect::MakeXYWH(100, 100, 100, 100);
    Matrix translate_matrix =
        Matrix::MakeTranslation({translation[0], translation[1]});
    if (enable_save_layer) {
      auto filter = flutter::DlMatrixImageFilter(
          translate_matrix, flutter::DlImageSampling::kNearestNeighbor);
      save_paint.setImageFilter(filter.shared());
      builder.SaveLayer(bounds, &save_paint);
    } else {
      builder.Save();
      builder.Transform(translate_matrix);
    }
 
    Matrix filter_matrix;
    filter_matrix.Translate({150, 150});
    filter_matrix.Scale({0.2f, 0.2f});
    filter_matrix.Translate({-150, -150});
    auto filter = flutter::DlMatrixImageFilter(
        filter_matrix, flutter::DlImageSampling::kNearestNeighbor);
 
    save_paint.setImageFilter(filter.shared());
 
    builder.SaveLayer(bounds, &save_paint);
    flutter::DlPaint paint2;
    paint2.setColor(flutter::DlColor::kBlue());
    builder.DrawRect(bounds, paint2);
    builder.Restore();
    builder.Restore();
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlack(), flutter::DlColor::kBlue(), flutter::kNearestNeighbor, flutter::kStroke, flutter::DlColor::kYellow(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::SaveLayer(), impeller::Matrix::Scale(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setImageFilter(), flutter::DlPaint::setStrokeWidth(), flutter::DisplayListBuilder::Transform(), and impeller::Matrix::Translate().

◆ TEST_P() [451/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawWithOddPathWinding
	)

Definition at line 404 of file dl_unittests.cc.

                                                   {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
 
  paint.setColor(flutter::DlColor::kRed());
  paint.setDrawStyle(flutter::DlDrawStyle::kFill);
 
  builder.Translate(300, 300);
  flutter::DlPathBuilder path_builder;
  path_builder.AddCircle(DlPoint(0, 0), 100);
  path_builder.AddCircle(DlPoint(0, 0), 50);
  path_builder.SetFillType(flutter::DlPathFillType::kOdd);
  builder.DrawPath(path_builder.TakePath(), paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DlPathBuilder::AddCircle(), flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawPath(), flutter::kFill, flutter::DlColor::kRed(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPathBuilder::SetFillType(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [452/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroLengthLine
	)

Definition at line 953 of file dl_unittests.cc.

                                               {
  flutter::DisplayListBuilder builder;
  std::vector<flutter::DlStrokeCap> caps = {
      flutter::DlStrokeCap::kButt,
      flutter::DlStrokeCap::kRound,
      flutter::DlStrokeCap::kSquare,
  };
  flutter::DlPaint paint =
      flutter::DlPaint()                                         //
          .setColor(flutter::DlColor::kYellow().withAlpha(127))  //
          .setDrawStyle(flutter::DlDrawStyle::kStroke)           //
          .setStrokeCap(flutter::DlStrokeCap::kButt)             //
          .setStrokeWidth(20);
  DlPath path = DlPath::MakeLine({150, 50}, {150, 50});
  for (auto cap : caps) {
    paint.setStrokeCap(cap);
    builder.DrawLine(DlPoint(50, 50), DlPoint(50, 50), paint);
    builder.DrawPath(path, paint);
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPath(), flutter::kButt, flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::DlColor::kYellow(), flutter::DlPath::MakeLine(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [453/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		CanDrawZeroWidthLine
	)

Definition at line 1024 of file dl_unittests.cc.

                                              {
  flutter::DisplayListBuilder builder;
  std::vector<flutter::DlStrokeCap> caps = {
      flutter::DlStrokeCap::kButt,
      flutter::DlStrokeCap::kRound,
      flutter::DlStrokeCap::kSquare,
  };
  flutter::DlPaint paint =                              //
      flutter::DlPaint()                                //
          .setColor(flutter::DlColor::kWhite())         //
          .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
          .setStrokeWidth(0);
  flutter::DlPaint outline_paint =                      //
      flutter::DlPaint()                                //
          .setColor(flutter::DlColor::kYellow())        //
          .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
          .setStrokeCap(flutter::DlStrokeCap::kSquare)  //
          .setStrokeWidth(1);
  DlPath path = DlPath::MakeLine({150, 50}, {160, 50});
  for (auto cap : caps) {
    paint.setStrokeCap(cap);
    builder.DrawLine(DlPoint(50, 50), DlPoint(60, 50), paint);
    builder.DrawRect(DlRect::MakeLTRB(45, 45, 65, 55), outline_paint);
    builder.DrawLine(DlPoint{100, 50}, DlPoint{100, 50}, paint);
    if (cap != flutter::DlStrokeCap::kButt) {
      builder.DrawRect(DlRect::MakeLTRB(95, 45, 105, 55), outline_paint);
    }
    builder.DrawPath(path, paint);
    builder.DrawRect(path.GetBounds().Expand(5, 5), outline_paint);
    builder.Translate(0, 150);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawLine(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::kButt, flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::DlColor::kWhite(), flutter::DlColor::kYellow(), flutter::DlPath::MakeLine(), impeller::TRect< Scalar >::MakeLTRB(), flutter::path, flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [454/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		ClipDrawRRectWithNonCircularRadii
	)

Definition at line 1502 of file dl_unittests.cc.

                                                           {
  flutter::DisplayListBuilder builder;
 
  flutter::DlPaint fill_paint =                       //
      flutter::DlPaint()                              //
          .setColor(flutter::DlColor::kBlue())        //
          .setDrawStyle(flutter::DlDrawStyle::kFill)  //
          .setStrokeWidth(10);
  flutter::DlPaint stroke_paint =                       //
      flutter::DlPaint()                                //
          .setColor(flutter::DlColor::kGreen())         //
          .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
          .setStrokeWidth(10);
 
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 100, 300, 300), 120, 40),
      fill_paint);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 100, 300, 300), 120, 40),
      stroke_paint);
 
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 500, 300, 300), 40, 120),
      fill_paint);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 500, 300, 300), 40, 120),
      stroke_paint);
 
  flutter::DlPaint reference_paint =                  //
      flutter::DlPaint()                              //
          .setColor(flutter::DlColor::kMidGrey())     //
          .setDrawStyle(flutter::DlDrawStyle::kFill)  //
          .setStrokeWidth(10);
 
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(500, 500, 300, 300), 40, 40),
      reference_paint);
  builder.DrawRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 100, 300, 300), 120, 120),
      reference_paint);
 
  flutter::DlPaint clip_fill_paint =                  //
      flutter::DlPaint()                              //
          .setColor(flutter::DlColor::kCyan())        //
          .setDrawStyle(flutter::DlDrawStyle::kFill)  //
          .setStrokeWidth(10);
 
  builder.Save();
  builder.ClipRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(900, 100, 300, 300), 120, 40));
  builder.DrawPaint(clip_fill_paint);
  builder.Restore();
 
  builder.Save();
  builder.ClipRoundRect(
      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(100, 900, 300, 300), 40, 120));
  builder.DrawPaint(clip_fill_paint);
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::ClipRoundRect(), flutter::DisplayListBuilder::DrawPaint(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::DlColor::kCyan(), flutter::kFill, flutter::DlColor::kGreen(), flutter::DlColor::kMidGrey(), flutter::kStroke, impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [455/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawCirclesWithTransformations
	)

Definition at line 1455 of file dl_unittests.cc.

                                                        {
  auto callback = [&]() {
    static float filled_radius = 100.0;
    static float filled_alpha = 255.0;
    static float filled_scale[2] = {1.0, 1.0};
    static float stroked_radius = 20.0;
    static float stroke_width = 10.0;
    static float stroke_width_fine = 0.0;
    static float stroked_alpha = 255.0;
    static float stroked_scale[2] = {1.0, 1.0};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Filled Radius", &filled_radius, 0, 500);
      ImGui::SliderFloat("Filled Alpha", &filled_alpha, 0, 255);
      ImGui::SliderFloat2("Filled Scale", filled_scale, 0, 10.0);
      ImGui::SliderFloat("Stroked Radius", &stroked_radius, 0, 500);
      ImGui::SliderFloat("Stroked Width", &stroke_width, 0, 500);
      ImGui::SliderFloat("Stroked Width Fine", &stroke_width_fine, 0, 5);
      ImGui::SliderFloat("Stroked Alpha", &stroked_alpha, 0, 10.0);
      ImGui::SliderFloat2("Stroked Scale", stroked_scale, 0, 10.0);
      ImGui::End();
    }
 
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    paint.setColor(flutter::DlColor::kBlue().withAlpha(filled_alpha));
    paint.setDrawStyle(flutter::DlDrawStyle::kFill);
    builder.Save();
    builder.Scale(filled_scale[0], filled_scale[1]);
    builder.DrawCircle(DlPoint(500, 750), filled_radius, paint);
    builder.Restore();
 
    paint.setColor(flutter::DlColor::kRed().withAlpha(stroked_alpha));
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setStrokeWidth(stroke_width + stroke_width_fine);
    builder.Save();
    builder.Scale(stroked_scale[0], stroked_scale[1]);
    builder.DrawCircle(DlPoint(1250, 750), stroked_radius, paint);
    builder.Restore();
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawCircle(), flutter::DlColor::kBlue(), flutter::kFill, flutter::DlColor::kRed(), flutter::kStroke, flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and flutter::DlPaint::setStrokeWidth().

◆ TEST_P() [456/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawMaskBlursThatMightUseSaveLayers
	)

Definition at line 1678 of file dl_unittests.cc.

                                                             {
  flutter::DisplayListBuilder builder;
  builder.DrawColor(flutter::DlColor::kWhite(), flutter::DlBlendMode::kSrc);
  Vector2 scale = GetContentScale();
  builder.Scale(scale.x, scale.y);
 
  builder.Save();
  // We need a small transform op to avoid a deferred save
  builder.Translate(1.0f, 1.0f);
  auto solid_filter =
      flutter::DlBlurMaskFilter::Make(flutter::DlBlurStyle::kSolid, 5.0f);
  flutter::DlPaint solid_alpha_paint =
      flutter::DlPaint()                        //
          .setMaskFilter(solid_filter)          //
          .setColor(flutter::DlColor::kBlue())  //
          .setAlpha(0x7f);
  for (int x = 1; x <= 4; x++) {
    for (int y = 1; y <= 4; y++) {
      builder.DrawRect(DlRect::MakeXYWH(x * 100, y * 100, 80, 80),
                       solid_alpha_paint);
    }
  }
  builder.Restore();
 
  builder.Save();
  builder.Translate(500.0f, 0.0f);
  auto normal_filter =
      flutter::DlBlurMaskFilter::Make(flutter::DlBlurStyle::kNormal, 5.0f);
  auto rotate_if = flutter::DlMatrixImageFilter::Make(
      Matrix::MakeRotationZ(Degrees(10)), flutter::DlImageSampling::kLinear);
  flutter::DlPaint normal_if_paint =
      flutter::DlPaint()                         //
          .setMaskFilter(solid_filter)           //
          .setImageFilter(rotate_if)             //
          .setColor(flutter::DlColor::kGreen())  //
          .setAlpha(0x7f);
  for (int x = 1; x <= 4; x++) {
    for (int y = 1; y <= 4; y++) {
      builder.DrawRect(DlRect::MakeXYWH(x * 100, y * 100, 80, 80),
                       normal_if_paint);
    }
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawColor(), flutter::DisplayListBuilder::DrawRect(), flutter::DlColor::kBlue(), flutter::DlColor::kGreen(), flutter::kLinear, flutter::kNormal, flutter::kSolid, flutter::DlColor::kWhite(), flutter::DlMatrixImageFilter::Make(), flutter::DlBlurMaskFilter::Make(), impeller::Matrix::MakeRotationZ(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setAlpha(), flutter::DlPaint::setColor(), flutter::DlPaint::setImageFilter(), flutter::DlPaint::setMaskFilter(), flutter::DisplayListBuilder::Translate(), x, impeller::TPoint< T >::x, impeller::TPoint< T >::y, and y.

◆ TEST_P() [457/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawPaintIgnoresMaskFilter
	)

Definition at line 1655 of file dl_unittests.cc.

                                                    {
  flutter::DisplayListBuilder builder;
  builder.DrawPaint(flutter::DlPaint().setColor(flutter::DlColor::kWhite()));
 
  auto filter = flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
  builder.DrawCircle(DlPoint(300, 300), 200,
                     flutter::DlPaint().setMaskFilter(&filter));
 
  std::vector<flutter::DlColor> colors = {flutter::DlColor::kGreen(),
                                          flutter::DlColor::kGreen()};
  const float stops[2] = {0.0, 1.0};
  auto linear = flutter::DlColorSource::MakeLinear(
      {100.0, 100.0}, {300.0, 300.0}, 2, colors.data(), stops,
      flutter::DlTileMode::kRepeat);
  flutter::DlPaint blend_paint =
      flutter::DlPaint()           //
          .setColorSource(linear)  //
          .setBlendMode(flutter::DlBlendMode::kScreen);
  builder.DrawPaint(blend_paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawPaint(), flutter::DlColor::kGreen(), flutter::kNormal, flutter::kRepeat, flutter::DlColor::kWhite(), flutter::DlColorSource::MakeLinear(), flutter::DlPaint::setBlendMode(), and flutter::DlPaint::setColorSource().

◆ TEST_P() [458/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawShapes
	)

Definition at line 1416 of file dl_unittests.cc.

                                    {
  flutter::DisplayListBuilder builder;
  std::vector<flutter::DlStrokeJoin> joins = {
      flutter::DlStrokeJoin::kBevel,
      flutter::DlStrokeJoin::kRound,
      flutter::DlStrokeJoin::kMiter,
  };
  flutter::DlPaint paint =                            //
      flutter::DlPaint()                              //
          .setColor(flutter::DlColor::kWhite())       //
          .setDrawStyle(flutter::DlDrawStyle::kFill)  //
          .setStrokeWidth(10);
  flutter::DlPaint stroke_paint =                       //
      flutter::DlPaint()                                //
          .setColor(flutter::DlColor::kWhite())         //
          .setDrawStyle(flutter::DlDrawStyle::kStroke)  //
          .setStrokeWidth(10);
  DlPath path = DlPath::MakeLine({150, 50}, {160, 50});
 
  builder.Translate(300, 50);
  builder.Scale(0.8, 0.8);
  for (auto join : joins) {
    paint.setStrokeJoin(join);
    stroke_paint.setStrokeJoin(join);
    builder.DrawRect(DlRect::MakeXYWH(0, 0, 100, 100), paint);
    builder.DrawRect(DlRect::MakeXYWH(0, 150, 100, 100), stroke_paint);
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(150, 0, 100, 100), 30, 30),
        paint);
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(150, 150, 100, 100), 30, 30),
        stroke_paint);
    builder.DrawCircle(DlPoint(350, 50), 50, paint);
    builder.DrawCircle(DlPoint(350, 200), 50, stroke_paint);
    builder.Translate(0, 300);
  }
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawCircle(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::kBevel, flutter::kFill, flutter::kMiter, flutter::kRound, flutter::kStroke, flutter::DlColor::kWhite(), flutter::DlPath::MakeLine(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [459/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		DrawVerticesBlendModes
	)

Definition at line 1564 of file dl_unittests.cc.

                                                {
  std::vector<const char*> blend_mode_names;
  std::vector<flutter::DlBlendMode> blend_mode_values;
  {
    const std::vector<std::tuple<const char*, flutter::DlBlendMode>> blends = {
        // Pipeline blends (Porter-Duff alpha compositing)
        {"Clear", flutter::DlBlendMode::kClear},
        {"Source", flutter::DlBlendMode::kSrc},
        {"Destination", flutter::DlBlendMode::kDst},
        {"SourceOver", flutter::DlBlendMode::kSrcOver},
        {"DestinationOver", flutter::DlBlendMode::kDstOver},
        {"SourceIn", flutter::DlBlendMode::kSrcIn},
        {"DestinationIn", flutter::DlBlendMode::kDstIn},
        {"SourceOut", flutter::DlBlendMode::kSrcOut},
        {"DestinationOut", flutter::DlBlendMode::kDstOut},
        {"SourceATop", flutter::DlBlendMode::kSrcATop},
        {"DestinationATop", flutter::DlBlendMode::kDstATop},
        {"Xor", flutter::DlBlendMode::kXor},
        {"Plus", flutter::DlBlendMode::kPlus},
        {"Modulate", flutter::DlBlendMode::kModulate},
        // Advanced blends (color component blends)
        {"Screen", flutter::DlBlendMode::kScreen},
        {"Overlay", flutter::DlBlendMode::kOverlay},
        {"Darken", flutter::DlBlendMode::kDarken},
        {"Lighten", flutter::DlBlendMode::kLighten},
        {"ColorDodge", flutter::DlBlendMode::kColorDodge},
        {"ColorBurn", flutter::DlBlendMode::kColorBurn},
        {"HardLight", flutter::DlBlendMode::kHardLight},
        {"SoftLight", flutter::DlBlendMode::kSoftLight},
        {"Difference", flutter::DlBlendMode::kDifference},
        {"Exclusion", flutter::DlBlendMode::kExclusion},
        {"Multiply", flutter::DlBlendMode::kMultiply},
        {"Hue", flutter::DlBlendMode::kHue},
        {"Saturation", flutter::DlBlendMode::kSaturation},
        {"Color", flutter::DlBlendMode::kColor},
        {"Luminosity", flutter::DlBlendMode::kLuminosity},
    };
    assert(blends.size() ==
           static_cast<size_t>(flutter::DlBlendMode::kLastMode) + 1);
    for (const auto& [name, mode] : blends) {
      blend_mode_names.push_back(name);
      blend_mode_values.push_back(mode);
    }
  }
 
  auto callback = [&]() {
    static int current_blend_index = 3;
    static float dst_alpha = 1;
    static float src_alpha = 1;
    static float color0[4] = {1.0f, 0.0f, 0.0f, 1.0f};
    static float color1[4] = {0.0f, 1.0f, 0.0f, 1.0f};
    static float color2[4] = {0.0f, 0.0f, 1.0f, 1.0f};
    static float src_color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::ListBox("Blending mode", &current_blend_index,
                     blend_mode_names.data(), blend_mode_names.size());
      ImGui::SliderFloat("Source alpha", &src_alpha, 0, 1);
      ImGui::ColorEdit4("Color A", color0);
      ImGui::ColorEdit4("Color B", color1);
      ImGui::ColorEdit4("Color C", color2);
      ImGui::ColorEdit4("Source Color", src_color);
      ImGui::SliderFloat("Destination alpha", &dst_alpha, 0, 1);
      ImGui::End();
    }
 
    std::vector<DlPoint> positions = {DlPoint(100, 300),  //
                                      DlPoint(200, 100),  //
                                      DlPoint(300, 300)};
    std::vector<flutter::DlColor> colors = {
        toColor(color0).modulateOpacity(dst_alpha),
        toColor(color1).modulateOpacity(dst_alpha),
        toColor(color2).modulateOpacity(dst_alpha)};
 
    auto vertices = flutter::DlVertices::Make(
        flutter::DlVertexMode::kTriangles, 3, positions.data(),
        /*texture_coordinates=*/nullptr, colors.data());
 
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    paint.setColor(toColor(src_color).modulateOpacity(src_alpha));
    builder.DrawVertices(vertices, blend_mode_values[current_blend_index],
                         paint);
    return builder.Build();
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DisplayListBuilder::DrawVertices(), flutter::kTriangles, flutter::DlVertices::Make(), flutter::mode, flutter::DlColor::modulateOpacity(), flutter::name, flutter::DlPaint::setColor(), and toColor().

◆ TEST_P() [460/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		IgnoreMaskFilterWhenSavingLayer
	)

Definition at line 526 of file dl_unittests.cc.

                                                         {
  auto texture = CreateTextureForFixture("embarcadero.jpg");
  flutter::DisplayListBuilder builder;
  auto filter = flutter::DlBlurMaskFilter(flutter::DlBlurStyle::kNormal, 10.0f);
  flutter::DlPaint paint;
  paint.setMaskFilter(&filter);
  builder.SaveLayer(std::nullopt, &paint);
  builder.DrawImage(DlImageImpeller::Make(texture), DlPoint(100, 100),
                    flutter::DlImageSampling::kNearestNeighbor);
  builder.Restore();
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImage(), flutter::kNearestNeighbor, flutter::kNormal, impeller::DlImageImpeller::Make(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::SaveLayer(), flutter::DlPaint::setMaskFilter(), and texture.

◆ TEST_P() [461/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		MaskBlursApplyCorrectlyToColorSources
	)

Definition at line 1368 of file dl_unittests.cc.

                                                               {
  auto blur_filter = std::make_shared<flutter::DlBlurMaskFilter>(
      flutter::DlBlurStyle::kNormal, 10);
 
  flutter::DisplayListBuilder builder;
 
  std::array<flutter::DlColor, 2> colors = {flutter::DlColor::kBlue(),
                                            flutter::DlColor::kGreen()};
  std::array<float, 2> stops = {0, 1};
  auto texture = CreateTextureForFixture("airplane.jpg");
  auto matrix = flutter::DlMatrix::MakeTranslation({-300, -110});
  std::array<std::shared_ptr<flutter::DlColorSource>, 2> color_sources = {
      flutter::DlColorSource::MakeImage(
          DlImageImpeller::Make(texture), flutter::DlTileMode::kRepeat,
          flutter::DlTileMode::kRepeat, flutter::DlImageSampling::kLinear,
          &matrix),
      flutter::DlColorSource::MakeLinear(
          flutter::DlPoint(0, 0), flutter::DlPoint(100, 50), 2, colors.data(),
          stops.data(), flutter::DlTileMode::kClamp),
  };
 
  builder.Save();
  builder.Translate(0, 100);
  for (const auto& color_source : color_sources) {
    flutter::DlPaint paint;
    paint.setColorSource(color_source);
    paint.setMaskFilter(blur_filter);
 
    builder.Save();
    builder.Translate(100, 0);
    paint.setDrawStyle(flutter::DlDrawStyle::kFill);
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 30, 30), paint);
 
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
    paint.setStrokeWidth(10);
    builder.Translate(200, 0);
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 30, 30), paint);
 
    builder.Restore();
    builder.Translate(0, 100);
  }
  builder.Restore();
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::DlColor::kBlue(), flutter::kClamp, flutter::kFill, flutter::DlColor::kGreen(), flutter::kLinear, flutter::kNormal, flutter::kRepeat, flutter::kStroke, impeller::DlImageImpeller::Make(), flutter::DlColorSource::MakeImage(), flutter::DlColorSource::MakeLinear(), impeller::RoundRect::MakeRectXY(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeWH(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DlPaint::setColorSource(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setMaskFilter(), flutter::DlPaint::setStrokeWidth(), texture, and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [462/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		NinePatchImageColorFilter
	)

Definition at line 902 of file dl_unittests.cc.

                                                   {
  auto texture = CreateTextureForFixture("nine_patch2.png");
 
  auto filter = flutter::DlColorFilter::MakeBlend(flutter::DlColor::kGreen(),
                                                  flutter::DlBlendMode::kSrcIn);
  flutter::DlPaint paint;
  paint.setColorFilter(filter);
 
  flutter::DisplayListBuilder builder;
  builder.DrawImageNine(DlImageImpeller::Make(texture),
                        DlIRect::MakeXYWH(10, 10, 1, 1),
                        DlRect::MakeXYWH(0, 0, 200, 100),
                        flutter::DlFilterMode::kNearest, &paint);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::DlColor::kGreen(), flutter::kNearest, impeller::DlImageImpeller::Make(), flutter::DlColorFilter::MakeBlend(), impeller::TRect< T >::MakeXYWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColorFilter(), and texture.

◆ TEST_P() [463/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		NinePatchImagePrecision
	)

Definition at line 890 of file dl_unittests.cc.

                                                 {
  // Draw a nine patch image with colored corners and verify that the corner
  // color does not leak outside the intended region.
  auto texture = CreateTextureForFixture("nine_patch_corners.png");
  flutter::DisplayListBuilder builder;
  builder.DrawImageNine(DlImageImpeller::Make(texture),
                        DlIRect::MakeXYWH(10, 10, 1, 1),
                        DlRect::MakeXYWH(0, 0, 200, 100),
                        flutter::DlFilterMode::kNearest, nullptr);
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawImageNine(), flutter::kNearest, impeller::DlImageImpeller::Make(), impeller::TRect< T >::MakeXYWH(), impeller::TRect< Scalar >::MakeXYWH(), and texture.

◆ TEST_P() [464/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		StrokedPathsDrawCorrectly
	)

Definition at line 221 of file dl_unittests.cc.

                                                   {
  auto callback = [&]() {
    flutter::DisplayListBuilder builder;
    flutter::DlPaint paint;
 
    paint.setColor(flutter::DlColor::kRed());
    paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
 
    static float stroke_width = 10.0f;
    static int selected_stroke_type = 0;
    static int selected_join_type = 0;
    const char* stroke_types[] = {"Butte", "Round", "Square"};
    const char* join_type[] = {"kMiter", "Round", "kBevel"};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Cap", &selected_stroke_type, stroke_types,
                   sizeof(stroke_types) / sizeof(char*));
      ImGui::Combo("Join", &selected_join_type, join_type,
                   sizeof(join_type) / sizeof(char*));
      ImGui::SliderFloat("Stroke Width", &stroke_width, 10.0f, 50.0f);
      ImGui::End();
    }
 
    flutter::DlStrokeCap cap;
    flutter::DlStrokeJoin join;
    switch (selected_stroke_type) {
      case 0:
        cap = flutter::DlStrokeCap::kButt;
        break;
      case 1:
        cap = flutter::DlStrokeCap::kRound;
        break;
      case 2:
        cap = flutter::DlStrokeCap::kSquare;
        break;
      default:
        cap = flutter::DlStrokeCap::kButt;
        break;
    }
    switch (selected_join_type) {
      case 0:
        join = flutter::DlStrokeJoin::kMiter;
        break;
      case 1:
        join = flutter::DlStrokeJoin::kRound;
        break;
      case 2:
        join = flutter::DlStrokeJoin::kBevel;
        break;
      default:
        join = flutter::DlStrokeJoin::kMiter;
        break;
    }
    paint.setStrokeCap(cap);
    paint.setStrokeJoin(join);
    paint.setStrokeWidth(stroke_width);
 
    // Make rendering better to watch.
    builder.Scale(1.5f, 1.5f);
 
    // Rectangle
    builder.Translate(100, 100);
    builder.DrawRect(DlRect::MakeWH(100, 100), paint);
 
    // Rounded rectangle
    builder.Translate(150, 0);
    builder.DrawRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 10, 10), paint);
 
    // Double rounded rectangle
    builder.Translate(150, 0);
    builder.DrawDiffRoundRect(
        DlRoundRect::MakeRectXY(DlRect::MakeWH(100, 50), 10, 10),
        DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 10, 80, 30), 10, 10),
        paint);
 
    // Contour with duplicate join points
    {
      builder.Translate(150, 0);
      flutter::DlPathBuilder path_builder;
      path_builder.MoveTo(DlPoint(0, 0));
      path_builder.LineTo(DlPoint(0, 0));
      path_builder.LineTo(DlPoint(100, 0));
      path_builder.LineTo(DlPoint(100, 0));
      path_builder.LineTo(DlPoint(100, 100));
      builder.DrawPath(path_builder.TakePath(), paint);
    }
 
    // Contour with duplicate start and end points
 
    // Line.
    builder.Translate(200, 0);
    {
      builder.Save();
 
      flutter::DlPathBuilder line_path_builder;
      line_path_builder.MoveTo(DlPoint(0, 0));
      line_path_builder.MoveTo(DlPoint(0, 0));
      line_path_builder.LineTo(DlPoint(0, 0));
      line_path_builder.LineTo(DlPoint(0, 0));
      line_path_builder.LineTo(DlPoint(50, 50));
      line_path_builder.LineTo(DlPoint(50, 50));
      line_path_builder.LineTo(DlPoint(100, 0));
      line_path_builder.LineTo(DlPoint(100, 0));
      DlPath line_path = line_path_builder.TakePath();
      builder.DrawPath(line_path, paint);
 
      builder.Translate(0, 100);
      builder.DrawPath(line_path, paint);
 
      builder.Translate(0, 100);
      flutter::DlPathBuilder line_path_builder2;
      line_path_builder2.MoveTo(DlPoint(0, 0));
      line_path_builder2.LineTo(DlPoint(0, 0));
      line_path_builder2.LineTo(DlPoint(0, 0));
      builder.DrawPath(line_path_builder2.TakePath(), paint);
 
      builder.Restore();
    }
 
    // Cubic.
    builder.Translate(150, 0);
    {
      builder.Save();
 
      flutter::DlPathBuilder cubic_path;
      cubic_path.MoveTo(DlPoint(0, 0));
      cubic_path.CubicCurveTo(DlPoint(0, 0),          //
                              DlPoint(140.0, 100.0),  //
                              DlPoint(140, 20));
      builder.DrawPath(cubic_path.TakePath(), paint);
 
      builder.Translate(0, 100);
      flutter::DlPathBuilder cubic_path2;
      cubic_path2.MoveTo(DlPoint(0, 0));
      cubic_path2.CubicCurveTo(DlPoint(0, 0),  //
                               DlPoint(0, 0),  //
                               DlPoint(150, 150));
      builder.DrawPath(cubic_path2.TakePath(), paint);
 
      builder.Translate(0, 100);
      flutter::DlPathBuilder cubic_path3;
      cubic_path3.MoveTo(DlPoint(0, 0));
      cubic_path3.CubicCurveTo(DlPoint(0, 0),  //
                               DlPoint(0, 0),  //
                               DlPoint(0, 0));
      builder.DrawPath(cubic_path3.TakePath(), paint);
 
      builder.Restore();
    }
 
    // Quad.
    builder.Translate(200, 0);
    {
      builder.Save();
 
      flutter::DlPathBuilder quad_path;
      quad_path.MoveTo(DlPoint(0, 0));
      quad_path.MoveTo(DlPoint(0, 0));
      quad_path.QuadraticCurveTo(DlPoint(100, 40), DlPoint(50, 80));
      builder.DrawPath(quad_path.TakePath(), paint);
 
      builder.Translate(0, 150);
      flutter::DlPathBuilder quad_path2;
      quad_path2.MoveTo(DlPoint(0, 0));
      quad_path2.MoveTo(DlPoint(0, 0));
      quad_path2.QuadraticCurveTo(DlPoint(0, 0), DlPoint(100, 100));
      builder.DrawPath(quad_path2.TakePath(), paint);
 
      builder.Translate(0, 100);
      flutter::DlPathBuilder quad_path3;
      quad_path3.MoveTo(DlPoint(0, 0));
      quad_path3.QuadraticCurveTo(DlPoint(0, 0), DlPoint(0, 0));
      builder.DrawPath(quad_path3.TakePath(), paint);
 
      builder.Restore();
    }
    return builder.Build();
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References flutter::DisplayListBuilder::Build(), callback, flutter::DlPathBuilder::CubicCurveTo(), flutter::DisplayListBuilder::DrawDiffRoundRect(), flutter::DisplayListBuilder::DrawPath(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawRoundRect(), flutter::kBevel, flutter::kButt, flutter::kMiter, flutter::DlColor::kRed(), flutter::kRound, flutter::kSquare, flutter::kStroke, flutter::DlPathBuilder::LineTo(), impeller::RoundRect::MakeRectXY(), impeller::TRect< Scalar >::MakeWH(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), flutter::DlPathBuilder::QuadraticCurveTo(), flutter::DisplayListBuilder::Restore(), flutter::DisplayListBuilder::Save(), flutter::DisplayListBuilder::Scale(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), flutter::DlPaint::setStrokeCap(), flutter::DlPaint::setStrokeJoin(), flutter::DlPaint::setStrokeWidth(), flutter::DlPathBuilder::TakePath(), and flutter::DisplayListBuilder::Translate().

◆ TEST_P() [465/662]

impeller::testing::TEST_P	(	DisplayListTest	,
		StrokedTextNotOffsetFromNormalText
	)

Definition at line 500 of file dl_unittests.cc.

                                                            {
  flutter::DisplayListBuilder builder;
  flutter::DlPaint paint;
  auto const& text_blob = SkTextBlob::MakeFromString("00000", CreateTestFont());
  auto text = flutter::DlTextImpeller::MakeFromBlob(text_blob);
 
  // https://api.flutter.dev/flutter/material/Colors/blue-constant.html.
  auto const& mat_blue = flutter::DlColor(0xFF2196f3);
 
  // Draw a blue filled rectangle so the text is easier to see.
  paint.setDrawStyle(flutter::DlDrawStyle::kFill);
  paint.setColor(mat_blue);
  builder.DrawRect(DlRect::MakeXYWH(0, 0, 500, 500), paint);
 
  // Draw stacked text, with stroked text on top.
  paint.setDrawStyle(flutter::DlDrawStyle::kFill);
  paint.setColor(flutter::DlColor::kWhite());
  builder.DrawText(text, 250, 250, paint);
 
  paint.setDrawStyle(flutter::DlDrawStyle::kStroke);
  paint.setColor(flutter::DlColor::kBlack());
  builder.DrawText(text, 250, 250, paint);
 
  ASSERT_TRUE(OpenPlaygroundHere(builder.Build()));
}

References flutter::DisplayListBuilder::Build(), flutter::DisplayListBuilder::DrawRect(), flutter::DisplayListBuilder::DrawText(), flutter::DlColor::kBlack(), flutter::kFill, flutter::kStroke, flutter::DlColor::kWhite(), flutter::DlTextImpeller::MakeFromBlob(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPaint::setColor(), flutter::DlPaint::setDrawStyle(), and text.

◆ TEST_P() [466/662]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanDumpToLog
	)

Definition at line 30 of file driver_info_vk_unittests.cc.

                                       {
  ASSERT_TRUE(GetContext());
  const auto& driver_info =
      SurfaceContextVK::Cast(*GetContext()).GetParent()->GetDriverInfo();
  ASSERT_NE(driver_info, nullptr);
  fml::testing::LogCapture log;
  driver_info->DumpToLog();
  EXPECT_TRUE(log.str().find("Driver Information") != std::string::npos);
}

References impeller::BackendCast< SurfaceContextVK, Context >::Cast(), impeller::SurfaceContextVK::GetParent(), and fml::testing::LogCapture::str().

◆ TEST_P() [467/662]

impeller::testing::TEST_P	(	DriverInfoVKTest	,
		CanQueryDriverInfo
	)

Definition at line 17 of file driver_info_vk_unittests.cc.

                                             {
  ASSERT_TRUE(GetContext());
  const auto& driver_info =
      SurfaceContextVK::Cast(*GetContext()).GetParent()->GetDriverInfo();
  ASSERT_NE(driver_info, nullptr);
  // 1.1 is the base Impeller version. The driver can't be lower than that.
  ASSERT_TRUE(driver_info->GetAPIVersion().IsAtLeast(Version{1, 1, 0}));
  ASSERT_NE(driver_info->GetVendor(), VendorVK::kUnknown);
  ASSERT_NE(driver_info->GetDeviceType(), DeviceTypeVK::kUnknown);
  ASSERT_NE(driver_info->GetDriverName(), "");
  EXPECT_FALSE(driver_info->IsKnownBadDriver());
}

References impeller::BackendCast< SurfaceContextVK, Context >::Cast(), impeller::SurfaceContextVK::GetParent(), and impeller::kUnknown.

◆ TEST_P() [468/662]

impeller::testing::TEST_P	(	EntityPassTargetTest	,
		SwapWithMSAAImplicitResolve
	)

Definition at line 46 of file entity_pass_target_unittests.cc.

                                                          {
  ContentContext& content_context = GetContentContext();
  auto buffer = content_context.GetContext()->CreateCommandBuffer();
  auto context = content_context.GetContext();
  auto& allocator = *context->GetResourceAllocator();
 
  // Emulate implicit MSAA resolve by making color resolve and msaa texture the
  // same.
  RenderTarget render_target;
  {
    PixelFormat pixel_format =
        context->GetCapabilities()->GetDefaultColorFormat();
 
    // Create MSAA color texture.
 
    TextureDescriptor color0_tex_desc;
    color0_tex_desc.storage_mode = StorageMode::kDevicePrivate;
    color0_tex_desc.type = TextureType::kTexture2DMultisample;
    color0_tex_desc.sample_count = SampleCount::kCount4;
    color0_tex_desc.format = pixel_format;
    color0_tex_desc.size = ISize{100, 100};
    color0_tex_desc.usage = TextureUsage::kRenderTarget;
 
    auto color0_msaa_tex = allocator.CreateTexture(color0_tex_desc);
 
    // Color attachment.
 
    ColorAttachment color0;
    color0.load_action = LoadAction::kDontCare;
    color0.store_action = StoreAction::kStoreAndMultisampleResolve;
    color0.texture = color0_msaa_tex;
    color0.resolve_texture = color0_msaa_tex;
 
    render_target.SetColorAttachment(color0, 0u);
    render_target.SetStencilAttachment(std::nullopt);
  }
 
  auto entity_pass_target = EntityPassTarget(render_target, false, true);
 
  auto color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
  auto msaa_tex = color0.texture;
  auto resolve_tex = color0.resolve_texture;
 
  ASSERT_EQ(msaa_tex, resolve_tex);
 
  entity_pass_target.Flip(content_context);
 
  color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
 
  ASSERT_NE(msaa_tex, color0.texture);
  ASSERT_NE(resolve_tex, color0.resolve_texture);
  ASSERT_EQ(color0.texture, color0.resolve_texture);
}

References allocator, flutter::buffer, context, impeller::TextureDescriptor::format, impeller::ContentContext::GetContext(), impeller::kCount4, impeller::kDevicePrivate, impeller::kDontCare, impeller::kRenderTarget, impeller::kStoreAndMultisampleResolve, impeller::kTexture2DMultisample, impeller::Attachment::load_action, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, impeller::TextureDescriptor::type, and impeller::TextureDescriptor::usage.

◆ TEST_P() [469/662]

impeller::testing::TEST_P	(	EntityPassTargetTest	,
		SwapWithMSAATexture
	)

Definition at line 19 of file entity_pass_target_unittests.cc.

                                                  {
  if (GetContentContext()
          .GetDeviceCapabilities()
          .SupportsImplicitResolvingMSAA()) {
    GTEST_SKIP() << "Implicit MSAA is used on this device.";
  }
  ContentContext& content_context = GetContentContext();
  auto buffer = content_context.GetContext()->CreateCommandBuffer();
  auto render_target =
      GetContentContext().GetRenderTargetCache()->CreateOffscreenMSAA(
          *content_context.GetContext(), {100, 100},
          /*mip_count=*/1);
 
  auto entity_pass_target = EntityPassTarget(render_target, false, false);
 
  auto color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
  auto msaa_tex = color0.texture;
  auto resolve_tex = color0.resolve_texture;
 
  entity_pass_target.Flip(content_context);
 
  color0 = entity_pass_target.GetRenderTarget().GetColorAttachment(0);
 
  ASSERT_EQ(msaa_tex, color0.texture);
  ASSERT_NE(resolve_tex, color0.resolve_texture);
}

References flutter::buffer, and impeller::ContentContext::GetContext().

◆ TEST_P() [470/662]

impeller::testing::TEST_P	(	EntityTest	,
		BezierCircleScaled
	)

Definition at line 873 of file entity_unittests.cc.

                                       {
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    static float scale = 20;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Scale", &scale, 1, 100);
      ImGui::End();
    }
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()));
    auto path = flutter::DlPathBuilder{}
                    .MoveTo({97.325, 34.818})
                    .CubicCurveTo({98.50862885295136, 34.81812293973836},
                                  {99.46822048142015, 33.85863261475589},
                                  {99.46822048142015, 32.67499810206613})
                    .CubicCurveTo({99.46822048142015, 31.491363589376355},
                                  {98.50862885295136, 30.53187326439389},
                                  {97.32499434685802, 30.531998226542708})
                    .CubicCurveTo({96.14153655073771, 30.532123170035373},
                                  {95.18222070648729, 31.491540299350355},
                                  {95.18222070648729, 32.67499810206613})
                    .CubicCurveTo({95.18222070648729, 33.85845590478189},
                                  {96.14153655073771, 34.81787303409686},
                                  {97.32499434685802, 34.81799797758954})
                    .Close()
                    .TakePath();
    entity.SetTransform(
        Matrix::MakeScale({scale, scale, 1.0}).Translate({-90, -20, 0}));
 
    std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
 
    auto contents = std::make_shared<SolidColorContents>(geom.get());
    contents->SetColor(Color::Red());
 
    entity.SetContents(contents);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, impeller::Close(), context, impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [471/662]

impeller::testing::TEST_P	(	EntityTest	,
		BlendingModeOptions
	)

Definition at line 739 of file entity_unittests.cc.

                                        {
  std::vector<const char*> blend_mode_names;
  std::vector<BlendMode> blend_mode_values;
  {
    // Force an exhausiveness check with a switch. When adding blend modes,
    // update this switch with a new name/value to make it selectable in the
    // test GUI.
 
    const BlendMode b{};
    static_assert(b == BlendMode::kClear);  // Ensure the first item in
                                            // the switch is the first
                                            // item in the enum.
    static_assert(Entity::kLastPipelineBlendMode == BlendMode::kModulate);
    switch (b) {
      case BlendMode::kClear:
        blend_mode_names.push_back("Clear");
        blend_mode_values.push_back(BlendMode::kClear);
      case BlendMode::kSrc:
        blend_mode_names.push_back("Source");
        blend_mode_values.push_back(BlendMode::kSrc);
      case BlendMode::kDst:
        blend_mode_names.push_back("Destination");
        blend_mode_values.push_back(BlendMode::kDst);
      case BlendMode::kSrcOver:
        blend_mode_names.push_back("SourceOver");
        blend_mode_values.push_back(BlendMode::kSrcOver);
      case BlendMode::kDstOver:
        blend_mode_names.push_back("DestinationOver");
        blend_mode_values.push_back(BlendMode::kDstOver);
      case BlendMode::kSrcIn:
        blend_mode_names.push_back("SourceIn");
        blend_mode_values.push_back(BlendMode::kSrcIn);
      case BlendMode::kDstIn:
        blend_mode_names.push_back("DestinationIn");
        blend_mode_values.push_back(BlendMode::kDstIn);
      case BlendMode::kSrcOut:
        blend_mode_names.push_back("SourceOut");
        blend_mode_values.push_back(BlendMode::kSrcOut);
      case BlendMode::kDstOut:
        blend_mode_names.push_back("DestinationOut");
        blend_mode_values.push_back(BlendMode::kDstOut);
      case BlendMode::kSrcATop:
        blend_mode_names.push_back("SourceATop");
        blend_mode_values.push_back(BlendMode::kSrcATop);
      case BlendMode::kDstATop:
        blend_mode_names.push_back("DestinationATop");
        blend_mode_values.push_back(BlendMode::kDstATop);
      case BlendMode::kXor:
        blend_mode_names.push_back("Xor");
        blend_mode_values.push_back(BlendMode::kXor);
      case BlendMode::kPlus:
        blend_mode_names.push_back("Plus");
        blend_mode_values.push_back(BlendMode::kPlus);
      case BlendMode::kModulate:
        blend_mode_names.push_back("Modulate");
        blend_mode_values.push_back(BlendMode::kModulate);
    };
  }
 
  auto callback = [&](ContentContext& context, RenderPass& pass) {
    auto world_matrix = Matrix::MakeScale(GetContentScale());
    auto draw_rect = [&context, &pass, &world_matrix](
                         Rect rect, Color color, BlendMode blend_mode) -> bool {
      using VS = SolidFillPipeline::VertexShader;
      using FS = SolidFillPipeline::FragmentShader;
 
      VertexBufferBuilder<VS::PerVertexData> vtx_builder;
      {
        auto r = rect.GetLTRB();
        vtx_builder.AddVertices({
            {Point(r[0], r[1])},
            {Point(r[2], r[1])},
            {Point(r[2], r[3])},
            {Point(r[0], r[1])},
            {Point(r[2], r[3])},
            {Point(r[0], r[3])},
        });
      }
 
      pass.SetCommandLabel("Blended Rectangle");
      auto options = OptionsFromPass(pass);
      options.blend_mode = blend_mode;
      options.primitive_type = PrimitiveType::kTriangle;
      pass.SetPipeline(context.GetSolidFillPipeline(options));
      pass.SetVertexBuffer(
          vtx_builder.CreateVertexBuffer(context.GetTransientsDataBuffer(),
                                         context.GetTransientsIndexesBuffer()));
 
      VS::FrameInfo frame_info;
      frame_info.mvp = pass.GetOrthographicTransform() * world_matrix;
      VS::BindFrameInfo(
          pass, context.GetTransientsDataBuffer().EmplaceUniform(frame_info));
      FS::FragInfo frag_info;
      frag_info.color = color.Premultiply();
      FS::BindFragInfo(
          pass, context.GetTransientsDataBuffer().EmplaceUniform(frag_info));
      return pass.Draw().ok();
    };
 
    static Color color1(1, 0, 0, 0.5), color2(0, 1, 0, 0.5);
    static int current_blend_index = 3;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::ColorEdit4("Color 1", reinterpret_cast<float*>(&color1));
      ImGui::ColorEdit4("Color 2", reinterpret_cast<float*>(&color2));
      ImGui::ListBox("Blending mode", &current_blend_index,
                     blend_mode_names.data(), blend_mode_names.size());
      ImGui::End();
    }
 
    BlendMode selected_mode = blend_mode_values[current_blend_index];
 
    Point a, b, c, d;
    static PlaygroundPoint point_a(Point(400, 100), 20, Color::White());
    static PlaygroundPoint point_b(Point(200, 300), 20, Color::White());
    std::tie(a, b) = DrawPlaygroundLine(point_a, point_b);
    static PlaygroundPoint point_c(Point(470, 190), 20, Color::White());
    static PlaygroundPoint point_d(Point(270, 390), 20, Color::White());
    std::tie(c, d) = DrawPlaygroundLine(point_c, point_d);
 
    bool result = true;
    result = result &&
             draw_rect(Rect::MakeXYWH(0, 0, pass.GetRenderTargetSize().width,
                                      pass.GetRenderTargetSize().height),
                       Color(), BlendMode::kClear);
    result = result && draw_rect(Rect::MakeLTRB(a.x, a.y, b.x, b.y), color1,
                                 BlendMode::kSrcOver);
    result = result && draw_rect(Rect::MakeLTRB(c.x, c.y, d.x, d.y), color2,
                                 selected_mode);
    return result;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), c, callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), d, impeller::DrawPlaygroundLine(), impeller::kClear, impeller::kDst, impeller::kDstATop, impeller::kDstIn, impeller::kDstOut, impeller::kDstOver, impeller::Entity::kLastPipelineBlendMode, impeller::kModulate, impeller::kPlus, impeller::kSrc, impeller::kSrcATop, impeller::kSrcIn, impeller::kSrcOut, impeller::kSrcOver, impeller::kTriangle, impeller::kXor, impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), impeller::OptionsFromPass(), impeller::Color::White(), flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [472/662]

impeller::testing::TEST_P	(	EntityTest	,
		BorderMaskBlurCoverageIsCorrect
	)

Definition at line 1370 of file entity_unittests.cc.

                                                    {
  auto geom = Geometry::MakeFillPath(
      flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
  auto fill = std::make_shared<SolidColorContents>(geom.get());
  fill->SetColor(Color::CornflowerBlue());
  auto border_mask_blur = FilterContents::MakeBorderMaskBlur(
      FilterInput::Make(fill), Radius{3}, Radius{4});
 
  {
    Entity e;
    e.SetTransform(Matrix());
    auto actual = border_mask_blur->GetCoverage(e);
    auto expected = Rect::MakeXYWH(-3, -4, 306, 408);
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
 
  {
    Entity e;
    e.SetTransform(Matrix::MakeRotationZ(Radians{kPi / 4}));
    auto actual = border_mask_blur->GetCoverage(e);
    auto expected = Rect::MakeXYWH(-287.792, -4.94975, 504.874, 504.874);
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
}

References ASSERT_RECT_NEAR, impeller::Color::CornflowerBlue(), flutter::kPi, impeller::FilterInput::Make(), impeller::FilterContents::MakeBorderMaskBlur(), impeller::Geometry::MakeFillPath(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeRotationZ(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [473/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanComputeGeometryForEmptyPathsWithoutCrashing
	)

Definition at line 2467 of file entity_unittests.cc.

                                                                   {
  flutter::DlPath path = flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 0, 0));
 
  EXPECT_TRUE(path.GetBounds().IsEmpty());
 
  auto geom = Geometry::MakeFillPath(path);
 
  Entity entity;
  RenderTarget target =
      GetContentContext().GetRenderTargetCache()->CreateOffscreen(*GetContext(),
                                                                  {1, 1}, 1u);
  testing::MockRenderPass render_pass(GetContext(), target);
  auto position_result =
      geom->GetPositionBuffer(GetContentContext(), entity, render_pass);
 
  EXPECT_EQ(position_result.vertex_buffer.vertex_count, 0u);
 
  EXPECT_EQ(geom->GetResultMode(), GeometryResult::Mode::kNormal);
}

References impeller::GeometryResult::kNormal, impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), flutter::path, render_pass, and target.

◆ TEST_P() [474/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanCreateEntity
	)

Definition at line 72 of file entity_unittests.cc.

                                    {
  Entity entity;
  ASSERT_TRUE(entity.GetTransform().IsIdentity());
}

References impeller::Entity::GetTransform(), and impeller::Matrix::IsIdentity().

◆ TEST_P() [475/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawCorrectlyWithRotatedTransform
	)

Definition at line 391 of file entity_unittests.cc.

                                                         {
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    const char* input_axis[] = {"X", "Y", "Z"};
    static int rotation_axis_index = 0;
    static float rotation = 0;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Rotation", &rotation, -kPi, kPi);
      ImGui::Combo("Rotation Axis", &rotation_axis_index, input_axis,
                   sizeof(input_axis) / sizeof(char*));
      if (ImGui::Button("Reset")) {
        rotation = 0;
      }
      ImGui::End();
    }
    Matrix rotation_matrix;
    switch (rotation_axis_index) {
      case 0:
        rotation_matrix = Matrix::MakeRotationX(Radians(rotation));
        break;
      case 1:
        rotation_matrix = Matrix::MakeRotationY(Radians(rotation));
        break;
      case 2:
        rotation_matrix = Matrix::MakeRotationZ(Radians(rotation));
        break;
      default:
        rotation_matrix = Matrix{};
        break;
    }
 
    Matrix current_transform =
        Matrix::MakeScale(GetContentScale())
            .MakeTranslation(
                Vector3(Point(pass.GetRenderTargetSize().width / 2.0,
                              pass.GetRenderTargetSize().height / 2.0)));
    Matrix result_transform = current_transform * rotation_matrix;
    flutter::DlPath path =
        flutter::DlPath::MakeRect(Rect::MakeXYWH(-300, -400, 600, 800));
 
    Entity entity;
    entity.SetTransform(result_transform);
 
    std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
 
    auto contents = std::make_shared<SolidColorContents>(geom.get());
    contents->SetColor(Color::Red());
 
    entity.SetContents(contents);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, flutter::kPi, impeller::Geometry::MakeFillPath(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [476/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawRoundSuperEllipseWithJustEnoughRadius
	)

Definition at line 2782 of file entity_unittests.cc.

                                                                 {
  // Regression test for https://github.com/flutter/flutter/issues/176894
  // Verify that a radius marginally above the minimum threshold can be
  // processed safely. The expectation is that the rounded corners are
  // drawn as rounded and that no NaNs or crashes occur.
  auto geom = Geometry::MakeRoundSuperellipse(
      Rect::MakeLTRB(200, 200, 300, 300), 1.1 * kEhCloseEnough);
 
  ContentContext content_context(GetContext(), /*typographer_context=*/nullptr);
  Entity entity;
 
  auto cmd_buffer = content_context.GetContext()->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(
      content_context.GetContext()->GetResourceAllocator());
 
  auto render_target = allocator.CreateOffscreen(
      *content_context.GetContext(), /*size=*/{500, 500}, /*mip_count=*/1);
  auto pass = cmd_buffer->CreateRenderPass(render_target);
 
  GeometryResult result =
      geom->GetPositionBuffer(content_context, entity, *pass);
 
  EXPECT_EQ(result.vertex_buffer.vertex_count, 200u);
  Point* written_data = reinterpret_cast<Point*>(
      (result.vertex_buffer.vertex_buffer.GetBuffer()->OnGetContents() +
       result.vertex_buffer.vertex_buffer.GetRange().offset));
 
  std::vector<Point> expected_head = {Point(250.0, 200.0), Point(299.9, 200.0),
                                      Point(200.1, 200.0), Point(299.9, 200.0)};
 
  for (size_t i = 0; i < expected_head.size(); i++) {
    const Point& point = written_data[i];
    EXPECT_NEAR(point.x, expected_head[i].x, 0.1);
    EXPECT_NEAR(point.y, expected_head[i].y, 0.1);
  }
}

References allocator, impeller::BufferView::GetBuffer(), impeller::ContentContext::GetContext(), impeller::BufferView::GetRange(), i, flutter::kEhCloseEnough, impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRoundSuperellipse(), impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), impeller::VertexBuffer::vertex_buffer, impeller::GeometryResult::vertex_buffer, impeller::VertexBuffer::vertex_count, flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [477/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanDrawRoundSuperEllipseWithTinyRadius
	)

Definition at line 2744 of file entity_unittests.cc.

                                                           {
  // Regression test for https://github.com/flutter/flutter/issues/176894
  // Verify that a radius marginally below the minimum threshold can be
  // processed safely. The expectation is that the rounded corners degenerate
  // into sharp corners (four corner points) and that no NaNs or crashes occur.
  auto geom = Geometry::MakeRoundSuperellipse(
      Rect::MakeLTRB(200, 200, 300, 300), 0.5 * kEhCloseEnough);
 
  ContentContext content_context(GetContext(), /*typographer_context=*/nullptr);
  Entity entity;
 
  auto cmd_buffer = content_context.GetContext()->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(
      content_context.GetContext()->GetResourceAllocator());
 
  auto render_target = allocator.CreateOffscreen(
      *content_context.GetContext(), /*size=*/{500, 500}, /*mip_count=*/1);
  auto pass = cmd_buffer->CreateRenderPass(render_target);
 
  GeometryResult result =
      geom->GetPositionBuffer(content_context, entity, *pass);
 
  EXPECT_EQ(result.vertex_buffer.vertex_count, 4u);
  Point* written_data = reinterpret_cast<Point*>(
      (result.vertex_buffer.vertex_buffer.GetBuffer()->OnGetContents() +
       result.vertex_buffer.vertex_buffer.GetRange().offset));
 
  std::vector<Point> expected = {Point(300.0, 200.0), Point(300.0, 300.0),
                                 Point(200.0, 200.0), Point(200.0, 300.0)};
 
  for (size_t i = 0; i < expected.size(); i++) {
    const Point& point = written_data[i];
    EXPECT_NEAR(point.x, expected[i].x, 0.1);
    EXPECT_NEAR(point.y, expected[i].y, 0.1);
  }
}

References allocator, impeller::BufferView::GetBuffer(), impeller::ContentContext::GetContext(), impeller::BufferView::GetRange(), i, flutter::kEhCloseEnough, impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRoundSuperellipse(), impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), impeller::VertexBuffer::vertex_buffer, impeller::GeometryResult::vertex_buffer, impeller::VertexBuffer::vertex_count, flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [478/662]

impeller::testing::TEST_P	(	EntityTest	,
		CanRenderEmptyPathsWithoutCrashing
	)

Definition at line 2487 of file entity_unittests.cc.

                                                       {
  flutter::DlPath path = flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 0, 0));
 
  EXPECT_TRUE(path.GetBounds().IsEmpty());
 
  std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
  auto contents = std::make_shared<SolidColorContents>(geom.get());
  contents->SetColor(Color::Red());
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  entity.SetContents(contents);
 
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeScale(), flutter::path, impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [479/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterContentsWithLargeGeometry
	)

Definition at line 2202 of file entity_unittests.cc.

                                                         {
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  auto src_geom = Geometry::MakeRect(Rect::MakeLTRB(-300, -500, 30000, 50000));
  auto src_contents = std::make_shared<SolidColorContents>(src_geom.get());
  src_contents->SetColor(Color::Red());
 
  auto dst_geom = Geometry::MakeRect(Rect::MakeLTRB(300, 500, 20000, 30000));
  auto dst_contents = std::make_shared<SolidColorContents>(dst_geom.get());
  dst_contents->SetColor(Color::Blue());
 
  auto contents = ColorFilterContents::MakeBlend(
      BlendMode::kSrcOver, {FilterInput::Make(dst_contents, false),
                            FilterInput::Make(src_contents, false)});
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::Color::Blue(), impeller::kSrcOver, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Matrix::MakeScale(), impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [480/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorAdvancedBlend
	)

Definition at line 1969 of file entity_unittests.cc.

                                                                {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kColorBurn, FilterInput::Make({image}), Color::Red());
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(filter);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::kColorBurn, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [481/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorClearBlend
	)

Definition at line 1985 of file entity_unittests.cc.

                                                             {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kClear, FilterInput::Make({image}), Color::Red());
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(filter);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::kClear, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [482/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorDstBlend
	)

Definition at line 2017 of file entity_unittests.cc.

                                                           {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kDst, FilterInput::Make({image}), Color::Red());
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(filter);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::kDst, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [483/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcBlend
	)

Definition at line 2001 of file entity_unittests.cc.

                                                           {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kSrc, FilterInput::Make({image}), Color::Red());
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(filter);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::kSrc, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [484/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorFilterWithForegroundColorSrcInBlend
	)

Definition at line 2033 of file entity_unittests.cc.

                                                             {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(
      BlendMode::kSrcIn, FilterInput::Make({image}), Color::Red());
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(filter);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::kSrcIn, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [485/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterCoverageIsCorrect
	)

Definition at line 1494 of file entity_unittests.cc.

                                                       {
  // Set up a simple color background.
  auto geom = Geometry::MakeFillPath(
      flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
  auto fill = std::make_shared<SolidColorContents>(geom.get());
  fill->SetColor(Color::Coral());
 
  // Set the color matrix filter.
  ColorMatrix matrix = {
      1, 1, 1, 1, 1,  //
      1, 1, 1, 1, 1,  //
      1, 1, 1, 1, 1,  //
      1, 1, 1, 1, 1,  //
  };
 
  auto filter =
      ColorFilterContents::MakeColorMatrix(FilterInput::Make(fill), matrix);
 
  Entity e;
  e.SetTransform(Matrix());
 
  // Confirm that the actual filter coverage matches the expected coverage.
  auto actual = filter->GetCoverage(e);
  auto expected = Rect::MakeXYWH(0, 0, 300, 400);
 
  ASSERT_TRUE(actual.has_value());
  ASSERT_RECT_NEAR(actual.value(), expected);
}

References ASSERT_RECT_NEAR, impeller::Color::Coral(), impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeColorMatrix(), impeller::Geometry::MakeFillPath(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [486/662]

impeller::testing::TEST_P	(	EntityTest	,
		ColorMatrixFilterEditable
	)

Definition at line 1523 of file entity_unittests.cc.

                                              {
  auto bay_bridge = CreateTextureForFixture("bay_bridge.jpg");
  ASSERT_TRUE(bay_bridge);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    // UI state.
    static ColorMatrix color_matrix = {
        1, 0, 0, 0, 0,  //
        0, 3, 0, 0, 0,  //
        0, 0, 1, 0, 0,  //
        0, 0, 0, 1, 0,  //
    };
    static float offset[2] = {500, 400};
    static float rotation = 0;
    static float scale[2] = {0.65, 0.65};
    static float skew[2] = {0, 0};
 
    // Define the ImGui
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Color Matrix", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      std::string label = "##1";
      for (int i = 0; i < 20; i += 5) {
        ImGui::InputScalarN(label.c_str(), ImGuiDataType_Float,
                            &(color_matrix.array[i]), 5, nullptr, nullptr,
                            "%.2f", 0);
        label[2]++;
      }
 
      ImGui::SliderFloat2("Translation", &offset[0], 0,
                          pass.GetRenderTargetSize().width);
      ImGui::SliderFloat("Rotation", &rotation, 0, kPi * 2);
      ImGui::SliderFloat2("Scale", &scale[0], 0, 3);
      ImGui::SliderFloat2("Skew", &skew[0], -3, 3);
      ImGui::End();
    }
 
    // Set the color matrix filter.
    auto filter = ColorFilterContents::MakeColorMatrix(
        FilterInput::Make(bay_bridge), color_matrix);
 
    // Define the entity with the color matrix filter.
    Entity entity;
    entity.SetTransform(
        Matrix::MakeScale(GetContentScale()) *
        Matrix::MakeTranslation(Vector3(offset[0], offset[1])) *
        Matrix::MakeRotationZ(Radians(rotation)) *
        Matrix::MakeScale(Vector2(scale[0], scale[1])) *
        Matrix::MakeSkew(skew[0], skew[1]) *
        Matrix::MakeTranslation(-Point(bay_bridge->GetSize()) / 2));
    entity.SetContents(filter);
    entity.Render(context, pass);
 
    return true;
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::ColorMatrix::array, callback, context, i, flutter::kPi, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeColorMatrix(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [487/662]

impeller::testing::TEST_P	(	EntityTest	,
		ConicalGradientContentsIsOpaque
	)

Definition at line 2093 of file entity_unittests.cc.

                                                    {
  Matrix matrix;
  auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
  ConicalGradientContents contents(geom.get());
 
  contents.SetColors({Color::CornflowerBlue()});
  EXPECT_FALSE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  EXPECT_FALSE(contents.IsOpaque(matrix));
 
  // Create stroked path that required alpha coverage.
  auto geom2 = Geometry::MakeStrokePath(
      flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
      {.width = 0.05f});
  ConicalGradientContents contents2(geom2.get());
  contents2.SetColors({Color::CornflowerBlue()});
 
  EXPECT_FALSE(contents2.IsOpaque(matrix));
}

References impeller::Color::CornflowerBlue(), impeller::Contents::IsOpaque(), impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::ConicalGradientContents::SetColors(), and impeller::Color::WithAlpha().

◆ TEST_P() [488/662]

impeller::testing::TEST_P	(	EntityTest	,
		ContentContextOptionsHasReasonableHashFunctions
	)

Definition at line 2267 of file entity_unittests.cc.

                                                                    {
  ContentContextOptions opts;
  auto hash_a = opts.ToKey();
 
  opts.blend_mode = BlendMode::kColorBurn;
  auto hash_b = opts.ToKey();
 
  opts.has_depth_stencil_attachments = false;
  auto hash_c = opts.ToKey();
 
  opts.primitive_type = PrimitiveType::kPoint;
  auto hash_d = opts.ToKey();
 
  EXPECT_NE(hash_a, hash_b);
  EXPECT_NE(hash_b, hash_c);
  EXPECT_NE(hash_c, hash_d);
}

References impeller::ContentContextOptions::blend_mode, impeller::ContentContextOptions::has_depth_stencil_attachments, impeller::kColorBurn, impeller::kPoint, impeller::ContentContextOptions::primitive_type, and impeller::ContentContextOptions::ToKey().

◆ TEST_P() [489/662]

impeller::testing::TEST_P	(	EntityTest	,
		ContentsGetBoundsForEmptyPathReturnsNullopt
	)

Definition at line 1236 of file entity_unittests.cc.

                                                                {
  Entity entity;
  entity.SetContents(std::make_shared<SolidColorContents>(nullptr));
  ASSERT_FALSE(entity.GetCoverage().has_value());
}

References impeller::Entity::GetCoverage(), and impeller::Entity::SetContents().

◆ TEST_P() [490/662]

impeller::testing::TEST_P	(	EntityTest	,
		CoverageForStrokePathWithNegativeValuesInTransform
	)

Definition at line 2049 of file entity_unittests.cc.

                                                                       {
  auto arrow_head = flutter::DlPathBuilder{}
                        .MoveTo({50, 120})
                        .LineTo({120, 190})
                        .LineTo({190, 120})
                        .TakePath();
  auto geometry = Geometry::MakeStrokePath(arrow_head,  //
                                           {
                                               .width = 15.0f,
                                               .cap = Cap::kRound,
                                               .join = Join::kRound,
                                               .miter_limit = 4.0f,
                                           });
 
  auto transform = Matrix::MakeTranslation({300, 300}) *
                   Matrix::MakeRotationZ(Radians(kPiOver2));
  // Note that e[0][0] used to be tested here, but it was -epsilon solely
  // due to floating point inaccuracy in the transcendental trig functions.
  // e[1][0] is the intended negative value that we care about (-1.0) as it
  // comes from the rotation of pi/2.
  EXPECT_LT(transform.e[1][0], 0.0f);
  auto coverage = geometry->GetCoverage(transform);
  ASSERT_RECT_NEAR(coverage.value(), Rect::MakeXYWH(102.5, 342.5, 85, 155));
}

References ASSERT_RECT_NEAR, impeller::Matrix::e, impeller::kPiOver2, impeller::kRound, impeller::LineTo(), impeller::Matrix::MakeRotationZ(), impeller::Geometry::MakeStrokePath(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), flutter::DlPathBuilder::MoveTo(), and transform.

◆ TEST_P() [491/662]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveAndOverlapTest
	)

Definition at line 445 of file entity_unittests.cc.

                                             {
  // Compare with https://fiddle.skia.org/c/7a05a3e186c65a8dfb732f68020aae06
  flutter::DlPath path =
      flutter::DlPathBuilder{}
          .MoveTo({359.934, 96.6335})
          .CubicCurveTo({358.189, 96.7055}, {356.436, 96.7908},
                        {354.673, 96.8895})
          .CubicCurveTo({354.571, 96.8953}, {354.469, 96.9016},
                        {354.367, 96.9075})
          .CubicCurveTo({352.672, 97.0038}, {350.969, 97.113},
                        {349.259, 97.2355})
          .CubicCurveTo({349.048, 97.2506}, {348.836, 97.2678},
                        {348.625, 97.2834})
          .CubicCurveTo({347.019, 97.4014}, {345.407, 97.5299},
                        {343.789, 97.6722})
          .CubicCurveTo({343.428, 97.704}, {343.065, 97.7402},
                        {342.703, 97.7734})
          .CubicCurveTo({341.221, 97.9086}, {339.736, 98.0505},
                        {338.246, 98.207})
          .CubicCurveTo({337.702, 98.2642}, {337.156, 98.3292},
                        {336.612, 98.3894})
          .CubicCurveTo({335.284, 98.5356}, {333.956, 98.6837},
                        {332.623, 98.8476})
          .CubicCurveTo({332.495, 98.8635}, {332.366, 98.8818},
                        {332.237, 98.8982})
          .LineTo({332.237, 102.601})
          .LineTo({321.778, 102.601})
          .LineTo({321.778, 100.382})
          .CubicCurveTo({321.572, 100.413}, {321.367, 100.442},
                        {321.161, 100.476})
          .CubicCurveTo({319.22, 100.79}, {317.277, 101.123},
                        {315.332, 101.479})
          .CubicCurveTo({315.322, 101.481}, {315.311, 101.482},
                        {315.301, 101.484})
          .LineTo({310.017, 105.94})
          .LineTo({309.779, 105.427})
          .LineTo({314.403, 101.651})
          .CubicCurveTo({314.391, 101.653}, {314.379, 101.656},
                        {314.368, 101.658})
          .CubicCurveTo({312.528, 102.001}, {310.687, 102.366},
                        {308.846, 102.748})
          .CubicCurveTo({307.85, 102.955}, {306.855, 103.182}, {305.859, 103.4})
          .CubicCurveTo({305.048, 103.579}, {304.236, 103.75},
                        {303.425, 103.936})
          .LineTo({299.105, 107.578})
          .LineTo({298.867, 107.065})
          .LineTo({302.394, 104.185})
          .LineTo({302.412, 104.171})
          .CubicCurveTo({301.388, 104.409}, {300.366, 104.67},
                        {299.344, 104.921})
          .CubicCurveTo({298.618, 105.1}, {297.89, 105.269}, {297.165, 105.455})
          .CubicCurveTo({295.262, 105.94}, {293.36, 106.445},
                        {291.462, 106.979})
          .CubicCurveTo({291.132, 107.072}, {290.802, 107.163},
                        {290.471, 107.257})
          .CubicCurveTo({289.463, 107.544}, {288.455, 107.839},
                        {287.449, 108.139})
          .CubicCurveTo({286.476, 108.431}, {285.506, 108.73},
                        {284.536, 109.035})
          .CubicCurveTo({283.674, 109.304}, {282.812, 109.579},
                        {281.952, 109.859})
          .CubicCurveTo({281.177, 110.112}, {280.406, 110.377},
                        {279.633, 110.638})
          .CubicCurveTo({278.458, 111.037}, {277.256, 111.449},
                        {276.803, 111.607})
          .CubicCurveTo({276.76, 111.622}, {276.716, 111.637},
                        {276.672, 111.653})
          .CubicCurveTo({275.017, 112.239}, {273.365, 112.836},
                        {271.721, 113.463})
          .LineTo({271.717, 113.449})
          .CubicCurveTo({271.496, 113.496}, {271.238, 113.559},
                        {270.963, 113.628})
          .CubicCurveTo({270.893, 113.645}, {270.822, 113.663},
                        {270.748, 113.682})
          .CubicCurveTo({270.468, 113.755}, {270.169, 113.834},
                        {269.839, 113.926})
          .CubicCurveTo({269.789, 113.94}, {269.732, 113.957},
                        {269.681, 113.972})
          .CubicCurveTo({269.391, 114.053}, {269.081, 114.143},
                        {268.756, 114.239})
          .CubicCurveTo({268.628, 114.276}, {268.5, 114.314},
                        {268.367, 114.354})
          .CubicCurveTo({268.172, 114.412}, {267.959, 114.478},
                        {267.752, 114.54})
          .CubicCurveTo({263.349, 115.964}, {258.058, 117.695},
                        {253.564, 119.252})
          .CubicCurveTo({253.556, 119.255}, {253.547, 119.258},
                        {253.538, 119.261})
          .CubicCurveTo({251.844, 119.849}, {250.056, 120.474},
                        {248.189, 121.131})
          .CubicCurveTo({248, 121.197}, {247.812, 121.264}, {247.621, 121.331})
          .CubicCurveTo({247.079, 121.522}, {246.531, 121.715},
                        {245.975, 121.912})
          .CubicCurveTo({245.554, 122.06}, {245.126, 122.212},
                        {244.698, 122.364})
          .CubicCurveTo({244.071, 122.586}, {243.437, 122.811},
                        {242.794, 123.04})
          .CubicCurveTo({242.189, 123.255}, {241.58, 123.472},
                        {240.961, 123.693})
          .CubicCurveTo({240.659, 123.801}, {240.357, 123.909},
                        {240.052, 124.018})
          .CubicCurveTo({239.12, 124.351}, {238.18, 124.687}, {237.22, 125.032})
          .LineTo({237.164, 125.003})
          .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
                        {235.81, 125.538})
          .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
                        {234.592, 125.977})
          .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
                        {234.59, 125.977})
          .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
                        {192.381, 141.429})
          .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
          .LineTo({360, 160})
          .LineTo({360, 119.256})
          .LineTo({360, 106.332})
          .LineTo({360, 96.6307})
          .CubicCurveTo({359.978, 96.6317}, {359.956, 96.6326},
                        {359.934, 96.6335})
          .Close()
          .MoveTo({337.336, 124.143})
          .CubicCurveTo({337.274, 122.359}, {338.903, 121.511},
                        {338.903, 121.511})
          .CubicCurveTo({338.903, 121.511}, {338.96, 123.303},
                        {337.336, 124.143})
          .Close()
          .MoveTo({340.082, 121.849})
          .CubicCurveTo({340.074, 121.917}, {340.062, 121.992},
                        {340.046, 122.075})
          .CubicCurveTo({340.039, 122.109}, {340.031, 122.142},
                        {340.023, 122.177})
          .CubicCurveTo({340.005, 122.26}, {339.98, 122.346},
                        {339.952, 122.437})
          .CubicCurveTo({339.941, 122.473}, {339.931, 122.507},
                        {339.918, 122.544})
          .CubicCurveTo({339.873, 122.672}, {339.819, 122.804},
                        {339.75, 122.938})
          .CubicCurveTo({339.747, 122.944}, {339.743, 122.949},
                        {339.74, 122.955})
          .CubicCurveTo({339.674, 123.08}, {339.593, 123.205},
                        {339.501, 123.328})
          .CubicCurveTo({339.473, 123.366}, {339.441, 123.401},
                        {339.41, 123.438})
          .CubicCurveTo({339.332, 123.534}, {339.243, 123.625},
                        {339.145, 123.714})
          .CubicCurveTo({339.105, 123.75}, {339.068, 123.786},
                        {339.025, 123.821})
          .CubicCurveTo({338.881, 123.937}, {338.724, 124.048},
                        {338.539, 124.143})
          .CubicCurveTo({338.532, 123.959}, {338.554, 123.79},
                        {338.58, 123.626})
          .CubicCurveTo({338.58, 123.625}, {338.58, 123.625}, {338.58, 123.625})
          .CubicCurveTo({338.607, 123.455}, {338.65, 123.299},
                        {338.704, 123.151})
          .CubicCurveTo({338.708, 123.14}, {338.71, 123.127},
                        {338.714, 123.117})
          .CubicCurveTo({338.769, 122.971}, {338.833, 122.838},
                        {338.905, 122.712})
          .CubicCurveTo({338.911, 122.702}, {338.916, 122.69200000000001},
                        {338.922, 122.682})
          .CubicCurveTo({338.996, 122.557}, {339.072, 122.444},
                        {339.155, 122.34})
          .CubicCurveTo({339.161, 122.333}, {339.166, 122.326},
                        {339.172, 122.319})
          .CubicCurveTo({339.256, 122.215}, {339.339, 122.12},
                        {339.425, 122.037})
          .CubicCurveTo({339.428, 122.033}, {339.431, 122.03},
                        {339.435, 122.027})
          .CubicCurveTo({339.785, 121.687}, {340.106, 121.511},
                        {340.106, 121.511})
          .CubicCurveTo({340.106, 121.511}, {340.107, 121.645},
                        {340.082, 121.849})
          .Close()
          .MoveTo({340.678, 113.245})
          .CubicCurveTo({340.594, 113.488}, {340.356, 113.655},
                        {340.135, 113.775})
          .CubicCurveTo({339.817, 113.948}, {339.465, 114.059},
                        {339.115, 114.151})
          .CubicCurveTo({338.251, 114.379}, {337.34, 114.516},
                        {336.448, 114.516})
          .CubicCurveTo({335.761, 114.516}, {335.072, 114.527},
                        {334.384, 114.513})
          .CubicCurveTo({334.125, 114.508}, {333.862, 114.462},
                        {333.605, 114.424})
          .CubicCurveTo({332.865, 114.318}, {332.096, 114.184},
                        {331.41, 113.883})
          .CubicCurveTo({330.979, 113.695}, {330.442, 113.34},
                        {330.672, 112.813})
          .CubicCurveTo({331.135, 111.755}, {333.219, 112.946},
                        {334.526, 113.833})
          .CubicCurveTo({334.54, 113.816}, {334.554, 113.8}, {334.569, 113.784})
          .CubicCurveTo({333.38, 112.708}, {331.749, 110.985},
                        {332.76, 110.402})
          .CubicCurveTo({333.769, 109.82}, {334.713, 111.93},
                        {335.228, 113.395})
          .CubicCurveTo({334.915, 111.889}, {334.59, 109.636},
                        {335.661, 109.592})
          .CubicCurveTo({336.733, 109.636}, {336.408, 111.889},
                        {336.07, 113.389})
          .CubicCurveTo({336.609, 111.93}, {337.553, 109.82},
                        {338.563, 110.402})
          .CubicCurveTo({339.574, 110.984}, {337.942, 112.708},
                        {336.753, 113.784})
          .CubicCurveTo({336.768, 113.8}, {336.782, 113.816},
                        {336.796, 113.833})
          .CubicCurveTo({338.104, 112.946}, {340.187, 111.755},
                        {340.65, 112.813})
          .CubicCurveTo({340.71, 112.95}, {340.728, 113.102},
                        {340.678, 113.245})
          .Close()
          .MoveTo({346.357, 106.771})
          .CubicCurveTo({346.295, 104.987}, {347.924, 104.139},
                        {347.924, 104.139})
          .CubicCurveTo({347.924, 104.139}, {347.982, 105.931},
                        {346.357, 106.771})
          .Close()
          .MoveTo({347.56, 106.771})
          .CubicCurveTo({347.498, 104.987}, {349.127, 104.139},
                        {349.127, 104.139})
          .CubicCurveTo({349.127, 104.139}, {349.185, 105.931},
                        {347.56, 106.771})
          .Close()
          .TakePath();
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
 
  std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
 
  auto contents = std::make_shared<SolidColorContents>(geom.get());
  contents->SetColor(Color::Red());
 
  entity.SetContents(contents);
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::Close(), impeller::LineTo(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::Color::Red(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [492/662]

impeller::testing::TEST_P	(	EntityTest	,
		CubicCurveTest
	)

Definition at line 363 of file entity_unittests.cc.

                                   {
  // Compare with https://fiddle.skia.org/c/b3625f26122c9de7afe7794fcf25ead3
  flutter::DlPath path =
      flutter::DlPathBuilder{}
          .MoveTo({237.164, 125.003})
          .CubicCurveTo({236.709, 125.184}, {236.262, 125.358},
                        {235.81, 125.538})
          .CubicCurveTo({235.413, 125.68}, {234.994, 125.832},
                        {234.592, 125.977})
          .CubicCurveTo({234.592, 125.977}, {234.591, 125.977},
                        {234.59, 125.977})
          .CubicCurveTo({222.206, 130.435}, {207.708, 135.753},
                        {192.381, 141.429})
          .CubicCurveTo({162.77, 151.336}, {122.17, 156.894}, {84.1123, 160})
          .Close()
          .TakePath();
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
 
  std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(path);
 
  auto contents = std::make_shared<SolidColorContents>(geom.get());
  contents->SetColor(Color::Red());
 
  entity.SetContents(contents);
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::Close(), impeller::Geometry::MakeFillPath(), impeller::Matrix::MakeScale(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::Color::Red(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and flutter::DlPathBuilder::TakePath().

◆ TEST_P() [493/662]

impeller::testing::TEST_P	(	EntityTest	,
		DecalSpecializationAppliedToMorphologyFilter
	)

Definition at line 2251 of file entity_unittests.cc.

                                                                 {
  ContentContext& content_context = GetContentContext();
  auto default_color_burn = content_context.GetMorphologyFilterPipeline({
      .color_attachment_pixel_format = PixelFormat::kR8G8B8A8UNormInt,
  });
 
  auto decal_supported = static_cast<Scalar>(
      GetContext()->GetCapabilities()->SupportsDecalSamplerAddressMode());
  std::vector<Scalar> expected_constants = {decal_supported};
  ASSERT_EQ(default_color_burn->GetDescriptor().GetSpecializationConstants(),
            expected_constants);
}

References impeller::ContentContext::GetMorphologyFilterPipeline(), and impeller::kR8G8B8A8UNormInt.

◆ TEST_P() [494/662]

impeller::testing::TEST_P	(	EntityTest	,
		DrawRoundSuperEllipse
	)

Definition at line 2537 of file entity_unittests.cc.

                                          {
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    // UI state.
    static int style_index = 0;
    static Point center = {830, 830};
    static Point size = {600, 600};
    static bool horizontal_symmetry = true;
    static bool vertical_symmetry = true;
    static bool corner_symmetry = true;
 
    const char* style_options[] = {"Fill", "Stroke"};
 
    // Initially radius_tl[0] will be mirrored to all 8 values since all 3
    // symmetries are enabled.
    static std::array<float, 2> radius_tl = {200};
    static std::array<float, 2> radius_tr;
    static std::array<float, 2> radius_bl;
    static std::array<float, 2> radius_br;
 
    auto AddRadiusControl = [](std::array<float, 2>& radii, const char* tb_name,
                               const char* lr_name) {
      std::string name = "Radius";
      if (!horizontal_symmetry || !vertical_symmetry) {
        name += ":";
      }
      if (!vertical_symmetry) {
        name = name + " " + tb_name;
      }
      if (!horizontal_symmetry) {
        name = name + " " + lr_name;
      }
      if (corner_symmetry) {
        ImGui::SliderFloat(name.c_str(), radii.data(), 0, 1000);
      } else {
        ImGui::SliderFloat2(name.c_str(), radii.data(), 0, 1000);
      }
    };
 
    if (corner_symmetry) {
      radius_tl[1] = radius_tl[0];
      radius_tr[1] = radius_tr[0];
      radius_bl[1] = radius_bl[0];
      radius_br[1] = radius_br[0];
    }
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Style", &style_index, style_options,
                   sizeof(style_options) / sizeof(char*));
      ImGui::SliderFloat2("Center", &center.x, 0, 1000);
      ImGui::SliderFloat2("Size", &size.x, 0, 1000);
      ImGui::Checkbox("Symmetry: Horizontal", &horizontal_symmetry);
      ImGui::Checkbox("Symmetry: Vertical", &vertical_symmetry);
      ImGui::Checkbox("Symmetry: Corners", &corner_symmetry);
      AddRadiusControl(radius_tl, "Top", "Left");
      if (!horizontal_symmetry) {
        AddRadiusControl(radius_tr, "Top", "Right");
      } else {
        radius_tr = radius_tl;
      }
      if (!vertical_symmetry) {
        AddRadiusControl(radius_bl, "Bottom", "Left");
      } else {
        radius_bl = radius_tl;
      }
      if (!horizontal_symmetry && !vertical_symmetry) {
        AddRadiusControl(radius_br, "Bottom", "Right");
      } else {
        if (horizontal_symmetry) {
          radius_br = radius_bl;
        } else {
          radius_br = radius_tr;
        }
      }
      ImGui::End();
    }
 
    RoundingRadii radii{
        .top_left = {radius_tl[0], radius_tl[1]},
        .top_right = {radius_tr[0], radius_tr[1]},
        .bottom_left = {radius_bl[0], radius_bl[1]},
        .bottom_right = {radius_br[0], radius_br[1]},
    };
 
    auto rse = RoundSuperellipse::MakeRectRadii(
        Rect::MakeEllipseBounds(center, size * 0.5f), radii);
 
    flutter::DlPath path;
    std::unique_ptr<Geometry> geom;
    if (style_index == 0) {
      geom = std::make_unique<RoundSuperellipseGeometry>(
          Rect::MakeEllipseBounds(center, size * 0.5f), radii);
    } else {
      path = flutter::DlPath::MakeRoundSuperellipse(rse);
      geom = Geometry::MakeStrokePath(path, {.width = 2.0f});
    }
 
    auto contents = std::make_shared<SolidColorContents>(geom.get());
    contents->SetColor(Color::Red());
 
    Entity entity;
    entity.SetContents(contents);
 
    return entity.Render(context, pass);
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::RoundSuperellipse::MakeRectRadii(), flutter::DlPath::MakeRoundSuperellipse(), impeller::Geometry::MakeStrokePath(), flutter::name, flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), flutter::size, and impeller::RoundingRadii::top_left.

◆ TEST_P() [495/662]

impeller::testing::TEST_P	(	EntityTest	,
		DrawRoundSuperEllipseWithLargeN
	)

Definition at line 2646 of file entity_unittests.cc.

                                                    {
  // This playground shows the enlarged corner of a rounded superellipse to
  // compare pathing algorithm against the filling algorithm (benchmark) at very
  // large ratio.
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    constexpr float corner_radius = 100.0;
 
    // UI state.
    static float logarithm_of_ratio = 1.5;  // ratio = size / corner_radius
 
    float ratio = std::exp(logarithm_of_ratio);
 
    float rect_size = corner_radius * ratio;
    Rect rect = Rect::MakeLTRB(0, 0, rect_size, rect_size);
    constexpr float screen_canvas_padding = 200.0f;
    constexpr float screen_canvas_size = 1000.0f;
 
    // Scale so that "corner radius" is as long as half the canvas.
    float scale = screen_canvas_size / 2 / corner_radius;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("log(Ratio)", &logarithm_of_ratio, 1.0, 8.0);
      ImGui::LabelText("Ratio", "%.2g", static_cast<double>(ratio));
      ImGui::Text("  where Ratio = RectSize / CornerRadius");
      ImGui::End();
    }
 
    auto top_right = Vector2(screen_canvas_size * 1.3f, screen_canvas_padding);
    auto transform = Matrix::MakeTranslation(top_right) *
                     Matrix::MakeScale(Vector2(scale, scale)) *
                     Matrix::MakeTranslation(Vector2(-rect_size, 0));
    bool success = true;
 
    auto fill_geom =
        std::make_unique<RoundSuperellipseGeometry>(rect, corner_radius);
    // Fill
    {
      auto contents = std::make_shared<SolidColorContents>(fill_geom.get());
      contents->SetColor(Color::Red());
 
      Entity entity;
      entity.SetContents(contents);
      entity.SetTransform(transform);
 
      success = success && entity.Render(context, pass);
    }
 
    // Stroke
    auto path = flutter::DlPath::MakeRoundSuperellipse(
        RoundSuperellipse::MakeRectRadius(rect, corner_radius));
    auto stroke_geom = Geometry::MakeStrokePath(path, {.width = 2 / scale});
    {
      auto contents = std::make_shared<SolidColorContents>(stroke_geom.get());
      contents->SetColor(Color::Blue());
 
      Entity entity;
      entity.SetContents(contents);
      entity.SetTransform(transform);
 
      success = success && entity.Render(context, pass);
    }
 
    // Draw a ruler to show the length in portion of rect size.
    auto screen_top_right =
        Matrix::MakeScale(GetContentScale()).Invert() * top_right;
    constexpr float font_size = 13.0f;
    for (int i = -1; i < 100; i++) {
      float screen_offset_y = static_cast<float>(i) * 20.0f;
      std::string label;
      if (i == -1) {
        label = "Ruler: (in portion of rect size)";
      } else if (i == 0) {
        label = "- 0.0";
      } else {
        float portion_of_rect =
            screen_offset_y * GetContentScale().y / scale / rect_size;
        label = std::format("- {:.2g}", portion_of_rect);
      }
      if (IsPlaygroundEnabled()) {
        ImGui::GetBackgroundDrawList()->AddText(
            nullptr, font_size,
            // Draw the ruler at around the flat part of the curve, which is
            // somewhere to the left of the top right corner.
            //
            // Offset vertically by font_size/2 so that the hyphen aligns with
            // the top of shape.
            {screen_top_right.x - 500,
             screen_top_right.y + screen_offset_y - font_size / 2},
            IM_COL32_WHITE, label.c_str());
      }
    }
    return success;
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::Color::Blue(), callback, context, font_size, i, impeller::Matrix::Invert(), impeller::TRect< Scalar >::MakeLTRB(), impeller::RoundSuperellipse::MakeRectRadius(), flutter::DlPath::MakeRoundSuperellipse(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), impeller::Matrix::MakeTranslation(), flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and transform.

◆ TEST_P() [496/662]

impeller::testing::TEST_P	(	EntityTest	,
		DrawSuperEllipse
	)

Definition at line 2503 of file entity_unittests.cc.

                                     {
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    // UI state.
    static float alpha = 10;
    static float beta = 10;
    static float radius = 40;
    static int degree = 4;
    static Color color = Color::Red();
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Alpha", &alpha, 0, 100);
      ImGui::SliderFloat("Beta", &beta, 0, 100);
      ImGui::SliderInt("Degreee", &degree, 1, 20);
      ImGui::SliderFloat("Radius", &radius, 0, 400);
      ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&color));
      ImGui::End();
    }
 
    std::unique_ptr<SuperellipseGeometry> geom =
        std::make_unique<SuperellipseGeometry>(Point{400, 400}, radius, degree,
                                               alpha, beta);
    auto contents = std::make_shared<SolidColorContents>(geom.get());
    contents->SetColor(color);
 
    Entity entity;
    entity.SetContents(contents);
 
    return entity.Render(context, pass);
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, impeller::Color::Red(), impeller::Entity::Render(), and impeller::Entity::SetContents().

◆ TEST_P() [497/662]

impeller::testing::TEST_P	(	EntityTest	,
		FailOnValidationError
	)

Definition at line 2453 of file entity_unittests.cc.

                                          {
  if (GetParam() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Validation is only fatal on Vulkan backend.";
  }
  EXPECT_DEATH(
      // The easiest way to trigger a validation error is to try to compile
      // a shader with an unsupported pixel format.
      GetContentContext().GetBlendColorBurnPipeline({
          .color_attachment_pixel_format = PixelFormat::kUnknown,
          .has_depth_stencil_attachments = false,
      }),
      "");
}

References impeller::kUnknown, and impeller::kVulkan.

◆ TEST_P() [498/662]

impeller::testing::TEST_P	(	EntityTest	,
		FillPathGeometryGetPositionBufferReturnsExpectedMode
	)

Definition at line 2311 of file entity_unittests.cc.

                                                                         {
  RenderTarget target;
  testing::MockRenderPass mock_pass(GetContext(), target);
 
  auto get_result = [this, &mock_pass](const flutter::DlPath& path) {
    auto geometry = Geometry::MakeFillPath(
        path, /* inner rect */ Rect::MakeLTRB(0, 0, 100, 100));
    return geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
  };
 
  // Convex path
  {
    GeometryResult result =
        get_result(flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 100, 100)));
    EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal);
  }
 
  // Concave path
  {
    flutter::DlPath path = flutter::DlPathBuilder{}
                               .MoveTo({0, 0})
                               .LineTo({100, 0})
                               .LineTo({100, 100})
                               .LineTo({51, 50})
                               .Close()
                               .TakePath();
    GeometryResult result = get_result(path);
    EXPECT_EQ(result.mode, GeometryResult::Mode::kNonZero);
  }
}

References impeller::Close(), impeller::GeometryResult::kNonZero, impeller::GeometryResult::kNormal, impeller::LineTo(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), impeller::GeometryResult::mode, flutter::DlPathBuilder::MoveTo(), flutter::path, flutter::DlPathBuilder::TakePath(), and target.

◆ TEST_P() [499/662]

impeller::testing::TEST_P	(	EntityTest	,
		FilterCoverageRespectsCropRect
	)

Definition at line 77 of file entity_unittests.cc.

                                                   {
  auto image = CreateTextureForFixture("boston.jpg");
  auto filter = ColorFilterContents::MakeBlend(BlendMode::kSoftLight,
                                               FilterInput::Make({image}));
 
  // Without the crop rect (default behavior).
  {
    auto actual = filter->GetCoverage({});
    auto expected = Rect::MakeSize(image->GetSize());
 
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
 
  // With the crop rect.
  {
    auto expected = Rect::MakeLTRB(50, 50, 100, 100);
    filter->SetCoverageHint(expected);
    auto actual = filter->GetCoverage({});
 
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
}

References ASSERT_RECT_NEAR, image, impeller::kSoftLight, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::TRect< Scalar >::MakeSize().

◆ TEST_P() [500/662]

impeller::testing::TEST_P	(	EntityTest	,
		Filters
	)

Definition at line 915 of file entity_unittests.cc.

                            {
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  auto kalimba = CreateTextureForFixture("kalimba.jpg");
  ASSERT_TRUE(bridge && boston && kalimba);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    auto fi_bridge = FilterInput::Make(bridge);
    auto fi_boston = FilterInput::Make(boston);
    auto fi_kalimba = FilterInput::Make(kalimba);
 
    std::shared_ptr<FilterContents> blend0 = ColorFilterContents::MakeBlend(
        BlendMode::kModulate, {fi_kalimba, fi_boston});
 
    auto blend1 = ColorFilterContents::MakeBlend(
        BlendMode::kScreen,
        {FilterInput::Make(blend0), fi_bridge, fi_bridge, fi_bridge});
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()) *
                        Matrix::MakeTranslation({500, 300}) *
                        Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity.SetContents(blend1);
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, impeller::kModulate, impeller::kScreen, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::Entity::SetTransform().

◆ TEST_P() [501/662]

impeller::testing::TEST_P	(	EntityTest	,
		GaussianBlurFilter
	)

Definition at line 943 of file entity_unittests.cc.

                                       {
  auto boston =
      CreateTextureForFixture("boston.jpg", /*enable_mipmapping=*/true);
  ASSERT_TRUE(boston);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    const char* input_type_names[] = {"Texture", "Solid Color"};
    const char* blur_type_names[] = {"Image blur", "Mask blur"};
    const char* pass_variation_names[] = {"New"};
    const char* blur_style_names[] = {"Normal", "Solid", "Outer", "Inner"};
    const char* tile_mode_names[] = {"Clamp", "Repeat", "Mirror", "Decal"};
    const FilterContents::BlurStyle blur_styles[] = {
        FilterContents::BlurStyle::kNormal, FilterContents::BlurStyle::kSolid,
        FilterContents::BlurStyle::kOuter, FilterContents::BlurStyle::kInner};
    const Entity::TileMode tile_modes[] = {
        Entity::TileMode::kClamp, Entity::TileMode::kRepeat,
        Entity::TileMode::kMirror, Entity::TileMode::kDecal};
 
    // UI state.
    static int selected_input_type = 0;
    static Color input_color = Color::Black();
    static int selected_blur_type = 0;
    static int selected_pass_variation = 0;
    static bool combined_sigma = false;
    static float blur_amount_coarse[2] = {0, 0};
    static float blur_amount_fine[2] = {10, 10};
    static int selected_blur_style = 0;
    static int selected_tile_mode = 3;
    static Color cover_color(1, 0, 0, 0.2);
    static Color bounds_color(0, 1, 0, 0.1);
    static float offset[2] = {500, 400};
    static float rotation = 0;
    static float scale[2] = {0.65, 0.65};
    static float skew[2] = {0, 0};
    static float path_rect[4] = {0, 0,
                                 static_cast<float>(boston->GetSize().width),
                                 static_cast<float>(boston->GetSize().height)};
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Input type", &selected_input_type, input_type_names,
                   sizeof(input_type_names) / sizeof(char*));
      if (selected_input_type == 0) {
        ImGui::SliderFloat("Input opacity", &input_color.alpha, 0, 1);
      } else {
        ImGui::ColorEdit4("Input color",
                          reinterpret_cast<float*>(&input_color));
      }
      ImGui::Combo("Blur type", &selected_blur_type, blur_type_names,
                   sizeof(blur_type_names) / sizeof(char*));
      if (selected_blur_type == 0) {
        ImGui::Combo("Pass variation", &selected_pass_variation,
                     pass_variation_names,
                     sizeof(pass_variation_names) / sizeof(char*));
      }
      ImGui::Checkbox("Combined sigma", &combined_sigma);
      if (combined_sigma) {
        ImGui::SliderFloat("Sigma (coarse)", blur_amount_coarse, 0, 1000);
        ImGui::SliderFloat("Sigma (fine)", blur_amount_fine, 0, 10);
        blur_amount_coarse[1] = blur_amount_coarse[0];
        blur_amount_fine[1] = blur_amount_fine[0];
      } else {
        ImGui::SliderFloat2("Sigma (coarse)", blur_amount_coarse, 0, 1000);
        ImGui::SliderFloat2("Sigma (fine)", blur_amount_fine, 0, 10);
      }
      ImGui::Combo("Blur style", &selected_blur_style, blur_style_names,
                   sizeof(blur_style_names) / sizeof(char*));
      ImGui::Combo("Tile mode", &selected_tile_mode, tile_mode_names,
                   sizeof(tile_mode_names) / sizeof(char*));
      ImGui::ColorEdit4("Cover color", reinterpret_cast<float*>(&cover_color));
      ImGui::ColorEdit4("Bounds color ",
                        reinterpret_cast<float*>(&bounds_color));
      ImGui::SliderFloat2("Translation", offset, 0,
                          pass.GetRenderTargetSize().width);
      ImGui::SliderFloat("Rotation", &rotation, 0, kPi * 2);
      ImGui::SliderFloat2("Scale", scale, 0, 3);
      ImGui::SliderFloat2("Skew", skew, -3, 3);
      ImGui::SliderFloat4("Path XYWH", path_rect, -1000, 1000);
      ImGui::End();
    }
 
    auto blur_sigma_x = Sigma{blur_amount_coarse[0] + blur_amount_fine[0]};
    auto blur_sigma_y = Sigma{blur_amount_coarse[1] + blur_amount_fine[1]};
 
    std::shared_ptr<Contents> input;
    Size input_size;
 
    auto input_rect =
        Rect::MakeXYWH(path_rect[0], path_rect[1], path_rect[2], path_rect[3]);
 
    std::unique_ptr<Geometry> solid_color_input;
    if (selected_input_type == 0) {
      auto texture = std::make_shared<TextureContents>();
      texture->SetSourceRect(Rect::MakeSize(boston->GetSize()));
      texture->SetDestinationRect(input_rect);
      texture->SetTexture(boston);
      texture->SetOpacity(input_color.alpha);
 
      input = texture;
      input_size = input_rect.GetSize();
    } else {
      solid_color_input =
          Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
      auto fill = std::make_shared<SolidColorContents>(solid_color_input.get());
      fill->SetColor(input_color);
 
      input = fill;
      input_size = input_rect.GetSize();
    }
 
    std::shared_ptr<FilterContents> blur;
    switch (selected_pass_variation) {
      case 0:
        blur = std::make_shared<GaussianBlurFilterContents>(
            blur_sigma_x.sigma, blur_sigma_y.sigma,
            tile_modes[selected_tile_mode], /*bounds=*/std::nullopt,
            blur_styles[selected_blur_style],
            /*geometry=*/nullptr);
        blur->SetInputs({FilterInput::Make(input)});
        break;
      case 1:
        blur = FilterContents::MakeGaussianBlur(
            FilterInput::Make(input), blur_sigma_x, blur_sigma_y,
            tile_modes[selected_tile_mode],
            /*bounds=*/std::nullopt, blur_styles[selected_blur_style]);
        break;
    };
    FML_CHECK(blur);
 
    auto mask_blur = FilterContents::MakeBorderMaskBlur(
        FilterInput::Make(input), blur_sigma_x, blur_sigma_y,
        blur_styles[selected_blur_style]);
 
    auto ctm = Matrix::MakeScale(GetContentScale()) *
               Matrix::MakeTranslation(Vector3(offset[0], offset[1])) *
               Matrix::MakeRotationZ(Radians(rotation)) *
               Matrix::MakeScale(Vector2(scale[0], scale[1])) *
               Matrix::MakeSkew(skew[0], skew[1]) *
               Matrix::MakeTranslation(-Point(input_size) / 2);
 
    auto target_contents = selected_blur_type == 0 ? blur : mask_blur;
 
    Entity entity;
    entity.SetContents(target_contents);
    entity.SetTransform(ctm);
 
    entity.Render(context, pass);
 
    // Renders a red "cover" rectangle that shows the original position of the
    // unfiltered input.
    Entity cover_entity;
    auto geom = Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
    auto contents = std::make_shared<SolidColorContents>(geom.get());
    contents->SetColor(cover_color);
    cover_entity.SetContents(std::move(contents));
    cover_entity.SetTransform(ctm);
    cover_entity.Render(context, pass);
 
    // Renders a green bounding rect of the target filter.
    Entity bounds_entity;
    std::optional<Rect> target_contents_coverage =
        target_contents->GetCoverage(entity);
    if (target_contents_coverage.has_value()) {
      std::unique_ptr<Geometry> geom =
          Geometry::MakeFillPath(flutter::DlPath::MakeRect(
              target_contents->GetCoverage(entity).value()));
      auto contents = std::make_shared<SolidColorContents>(geom.get());
      contents->SetColor(bounds_color);
 
      bounds_entity.SetContents(contents);
      bounds_entity.SetTransform(Matrix());
      bounds_entity.Render(context, pass);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::Color::alpha, impeller::Color::Black(), callback, context, FML_CHECK, impeller::Entity::GetCoverage(), input(), impeller::Entity::kClamp, impeller::Entity::kDecal, impeller::FilterContents::kInner, impeller::Entity::kMirror, impeller::FilterContents::kNormal, impeller::FilterContents::kOuter, flutter::kPi, impeller::Entity::kRepeat, impeller::FilterContents::kSolid, impeller::FilterInput::Make(), impeller::FilterContents::MakeBorderMaskBlur(), impeller::Geometry::MakeFillPath(), impeller::FilterContents::MakeGaussianBlur(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [502/662]

impeller::testing::TEST_P	(	EntityTest	,
		GeometryBoundsAreTransformed
	)

Definition at line 102 of file entity_unittests.cc.

                                                 {
  auto geometry = Geometry::MakeRect(Rect::MakeXYWH(100, 100, 100, 100));
  auto transform = Matrix::MakeScale({2.0, 2.0, 2.0});
 
  ASSERT_RECT_NEAR(geometry->GetCoverage(transform).value(),
                   Rect::MakeXYWH(200, 200, 200, 200));
}

References ASSERT_RECT_NEAR, impeller::Geometry::MakeRect(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST_P() [503/662]

impeller::testing::TEST_P	(	EntityTest	,
		GiantStrokePathAllocation
	)

Definition at line 2852 of file entity_unittests.cc.

                                              {
  flutter::DlPathBuilder builder;
  for (int i = 0; i < 10000; i++) {
    builder.LineTo(Point(i, i));
  }
  flutter::DlPath path = builder.TakePath();
  auto geom = Geometry::MakeStrokePath(path, {.width = 10.0f});
 
  ContentContext content_context(GetContext(), /*typographer_context=*/nullptr);
  Entity entity;
 
  auto cmd_buffer = content_context.GetContext()->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(
      content_context.GetContext()->GetResourceAllocator());
 
  auto render_target = allocator.CreateOffscreen(
      *content_context.GetContext(), /*size=*/{10, 10}, /*mip_count=*/1);
  auto pass = cmd_buffer->CreateRenderPass(render_target);
 
  GeometryResult result =
      geom->GetPositionBuffer(content_context, entity, *pass);
 
  // Validate the buffer data overflowed the small buffer
  EXPECT_GT(result.vertex_buffer.vertex_count, kPointArenaSize);
 
  // Validate that there are no uninitialized points near the gap.
  Point* written_data = reinterpret_cast<Point*>(
      (result.vertex_buffer.vertex_buffer.GetBuffer()->OnGetContents() +
       result.vertex_buffer.vertex_buffer.GetRange().offset));
 
  std::vector<Point> expected = {
      Point(2043.46, 2050.54),  //
      Point(2050.54, 2043.46),  //
      Point(2044.46, 2051.54),  //
      Point(2051.54, 2044.46),  //
      Point(2045.46, 2052.54)   //
  };
 
  Point point = written_data[kPointArenaSize - 2];
  EXPECT_NEAR(point.x, expected[0].x, 0.1);
  EXPECT_NEAR(point.y, expected[0].y, 0.1);
 
  point = written_data[kPointArenaSize - 1];
  EXPECT_NEAR(point.x, expected[1].x, 0.1);
  EXPECT_NEAR(point.y, expected[1].y, 0.1);
 
  point = written_data[kPointArenaSize];
  EXPECT_NEAR(point.x, expected[2].x, 0.1);
  EXPECT_NEAR(point.y, expected[2].y, 0.1);
 
  point = written_data[kPointArenaSize + 1];
  EXPECT_NEAR(point.x, expected[3].x, 0.1);
  EXPECT_NEAR(point.y, expected[3].y, 0.1);
 
  point = written_data[kPointArenaSize + 2];
  EXPECT_NEAR(point.x, expected[4].x, 0.1);
  EXPECT_NEAR(point.y, expected[4].y, 0.1);
}

References allocator, impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), i, impeller::kPointArenaSize, flutter::DlPathBuilder::LineTo(), impeller::Geometry::MakeStrokePath(), impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), flutter::path, flutter::DlPathBuilder::TakePath(), impeller::VertexBuffer::vertex_buffer, impeller::GeometryResult::vertex_buffer, impeller::VertexBuffer::vertex_count, flutter::Point::x(), and flutter::Point::y().

◆ TEST_P() [504/662]

impeller::testing::TEST_P	(	EntityTest	,
		LinearGradientContentsIsOpaque
	)

Definition at line 2113 of file entity_unittests.cc.

                                                   {
  Matrix matrix;
  auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
  LinearGradientContents contents(geom.get());
 
  contents.SetColors({Color::CornflowerBlue()});
  EXPECT_TRUE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  EXPECT_FALSE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  EXPECT_FALSE(contents.IsOpaque(matrix));
 
  // Create stroked path that required alpha coverage.
  auto geom2 = Geometry::MakeStrokePath(
      flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
      {.width = 0.05f});
  LinearGradientContents contents2(geom2.get());
  contents2.SetColors({Color::CornflowerBlue()});
 
  EXPECT_FALSE(contents2.IsOpaque(matrix));
}

References impeller::Color::CornflowerBlue(), impeller::LinearGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::LinearGradientContents::SetColors(), impeller::LinearGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [505/662]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilter
	)

Definition at line 1602 of file entity_unittests.cc.

                                       {
  auto image = CreateTextureForFixture("kalimba.jpg");
  ASSERT_TRUE(image);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    auto filtered =
        ColorFilterContents::MakeLinearToSrgbFilter(FilterInput::Make(image));
 
    // Define the entity that will serve as the control image as a Gaussian blur
    // filter with no filter at all.
    Entity entity_left;
    entity_left.SetTransform(Matrix::MakeScale(GetContentScale()) *
                             Matrix::MakeTranslation({100, 300}) *
                             Matrix::MakeScale(Vector2{0.5, 0.5}));
    auto unfiltered = FilterContents::MakeGaussianBlur(FilterInput::Make(image),
                                                       Sigma{0}, Sigma{0});
    entity_left.SetContents(unfiltered);
 
    // Define the entity that will be filtered from linear to sRGB.
    Entity entity_right;
    entity_right.SetTransform(Matrix::MakeScale(GetContentScale()) *
                              Matrix::MakeTranslation({500, 300}) *
                              Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity_right.SetContents(filtered);
    return entity_left.Render(context, pass) &&
           entity_right.Render(context, pass);
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::FilterInput::Make(), impeller::FilterContents::MakeGaussianBlur(), impeller::ColorFilterContents::MakeLinearToSrgbFilter(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [506/662]

impeller::testing::TEST_P	(	EntityTest	,
		LinearToSrgbFilterCoverageIsCorrect
	)

Definition at line 1581 of file entity_unittests.cc.

                                                        {
  // Set up a simple color background.
  auto geom = Geometry::MakeFillPath(
      flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
  auto fill = std::make_shared<SolidColorContents>(geom.get());
  fill->SetColor(Color::MintCream());
 
  auto filter =
      ColorFilterContents::MakeLinearToSrgbFilter(FilterInput::Make(fill));
 
  Entity e;
  e.SetTransform(Matrix());
 
  // Confirm that the actual filter coverage matches the expected coverage.
  auto actual = filter->GetCoverage(e);
  auto expected = Rect::MakeXYWH(0, 0, 300, 400);
 
  ASSERT_TRUE(actual.has_value());
  ASSERT_RECT_NEAR(actual.value(), expected);
}

References ASSERT_RECT_NEAR, impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), impeller::ColorFilterContents::MakeLinearToSrgbFilter(), flutter::DlPath::MakeRect(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Color::MintCream(), and impeller::Entity::SetTransform().

◆ TEST_P() [507/662]

impeller::testing::TEST_P	(	EntityTest	,
		MorphologyFilter
	)

Definition at line 1122 of file entity_unittests.cc.

                                     {
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(boston);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    const char* morphology_type_names[] = {"Dilate", "Erode"};
    const FilterContents::MorphType morphology_types[] = {
        FilterContents::MorphType::kDilate, FilterContents::MorphType::kErode};
    static Color input_color = Color::Black();
    // UI state.
    static int selected_morphology_type = 0;
    static float radius[2] = {20, 20};
    static Color cover_color(1, 0, 0, 0.2);
    static Color bounds_color(0, 1, 0, 0.1);
    static float offset[2] = {500, 400};
    static float rotation = 0;
    static float scale[2] = {0.65, 0.65};
    static float skew[2] = {0, 0};
    static float path_rect[4] = {0, 0,
                                 static_cast<float>(boston->GetSize().width),
                                 static_cast<float>(boston->GetSize().height)};
    static float effect_transform_scale = 1;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Morphology type", &selected_morphology_type,
                   morphology_type_names,
                   sizeof(morphology_type_names) / sizeof(char*));
      ImGui::SliderFloat2("Radius", radius, 0, 200);
      ImGui::SliderFloat("Input opacity", &input_color.alpha, 0, 1);
      ImGui::ColorEdit4("Cover color", reinterpret_cast<float*>(&cover_color));
      ImGui::ColorEdit4("Bounds color ",
                        reinterpret_cast<float*>(&bounds_color));
      ImGui::SliderFloat2("Translation", offset, 0,
                          pass.GetRenderTargetSize().width);
      ImGui::SliderFloat("Rotation", &rotation, 0, kPi * 2);
      ImGui::SliderFloat2("Scale", scale, 0, 3);
      ImGui::SliderFloat2("Skew", skew, -3, 3);
      ImGui::SliderFloat4("Path XYWH", path_rect, -1000, 1000);
      ImGui::SliderFloat("Effect transform scale", &effect_transform_scale, 0,
                         3);
      ImGui::End();
    }
 
    std::shared_ptr<Contents> input;
    Size input_size;
 
    auto input_rect =
        Rect::MakeXYWH(path_rect[0], path_rect[1], path_rect[2], path_rect[3]);
    auto texture = std::make_shared<TextureContents>();
    texture->SetSourceRect(Rect::MakeSize(boston->GetSize()));
    texture->SetDestinationRect(input_rect);
    texture->SetTexture(boston);
    texture->SetOpacity(input_color.alpha);
 
    input = texture;
    input_size = input_rect.GetSize();
 
    auto contents = FilterContents::MakeMorphology(
        FilterInput::Make(input), Radius{radius[0]}, Radius{radius[1]},
        morphology_types[selected_morphology_type]);
    contents->SetEffectTransform(Matrix::MakeScale(
        Vector2{effect_transform_scale, effect_transform_scale}));
 
    auto ctm = Matrix::MakeScale(GetContentScale()) *
               Matrix::MakeTranslation(Vector3(offset[0], offset[1])) *
               Matrix::MakeRotationZ(Radians(rotation)) *
               Matrix::MakeScale(Vector2(scale[0], scale[1])) *
               Matrix::MakeSkew(skew[0], skew[1]) *
               Matrix::MakeTranslation(-Point(input_size) / 2);
 
    Entity entity;
    entity.SetContents(contents);
    entity.SetTransform(ctm);
 
    entity.Render(context, pass);
 
    // Renders a red "cover" rectangle that shows the original position of  the
    // unfiltered input.
    Entity cover_entity;
    auto geom = Geometry::MakeFillPath(flutter::DlPath::MakeRect(input_rect));
    auto cover_contents = std::make_shared<SolidColorContents>(geom.get());
    cover_contents->SetColor(cover_color);
    cover_entity.SetContents(cover_contents);
    cover_entity.SetTransform(ctm);
    cover_entity.Render(context, pass);
 
    // Renders a green bounding rect of the target filter.
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    if (contents_coverage.has_value()) {
      std::unique_ptr<Geometry> bounds_geom = Geometry::MakeFillPath(
          flutter::DlPath::MakeRect(contents_coverage.value()));
      auto bounds_contents =
          std::make_shared<SolidColorContents>(bounds_geom.get());
      bounds_contents->SetColor(bounds_color);
      Entity bounds_entity;
      bounds_entity.SetContents(std::move(bounds_contents));
      bounds_entity.SetTransform(Matrix());
 
      bounds_entity.Render(context, pass);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::Color::alpha, impeller::Color::Black(), callback, context, input(), impeller::FilterContents::kDilate, impeller::FilterContents::kErode, flutter::kPi, impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), impeller::FilterContents::MakeMorphology(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeSkew(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [508/662]

impeller::testing::TEST_P	(	EntityTest	,
		PointFieldGeometryCoverage
	)

Definition at line 2194 of file entity_unittests.cc.

                                               {
  std::vector<Point> points = {{10, 20}, {100, 200}};
  PointFieldGeometry geometry(points.data(), 2, 5.0, false);
  ASSERT_EQ(geometry.GetCoverage(Matrix()), Rect::MakeLTRB(5, 15, 105, 205));
  ASSERT_EQ(geometry.GetCoverage(Matrix::MakeTranslation({30, 0, 0})),
            Rect::MakeLTRB(35, 15, 135, 205));
}

References impeller::PointFieldGeometry::GetCoverage(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), and points.

◆ TEST_P() [509/662]

impeller::testing::TEST_P	(	EntityTest	,
		RadialGradientContentsIsOpaque
	)

Definition at line 2136 of file entity_unittests.cc.

                                                   {
  Matrix matrix;
  auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
  RadialGradientContents contents(geom.get());
 
  contents.SetColors({Color::CornflowerBlue()});
  EXPECT_TRUE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  EXPECT_FALSE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  EXPECT_FALSE(contents.IsOpaque(matrix));
 
  // Create stroked path that required alpha coverage.
  auto geom2 = Geometry::MakeStrokePath(
      flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
      {.width = 0.05});
  RadialGradientContents contents2(geom2.get());
  contents2.SetColors({Color::CornflowerBlue()});
 
  EXPECT_FALSE(contents2.IsOpaque(matrix));
}

References impeller::Color::CornflowerBlue(), impeller::RadialGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::RadialGradientContents::SetColors(), impeller::RadialGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [510/662]

impeller::testing::TEST_P	(	EntityTest	,
		RoundSuperellipseGetPositionBufferFlushes
	)

Definition at line 2973 of file entity_unittests.cc.

                                                              {
  RenderTarget target;
  testing::MockRenderPass mock_pass(GetContext(), target);
 
  auto content_context = std::make_shared<FlushTestContentContext>(
      GetContext(), GetTypographerContext(),
      std::make_shared<FlushTestAllocator>());
  auto geometry =
      Geometry::MakeRoundSuperellipse(Rect::MakeLTRB(0, 0, 100, 100), 5);
  auto result = geometry->GetPositionBuffer(*content_context, {}, mock_pass);
 
  auto device_buffer = reinterpret_cast<const FlushTestDeviceBuffer*>(
      result.vertex_buffer.vertex_buffer.GetBuffer());
  EXPECT_TRUE(device_buffer->flush_called());
}

References impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRoundSuperellipse(), and target.

◆ TEST_P() [511/662]

impeller::testing::TEST_P	(	EntityTest	,
		RRectShadowTest
	)

Definition at line 1439 of file entity_unittests.cc.

                                    {
  auto callback = [&](ContentContext& context, RenderPass& pass) {
    static Color color = Color::Red();
    static float corner_radius = 100;
    static float blur_radius = 100;
    static bool show_coverage = false;
    static Color coverage_color = Color::Green().WithAlpha(0.2);
    static PlaygroundPoint top_left_point(Point(200, 200), 30, Color::White());
    static PlaygroundPoint bottom_right_point(Point(600, 400), 30,
                                              Color::White());
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Corner radius", &corner_radius, 0, 300);
      ImGui::SliderFloat("Blur radius", &blur_radius, 0, 300);
      ImGui::ColorEdit4("Color", reinterpret_cast<Scalar*>(&color));
      ImGui::Checkbox("Show coverage", &show_coverage);
      if (show_coverage) {
        ImGui::ColorEdit4("Coverage color",
                          reinterpret_cast<Scalar*>(&coverage_color));
      }
      ImGui::End();
    }
 
    auto [top_left, bottom_right] =
        DrawPlaygroundLine(top_left_point, bottom_right_point);
    auto rect =
        Rect::MakeLTRB(top_left.x, top_left.y, bottom_right.x, bottom_right.y);
 
    auto contents = std::make_unique<SolidRRectBlurContents>();
    contents->SetShape(rect, corner_radius);
    contents->SetColor(color);
    contents->SetSigma(Radius(blur_radius));
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()));
    entity.SetContents(std::move(contents));
    entity.Render(context, pass);
 
    auto coverage = entity.GetCoverage();
    if (show_coverage && coverage.has_value()) {
      auto geom = Geometry::MakeFillPath(
          flutter::DlPath::MakeRect(entity.GetCoverage().value()));
      auto bounds_contents = std::make_unique<SolidColorContents>(geom.get());
      bounds_contents->SetColor(coverage_color.Premultiply());
      Entity bounds_entity;
      bounds_entity.SetContents(std::move(bounds_contents));
      bounds_entity.Render(context, pass);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References blur_radius, callback, context, impeller::DrawPlaygroundLine(), impeller::Entity::GetCoverage(), impeller::Color::Green(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeScale(), impeller::Color::Premultiply(), impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Color::White(), and impeller::Color::WithAlpha().

◆ TEST_P() [512/662]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffect
	)

Definition at line 1800 of file entity_unittests.cc.

                                  {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  bool expect_dirty = true;
 
  PipelineRef first_pipeline;
  std::unique_ptr<Geometry> geom = Geometry::MakeCover();
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    EXPECT_EQ(runtime_stage->IsDirty(), expect_dirty);
 
    auto contents = std::make_shared<RuntimeEffectContents>(geom.get());
    contents->SetRuntimeStage(runtime_stage);
 
    struct FragUniforms {
      Vector2 iResolution;
      Scalar iTime;
    } frag_uniforms = {
        .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
        .iTime = static_cast<Scalar>(GetSecondsElapsed()),
    };
    auto uniform_data = std::make_shared<std::vector<uint8_t>>();
    uniform_data->resize(sizeof(FragUniforms));
    memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
    contents->SetUniformData(uniform_data);
 
    Entity entity;
    entity.SetContents(contents);
    bool result = contents->Render(context, entity, pass);
 
    if (expect_dirty) {
      first_pipeline = pass.GetCommands().back().pipeline;
    } else {
      EXPECT_EQ(pass.GetCommands().back().pipeline, first_pipeline);
    }
    expect_dirty = false;
    return result;
  };
 
  // Simulate some renders and hot reloading of the shader.
  ContentContext& content_context = GetContentContext();
  {
    RenderTarget target =
        content_context.GetRenderTargetCache()->CreateOffscreen(
            *content_context.GetContext(), {1, 1}, 1u);
 
    testing::MockRenderPass mock_pass(GetContext(), target);
    callback(content_context, mock_pass);
    callback(content_context, mock_pass);
 
    // Dirty the runtime stage.
    auto runtime_stages_result =
        OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
    ABSL_ASSERT_OK(runtime_stages_result);
    runtime_stage = runtime_stages_result.value()[GetRuntimeStageBackend()];
 
    ASSERT_TRUE(runtime_stage->IsDirty());
    expect_dirty = true;
 
    callback(content_context, mock_pass);
  }
}

References callback, context, impeller::ContentContext::GetContext(), impeller::ContentContext::GetRenderTargetCache(), height, impeller::Geometry::MakeCover(), impeller::Entity::SetContents(), target, and width.

◆ TEST_P() [513/662]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanPrecache
	)

Definition at line 1915 of file entity_unittests.cc.

                                             {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  std::shared_ptr<RuntimeStage> runtime_stage =
      runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto geom = Geometry::MakeCover();
  auto contents = std::make_shared<RuntimeEffectContents>(geom.get());
  contents->SetRuntimeStage(runtime_stage);
 
  EXPECT_TRUE(contents->BootstrapShader(GetContentContext()));
}

References impeller::Geometry::MakeCover().

◆ TEST_P() [514/662]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectCanSuccessfullyRender
	)

Definition at line 1869 of file entity_unittests.cc.

                                                       {
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  auto runtime_stage = runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto geom = Geometry::MakeCover();
  auto contents = std::make_shared<RuntimeEffectContents>(geom.get());
  contents->SetRuntimeStage(runtime_stage);
 
  struct FragUniforms {
    Vector2 iResolution;
    Scalar iTime;
  } frag_uniforms = {
      .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
      .iTime = static_cast<Scalar>(GetSecondsElapsed()),
  };
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
  contents->SetUniformData(uniform_data);
 
  Entity entity;
  entity.SetContents(contents);
 
  // Create a render target with a depth-stencil, similar to how EntityPass
  // does.
  RenderTarget target =
      GetContentContext().GetRenderTargetCache()->CreateOffscreenMSAA(
          *GetContext(), {GetWindowSize().width, GetWindowSize().height}, 1,
          "RuntimeEffect Texture");
  testing::MockRenderPass pass(GetContext(), target);
 
  ASSERT_TRUE(contents->Render(GetContentContext(), entity, pass));
  ASSERT_EQ(pass.GetCommands().size(), 1u);
  const auto& command = pass.GetCommands()[0];
  ASSERT_TRUE(command.pipeline->GetDescriptor()
                  .GetDepthStencilAttachmentDescriptor()
                  .has_value());
  ASSERT_TRUE(command.pipeline->GetDescriptor()
                  .GetFrontStencilAttachmentDescriptor()
                  .has_value());
}

References impeller::RenderPass::GetCommands(), height, impeller::Geometry::MakeCover(), impeller::Entity::SetContents(), target, and width.

◆ TEST_P() [515/662]

impeller::testing::TEST_P	(	EntityTest	,
		RuntimeEffectSetsRightSizeWhenUniformIsStruct
	)

Definition at line 1931 of file entity_unittests.cc.

                                                                  {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only applies to Vulkan";
  }
 
  auto runtime_stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_example.frag.iplr");
  ABSL_ASSERT_OK(runtime_stages_result);
  auto runtime_stage = runtime_stages_result.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(runtime_stage);
  ASSERT_TRUE(runtime_stage->IsDirty());
 
  auto geom = Geometry::MakeCover();
  auto contents = std::make_shared<RuntimeEffectContents>(geom.get());
  contents->SetRuntimeStage(runtime_stage);
 
  struct FragUniforms {
    Vector2 iResolution;
    Scalar iTime;
  } frag_uniforms = {
      .iResolution = Vector2(GetWindowSize().width, GetWindowSize().height),
      .iTime = static_cast<Scalar>(GetSecondsElapsed()),
  };
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(sizeof(FragUniforms));
  memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
 
  auto buffer_view = RuntimeEffectContents::EmplaceUniform(
      uniform_data->data(), GetContentContext().GetTransientsDataBuffer(),
      runtime_stage->GetUniforms()[0]);
 
  // 16 bytes:
  //   8 bytes for iResolution
  //   4 bytes for iTime
  //   4 bytes padding
  EXPECT_EQ(buffer_view.GetRange().length, 16u);
}

References impeller::RuntimeEffectContents::EmplaceUniform(), height, impeller::kVulkan, impeller::Geometry::MakeCover(), and width.

◆ TEST_P() [516/662]

impeller::testing::TEST_P	(	EntityTest	,
		SetBlendMode
	)

Definition at line 1229 of file entity_unittests.cc.

                                 {
  Entity entity;
  ASSERT_EQ(entity.GetBlendMode(), BlendMode::kSrcOver);
  entity.SetBlendMode(BlendMode::kClear);
  ASSERT_EQ(entity.GetBlendMode(), BlendMode::kClear);
}

References impeller::Entity::GetBlendMode(), impeller::kClear, impeller::kSrcOver, and impeller::Entity::SetBlendMode().

◆ TEST_P() [517/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorApplyColorFilter
	)

Definition at line 2820 of file entity_unittests.cc.

                                               {
  auto geom = Geometry::MakeCover();
  auto contents = SolidColorContents(geom.get());
  contents.SetColor(Color::CornflowerBlue().WithAlpha(0.75));
  auto result = contents.ApplyColorFilter([](const Color& color) {
    return color.Blend(Color::LimeGreen().WithAlpha(0.75), BlendMode::kScreen);
  });
  ASSERT_TRUE(result);
  ASSERT_COLOR_NEAR(contents.GetColor(),
                    Color(0.424452, 0.828743, 0.79105, 0.9375));
}

References ASSERT_COLOR_NEAR, impeller::Color::Blend(), impeller::Color::CornflowerBlue(), impeller::kScreen, impeller::Color::LimeGreen(), and impeller::Geometry::MakeCover().

◆ TEST_P() [518/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsIsOpaque
	)

Definition at line 2074 of file entity_unittests.cc.

                                               {
  Matrix matrix;
  auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
  SolidColorContents contents(geom.get());
 
  contents.SetColor(Color::CornflowerBlue());
  EXPECT_TRUE(contents.IsOpaque(matrix));
  contents.SetColor(Color::CornflowerBlue().WithAlpha(0.5));
  EXPECT_FALSE(contents.IsOpaque(matrix));
 
  // Create stroked path that required alpha coverage.
  auto geom2 = Geometry::MakeStrokePath(
      flutter::DlPath::MakeLine({0, 0}, {100, 100}), {.width = 0.05});
  SolidColorContents contents2(geom2.get());
  contents2.SetColor(Color::CornflowerBlue());
 
  EXPECT_FALSE(contents2.IsOpaque(matrix));
}

References impeller::Color::CornflowerBlue(), impeller::SolidColorContents::IsOpaque(), flutter::DlPath::MakeLine(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), and impeller::SolidColorContents::SetColor().

◆ TEST_P() [519/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetMiterLimit
	)

Definition at line 711 of file entity_unittests.cc.

                                                          {
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{});
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                             {
                                                 .width = 1.0f,
                                                 .miter_limit = 8.0f,
                                             });
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 8);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                             {
                                                 .width = 1.0f,
                                                 .miter_limit = -1.0f,
                                             });
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_FLOAT_EQ(path_geometry->GetMiterLimit(), 4);
  }
}

References impeller::Geometry::MakeStrokePath().

◆ TEST_P() [520/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidColorContentsStrokeSetStrokeCapsAndJoins
	)

Definition at line 679 of file entity_unittests.cc.

                                                                  {
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{});
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    // Defaults.
    ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kButt);
    ASSERT_EQ(path_geometry->GetStrokeJoin(), Join::kMiter);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                             {
                                                 .width = 1.0f,
                                                 .cap = Cap::kSquare,
                                                 .miter_limit = 4.0f,
                                             });
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kSquare);
  }
 
  {
    auto geometry = Geometry::MakeStrokePath(flutter::DlPath{},  //
                                             {
                                                 .width = 1.0f,
                                                 .cap = Cap::kRound,
                                                 .miter_limit = 4.0f,
                                             });
    auto path_geometry = static_cast<StrokePathGeometry*>(geometry.get());
    ASSERT_EQ(path_geometry->GetStrokeCap(), Cap::kRound);
  }
}

References impeller::kButt, impeller::kMiter, impeller::kRound, impeller::kSquare, and impeller::Geometry::MakeStrokePath().

◆ TEST_P() [521/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidFillCoverageIsCorrect
	)

Definition at line 1397 of file entity_unittests.cc.

                                               {
  // No transform
  {
    auto expected = Rect::MakeLTRB(100, 110, 200, 220);
    auto geom = Geometry::MakeFillPath(flutter::DlPath::MakeRect(expected));
    auto fill = std::make_shared<SolidColorContents>(geom.get());
    fill->SetColor(Color::CornflowerBlue());
 
    auto coverage = fill->GetCoverage({});
    ASSERT_TRUE(coverage.has_value());
    ASSERT_RECT_NEAR(coverage.value(), expected);
  }
 
  // Entity transform
  {
    auto geom = Geometry::MakeFillPath(
        flutter::DlPath::MakeRect(Rect::MakeLTRB(100, 110, 200, 220)));
    auto fill = std::make_shared<SolidColorContents>(geom.get());
    fill->SetColor(Color::CornflowerBlue());
 
    Entity entity;
    entity.SetTransform(Matrix::MakeTranslation(Vector2(4, 5)));
    entity.SetContents(std::move(fill));
 
    auto coverage = entity.GetCoverage();
    auto expected = Rect::MakeLTRB(104, 115, 204, 225);
    ASSERT_TRUE(coverage.has_value());
    ASSERT_RECT_NEAR(coverage.value(), expected);
  }
 
  // No coverage for fully transparent colors
  {
    auto geom = Geometry::MakeFillPath(
        flutter::DlPath::MakeRect(Rect::MakeLTRB(100, 110, 200, 220)));
    auto fill = std::make_shared<SolidColorContents>(geom.get());
    fill->SetColor(Color::WhiteTransparent());
 
    auto coverage = fill->GetCoverage({});
    ASSERT_FALSE(coverage.has_value());
  }
}

References ASSERT_RECT_NEAR, impeller::Color::CornflowerBlue(), impeller::Entity::GetCoverage(), impeller::Geometry::MakeFillPath(), impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeTranslation(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), and impeller::Color::WhiteTransparent().

◆ TEST_P() [522/662]

impeller::testing::TEST_P	(	EntityTest	,
		SolidStrokeCoverageIsCorrect
	)

Definition at line 1302 of file entity_unittests.cc.

                                                 {
  {
    auto geometry = Geometry::MakeStrokePath(
        flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
        {
            .width = 4.0f,
            .cap = Cap::kButt,
            .join = Join::kBevel,
            .miter_limit = 4.0f,
        });
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>(geometry.get());
    contents->SetColor(Color::Black());
    entity.SetContents(std::move(contents));
    auto actual = entity.GetCoverage();
    auto expected = Rect::MakeLTRB(-2, -2, 12, 12);
 
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
 
  // Cover the Cap::kSquare case.
  {
    auto geometry = Geometry::MakeStrokePath(
        flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
        {
            .width = 4.0,
            .cap = Cap::kSquare,
            .join = Join::kBevel,
            .miter_limit = 4.0,
        });
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>(geometry.get());
    contents->SetColor(Color::Black());
    entity.SetContents(std::move(contents));
    auto actual = entity.GetCoverage();
    auto expected =
        Rect::MakeLTRB(-sqrt(8), -sqrt(8), 10 + sqrt(8), 10 + sqrt(8));
 
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
 
  // Cover the Join::kMiter case.
  {
    auto geometry = Geometry::MakeStrokePath(
        flutter::DlPath::MakeLine({0, 0}, {10, 10}),  //
        {
            .width = 4.0f,
            .cap = Cap::kSquare,
            .join = Join::kMiter,
            .miter_limit = 2.0f,
        });
 
    Entity entity;
    auto contents = std::make_unique<SolidColorContents>(geometry.get());
    contents->SetColor(Color::Black());
    entity.SetContents(std::move(contents));
    auto actual = entity.GetCoverage();
    auto expected = Rect::MakeLTRB(-4, -4, 14, 14);
 
    ASSERT_TRUE(actual.has_value());
    ASSERT_RECT_NEAR(actual.value(), expected);
  }
}

References ASSERT_RECT_NEAR, impeller::Color::Black(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kSquare, flutter::DlPath::MakeLine(), impeller::TRect< Scalar >::MakeLTRB(), and impeller::Geometry::MakeStrokePath().

◆ TEST_P() [523/662]

impeller::testing::TEST_P	(	EntityTest	,
		SpecializationConstantsAreAppliedToVariants
	)

Definition at line 2228 of file entity_unittests.cc.

                                                                {
  ContentContext& content_context = GetContentContext();
 
  auto default_gyph = content_context.GetGlyphAtlasPipeline({
      .color_attachment_pixel_format = PixelFormat::kR8G8B8A8UNormInt,
      .has_depth_stencil_attachments = false,
  });
  auto alt_gyph = content_context.GetGlyphAtlasPipeline(
      {.color_attachment_pixel_format = PixelFormat::kR8G8B8A8UNormInt,
       .has_depth_stencil_attachments = true});
 
  EXPECT_NE(default_gyph, alt_gyph);
  EXPECT_EQ(default_gyph->GetDescriptor().GetSpecializationConstants(),
            alt_gyph->GetDescriptor().GetSpecializationConstants());
 
  auto use_a8 = GetContext()->GetCapabilities()->GetDefaultGlyphAtlasFormat() ==
                PixelFormat::kA8UNormInt;
 
  std::vector<Scalar> expected_constants = {static_cast<Scalar>(use_a8)};
  EXPECT_EQ(default_gyph->GetDescriptor().GetSpecializationConstants(),
            expected_constants);
}

References impeller::ContentContext::GetGlyphAtlasPipeline(), impeller::kA8UNormInt, and impeller::kR8G8B8A8UNormInt.

◆ TEST_P() [524/662]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilter
	)

Definition at line 1654 of file entity_unittests.cc.

                                       {
  auto image = CreateTextureForFixture("embarcadero.jpg");
  ASSERT_TRUE(image);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    auto filtered =
        ColorFilterContents::MakeSrgbToLinearFilter(FilterInput::Make(image));
 
    // Define the entity that will serve as the control image as a Gaussian blur
    // filter with no filter at all.
    Entity entity_left;
    entity_left.SetTransform(Matrix::MakeScale(GetContentScale()) *
                             Matrix::MakeTranslation({100, 300}) *
                             Matrix::MakeScale(Vector2{0.5, 0.5}));
    auto unfiltered = FilterContents::MakeGaussianBlur(FilterInput::Make(image),
                                                       Sigma{0}, Sigma{0});
    entity_left.SetContents(unfiltered);
 
    // Define the entity that will be filtered from sRGB to linear.
    Entity entity_right;
    entity_right.SetTransform(Matrix::MakeScale(GetContentScale()) *
                              Matrix::MakeTranslation({500, 300}) *
                              Matrix::MakeScale(Vector2{0.5, 0.5}));
    entity_right.SetContents(filtered);
    return entity_left.Render(context, pass) &&
           entity_right.Render(context, pass);
  };
 
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, image, impeller::FilterInput::Make(), impeller::FilterContents::MakeGaussianBlur(), impeller::Matrix::MakeScale(), impeller::ColorFilterContents::MakeSrgbToLinearFilter(), impeller::Matrix::MakeTranslation(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [525/662]

impeller::testing::TEST_P	(	EntityTest	,
		SrgbToLinearFilterCoverageIsCorrect
	)

Definition at line 1633 of file entity_unittests.cc.

                                                        {
  // Set up a simple color background.
  auto geom = Geometry::MakeFillPath(
      flutter::DlPath::MakeRect(Rect::MakeXYWH(0, 0, 300, 400)));
  auto fill = std::make_shared<SolidColorContents>(geom.get());
  fill->SetColor(Color::DeepPink());
 
  auto filter =
      ColorFilterContents::MakeSrgbToLinearFilter(FilterInput::Make(fill));
 
  Entity e;
  e.SetTransform(Matrix());
 
  // Confirm that the actual filter coverage matches the expected coverage.
  auto actual = filter->GetCoverage(e);
  auto expected = Rect::MakeXYWH(0, 0, 300, 400);
 
  ASSERT_TRUE(actual.has_value());
  ASSERT_RECT_NEAR(actual.value(), expected);
}

References ASSERT_RECT_NEAR, impeller::Color::DeepPink(), impeller::FilterInput::Make(), impeller::Geometry::MakeFillPath(), flutter::DlPath::MakeRect(), impeller::ColorFilterContents::MakeSrgbToLinearFilter(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Entity::SetTransform().

◆ TEST_P() [526/662]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeArcGeometryGetPositionBufferReturnsExpectedMode
	)

Definition at line 2342 of file entity_unittests.cc.

                                                                          {
  RenderTarget target;
  testing::MockRenderPass mock_pass(GetContext(), target);
  Rect oval_bounds = Rect::MakeLTRB(100, 100, 200, 200);
 
  // Butt caps never overlap
  {
    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kButt};
    for (auto start = 0; start < 360; start += 60) {
      for (auto sweep = 0; sweep < 360; sweep += 12) {
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), stroke);
 
        GeometryResult result =
            geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
 
        EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
            << "start: " << start << " sweep: " << sweep;
      }
    }
  }
 
  // Round caps with 10 stroke width overlap starting at 348.6 degrees
  {
    StrokeParameters stroke = {.width = 10.0f, .cap = Cap::kRound};
    for (auto start = 0; start < 360; start += 60) {
      for (auto sweep = 0; sweep < 360; sweep += 12) {
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), stroke);
 
        GeometryResult result =
            geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
 
        if (sweep < 348.6) {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
              << "start: " << start << " sweep: " << sweep;
        } else {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
              << "start: " << start << " sweep: " << sweep;
        }
      }
    }
  }
 
  // Round caps with 50 stroke width overlap starting at 300.1 degrees
  {
    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kRound};
    for (auto start = 0; start < 360; start += 60) {
      for (auto sweep = 0; sweep < 360; sweep += 12) {
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), stroke);
 
        GeometryResult result =
            geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
 
        if (sweep < 300.0) {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
              << "start: " << start << " sweep: " << sweep;
        } else {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
              << "start: " << start << " sweep: " << sweep;
        }
      }
    }
  }
 
  // Square caps with 10 stroke width overlap starting at 347.4 degrees
  {
    StrokeParameters stroke = {.width = 10.0f, .cap = Cap::kSquare};
    for (auto start = 0; start < 360; start += 60) {
      for (auto sweep = 0; sweep < 360; sweep += 12) {
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), stroke);
 
        GeometryResult result =
            geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
 
        if (sweep < 347.4) {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
              << "start: " << start << " sweep: " << sweep;
        } else {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
              << "start: " << start << " sweep: " << sweep;
        }
      }
    }
  }
 
  // Square caps with 50 stroke width overlap starting at 270.1 degrees
  {
    StrokeParameters stroke = {.width = 50.0f, .cap = Cap::kSquare};
    for (auto start = 0; start < 360; start += 60) {
      for (auto sweep = 0; sweep < 360; sweep += 12) {
        auto geometry = Geometry::MakeStrokedArc(oval_bounds, Degrees(start),
                                                 Degrees(sweep), stroke);
 
        GeometryResult result =
            geometry->GetPositionBuffer(GetContentContext(), {}, mock_pass);
 
        if (sweep < 270.1) {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kNormal)
              << "start: " << start << " sweep: " << sweep;
        } else {
          EXPECT_EQ(result.mode, GeometryResult::Mode::kPreventOverdraw)
              << "start: " << start << " sweep: " << sweep;
        }
      }
    }
  }
}

References impeller::kButt, impeller::GeometryResult::kNormal, impeller::GeometryResult::kPreventOverdraw, impeller::kRound, impeller::kSquare, impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeStrokedArc(), impeller::GeometryResult::mode, start, target, and impeller::StrokeParameters::width.

◆ TEST_P() [527/662]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeCapAndJoinTest
	)

Definition at line 196 of file entity_unittests.cc.

                                         {
  const Point padding(300, 250);
  const Point margin(140, 180);
 
  auto callback = [&](ContentContext& context, RenderPass& pass) {
    // Slightly above sqrt(2) by default, so that right angles are just below
    // the limit and acute angles are over the limit (causing them to get
    // beveled).
    static Scalar miter_limit = 1.41421357;
    static Scalar width = 30;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Miter limit", &miter_limit, 0, 30);
      ImGui::SliderFloat("Stroke width", &width, 0, 100);
      if (ImGui::Button("Reset")) {
        miter_limit = 1.41421357;
        width = 30;
      }
      ImGui::End();
    }
 
    auto world_matrix = Matrix::MakeScale(GetContentScale());
    auto render_path = [width = width, &context, &pass, &world_matrix](
                           const flutter::DlPath& path, Cap cap, Join join) {
      std::unique_ptr<Geometry> geom =
          Geometry::MakeStrokePath(path, {
                                             .width = width,
                                             .cap = cap,
                                             .join = join,
                                             .miter_limit = miter_limit,
                                         });
      auto contents = std::make_unique<SolidColorContents>(geom.get());
      contents->SetColor(Color::Red());
 
      Entity entity;
      entity.SetTransform(world_matrix);
      entity.SetContents(std::move(contents));
 
      auto coverage = entity.GetCoverage();
      if (coverage.has_value()) {
        std::unique_ptr<Geometry> geom = Geometry::MakeFillPath(
            flutter::DlPath::MakeRect(entity.GetCoverage().value()));
 
        auto bounds_contents = std::make_unique<SolidColorContents>(geom.get());
        bounds_contents->SetColor(Color::Green().WithAlpha(0.5));
        Entity bounds_entity;
        bounds_entity.SetContents(std::move(bounds_contents));
        bounds_entity.Render(context, pass);
      }
 
      entity.Render(context, pass);
    };
 
    const Point a_def(0, 0), b_def(0, 100), c_def(150, 0), d_def(150, -100),
        e_def(75, 75);
    const Scalar r = 30;
    // Cap::kButt demo.
    {
      Point off = Point(0, 0) * padding + margin;
      static PlaygroundPoint point_a(off + a_def, r, Color::Black());
      static PlaygroundPoint point_b(off + b_def, r, Color::White());
      auto [a, b] = DrawPlaygroundLine(point_a, point_b);
      static PlaygroundPoint point_c(off + c_def, r, Color::Black());
      static PlaygroundPoint point_d(off + d_def, r, Color::White());
      auto [c, d] = DrawPlaygroundLine(point_c, point_d);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .CubicCurveTo(b, d, c)
                      .TakePath(),
                  Cap::kButt, Join::kBevel);
    }
 
    // Cap::kSquare demo.
    {
      Point off = Point(1, 0) * padding + margin;
      static PlaygroundPoint point_a(off + a_def, r, Color::Black());
      static PlaygroundPoint point_b(off + b_def, r, Color::White());
      auto [a, b] = DrawPlaygroundLine(point_a, point_b);
      static PlaygroundPoint point_c(off + c_def, r, Color::Black());
      static PlaygroundPoint point_d(off + d_def, r, Color::White());
      auto [c, d] = DrawPlaygroundLine(point_c, point_d);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .CubicCurveTo(b, d, c)
                      .TakePath(),
                  Cap::kSquare, Join::kBevel);
    }
 
    // Cap::kRound demo.
    {
      Point off = Point(2, 0) * padding + margin;
      static PlaygroundPoint point_a(off + a_def, r, Color::Black());
      static PlaygroundPoint point_b(off + b_def, r, Color::White());
      auto [a, b] = DrawPlaygroundLine(point_a, point_b);
      static PlaygroundPoint point_c(off + c_def, r, Color::Black());
      static PlaygroundPoint point_d(off + d_def, r, Color::White());
      auto [c, d] = DrawPlaygroundLine(point_c, point_d);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .CubicCurveTo(b, d, c)
                      .TakePath(),
                  Cap::kRound, Join::kBevel);
    }
 
    // Join::kBevel demo.
    {
      Point off = Point(0, 1) * padding + margin;
      static PlaygroundPoint point_a =
          PlaygroundPoint(off + a_def, r, Color::White());
      static PlaygroundPoint point_b =
          PlaygroundPoint(off + e_def, r, Color::White());
      static PlaygroundPoint point_c =
          PlaygroundPoint(off + c_def, r, Color::White());
      Point a = DrawPlaygroundPoint(point_a);
      Point b = DrawPlaygroundPoint(point_b);
      Point c = DrawPlaygroundPoint(point_c);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .LineTo(b)
                      .LineTo(c)
                      .Close()
                      .TakePath(),
                  Cap::kButt, Join::kBevel);
    }
 
    // Join::kMiter demo.
    {
      Point off = Point(1, 1) * padding + margin;
      static PlaygroundPoint point_a(off + a_def, r, Color::White());
      static PlaygroundPoint point_b(off + e_def, r, Color::White());
      static PlaygroundPoint point_c(off + c_def, r, Color::White());
      Point a = DrawPlaygroundPoint(point_a);
      Point b = DrawPlaygroundPoint(point_b);
      Point c = DrawPlaygroundPoint(point_c);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .LineTo(b)
                      .LineTo(c)
                      .Close()
                      .TakePath(),
                  Cap::kButt, Join::kMiter);
    }
 
    // Join::kRound demo.
    {
      Point off = Point(2, 1) * padding + margin;
      static PlaygroundPoint point_a(off + a_def, r, Color::White());
      static PlaygroundPoint point_b(off + e_def, r, Color::White());
      static PlaygroundPoint point_c(off + c_def, r, Color::White());
      Point a = DrawPlaygroundPoint(point_a);
      Point b = DrawPlaygroundPoint(point_b);
      Point c = DrawPlaygroundPoint(point_c);
      render_path(flutter::DlPathBuilder{}  //
                      .MoveTo(a)
                      .LineTo(b)
                      .LineTo(c)
                      .Close()
                      .TakePath(),
                  Cap::kButt, Join::kRound);
    }
 
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References impeller::Color::Black(), c, callback, impeller::Close(), context, d, impeller::DrawPlaygroundLine(), impeller::DrawPlaygroundPoint(), impeller::Entity::GetCoverage(), impeller::Color::Green(), impeller::kBevel, impeller::kButt, impeller::kMiter, impeller::kRound, impeller::kSquare, impeller::LineTo(), impeller::Geometry::MakeFillPath(), flutter::DlPath::MakeRect(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), padding, flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::Color::White(), and width.

◆ TEST_P() [528/662]

impeller::testing::TEST_P	(	EntityTest	,
		StrokeWithTextureContents
	)

Definition at line 130 of file entity_unittests.cc.

                                              {
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  flutter::DlPath path = flutter::DlPathBuilder{}
                             .MoveTo({100, 100})
                             .LineTo({100, 200})
                             .MoveTo({100, 300})
                             .LineTo({100, 400})
                             .MoveTo({100, 500})
                             .LineTo({100, 600})
                             .TakePath();
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  std::unique_ptr<Geometry> geom =
      Geometry::MakeStrokePath(path, {.width = 100.0f});
  auto contents = std::make_unique<TiledTextureContents>(geom.get());
  contents->SetTexture(bridge);
  contents->SetTileModes(Entity::TileMode::kClamp, Entity::TileMode::kClamp);
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::Entity::kClamp, impeller::LineTo(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::MoveTo(), flutter::path, impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [529/662]

impeller::testing::TEST_P	(	EntityTest	,
		SweepGradientContentsIsOpaque
	)

Definition at line 2159 of file entity_unittests.cc.

                                                  {
  Matrix matrix;
  auto geom = Geometry::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
  SweepGradientContents contents(geom.get());
 
  contents.SetColors({Color::CornflowerBlue()});
  EXPECT_TRUE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue().WithAlpha(0.5)});
  EXPECT_FALSE(contents.IsOpaque(matrix));
  contents.SetColors({Color::CornflowerBlue()});
  contents.SetTileMode(Entity::TileMode::kDecal);
  EXPECT_FALSE(contents.IsOpaque(matrix));
 
  // Create stroked path that required alpha coverage.
  auto geom2 = Geometry::MakeStrokePath(
      flutter::DlPathBuilder{}.MoveTo({0, 0}).LineTo({100, 100}).TakePath(),
      {.width = 0.05f});
  SweepGradientContents contents2(geom2.get());
  contents2.SetColors({Color::CornflowerBlue()});
 
  EXPECT_FALSE(contents2.IsOpaque(matrix));
}

References impeller::Color::CornflowerBlue(), impeller::SweepGradientContents::IsOpaque(), impeller::Entity::kDecal, impeller::LineTo(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Geometry::MakeRect(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::SweepGradientContents::SetColors(), impeller::SweepGradientContents::SetTileMode(), and impeller::Color::WithAlpha().

◆ TEST_P() [530/662]

impeller::testing::TEST_P	(	EntityTest	,
		TextContentsCeilsGlyphScaleToDecimal
	)

Definition at line 2220 of file entity_unittests.cc.

                                                         {
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.4321111f), Rational(43, 100));
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.5321111f), Rational(53, 100));
  ASSERT_EQ(TextFrame::RoundScaledFontSize(2.1f), Rational(21, 10));
  ASSERT_EQ(TextFrame::RoundScaledFontSize(0.0f), Rational(0, 1));
  ASSERT_EQ(TextFrame::RoundScaledFontSize(100000000.0f), Rational(48, 1));
}

References impeller::TextFrame::RoundScaledFontSize().

◆ TEST_P() [531/662]

impeller::testing::TEST_P	(	EntityTest	,
		ThreeStrokesInOnePath
	)

Definition at line 110 of file entity_unittests.cc.

                                          {
  flutter::DlPath path = flutter::DlPathBuilder{}
                             .MoveTo({100, 100})
                             .LineTo({100, 200})
                             .MoveTo({100, 300})
                             .LineTo({100, 400})
                             .MoveTo({100, 500})
                             .LineTo({100, 600})
                             .TakePath();
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale(GetContentScale()));
  std::unique_ptr<Geometry> geom =
      Geometry::MakeStrokePath(path, {.width = 5.0f});
  auto contents = std::make_unique<SolidColorContents>(geom.get());
  contents->SetColor(Color::Red());
  entity.SetContents(std::move(contents));
  ASSERT_TRUE(OpenPlaygroundHere(std::move(entity)));
}

References impeller::LineTo(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), impeller::MoveTo(), flutter::path, impeller::Color::Red(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [532/662]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsIsOpaque
	)

Definition at line 2182 of file entity_unittests.cc.

                                                 {
  Matrix matrix;
  auto bay_bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto geom = Geometry::MakeCover();
  TiledTextureContents contents(geom.get());
  contents.SetTexture(bay_bridge);
  // This is a placeholder test. Images currently never decompress as opaque
  // (whether in Flutter or the playground), and so this should currently always
  // return false in practice.
  EXPECT_FALSE(contents.IsOpaque(matrix));
}

References impeller::TiledTextureContents::IsOpaque(), impeller::Geometry::MakeCover(), and impeller::TiledTextureContents::SetTexture().

◆ TEST_P() [533/662]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipeline
	)

Definition at line 21 of file tiled_texture_contents_unittests.cc.

                                                                   {
  TextureDescriptor texture_desc;
  texture_desc.size = {100, 100};
  texture_desc.type = TextureType::kTexture2D;
  texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_desc.storage_mode = StorageMode::kDevicePrivate;
  auto texture =
      GetContext()->GetResourceAllocator()->CreateTexture(texture_desc);
 
  auto geom = Geometry::MakeCover();
  TiledTextureContents contents(geom.get());
  contents.SetTexture(texture);
 
  ContentContext& content_context = GetContentContext();
  auto buffer = content_context.GetContext()->CreateCommandBuffer();
  auto render_target =
      GetContentContext().GetRenderTargetCache()->CreateOffscreenMSAA(
          *content_context.GetContext(), {100, 100},
          /*mip_count=*/1);
  auto render_pass = buffer->CreateRenderPass(render_target);
  auto recording_pass = std::make_shared<RecordingRenderPass>(
      render_pass, GetContext(), render_target);
 
  ASSERT_TRUE(contents.Render(GetContentContext(), {}, *recording_pass));
  const std::vector<Command>& commands = recording_pass->GetCommands();
 
  ASSERT_EQ(commands.size(), 1u);
#ifdef IMPELLER_DEBUG
  EXPECT_TRUE(commands[0].pipeline->GetDescriptor().GetLabel().find(
                  "TextureFill Pipeline") != std::string::npos);
#endif  // IMPELLER_DEBUG
  auto options = OptionsFromPassAndEntity(*recording_pass, {});
  options.primitive_type = PrimitiveType::kTriangleStrip;
  EXPECT_EQ(commands[0].pipeline,
            GetContentContext().GetTiledTexturePipeline(options));
 
  if (GetParam() == PlaygroundBackend::kMetal) {
    recording_pass->EncodeCommands();
  }
}

References flutter::buffer, impeller::TextureDescriptor::format, impeller::ContentContext::GetContext(), impeller::kDevicePrivate, impeller::kMetal, impeller::kR8G8B8A8UNormInt, impeller::kTexture2D, impeller::kTriangleStrip, impeller::Geometry::MakeCover(), impeller::OptionsFromPassAndEntity(), pipeline, impeller::ContentContextOptions::primitive_type, impeller::TiledTextureContents::Render(), render_pass, impeller::TiledTextureContents::SetTexture(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::type.

◆ TEST_P() [534/662]

impeller::testing::TEST_P	(	EntityTest	,
		TiledTextureContentsRendersWithCorrectPipelineExternalOES
	)

Definition at line 64 of file tiled_texture_contents_unittests.cc.

                                                                              {
  if (GetParam() != PlaygroundBackend::kOpenGLES &&
      GetParam() != PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP()
        << "External OES textures are only valid for the OpenGLES backend.";
  }
 
  TextureDescriptor texture_desc;
  texture_desc.size = {100, 100};
  texture_desc.type = TextureType::kTextureExternalOES;
  texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_desc.storage_mode = StorageMode::kDevicePrivate;
  auto texture =
      GetContext()->GetResourceAllocator()->CreateTexture(texture_desc);
  auto contents = TextureContents::MakeRect(Rect::MakeSize(texture->GetSize()));
  contents->SetTexture(texture);
  contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
  contents->SetStrictSourceRect(false);
 
  ContentContext& content_context = GetContentContext();
  auto buffer = content_context.GetContext()->CreateCommandBuffer();
  auto render_target =
      GetContentContext().GetRenderTargetCache()->CreateOffscreenMSAA(
          *content_context.GetContext(), {100, 100},
          /*mip_count=*/1);
  auto render_pass = buffer->CreateRenderPass(render_target);
 
  ASSERT_TRUE(contents->Render(GetContentContext(), {}, *render_pass));
  const std::vector<Command>& commands = render_pass->GetCommands();
 
  ASSERT_EQ(commands.size(), 1u);
 
  auto options = OptionsFromPassAndEntity(*render_pass, {});
  options.primitive_type = PrimitiveType::kTriangleStrip;
  EXPECT_EQ(commands[0].pipeline,
            GetContentContext().GetTiledTextureExternalPipeline(options));
}

References flutter::buffer, impeller::TextureDescriptor::format, impeller::ContentContext::GetContext(), impeller::kDevicePrivate, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kR8G8B8A8UNormInt, impeller::kTextureExternalOES, impeller::kTriangleStrip, impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::OptionsFromPassAndEntity(), pipeline, impeller::ContentContextOptions::primitive_type, render_pass, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::type.

◆ TEST_P() [535/662]

impeller::testing::TEST_P	(	EntityTest	,
		TriangleInsideASquare
	)

Definition at line 152 of file entity_unittests.cc.

                                          {
  auto callback = [&](ContentContext& context, RenderPass& pass) {
    Point offset(100, 100);
 
    static PlaygroundPoint point_a(Point(10, 10) + offset, 20, Color::White());
    Point a = DrawPlaygroundPoint(point_a);
    static PlaygroundPoint point_b(Point(210, 10) + offset, 20, Color::White());
    Point b = DrawPlaygroundPoint(point_b);
    static PlaygroundPoint point_c(Point(210, 210) + offset, 20,
                                   Color::White());
    Point c = DrawPlaygroundPoint(point_c);
    static PlaygroundPoint point_d(Point(10, 210) + offset, 20, Color::White());
    Point d = DrawPlaygroundPoint(point_d);
    static PlaygroundPoint point_e(Point(50, 50) + offset, 20, Color::White());
    Point e = DrawPlaygroundPoint(point_e);
    static PlaygroundPoint point_f(Point(100, 50) + offset, 20, Color::White());
    Point f = DrawPlaygroundPoint(point_f);
    static PlaygroundPoint point_g(Point(50, 150) + offset, 20, Color::White());
    Point g = DrawPlaygroundPoint(point_g);
    flutter::DlPath path = flutter::DlPathBuilder{}
                               .MoveTo(a)
                               .LineTo(b)
                               .LineTo(c)
                               .LineTo(d)
                               .Close()
                               .MoveTo(e)
                               .LineTo(f)
                               .LineTo(g)
                               .Close()
                               .TakePath();
 
    Entity entity;
    entity.SetTransform(Matrix::MakeScale(GetContentScale()));
    std::unique_ptr<Geometry> geom =
        Geometry::MakeStrokePath(path, {.width = 20.0});
    auto contents = std::make_unique<SolidColorContents>(geom.get());
    contents->SetColor(Color::Red());
    entity.SetContents(std::move(contents));
 
    return entity.Render(context, pass);
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References c, callback, flutter::DlPathBuilder::Close(), context, d, impeller::DrawPlaygroundPoint(), flutter::DlPathBuilder::LineTo(), impeller::Matrix::MakeScale(), impeller::Geometry::MakeStrokePath(), flutter::DlPathBuilder::MoveTo(), flutter::path, impeller::Color::Red(), impeller::Entity::Render(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), flutter::DlPathBuilder::TakePath(), and impeller::Color::White().

◆ TEST_P() [536/662]

impeller::testing::TEST_P	(	EntityTest	,
		YUVToRGBFilter
	)

Definition at line 1763 of file entity_unittests.cc.

                                   {
  if (GetParam() != PlaygroundBackend::kMetal &&
      GetParam() != PlaygroundBackend::kMetalSDF) {
    // @see (114588) : Support YUV to RGB filter on OpenGLES backend.
    // The issue was closed as low priority as the support is only really
    // needed for iOS. Also, Vulkan isn't supported either.
    GTEST_SKIP() << "YUV to RGB filter is only supported on Metal backends.";
  }
 
  auto callback = [&](ContentContext& context, RenderPass& pass) -> bool {
    YUVColorSpace yuv_color_space_array[2]{YUVColorSpace::kBT601FullRange,
                                           YUVColorSpace::kBT601LimitedRange};
    for (int i = 0; i < 2; i++) {
      auto yuv_color_space = yuv_color_space_array[i];
      auto textures =
          CreateTestYUVTextures(GetContext().get(), yuv_color_space);
      auto filter_contents = FilterContents::MakeYUVToRGBFilter(
          textures[0], textures[1], yuv_color_space);
      Entity filter_entity;
      filter_entity.SetContents(filter_contents);
      auto snapshot =
          filter_contents->RenderToSnapshot(context, filter_entity, {});
 
      Entity entity;
      auto contents = TextureContents::MakeRect(Rect::MakeLTRB(0, 0, 256, 256));
      contents->SetTexture(snapshot->texture);
      contents->SetSourceRect(Rect::MakeSize(snapshot->texture->GetSize()));
      entity.SetContents(contents);
      entity.SetTransform(
          Matrix::MakeTranslation({static_cast<Scalar>(100 + 400 * i), 300}));
      entity.Render(context, pass);
    }
    return true;
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback, context, CreateTestYUVTextures(), i, impeller::kBT601FullRange, impeller::kBT601LimitedRange, impeller::kMetal, impeller::kMetalSDF, impeller::TRect< Scalar >::MakeLTRB(), impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeTranslation(), impeller::FilterContents::MakeYUVToRGBFilter(), impeller::Entity::Render(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ TEST_P() [537/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CalculateUVsSimple
	)

Definition at line 364 of file gaussian_blur_filter_contents_unittests.cc.

                                                           {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  auto filter_input = FilterInput::Make(texture);
  Entity entity;
  Quad uvs = GaussianBlurFilterContents::CalculateUVs(
      filter_input, entity, Rect::MakeSize(ISize(100, 100)), ISize(100, 100));
  std::optional<Rect> uvs_bounds = Rect::MakePointBounds(uvs);
  EXPECT_TRUE(uvs_bounds.has_value());
  if (uvs_bounds.has_value()) {
    EXPECT_TRUE(RectNear(uvs_bounds.value(), Rect::MakeXYWH(0, 0, 1, 1)));
  }
}

References impeller::GaussianBlurFilterContents::CalculateUVs(), impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakePointBounds(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), RectNear(), texture, and uvs.

◆ TEST_P() [538/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithEffectTransform
	)

Definition at line 191 of file gaussian_blur_filter_contents_unittests.cc.

                                                                    {
  Matrix effect_transform = Matrix::MakeScale({2.0, 2.0, 1.0});
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, effect_transform);
  ASSERT_TRUE(sigma_radius_1.ok());
  GaussianBlurFilterContents contents(
      /*sigma_x=*/sigma_radius_1.value(),
      /*sigma_y=*/sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  FilterInput::Vector inputs = {FilterInput::Make(texture)};
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 100, 0}));
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, effect_transform);
  EXPECT_TRUE(coverage.has_value());
  if (coverage.has_value()) {
    EXPECT_RECT_NEAR(coverage.value(),
                     Rect::MakeLTRB(100 - 1, 100 - 1, 200 + 1, 200 + 1));
  }
}

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [539/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		CoverageWithTexture
	)

Definition at line 169 of file gaussian_blur_filter_contents_unittests.cc.

                                                            {
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  GaussianBlurFilterContents contents(
      /*sigma_X=*/sigma_radius_1.value(),
      /*sigma_y=*/sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  FilterInput::Vector inputs = {FilterInput::Make(texture)};
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 100, 0}));
  std::optional<Rect> coverage =
      contents.GetFilterCoverage(inputs, entity, /*effect_transform=*/Matrix());
 
  EXPECT_TRUE(coverage.has_value());
  if (coverage.has_value()) {
    EXPECT_RECT_NEAR(coverage.value(), Rect::MakeLTRB(99, 99, 201, 201));
  }
}

References EXPECT_RECT_NEAR, impeller::GaussianBlurFilterContents::GetFilterCoverage(), impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), fml::StatusOr< T >::ok(), impeller::Entity::SetTransform(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [540/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverage
	)

Definition at line 265 of file gaussian_blur_filter_contents_unittests.cc.

                                                                         {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(contents_coverage.value(),
                           Rect::MakeLTRB(-1, -1, 101, 101)));
      EXPECT_TRUE(
          RectNear(result_coverage.value(), Rect::MakeLTRB(-1, -1, 101, 101)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), fml::StatusOr< T >::ok(), RectNear(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [541/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageRotated
	)

Definition at line 330 of file gaussian_blur_filter_contents_unittests.cc.

                                                {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(400, 300));
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  // Rotate around the top left corner, then push it over to (100, 100).
  entity.SetTransform(Matrix::MakeTranslation({400, 100, 0}) *
                      Matrix::MakeRotationZ(Degrees(90.0)));
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(contents_coverage.value(),
                           Rect::MakeLTRB(99, 99, 401, 501)));
      EXPECT_TRUE(
          RectNear(result_coverage.value(), Rect::MakeLTRB(99, 99, 401, 501)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), RectNear(), impeller::Entity::SetTransform(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [542/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 296 of file gaussian_blur_filter_contents_unittests.cc.

                                                  {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  ASSERT_TRUE(sigma_radius_1.ok());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture)});
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
 
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(contents_coverage.value(),
                           Rect::MakeLTRB(99, 199, 201, 301)));
      EXPECT_TRUE(
          RectNear(result_coverage.value(), Rect::MakeLTRB(99, 199, 201, 301)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeTranslation(), fml::StatusOr< T >::ok(), RectNear(), impeller::Entity::SetTransform(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [543/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRect
	)

Definition at line 377 of file gaussian_blur_filter_contents_unittests.cc.

                                                                           {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  auto texture_contents = std::make_shared<TextureContents>();
  texture_contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
  texture_contents->SetTexture(texture);
  texture_contents->SetDestinationRect(Rect::MakeXYWH(
      50, 40, texture->GetSize().width, texture->GetSize().height));
 
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
      EXPECT_TRUE(RectNear(result_coverage.value(),
                           Rect::MakeLTRB(49.f, 39.f, 151.f, 141.f)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeLTRB(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), RectNear(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [544/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithDestinationRectScaled
	)

Definition at line 412 of file gaussian_blur_filter_contents_unittests.cc.

                                                 {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  auto texture_contents = std::make_shared<TextureContents>();
  texture_contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
  texture_contents->SetTexture(texture);
  texture_contents->SetDestinationRect(Rect::MakeXYWH(
      50, 40, texture->GetSize().width, texture->GetSize().height));
 
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, Matrix());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  entity.SetTransform(Matrix::MakeScale({2.0, 2.0, 1.0}));
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
      // Scaling a blurred entity doesn't seem to scale the blur radius linearly
      // when comparing results with rrect_blur. That's why this is not
      // Rect::MakeXYWH(98.f, 78.f, 204.0f, 204.f).
      EXPECT_TRUE(RectNear(contents_coverage.value(),
                           Rect::MakeXYWH(94.f, 74.f, 212.0f, 212.f)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), RectNear(), impeller::Entity::SetTransform(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [545/662]

impeller::testing::TEST_P	(	GaussianBlurFilterContentsTest	,
		TextureContentsWithEffectTransform
	)

Definition at line 452 of file gaussian_blur_filter_contents_unittests.cc.

                                                                           {
  Matrix effect_transform = Matrix::MakeScale({2.0, 2.0, 1.0});
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  auto texture_contents = std::make_shared<TextureContents>();
  texture_contents->SetSourceRect(Rect::MakeSize(texture->GetSize()));
  texture_contents->SetTexture(texture);
  texture_contents->SetDestinationRect(Rect::MakeXYWH(
      50, 40, texture->GetSize().width, texture->GetSize().height));
 
  fml::StatusOr<Scalar> sigma_radius_1 =
      CalculateSigmaForBlurRadius(1.0, effect_transform);
  ASSERT_TRUE(sigma_radius_1.ok());
  auto contents = std::make_unique<GaussianBlurFilterContents>(
      sigma_radius_1.value(), sigma_radius_1.value(), Entity::TileMode::kDecal,
      /*bounds=*/std::nullopt, FilterContents::BlurStyle::kNormal,
      /*mask_geometry=*/nullptr);
  contents->SetInputs({FilterInput::Make(texture_contents)});
  contents->SetEffectTransform(effect_transform);
  ContentContext& renderer = GetContentContext();
 
  Entity entity;
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
  EXPECT_TRUE(result.has_value());
  if (result.has_value()) {
    EXPECT_EQ(result.value().GetBlendMode(), BlendMode::kSrcOver);
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    EXPECT_TRUE(result_coverage.has_value());
    EXPECT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(result_coverage.value(), contents_coverage.value()));
      EXPECT_TRUE(RectNear(contents_coverage.value(),
                           Rect::MakeXYWH(49.f, 39.f, 102.f, 102.f)));
    }
  }
}

References impeller::Entity::kDecal, impeller::FilterContents::kNormal, impeller::kSrcOver, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeSize(), impeller::TRect< Scalar >::MakeXYWH(), fml::StatusOr< T >::ok(), RectNear(), texture, and fml::StatusOr< T >::value().

◆ TEST_P() [546/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplace
	)

Definition at line 36 of file host_buffer_unittests.cc.

                                   {
  struct Length2 {
    uint8_t pad[2];
  };
  static_assert(sizeof(Length2) == 2u);
 
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  for (size_t i = 0; i < 12500; i++) {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.GetRange(), Range(i * sizeof(Length2), 2u));
  }
}

References flutter::buffer, impeller::HostBuffer::Create(), i, and view.

◆ TEST_P() [547/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		CanEmplaceWithAlignment
	)

Definition at line 52 of file host_buffer_unittests.cc.

                                                {
  struct Length2 {
    uint8_t pad[2];
  };
  static_assert(sizeof(Length2) == 2);
  struct alignas(16) Align16 {
    uint8_t pad[2];
  };
  static_assert(alignof(Align16) == 16);
  static_assert(sizeof(Align16) == 16);
 
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
  ASSERT_TRUE(buffer);
 
  {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.GetRange(), Range(0u, 2u));
  }
 
  {
    auto view = buffer->Emplace(Align16{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.GetRange().offset, 16u);
    ASSERT_EQ(view.GetRange().length, 16u);
  }
  {
    auto view = buffer->Emplace(Length2{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.GetRange(), Range(32u, 2u));
  }
 
  {
    auto view = buffer->Emplace(Align16{});
    ASSERT_TRUE(view);
    ASSERT_EQ(view.GetRange().offset, 48u);
    ASSERT_EQ(view.GetRange().length, 16u);
  }
}

References flutter::buffer, impeller::HostBuffer::Create(), and view.

◆ TEST_P() [548/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		CompletedEntriesAreReusedWithoutTrackerChurn
	)

Definition at line 262 of file host_buffer_unittests.cc.

                                                                     {
  auto tracker = std::make_shared<GpuSubmissionTracker>();
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256, tracker);
 
  // Simulate frames whose GPU work completes promptly. Entries must be
  // reused, not replaced.
  const DeviceBuffer* entry = buffer->EmplaceUniform(0.0f).GetBuffer();
  for (size_t i = 0; i < kHostBufferArenaSize * 3; i++) {
    tracker->RecordCompletion(tracker->RecordSubmission());
    buffer->Reset();
  }
  EXPECT_EQ(buffer->EmplaceUniform(0.0f).GetBuffer(), entry);
}

References flutter::buffer, impeller::HostBuffer::Create(), i, and impeller::kHostBufferArenaSize.

◆ TEST_P() [549/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplaceWithFailingAllocationDoesntCrash
	)

Definition at line 277 of file host_buffer_unittests.cc.

                                                                {
  ScopedValidationDisable disable;
  std::shared_ptr<FailingAllocator> allocator =
      std::make_shared<FailingAllocator>(GetContext()->GetResourceAllocator());
  auto buffer =
      HostBuffer::Create(allocator, GetContext()->GetIdleWaiter(), 256);
 
  auto view = buffer->Emplace(nullptr, kMagicFailingAllocation, 0);
 
  EXPECT_EQ(view.GetBuffer(), nullptr);
  EXPECT_EQ(view.GetRange().offset, 0u);
  EXPECT_EQ(view.GetRange().length, 0u);
}

References allocator, flutter::buffer, impeller::HostBuffer::Create(), kMagicFailingAllocation, and view.

◆ TEST_P() [550/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplaceWithProcIsAligned
	)

Definition at line 180 of file host_buffer_unittests.cc.

                                                 {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  BufferView view = buffer->Emplace(std::array<char, 21>());
  EXPECT_EQ(view.GetRange(), Range(0, 21));
 
  view = buffer->Emplace(64, 16, [](uint8_t*) {});
  EXPECT_EQ(view.GetRange(), Range(32, 64));
}

References flutter::buffer, impeller::HostBuffer::Create(), and view.

◆ TEST_P() [551/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBuffer
	)

Definition at line 135 of file host_buffer_unittests.cc.

                                                                        {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  // Emplace an amount larger than the block size, to verify that the host
  // buffer does not create a buffer.
  auto buffer_view = buffer->Emplace(nullptr, 1024000 + 10, 0);
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
}

References flutter::buffer, and impeller::HostBuffer::Create().

◆ TEST_P() [552/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		EmplacingLargerThanBlockSizeCreatesOneOffBufferCallback
	)

Definition at line 121 of file host_buffer_unittests.cc.

                                                                {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  // Emplace an amount larger than the block size, to verify that the host
  // buffer does not create a buffer.
  auto buffer_view = buffer->Emplace(1024000 + 10, 0, [](uint8_t* data) {});
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
}

References flutter::buffer, impeller::HostBuffer::Create(), and flutter::data.

◆ TEST_P() [553/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		HostBufferInitialState
	)

Definition at line 93 of file host_buffer_unittests.cc.

                                               {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
}

References flutter::buffer, and impeller::HostBuffer::Create().

◆ TEST_P() [554/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		IdleWaiter
	)

Definition at line 27 of file host_buffer_unittests.cc.

                                   {
  auto mock_idle_waiter = std::make_shared<MockIdleWaiter>();
  {
    auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                     mock_idle_waiter, 256);
    EXPECT_CALL(*mock_idle_waiter, WaitIdle());
  }
}

References flutter::buffer, and impeller::HostBuffer::Create().

◆ TEST_P() [555/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		PendingEntriesAreReplacedNotReused
	)

Definition at line 238 of file host_buffer_unittests.cc.

                                                           {
  auto tracker = std::make_shared<GpuSubmissionTracker>();
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256, tracker);
 
  // Write to the first arena entry and pretend its GPU work never completes.
  const DeviceBuffer* first_entry = buffer->EmplaceUniform(0.0f).GetBuffer();
  uint64_t pending = tracker->RecordSubmission();
  for (size_t i = 0; i < kHostBufferArenaSize; i++) {
    buffer->Reset();
  }
 
  // The entry must be replaced with a fresh allocation.
  EXPECT_NE(buffer->EmplaceUniform(0.0f).GetBuffer(), first_entry);
 
  // Once completed, entries are reused in place.
  tracker->RecordCompletion(pending);
  const DeviceBuffer* second_entry = buffer->EmplaceUniform(0.0f).GetBuffer();
  for (size_t i = 0; i < kHostBufferArenaSize; i++) {
    buffer->Reset();
  }
  EXPECT_EQ(buffer->EmplaceUniform(0.0f).GetBuffer(), second_entry);
}

References flutter::buffer, impeller::HostBuffer::Create(), i, and impeller::kHostBufferArenaSize.

◆ TEST_P() [556/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		ResetIncrementsFrameCounter
	)

Definition at line 102 of file host_buffer_unittests.cc.

                                                    {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
 
  buffer->Reset();
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 1u);
 
  buffer->Reset();
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 2u);
 
  buffer->Reset();
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 3u);
 
  buffer->Reset();
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
}

References flutter::buffer, and impeller::HostBuffer::Create().

◆ TEST_P() [557/662]

impeller::testing::TEST_P	(	HostBufferTest	,
		UnusedBuffersAreDiscardedWhenResetting
	)

Definition at line 148 of file host_buffer_unittests.cc.

                                                               {
  auto buffer = HostBuffer::Create(GetContext()->GetResourceAllocator(),
                                   GetContext()->GetIdleWaiter(), 256);
 
  // Emplace two large allocations to force the allocation of a second buffer.
  auto buffer_view_a = buffer->Emplace(1020000, 0, [](uint8_t* data) {});
  auto buffer_view_b = buffer->Emplace(1020000, 0, [](uint8_t* data) {});
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 1u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 2u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
 
  // Reset until we get back to this frame.
  for (auto i = 0; i < 4; i++) {
    buffer->Reset();
  }
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 2u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
 
  // Now when we reset, the buffer should get dropped.
  // Reset until we get back to this frame.
  for (auto i = 0; i < 4; i++) {
    buffer->Reset();
  }
 
  EXPECT_EQ(buffer->GetStateForTest().current_buffer, 0u);
  EXPECT_EQ(buffer->GetStateForTest().total_buffer_count, 1u);
  EXPECT_EQ(buffer->GetStateForTest().current_frame, 0u);
}

References flutter::buffer, impeller::HostBuffer::Create(), flutter::data, and i.

◆ TEST_P() [558/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassScale
	)

Definition at line 175 of file matrix_filter_contents_unittests.cc.

                                                            {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
  contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
  contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
  contents.SetRenderingMode(
      Entity::RenderingMode::kSubpassAppendSnapshotTransform);
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 300, 300));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassAppendSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [559/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageClippedSubpassTranslate
	)

Definition at line 138 of file matrix_filter_contents_unittests.cc.

                                                                {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
  contents.SetMatrix(Matrix::MakeTranslation({50, 100, 0}));
  contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
  contents.SetRenderingMode(
      Entity::RenderingMode::kSubpassAppendSnapshotTransform);
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(200, 400, 100, 100));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassAppendSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [560/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageIdentity
	)

Definition at line 106 of file matrix_filter_contents_unittests.cc.

                                                                           {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 100, 100));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetInputs(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [561/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageScale
	)

Definition at line 158 of file matrix_filter_contents_unittests.cc.

                                                                        {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
  contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
  contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(100, 200, 300, 300));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [562/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageSubpassScale
	)

Definition at line 195 of file matrix_filter_contents_unittests.cc.

                                                                               {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
  contents.SetMatrix(Matrix::MakeScale({3, 3, 1}));
  contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
  contents.SetRenderingMode(
      Entity::RenderingMode::kSubpassPrependSnapshotTransform);
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(300, 600, 300, 300));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::MatrixFilterContents::SetRenderingMode(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [563/662]

impeller::testing::TEST_P	(	MatrixFilterContentsTest	,
		RenderCoverageMatchesGetCoverageTranslate
	)

Definition at line 121 of file matrix_filter_contents_unittests.cc.

                                                                            {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  MatrixFilterContents contents;
  contents.SetInputs({FilterInput::Make(texture)});
  contents.SetMatrix(Matrix::MakeTranslation({50, 100, 0}));
  contents.SetEffectTransform(Matrix::MakeScale({2, 2, 1}));
 
  Entity entity;
  entity.SetTransform(Matrix::MakeTranslation({100, 200, 0}));
 
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents.GetEntity(renderer, entity, /*coverage_hint=*/{});
  expectRenderCoverageEqual(result, contents.GetCoverage(entity),
                            Rect::MakeXYWH(150, 300, 100, 100));
}

References impeller::FilterContents::GetCoverage(), impeller::FilterContents::GetEntity(), impeller::FilterInput::Make(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), impeller::FilterContents::SetEffectTransform(), impeller::FilterContents::SetInputs(), impeller::MatrixFilterContents::SetMatrix(), impeller::Entity::SetTransform(), and texture.

◆ TEST_P() [564/662]

impeller::testing::TEST_P	(	MorphologyFilterContentsTest	,
		RenderCoverageMatchesGetCoverage
	)

Definition at line 44 of file morphology_filter_contents_unittests.cc.

                                                                       {
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  ASSERT_NE(texture, nullptr);
  auto contents = FilterContents::MakeDirectionalMorphology(
      FilterInput::Make(texture), Radius{2.0}, Vector2(1, 0),
      FilterContents::MorphType::kDilate);
 
  Entity entity;
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
 
  ASSERT_TRUE(result.has_value());
  if (result.has_value()) {
    std::optional<Rect> result_coverage = result.value().GetCoverage();
    std::optional<Rect> contents_coverage = contents->GetCoverage(entity);
    Rect expected = Rect::MakeLTRB(-2, 0, 102, 100);
    ASSERT_TRUE(result_coverage.has_value());
    ASSERT_TRUE(contents_coverage.has_value());
    if (result_coverage.has_value() && contents_coverage.has_value()) {
      EXPECT_TRUE(RectNear(result_coverage.value(), expected));
      EXPECT_TRUE(RectNear(contents_coverage.value(), expected));
    }
  }
}

References impeller::FilterContents::kDilate, impeller::FilterInput::Make(), impeller::FilterContents::MakeDirectionalMorphology(), impeller::TRect< Scalar >::MakeLTRB(), RectNear(), and texture.

◆ TEST_P() [565/662]

impeller::testing::TEST_P	(	MorphologyFilterContentsTest	,
		RenderDilateWithFractionalCoverageIsSymmetric
	)

Definition at line 70 of file morphology_filter_contents_unittests.cc.

                                                      {
  // Non-integer scale and radius produce a fractional pixel expansion
  // 1.5 * 2.625 = 3.9375, exercising the render target ceiling logic.
  Scalar radius = 1.5;
  Scalar scale = 2.625;
 
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  ASSERT_NE(texture, nullptr);
  auto contents = FilterContents::MakeDirectionalMorphology(
      FilterInput::Make(texture), Radius{radius}, Vector2(1, 0),
      FilterContents::MorphType::kDilate);
  contents->SetEffectTransform(Matrix::MakeScale(Vector2(scale, scale)));
 
  Entity entity;
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
 
  ASSERT_TRUE(result.has_value());
  if (result.has_value()) {
    std::optional<Rect> result_coverage = result->GetCoverage();
    ASSERT_TRUE(result_coverage.has_value());
    if (result_coverage.has_value()) {
      Scalar expected_expansion = radius * scale;
      EXPECT_TRUE(result_coverage->Contains(Rect::MakeLTRB(
          -expected_expansion, 0, 100 + expected_expansion, 100)));
      Scalar left_expansion = 0 - result_coverage->GetLeft();
      Scalar right_expansion = result_coverage->GetRight() - 100;
      EXPECT_NEAR(left_expansion, right_expansion, 0.5);
    }
  }
}

References impeller::FilterContents::kDilate, impeller::FilterInput::Make(), impeller::FilterContents::MakeDirectionalMorphology(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), and texture.

◆ TEST_P() [566/662]

impeller::testing::TEST_P	(	MorphologyFilterContentsTest	,
		RenderDilateYWithFractionalCoverageIsSymmetric
	)

Definition at line 104 of file morphology_filter_contents_unittests.cc.

                                                       {
  // Non-integer scale and radius produce a fractional pixel expansion
  // 1.5 * 2.625 = 3.9375, exercising the render target ceiling logic.
  Scalar radius = 1.5;
  Scalar scale = 2.625;
 
  std::shared_ptr<Texture> texture = MakeTexture(ISize(100, 100));
  ASSERT_NE(texture, nullptr);
  auto contents = FilterContents::MakeDirectionalMorphology(
      FilterInput::Make(texture), Radius{radius}, Vector2(0, 1),
      FilterContents::MorphType::kDilate);
  contents->SetEffectTransform(Matrix::MakeScale(Vector2(scale, scale)));
 
  Entity entity;
  ContentContext& renderer = GetContentContext();
  std::optional<Entity> result =
      contents->GetEntity(renderer, entity, /*coverage_hint=*/{});
 
  ASSERT_TRUE(result.has_value());
  if (result.has_value()) {
    std::optional<Rect> result_coverage = result->GetCoverage();
    ASSERT_TRUE(result_coverage.has_value());
    if (result_coverage.has_value()) {
      Scalar expected_expansion = radius * scale;
      EXPECT_TRUE(result_coverage->Contains(Rect::MakeLTRB(
          0, -expected_expansion, 100, 100 + expected_expansion)));
      Scalar top_expansion = 0 - result_coverage->GetTop();
      Scalar bottom_expansion = result_coverage->GetBottom() - 100;
      EXPECT_NEAR(top_expansion, bottom_expansion, 0.5);
    }
  }
}

References impeller::FilterContents::kDilate, impeller::FilterInput::Make(), impeller::FilterContents::MakeDirectionalMorphology(), impeller::TRect< Scalar >::MakeLTRB(), impeller::Matrix::MakeScale(), and texture.

◆ TEST_P() [567/662]

impeller::testing::TEST_P	(	PipelineCacheDataVKPlaygroundTest	,
		CanPersistAndRetrievePipelineCache
	)

Definition at line 117 of file pipeline_cache_data_vk_unittests.cc.

                                                                              {
  fml::ScopedTemporaryDirectory temp_dir;
  const auto& surface_context = SurfaceContextVK::Cast(*GetContext());
  const auto& context_vk = ContextVK::Cast(*surface_context.GetParent());
  const auto& caps = CapabilitiesVK::Cast(*context_vk.GetCapabilities());
 
  {
    auto cache = context_vk.GetDevice().createPipelineCacheUnique({});
    ASSERT_EQ(cache.result, vk::Result::eSuccess);
    ASSERT_FALSE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
    ASSERT_TRUE(PipelineCacheDataPersist(
        temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
  }
  ASSERT_TRUE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
 
  auto mapping = PipelineCacheDataRetrieve(temp_dir.fd(),
                                           caps.GetPhysicalDeviceProperties());
  ASSERT_NE(mapping, nullptr);
  // Assert that the utility has stripped away the cache header giving us clean
  // pipeline cache bootstrap information.
  vk::PipelineCacheHeaderVersionOne vk_cache_header;
  ASSERT_GE(mapping->GetSize(), sizeof(vk_cache_header));
  std::memcpy(&vk_cache_header, mapping->GetMapping(), sizeof(vk_cache_header));
  ASSERT_EQ(vk_cache_header.headerVersion,
            vk::PipelineCacheHeaderVersion::eOne);
}

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::BackendCast< ContextVK, Context >::Cast(), impeller::BackendCast< SurfaceContextVK, Context >::Cast(), fml::ScopedTemporaryDirectory::fd(), fml::FileExists(), impeller::PipelineCacheDataPersist(), and impeller::PipelineCacheDataRetrieve().

◆ TEST_P() [568/662]

impeller::testing::TEST_P	(	PipelineCacheDataVKPlaygroundTest	,
		IntegrityChecksArePerformedOnPersistedData
	)

Definition at line 144 of file pipeline_cache_data_vk_unittests.cc.

                                                   {
  fml::ScopedTemporaryDirectory temp_dir;
  const auto& surface_context = SurfaceContextVK::Cast(*GetContext());
  const auto& context_vk = ContextVK::Cast(*surface_context.GetParent());
  const auto& caps = CapabilitiesVK::Cast(*context_vk.GetCapabilities());
 
  {
    auto cache = context_vk.GetDevice().createPipelineCacheUnique({});
    ASSERT_EQ(cache.result, vk::Result::eSuccess);
    ASSERT_FALSE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
    ASSERT_TRUE(PipelineCacheDataPersist(
        temp_dir.fd(), caps.GetPhysicalDeviceProperties(), cache.value));
  }
  ASSERT_TRUE(fml::FileExists(temp_dir.fd(), "flutter.impeller.vkcache"));
  auto incompatible_caps = caps.GetPhysicalDeviceProperties();
  // Simulate a driver version bump.
  incompatible_caps.driverVersion =
      caps.GetPhysicalDeviceProperties().driverVersion + 1u;
  auto mapping = PipelineCacheDataRetrieve(temp_dir.fd(), incompatible_caps);
  ASSERT_EQ(mapping, nullptr);
}

References impeller::BackendCast< CapabilitiesVK, Capabilities >::Cast(), impeller::BackendCast< ContextVK, Context >::Cast(), impeller::BackendCast< SurfaceContextVK, Context >::Cast(), fml::ScopedTemporaryDirectory::fd(), fml::FileExists(), impeller::PipelineCacheDataPersist(), and impeller::PipelineCacheDataRetrieve().

◆ TEST_P() [569/662]

impeller::testing::TEST_P	(	PipelineLibraryGLESTest	,
		ChangingSpecConstantsCausesNewProgramObject
	)

Definition at line 46 of file pipeline_library_gles_unittests.cc.

                                                                             {
  using VS = SpecConstantVertexShader;
  using FS = SpecConstantFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  desc->SetSpecializationConstants({2.0f});
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
  auto new_desc = desc;
  // Changing the spec. constants should result in a new program object.
  new_desc->SetSpecializationConstants({4.0f});
  auto new_pipeline =
      context->GetPipelineLibrary()->GetPipeline(new_desc).Get();
  ASSERT_TRUE(new_pipeline && new_pipeline->IsValid());
  const auto& pipeline_gles = PipelineGLES::Cast(*pipeline);
  const auto& new_pipeline_gles = PipelineGLES::Cast(*new_pipeline);
  // The program handles should be live and equal.
  ASSERT_FALSE(pipeline_gles.GetProgramHandle().IsDead());
  ASSERT_FALSE(new_pipeline_gles.GetProgramHandle().IsDead());
  ASSERT_FALSE(pipeline_gles.GetProgramHandle().GetName().value() ==
               new_pipeline_gles.GetProgramHandle().GetName().value());
}

References impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::Cast(), context, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), and pipeline.

◆ TEST_P() [570/662]

impeller::testing::TEST_P	(	PipelineLibraryGLESTest	,
		ClearingPipelineWillAlsoClearProgramHandle
	)

Definition at line 71 of file pipeline_library_gles_unittests.cc.

                                                                            {
  using VS = SpecConstantVertexShader;
  using FS = SpecConstantFragmentShader;
  std::shared_ptr<Context> context = GetContext();
  std::optional<PipelineDescriptor> desc =
      PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
 
  std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline =
      context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
  const auto& pipeline_gles = PipelineGLES::Cast(*pipeline);
  HandleGLES handle = pipeline_gles.GetProgramHandle();
 
  // Clear the pipeline descriptor.
  auto entrypoint =
      pipeline->GetDescriptor().GetEntrypointForStage(ShaderStage::kFragment);
  context->GetPipelineLibrary()->RemovePipelinesWithEntryPoint(entrypoint);
 
  // Re-create the pipeline
  std::shared_ptr<Pipeline<PipelineDescriptor>> pipeline_2 =
      context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
  const auto& pipeline_gles_2 = PipelineGLES::Cast(*pipeline_2);
  HandleGLES handle_2 = pipeline_gles_2.GetProgramHandle();
 
  EXPECT_FALSE(HandleGLES::Equal{}(handle, handle_2));
}

References impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::Cast(), context, impeller::kFragment, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), and pipeline.

◆ TEST_P() [571/662]

impeller::testing::TEST_P	(	PipelineLibraryGLESTest	,
		ProgramHandlesAreReused
	)

Definition at line 19 of file pipeline_library_gles_unittests.cc.

                                                         {
  using VS = SpecConstantVertexShader;
  using FS = SpecConstantFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
  auto new_desc = desc;
  // Changing the sample counts should not result in a new program object.
  new_desc->SetSampleCount(SampleCount::kCount4);
  // Make sure we don't hit the top-level descriptor cache. This will cause
  // caching irrespective of backends.
  ASSERT_FALSE(desc->IsEqual(new_desc.value()));
  auto new_pipeline =
      context->GetPipelineLibrary()->GetPipeline(new_desc).Get();
  ASSERT_TRUE(new_pipeline && new_pipeline->IsValid());
  const auto& pipeline_gles = PipelineGLES::Cast(*pipeline);
  const auto& new_pipeline_gles = PipelineGLES::Cast(*new_pipeline);
  // The program handles should be live and equal.
  ASSERT_FALSE(pipeline_gles.GetProgramHandle().IsDead());
  ASSERT_FALSE(new_pipeline_gles.GetProgramHandle().IsDead());
  ASSERT_EQ(pipeline_gles.GetProgramHandle().GetName().value(),
            new_pipeline_gles.GetProgramHandle().GetName().value());
}

References impeller::BackendCast< PipelineGLES, Pipeline< PipelineDescriptor > >::Cast(), context, impeller::kCount4, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), and pipeline.

◆ TEST_P() [572/662]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateRenderPassAndSubmit
	)

Definition at line 317 of file renderer_dart_unittests.cc.

                                                       {
  ASSERT_TRUE(RenderDartToPlayground("canCreateRenderPassAndSubmit"));
}

◆ TEST_P() [573/662]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanCreateShaderLibrary
	)

Definition at line 309 of file renderer_dart_unittests.cc.

                                                 {
  ASSERT_TRUE(RunDartFunction("canCreateShaderLibrary"));
}

◆ TEST_P() [574/662]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanInstantiateFlutterGPUContext
	)

These test entries correspond to Dart functions located in flutter/impeller/fixtures/dart_tests.dart

Definition at line 305 of file renderer_dart_unittests.cc.

                                                          {
  ASSERT_TRUE(RunDartFunction("instantiateDefaultContext"));
}

◆ TEST_P() [575/662]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanReflectUniformStructs
	)

Definition at line 313 of file renderer_dart_unittests.cc.

                                                   {
  ASSERT_TRUE(RunDartFunction("canReflectUniformStructs"));
}

◆ TEST_P() [576/662]

impeller::testing::TEST_P	(	RendererDartTest	,
		CanRunDartInPlaygroundFrame
	)

Definition at line 288 of file renderer_dart_unittests.cc.

                                                      {
  SinglePassCallback callback = [&](RenderPass& pass) {
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Dart test", nullptr);
      ImGui::Text(
          "This test executes Dart code during the playground frame callback.");
      ImGui::End();
    }
 
    return RunDartFunction("sayHi");
  };
  ASSERT_TRUE(OpenPlaygroundHere(callback));
}

References callback.

◆ TEST_P() [577/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		BabysFirstTriangle
	)

Definition at line 56 of file renderer_golden_unittests.cc.

                                               {
  using VS = BabyVertexShader;
  using FS = BabyFragmentShader;
 
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
 
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline);
 
  VertexBufferBuilder<VS::PerVertexData> vertex_buffer_builder;
  vertex_buffer_builder.AddVertices({
      {{-0.5, -0.5}, Color::Red(), Color::Green()},
      {{0.0, 0.5}, Color::Green(), Color::Blue()},
      {{0.5, -0.5}, Color::Blue(), Color::Red()},
  });
  auto vertex_buffer = vertex_buffer_builder.CreateVertexBuffer(
      *context->GetResourceAllocator());
 
  auto host_buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
 
  ASSERT_TRUE(OpenPlaygroundHere([&](RenderPass& pass) -> bool {
    // The harness runs the callback once per pass; start each from a clean
    // host buffer.
    host_buffer->Reset();
    pass.SetPipeline(pipeline);
    pass.SetVertexBuffer(vertex_buffer);
 
    FS::FragInfo frag_info;
    frag_info.time = 0.0f;
    FS::BindFragInfo(pass, host_buffer->EmplaceUniform(frag_info));
 
    return pass.Draw().ok();
  }));
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::Color::Blue(), context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::RenderPass::Draw(), impeller::Color::Green(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), fml::Status::ok(), pipeline, impeller::Color::Red(), impeller::RenderPass::SetPipeline(), and impeller::RenderPass::SetVertexBuffer().

◆ TEST_P() [578/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanRenderASTCCompressedTexture
	)

Definition at line 338 of file renderer_golden_unittests.cc.

                                                           {
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
  if (!context->GetCapabilities()->SupportsTextureCompression(
          CompressedTextureFamily::kASTC)) {
    GTEST_SKIP() << "Backend does not support ASTC texture compression.";
  }
 
  // An ASTC void-extent block encodes one constant color directly: the 0xFC
  // 0xFD header marks a 2D LDR void-extent with the "no extent" sentinel
  // coordinates (all ones), followed by four little-endian UNORM16 channels
  // (R, G, B, A). Alpha is opaque.
  auto astc_solid_block = [](uint16_t r, uint16_t g,
                             uint16_t b) -> std::array<uint8_t, 16> {
    return {{0xFC, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
             static_cast<uint8_t>(r & 0xFF), static_cast<uint8_t>(r >> 8),
             static_cast<uint8_t>(g & 0xFF), static_cast<uint8_t>(g >> 8),
             static_cast<uint8_t>(b & 0xFF), static_cast<uint8_t>(b >> 8), 0xFF,
             0xFF}};
  };
  // Red, green, blue, white.
  const std::array<std::array<uint8_t, 16>, 4> blocks = {
      {astc_solid_block(0xFFFF, 0, 0), astc_solid_block(0, 0xFFFF, 0),
       astc_solid_block(0, 0, 0xFFFF),
       astc_solid_block(0xFFFF, 0xFFFF, 0xFFFF)}};
  std::vector<uint8_t> data;
  for (const auto& block : blocks) {
    data.insert(data.end(), block.begin(), block.end());
  }
 
  DrawCompressedTextureGolden(*this, PixelFormat::kASTC4x4LDR, data,
                              ISize{8, 8});
}

References context, flutter::data, DrawCompressedTextureGolden(), impeller::kASTC, and impeller::kASTC4x4LDR.

◆ TEST_P() [579/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanRenderBC1CompressedTexture
	)

Definition at line 270 of file renderer_golden_unittests.cc.

                                                          {
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
  if (!context->GetCapabilities()->SupportsTextureCompression(
          CompressedTextureFamily::kBC)) {
    GTEST_SKIP() << "Backend does not support BC texture compression.";
  }
 
  // A solid-color BC1 block stores the color in both RGB565 endpoints with
  // all-zero selector bits, which decodes to a single opaque color.
  auto bc1_solid_block = [](uint16_t rgb565) -> std::array<uint8_t, 8> {
    const auto lo = static_cast<uint8_t>(rgb565 & 0xFF);
    const auto hi = static_cast<uint8_t>(rgb565 >> 8);
    return {{lo, hi, lo, hi, 0, 0, 0, 0}};
  };
  // RGB565: red, green, blue, white.
  const std::array<std::array<uint8_t, 8>, 4> blocks = {
      {bc1_solid_block(0xF800), bc1_solid_block(0x07E0),
       bc1_solid_block(0x001F), bc1_solid_block(0xFFFF)}};
  std::vector<uint8_t> data;
  for (const auto& block : blocks) {
    data.insert(data.end(), block.begin(), block.end());
  }
 
  DrawCompressedTextureGolden(*this, PixelFormat::kBC1RGBAUNormInt, data,
                              ISize{8, 8});
}

References context, flutter::data, DrawCompressedTextureGolden(), impeller::kBC, and impeller::kBC1RGBAUNormInt.

◆ TEST_P() [580/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanRenderETC2CompressedTexture
	)

Definition at line 302 of file renderer_golden_unittests.cc.

                                                           {
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
  if (!context->GetCapabilities()->SupportsTextureCompression(
          CompressedTextureFamily::kETC2)) {
    GTEST_SKIP() << "Backend does not support ETC2 texture compression.";
  }
 
  // A solid-color ETC2 RGB8 block in "individual" mode (differential bit 0,
  // which decodes like ETC1). The 64-bit block is laid out big-endian (byte 0
  // most significant): byte 0 = R nibbles (R1,R2), byte 1 = G, byte 2 = B,
  // byte 3 = codeword/diff/flip bits (all 0), bytes 4..7 = the two pixel-index
  // bit planes. Both sub-blocks share the base color and every texel uses index
  // 0 (all-zero planes), so the block is one flat color.
  auto etc2_solid_block = [](uint8_t r, uint8_t g,
                             uint8_t b) -> std::array<uint8_t, 8> {
    return {{r, g, b, 0x00, 0x00, 0x00, 0x00, 0x00}};
  };
  // Red, green, blue, white. Each channel byte is 0xFF (nibble 0xF, ~255) or
  // 0x00.
  const std::array<std::array<uint8_t, 8>, 4> blocks = {
      {etc2_solid_block(0xFF, 0x00, 0x00), etc2_solid_block(0x00, 0xFF, 0x00),
       etc2_solid_block(0x00, 0x00, 0xFF), etc2_solid_block(0xFF, 0xFF, 0xFF)}};
  std::vector<uint8_t> data;
  for (const auto& block : blocks) {
    data.insert(data.end(), block.begin(), block.end());
  }
 
  DrawCompressedTextureGolden(*this, PixelFormat::kETC2RGB8UNormInt, data,
                              ISize{8, 8});
}

References context, flutter::data, DrawCompressedTextureGolden(), impeller::kETC2, and impeller::kETC2RGB8UNormInt.

◆ TEST_P() [581/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanRenderInstancedWithVertexAttributes
	)

Definition at line 102 of file renderer_golden_unittests.cc.

                                                                   {
  using VS = InstancedAttributesVertexShader;
  using FS = InstancedAttributesFragmentShader;
 
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
 
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
 
  // Per-instance data is laid out contiguously, one record per instance.
  struct InstanceData {
    Vector2 offset;
    Vector4 color;
  };
 
  // Two vertex bindings: binding 0 carries per-vertex geometry and advances
  // once per vertex; binding 1 carries per-instance data and advances once
  // per instance.
  auto vertex_desc = std::make_shared<VertexDescriptor>();
  ShaderStageIOSlot position_slot = VS::kInputVertexPosition;
  ShaderStageIOSlot offset_slot = VS::kInputInstanceOffset;
  ShaderStageIOSlot color_slot = VS::kInputInstanceColor;
  position_slot.binding = 0;
  position_slot.offset = 0;
  offset_slot.binding = 1;
  offset_slot.offset = offsetof(InstanceData, offset);
  color_slot.binding = 1;
  color_slot.offset = offsetof(InstanceData, color);
  const std::vector<ShaderStageIOSlot> io_slots = {position_slot, offset_slot,
                                                   color_slot};
  const std::vector<ShaderStageBufferLayout> layouts = {
      ShaderStageBufferLayout{.stride = sizeof(Vector2),
                              .binding = 0,
                              .input_rate = VertexInputRate::kVertex},
      ShaderStageBufferLayout{.stride = sizeof(InstanceData),
                              .binding = 1,
                              .input_rate = VertexInputRate::kInstance},
  };
  vertex_desc->RegisterDescriptorSetLayouts(VS::kDescriptorSetLayouts);
  vertex_desc->RegisterDescriptorSetLayouts(FS::kDescriptorSetLayouts);
  vertex_desc->SetStageInputs(io_slots, layouts);
  desc->SetVertexDescriptor(std::move(vertex_desc));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(pipeline);
 
  // A single triangle, drawn once per instance.
  std::array<Vector2, 3> geometry = {
      Vector2{0, 0},
      Vector2{0, 100},
      Vector2{100, 0},
  };
 
  static constexpr size_t kInstanceCount = 4u;
  std::array<InstanceData, kInstanceCount> instances = {
      InstanceData{Vector2{0, 0}, Vector4{1, 0, 0, 1}},
      InstanceData{Vector2{120, 0}, Vector4{0, 1, 0, 1}},
      InstanceData{Vector2{0, 120}, Vector4{0, 0, 1, 1}},
      InstanceData{Vector2{120, 120}, Vector4{1, 1, 0, 1}},
  };
 
  auto geometry_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
      reinterpret_cast<uint8_t*>(geometry.data()),
      geometry.size() * sizeof(Vector2));
  auto instance_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
      reinterpret_cast<uint8_t*>(instances.data()),
      instances.size() * sizeof(InstanceData));
  ASSERT_TRUE(geometry_buffer && instance_buffer);
 
  auto host_buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
 
  ASSERT_TRUE(OpenPlaygroundHere([&](RenderPass& pass) -> bool {
    // The harness runs the callback once per pass; start each from a clean
    // host buffer.
    host_buffer->Reset();
    pass.SetCommandLabel("InstancedAttributes");
    pass.SetPipeline(pipeline);
 
    std::array<BufferView, 2> vertex_buffers = {
        BufferView(geometry_buffer,
                   Range(0, geometry.size() * sizeof(Vector2))),
        BufferView(instance_buffer,
                   Range(0, instances.size() * sizeof(InstanceData))),
    };
    pass.SetVertexBuffer(vertex_buffers.data(), vertex_buffers.size());
    pass.SetElementCount(geometry.size());
    pass.SetInstanceCount(kInstanceCount);
 
    VS::FrameInfo frame_info;
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, host_buffer->EmplaceUniform(frame_info));
 
    return pass.Draw().ok();
  }));
}

References impeller::ShaderStageIOSlot::binding, context, impeller::HostBuffer::Create(), impeller::RenderPass::Draw(), impeller::RenderPass::GetOrthographicTransform(), impeller::kInstance, impeller::kVertex, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeScale(), impeller::ShaderStageIOSlot::offset, fml::Status::ok(), pipeline, impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetElementCount(), impeller::RenderPass::SetInstanceCount(), impeller::RenderPass::SetPipeline(), impeller::RenderPass::SetVertexBuffer(), and impeller::ShaderStageBufferLayout::stride.

◆ TEST_P() [582/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanSampleManuallyMippedTexture
	)

Definition at line 496 of file renderer_golden_unittests.cc.

                                                           {
  DrawManuallyMippedTextureGolden(*this, /*lod=*/0.0f);
}

References DrawManuallyMippedTextureGolden().

◆ TEST_P() [583/662]

impeller::testing::TEST_P	(	RendererGoldenTest	,
		CanSampleManuallyMippedTextureLod1
	)

Definition at line 501 of file renderer_golden_unittests.cc.

                                                               {
  DrawManuallyMippedTextureGolden(*this, /*lod=*/1.0f);
}

References DrawManuallyMippedTextureGolden().

◆ TEST_P() [584/662]

impeller::testing::TEST_P	(	RendererTest	,
		ArrayUniforms
	)

Definition at line 989 of file renderer_unittests.cc.

                                    {
  using VS = ArrayVertexShader;
  using FS = ArrayFragmentShader;
 
  auto context = GetContext();
  auto pipeline_descriptor =
      PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_descriptor.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*pipeline_descriptor));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    auto size = pass.GetRenderTargetSize();
 
    pass.SetPipeline(pipeline);
    pass.SetCommandLabel("Google Dots");
    VertexBufferBuilder<VS::PerVertexData> builder;
    builder.AddVertices({{Point()},
                         {Point(0, size.height)},
                         {Point(size.width, 0)},
                         {Point(size.width, 0)},
                         {Point(0, size.height)},
                         {Point(size.width, size.height)}});
    pass.SetVertexBuffer(
        builder.CreateVertexBuffer(*data_host_buffer, *indexes_host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
 
    auto time = GetSecondsElapsed();
    auto y_pos = [&time](float x) {
      return 400 + 10 * std::cos(time * 5 + x / 6);
    };
 
    FS::FragInfo fs_uniform = {
        .circle_positions = {Point(430, y_pos(0)), Point(480, y_pos(1)),
                             Point(530, y_pos(2)), Point(580, y_pos(3))},
        .colors = {Color::MakeRGBA8(66, 133, 244, 255),
                   Color::MakeRGBA8(219, 68, 55, 255),
                   Color::MakeRGBA8(244, 180, 0, 255),
                   Color::MakeRGBA8(15, 157, 88, 255)},
    };
    FS::BindFragInfo(pass, data_host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw();
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Color::MakeRGBA8(), impeller::Matrix::MakeScale(), pipeline, flutter::size, and x.

◆ TEST_P() [585/662]

impeller::testing::TEST_P	(	RendererTest	,
		AttachmentRejectsOutOfRangeSubresource
	)

Definition at line 1691 of file renderer_unittests.cc.

                                                             {
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
  desc.size = {100, 100};
  desc.mip_count = 2u;
  desc.usage = TextureUsage::kRenderTarget;
  auto texture = context->GetResourceAllocator()->CreateTexture(desc);
  ASSERT_TRUE(texture);
 
  ColorAttachment color0;
  color0.texture = texture;
  color0.load_action = LoadAction::kClear;
  color0.store_action = StoreAction::kStore;
  EXPECT_TRUE(color0.IsValid());
 
  // The out-of-range cases log validation errors on purpose.
  ScopedValidationDisable disable_validation;
 
  color0.mip_level = 2u;  // Only levels 0 and 1 exist.
  EXPECT_FALSE(color0.IsValid());
 
  color0.mip_level = 0u;
  color0.slice = 1u;  // A 2D texture has a single slice.
  EXPECT_FALSE(color0.IsValid());
}

References context, impeller::TextureDescriptor::format, impeller::Attachment::IsValid(), impeller::kClear, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kStore, impeller::Attachment::load_action, impeller::TextureDescriptor::mip_count, impeller::Attachment::mip_level, impeller::TextureDescriptor::size, impeller::Attachment::slice, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [586/662]

impeller::testing::TEST_P	(	RendererTest	,
		BindingNullTexturesDoesNotCrash
	)

Definition at line 1605 of file renderer_unittests.cc.

                                                      {
  using FS = BoxFadeFragmentShader;
 
  auto context = GetContext();
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  auto command_buffer = context->CreateCommandBuffer();
 
  RenderTargetAllocator allocator(context->GetResourceAllocator());
  RenderTarget target = allocator.CreateOffscreen(*context, {1, 1}, 1);
 
  auto pass = command_buffer->CreateRenderPass(target);
  EXPECT_FALSE(FS::BindContents2(*pass, nullptr, sampler));
}

References allocator, command_buffer, context, and target.

◆ TEST_P() [587/662]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebuffer
	)

Definition at line 18 of file render_pass_cache_unittests.cc.

                                                     {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only applies to Vulkan";
  }
 
  auto allocator = std::make_shared<RenderTargetAllocator>(
      GetContext()->GetResourceAllocator());
 
  RenderTarget render_target =
      allocator->CreateOffscreenMSAA(*GetContext(), {100, 100}, 1);
  std::shared_ptr<Texture> resolve_texture =
      render_target.GetColorAttachment(0).resolve_texture;
  TextureVK& texture_vk = TextureVK::Cast(*resolve_texture);
 
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
            nullptr);
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
            nullptr);
 
  auto buffer = GetContext()->CreateCommandBuffer();
  auto render_pass = buffer->CreateRenderPass(render_target);
 
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
            nullptr);
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
            nullptr);
 
  render_pass->EncodeCommands();
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
 
  // Can be reused without error.
  auto buffer_2 = GetContext()->CreateCommandBuffer();
  auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
 
  EXPECT_TRUE(render_pass_2->EncodeCommands());
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
}

References allocator, flutter::buffer, impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount4, impeller::kVulkan, render_pass, impeller::FramebufferAndRenderPass::render_pass, and impeller::Attachment::resolve_texture.

◆ TEST_P() [588/662]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebufferMixed
	)

Definition at line 94 of file render_pass_cache_unittests.cc.

                                                          {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only applies to Vulkan";
  }
 
  auto allocator = std::make_shared<RenderTargetAllocator>(
      GetContext()->GetResourceAllocator());
 
  RenderTarget render_target =
      allocator->CreateOffscreenMSAA(*GetContext(), {100, 100}, 1);
  std::shared_ptr<Texture> resolve_texture =
      render_target.GetColorAttachment(0).resolve_texture;
  TextureVK& texture_vk = TextureVK::Cast(*resolve_texture);
 
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
            nullptr);
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
            nullptr);
 
  auto buffer = GetContext()->CreateCommandBuffer();
  auto render_pass = buffer->CreateRenderPass(render_target);
 
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).framebuffer,
            nullptr);
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount4).render_pass,
            nullptr);
 
  render_pass->EncodeCommands();
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
 
  // Can be reused without error.
  auto buffer_2 = GetContext()->CreateCommandBuffer();
  auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
 
  EXPECT_TRUE(render_pass_2->EncodeCommands());
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
 
  // Now switch to single sample count and demonstrate no validation errors.
  {
    RenderTarget other_target;
    ColorAttachment color0;
    color0.load_action = LoadAction::kLoad;
    color0.store_action = StoreAction::kStore;
    color0.texture = resolve_texture;
    other_target.SetColorAttachment(color0, 0);
    other_target.SetDepthAttachment(std::nullopt);
    other_target.SetStencilAttachment(std::nullopt);
 
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
              nullptr);
    EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
              nullptr);
 
    auto buffer_3 = GetContext()->CreateCommandBuffer();
    auto render_pass_3 = buffer_3->CreateRenderPass(other_target);
 
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
              nullptr);
    EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
              nullptr);
 
    EXPECT_TRUE(render_pass_3->EncodeCommands());
    EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_3}).ok());
  }
}

References allocator, flutter::buffer, impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount1, impeller::kCount4, impeller::kLoad, impeller::kStore, impeller::kVulkan, impeller::Attachment::load_action, render_pass, impeller::FramebufferAndRenderPass::render_pass, impeller::Attachment::resolve_texture, impeller::RenderTarget::SetColorAttachment(), impeller::RenderTarget::SetDepthAttachment(), impeller::RenderTarget::SetStencilAttachment(), impeller::Attachment::store_action, and impeller::Attachment::texture.

◆ TEST_P() [589/662]

impeller::testing::TEST_P	(	RendererTest	,
		CachesRenderPassAndFramebufferNonMSAA
	)

Definition at line 56 of file render_pass_cache_unittests.cc.

                                                            {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only applies to Vulkan";
  }
 
  auto allocator = std::make_shared<RenderTargetAllocator>(
      GetContext()->GetResourceAllocator());
 
  RenderTarget render_target =
      allocator->CreateOffscreen(*GetContext(), {100, 100}, 1);
  std::shared_ptr<Texture> color_texture =
      render_target.GetColorAttachment(0).texture;
  TextureVK& texture_vk = TextureVK::Cast(*color_texture);
 
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
            nullptr);
  EXPECT_EQ(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
            nullptr);
 
  auto buffer = GetContext()->CreateCommandBuffer();
  auto render_pass = buffer->CreateRenderPass(render_target);
 
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).framebuffer,
            nullptr);
  EXPECT_NE(texture_vk.GetCachedFrameData(SampleCount::kCount1).render_pass,
            nullptr);
 
  render_pass->EncodeCommands();
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer}).ok());
 
  // Can be reused without error.
  auto buffer_2 = GetContext()->CreateCommandBuffer();
  auto render_pass_2 = buffer_2->CreateRenderPass(render_target);
 
  EXPECT_TRUE(render_pass_2->EncodeCommands());
  EXPECT_TRUE(GetContext()->GetCommandQueue()->Submit({buffer_2}).ok());
}

References allocator, flutter::buffer, impeller::BackendCast< TextureVK, Texture >::Cast(), impeller::FramebufferAndRenderPass::framebuffer, impeller::TextureVK::GetCachedFrameData(), impeller::RenderTarget::GetColorAttachment(), impeller::kCount1, impeller::kVulkan, render_pass, impeller::FramebufferAndRenderPass::render_pass, and impeller::Attachment::texture.

◆ TEST_P() [590/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToBuffer
	)

Definition at line 607 of file renderer_unittests.cc.

                                             {
  if (GetBackend() == PlaygroundBackend::kOpenGLES ||
      GetBackend() == PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP() << "Mipmap test shader not supported on GLES.";
  }
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  using VS = MipmapsVertexShader;
  using FS = MipmapsFragmentShader;
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto mipmaps_pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(mipmaps_pipeline);
 
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  TextureDescriptor texture_desc;
  texture_desc.storage_mode = StorageMode::kHostVisible;
  texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_desc.size = bridge->GetTextureDescriptor().size;
  texture_desc.mip_count = 1u;
  texture_desc.usage = TextureUsage::kRenderTarget |
                       TextureUsage::kShaderWrite | TextureUsage::kShaderRead;
  DeviceBufferDescriptor device_buffer_desc;
  device_buffer_desc.storage_mode = StorageMode::kHostVisible;
  device_buffer_desc.size =
      bridge->GetTextureDescriptor().GetByteSizeOfBaseMipLevel();
  auto device_buffer =
      context->GetResourceAllocator()->CreateBuffer(device_buffer_desc);
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  auto size = Point(boston->GetSize());
  vertex_builder.AddVertices({
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, 0}, {1.0, 0.0}},       // 2
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, size.y}, {0.0, 1.0}},       // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  Playground::RenderCallback callback = [&](RenderTarget& render_target) {
    {
      auto buffer = context->CreateCommandBuffer();
      if (!buffer) {
        return false;
      }
      buffer->SetLabel("Playground Command Buffer");
      auto pass = buffer->CreateBlitPass();
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Blit Pass");
 
      // Blit `bridge` to the top left corner of the texture.
      pass->AddCopy(bridge, device_buffer);
      pass->EncodeCommands();
 
      if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
        return false;
      }
    }
 
    {
      auto buffer = context->CreateCommandBuffer();
      if (!buffer) {
        return false;
      }
      buffer->SetLabel("Playground Command Buffer");
 
      auto pass = buffer->CreateRenderPass(render_target);
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Render Pass");
      {
        pass->SetCommandLabel("Image");
        pass->SetPipeline(mipmaps_pipeline);
        pass->SetVertexBuffer(vertex_buffer);
 
        VS::FrameInfo frame_info;
        EXPECT_EQ(pass->GetOrthographicTransform(),
                  Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
        frame_info.mvp = pass->GetOrthographicTransform() *
                         Matrix::MakeScale(GetContentScale());
        VS::BindFrameInfo(*pass, data_host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = 0;
        FS::BindFragInfo(*pass, data_host_buffer->EmplaceUniform(frag_info));
 
        raw_ptr<const Sampler> sampler =
            context->GetSamplerLibrary()->GetSampler({});
        auto buffer_view = DeviceBuffer::AsBufferView(device_buffer);
        auto texture =
            context->GetResourceAllocator()->CreateTexture(texture_desc);
        if (!texture->SetContents(device_buffer->OnGetContents(),
                                  buffer_view.GetRange().length)) {
          VALIDATION_LOG << "Could not upload texture to device memory";
          return false;
        }
        FS::BindTex(*pass, texture, sampler);
 
        pass->Draw().ok();
      }
      pass->EncodeCommands();
      if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
        return false;
      }
    }
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::DeviceBuffer::AsBufferView(), flutter::buffer, callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::kHostVisible, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::kShaderWrite, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::TextureDescriptor::mip_count, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::DeviceBufferDescriptor::size, impeller::TextureDescriptor::size, flutter::size, impeller::DeviceBufferDescriptor::storage_mode, impeller::TextureDescriptor::storage_mode, texture, impeller::TextureDescriptor::usage, and VALIDATION_LOG.

◆ TEST_P() [591/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanBlitTextureToTexture
	)

Definition at line 490 of file renderer_unittests.cc.

                                              {
  if (GetBackend() == PlaygroundBackend::kOpenGLES ||
      GetBackend() == PlaygroundBackend::kOpenGLESSDF ||
      GetBackend() == PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Mipmap test shader not supported on GLES or Vulkan.";
  }
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  using VS = MipmapsVertexShader;
  using FS = MipmapsFragmentShader;
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto mipmaps_pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(mipmaps_pipeline);
 
  TextureDescriptor texture_desc;
  texture_desc.storage_mode = StorageMode::kHostVisible;
  texture_desc.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_desc.size = {800, 600};
  texture_desc.mip_count = 1u;
  texture_desc.usage = TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
  auto texture = context->GetResourceAllocator()->CreateTexture(texture_desc);
  ASSERT_TRUE(texture);
 
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  auto size = Point(boston->GetSize());
  vertex_builder.AddVertices({
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, 0}, {1.0, 0.0}},       // 2
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, size.y}, {0.0, 1.0}},       // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  Playground::RenderCallback callback = [&](RenderTarget& render_target) {
    auto buffer = context->CreateCommandBuffer();
    if (!buffer) {
      return false;
    }
    buffer->SetLabel("Playground Command Buffer");
 
    {
      auto pass = buffer->CreateBlitPass();
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Blit Pass");
 
      // Blit `bridge` to the top left corner of the texture.
      // The bridge image is larger than the texture which can fail
      // if Metal validation is enabled as it is in run_tests.py.
      IRect bridge_bounds = IRect::MakeSize(bridge->GetSize());
      IRect texture_bounds = IRect::MakeSize(texture->GetSize());
      std::optional<IRect> blit_bounds =
          bridge_bounds.Intersection(texture_bounds);
      pass->AddCopy(bridge, texture, blit_bounds);
 
      if (!pass->EncodeCommands()) {
        return false;
      }
    }
 
    {
      auto pass = buffer->CreateRenderPass(render_target);
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Render Pass");
      {
        pass->SetCommandLabel("Image");
        pass->SetPipeline(mipmaps_pipeline);
        pass->SetVertexBuffer(vertex_buffer);
 
        VS::FrameInfo frame_info;
        EXPECT_EQ(pass->GetOrthographicTransform(),
                  Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
        frame_info.mvp = pass->GetOrthographicTransform() *
                         Matrix::MakeScale(GetContentScale());
        VS::BindFrameInfo(*pass, data_host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = 0;
        FS::BindFragInfo(*pass, data_host_buffer->EmplaceUniform(frag_info));
 
        auto sampler = context->GetSamplerLibrary()->GetSampler({});
        FS::BindTex(*pass, texture, sampler);
 
        pass->Draw();
      }
      pass->EncodeCommands();
    }
 
    if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
      return false;
    }
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), flutter::buffer, callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::TRect< T >::Intersection(), impeller::kHostVisible, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::kVulkan, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::TRect< T >::MakeSize(), impeller::TextureDescriptor::mip_count, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::TextureDescriptor::size, flutter::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [592/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanCreateBoxPrimitive
	)

Definition at line 69 of file renderer_unittests.cc.

                                            {
  using VS = BoxFadeVertexShader;
  using FS = BoxFadeFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  using BoxPipelineBuilder = PipelineBuilder<VS, FS>;
  auto desc = BoxPipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  desc->SetSampleCount(SampleCount::kCount4);
  desc->ClearStencilAttachments();
  desc->ClearDepthAttachment();
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  vertex_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    static bool wireframe;
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Checkbox("Wireframe", &wireframe);
      ImGui::End();
    }
 
    desc->SetPolygonMode(wireframe ? PolygonMode::kLine : PolygonMode::kFill);
    auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
 
    assert(pipeline && pipeline->IsValid());
 
    pass.SetCommandLabel("Box");
    pass.SetPipeline(pipeline);
    pass.SetVertexBuffer(
        vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator()));
 
    VS::UniformBuffer uniforms;
    EXPECT_EQ(pass.GetOrthographicTransform(),
              Matrix::MakeOrthographic(pass.GetRenderTargetSize()));
    uniforms.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindUniformBuffer(pass, data_host_buffer->EmplaceUniform(uniforms));
 
    FS::FrameInfo frame_info;
    frame_info.current_time = GetSecondsElapsed();
    frame_info.cursor_position = GetCursorPosition();
    frame_info.window_size.x = GetWindowSize().width;
    frame_info.window_size.y = GetWindowSize().height;
 
    FS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
    FS::BindContents1(pass, boston, sampler);
    FS::BindContents2(pass, bridge, sampler);
 
    data_host_buffer->Reset();
    return pass.Draw().ok();
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kCount4, impeller::kFill, impeller::kLine, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), pipeline, and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [593/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanGenerateMipmaps
	)

Definition at line 736 of file renderer_unittests.cc.

                                         {
  if (GetBackend() == PlaygroundBackend::kOpenGLES ||
      GetBackend() == PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP() << "Mipmap test shader not supported on GLES.";
  }
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  using VS = MipmapsVertexShader;
  using FS = MipmapsFragmentShader;
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto mipmaps_pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(mipmaps_pipeline);
 
  auto boston = CreateTextureForFixture("boston.jpg", true);
  ASSERT_TRUE(boston);
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  auto size = Point(boston->GetSize());
  vertex_builder.AddVertices({
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, 0}, {1.0, 0.0}},       // 2
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, 0}, {0.0, 0.0}},            // 1
      {{size.x, size.y}, {1.0, 1.0}},  // 3
      {{0, size.y}, {0.0, 1.0}},       // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  bool first_frame = true;
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  Playground::RenderCallback callback = [&](RenderTarget& render_target) {
    const char* mip_filter_names[] = {"Base", "Nearest", "Linear"};
    const MipFilter mip_filters[] = {MipFilter::kBase, MipFilter::kNearest,
                                     MipFilter::kLinear};
    const char* min_filter_names[] = {"Nearest", "Linear"};
    const MinMagFilter min_filters[] = {MinMagFilter::kNearest,
                                        MinMagFilter::kLinear};
 
    // UI state.
    static int selected_mip_filter = 1;
    static int selected_min_filter = 0;
    static float lod = 4.5;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::Combo("Mip filter", &selected_mip_filter, mip_filter_names,
                   sizeof(mip_filter_names) / sizeof(char*));
      ImGui::Combo("Min filter", &selected_min_filter, min_filter_names,
                   sizeof(min_filter_names) / sizeof(char*));
      ImGui::SliderFloat("LOD", &lod, 0, boston->GetMipCount() - 1);
      ImGui::End();
    }
 
    auto buffer = context->CreateCommandBuffer();
    if (!buffer) {
      return false;
    }
    buffer->SetLabel("Playground Command Buffer");
 
    if (first_frame) {
      auto pass = buffer->CreateBlitPass();
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Blit Pass");
 
      pass->GenerateMipmap(boston, "Boston Mipmap");
 
      pass->EncodeCommands();
    }
 
    first_frame = false;
 
    {
      auto pass = buffer->CreateRenderPass(render_target);
      if (!pass) {
        return false;
      }
      pass->SetLabel("Playground Render Pass");
      {
        pass->SetCommandLabel("Image LOD");
        pass->SetPipeline(mipmaps_pipeline);
        pass->SetVertexBuffer(vertex_buffer);
 
        VS::FrameInfo frame_info;
        EXPECT_EQ(pass->GetOrthographicTransform(),
                  Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
        frame_info.mvp = pass->GetOrthographicTransform() *
                         Matrix::MakeScale(GetContentScale());
        VS::BindFrameInfo(*pass, data_host_buffer->EmplaceUniform(frame_info));
 
        FS::FragInfo frag_info;
        frag_info.lod = lod;
        FS::BindFragInfo(*pass, data_host_buffer->EmplaceUniform(frag_info));
 
        SamplerDescriptor sampler_desc;
        sampler_desc.mip_filter = mip_filters[selected_mip_filter];
        sampler_desc.min_filter = min_filters[selected_min_filter];
        raw_ptr<const Sampler> sampler =
            context->GetSamplerLibrary()->GetSampler(sampler_desc);
        FS::BindTex(*pass, boston, sampler);
 
        pass->Draw();
      }
      pass->EncodeCommands();
    }
 
    if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
      return false;
    }
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), flutter::buffer, callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kBase, impeller::kLinear, impeller::kNearest, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::SamplerDescriptor::min_filter, impeller::SamplerDescriptor::mip_filter, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), and flutter::size.

◆ TEST_P() [594/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanLookupRenderTargetProperties
	)

Definition at line 1340 of file renderer_unittests.cc.

                                                      {
  auto context = GetContext();
  auto cmd_buffer = context->CreateCommandBuffer();
  auto render_target_cache = std::make_shared<RenderTargetAllocator>(
      GetContext()->GetResourceAllocator());
 
  auto render_target = render_target_cache->CreateOffscreen(
      *context, {100, 100}, /*mip_count=*/1);
  auto render_pass = cmd_buffer->CreateRenderPass(render_target);
 
  EXPECT_EQ(render_pass->GetSampleCount(), render_target.GetSampleCount());
  EXPECT_EQ(render_pass->GetRenderTargetPixelFormat(),
            render_target.GetRenderTargetPixelFormat());
  EXPECT_EQ(render_pass->HasStencilAttachment(),
            render_target.GetStencilAttachment().has_value());
  EXPECT_EQ(render_pass->GetRenderTargetSize(),
            render_target.GetRenderTargetSize());
  render_pass->EncodeCommands();
}

References context, and render_pass.

◆ TEST_P() [595/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderInstanced
	)

Definition at line 427 of file renderer_unittests.cc.

                                         {
  if (GetParam() == PlaygroundBackend::kOpenGLES ||
      GetParam() == PlaygroundBackend::kOpenGLESSDF) {
    // This test drives instancing through gl_InstanceIndex and a storage
    // buffer, both of which require OpenGL ES 3.1. The portable instance-rate
    // vertex attribute path, which works down to OpenGL ES 2.0, is covered by
    // CanRenderInstancedWithVertexAttributes.
    GTEST_SKIP() << "This test's instance-ID mechanism requires OpenGL ES 3.1; "
                    "CanRenderInstancedWithVertexAttributes covers the "
                    "portable instance-rate path.";
  }
  using VS = InstancedDrawVertexShader;
  using FS = InstancedDrawFragmentShader;
 
  VertexBufferBuilder<VS::PerVertexData> builder;
  builder.AddVertices({
      VS::PerVertexData{Point{10, 10}},
      VS::PerVertexData{Point{10, 110}},
      VS::PerVertexData{Point{110, 10}},
      VS::PerVertexData{Point{10, 110}},
      VS::PerVertexData{Point{110, 10}},
      VS::PerVertexData{Point{110, 110}},
  });
 
  std::shared_ptr<Context> context = GetContext();
  ASSERT_TRUE(context);
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto pipeline = GetContext()->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  static constexpr size_t kInstancesCount = 5u;
  VS::InstanceInfo<kInstancesCount> instances;
  for (size_t i = 0; i < kInstancesCount; i++) {
    instances.colors[i] = Color::Random();
  }
 
  auto [data_host_buffer, indexes_host_buffer] =
      createHostBuffers(GetContext());
  ASSERT_TRUE(OpenPlaygroundHere([&](RenderPass& pass) -> bool {
    pass.SetPipeline(pipeline);
    pass.SetCommandLabel("InstancedDraw");
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(),
              Matrix::MakeOrthographic(pass.GetRenderTargetSize()));
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
    VS::BindInstanceInfo(pass,
                         data_host_buffer->EmplaceStorageBuffer(instances));
    pass.SetVertexBuffer(
        builder.CreateVertexBuffer(*data_host_buffer, *indexes_host_buffer));
 
    pass.SetInstanceCount(kInstancesCount);
    pass.Draw();
 
    data_host_buffer->Reset();
    return true;
  }));
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::RenderPass::Draw(), impeller::RenderPass::GetOrthographicTransform(), impeller::RenderPass::GetRenderTargetSize(), i, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), pipeline, impeller::Color::Random(), impeller::RenderPass::SetCommandLabel(), impeller::RenderPass::SetInstanceCount(), impeller::RenderPass::SetPipeline(), and impeller::RenderPass::SetVertexBuffer().

◆ TEST_P() [596/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderMultiplePrimitives
	)

Definition at line 253 of file renderer_unittests.cc.

                                                  {
  using VS = BoxFadeVertexShader;
  using FS = BoxFadeFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  using BoxPipelineBuilder = PipelineBuilder<VS, FS>;
  auto desc = BoxPipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  auto box_pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(box_pipeline);
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  vertex_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    for (size_t i = 0; i < 1; i++) {
      for (size_t j = 0; j < 1; j++) {
        pass.SetCommandLabel("Box");
        pass.SetPipeline(box_pipeline);
        pass.SetVertexBuffer(vertex_buffer);
 
        FS::FrameInfo frame_info;
        frame_info.current_time = GetSecondsElapsed();
        frame_info.cursor_position = GetCursorPosition();
        frame_info.window_size.x = GetWindowSize().width;
        frame_info.window_size.y = GetWindowSize().height;
 
        FS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
        FS::BindContents1(pass, boston, sampler);
        FS::BindContents2(pass, bridge, sampler);
 
        VS::UniformBuffer uniforms;
        EXPECT_EQ(pass.GetOrthographicTransform(),
                  Matrix::MakeOrthographic(pass.GetRenderTargetSize()));
        uniforms.mvp = pass.GetOrthographicTransform() *
                       Matrix::MakeScale(GetContentScale()) *
                       Matrix::MakeTranslation({i * 50.0f, j * 50.0f, 0.0f});
        VS::BindUniformBuffer(pass, data_host_buffer->EmplaceUniform(uniforms));
        if (!pass.Draw().ok()) {
          return false;
        }
      }
    }
 
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), i, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), impeller::Matrix::MakeTranslation(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [597/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderPerspectiveCube
	)

Definition at line 141 of file renderer_unittests.cc.

                                               {
  using VS = ColorsVertexShader;
  using FS = ColorsFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*desc));
  desc->SetCullMode(CullMode::kBackFace);
  desc->SetWindingOrder(WindingOrder::kCounterClockwise);
 
  // Setup the vertex layout to take two bindings. The first for positions and
  // the second for colors.
  auto vertex_desc = std::make_shared<VertexDescriptor>();
  ShaderStageIOSlot position_slot = VS::kInputPosition;
  ShaderStageIOSlot color_slot = VS::kInputColor;
  position_slot.binding = 0;
  position_slot.offset = 0;
  color_slot.binding = 1;
  color_slot.offset = 0;
  const std::vector<ShaderStageIOSlot> io_slots = {position_slot, color_slot};
  const std::vector<ShaderStageBufferLayout> layouts = {
      ShaderStageBufferLayout{.stride = 12u, .binding = 0},
      ShaderStageBufferLayout{.stride = 16u, .binding = 1}};
  vertex_desc->RegisterDescriptorSetLayouts(VS::kDescriptorSetLayouts);
  vertex_desc->RegisterDescriptorSetLayouts(FS::kDescriptorSetLayouts);
  vertex_desc->SetStageInputs(io_slots, layouts);
  desc->SetVertexDescriptor(std::move(vertex_desc));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(std::move(desc)).Get();
  ASSERT_TRUE(pipeline);
 
  struct Cube {
    Vector3 positions[8] = {
        // -Z
        {-1, -1, -1},
        {1, -1, -1},
        {1, 1, -1},
        {-1, 1, -1},
        // +Z
        {-1, -1, 1},
        {1, -1, 1},
        {1, 1, 1},
        {-1, 1, 1},
    };
    Color colors[8] = {
        Color::Red(),   Color::Yellow(), Color::Green(), Color::Blue(),
        Color::Green(), Color::Blue(),   Color::Red(),   Color::Yellow(),
    };
    uint16_t indices[36] = {
        1, 5, 2, 2, 5, 6,  // +X
        4, 0, 7, 7, 0, 3,  // -X
        4, 5, 0, 0, 5, 1,  // +Y
        3, 2, 7, 7, 2, 6,  // -Y
        5, 4, 6, 6, 4, 7,  // +Z
        0, 1, 3, 3, 1, 2,  // -Z
    };
  } cube;
 
  auto device_buffer = context->GetResourceAllocator()->CreateBufferWithCopy(
      reinterpret_cast<uint8_t*>(&cube), sizeof(cube));
 
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  Vector3 euler_angles;
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    static Degrees fov_y(60);
    static Scalar distance = 10;
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Field of view", &fov_y.degrees, 0, 180);
      ImGui::SliderFloat("Camera distance", &distance, 0, 30);
      ImGui::End();
    }
 
    pass.SetCommandLabel("Perspective Cube");
    pass.SetPipeline(pipeline);
 
    std::array<BufferView, 2> vertex_buffers = {
        BufferView(device_buffer,
                   Range(offsetof(Cube, positions), sizeof(Cube::positions))),
        BufferView(device_buffer,
                   Range(offsetof(Cube, colors), sizeof(Cube::colors))),
    };
 
    BufferView index_buffer(
        device_buffer, Range(offsetof(Cube, indices), sizeof(Cube::indices)));
    pass.SetVertexBuffer(vertex_buffers.data(), vertex_buffers.size());
    pass.SetElementCount(36);
    pass.SetIndexBuffer(index_buffer, IndexType::k16bit);
 
    VS::UniformBuffer uniforms;
    Scalar time = GetSecondsElapsed();
    euler_angles = Vector3(0.19 * time, 0.7 * time, 0.43 * time);
 
    uniforms.mvp =
        Matrix::MakePerspective(fov_y, pass.GetRenderTargetSize(), 0, 10) *
        Matrix::MakeTranslation({0, 0, distance}) *
        Matrix::MakeRotationX(Radians(euler_angles.x)) *
        Matrix::MakeRotationY(Radians(euler_angles.y)) *
        Matrix::MakeRotationZ(Radians(euler_angles.z));
    VS::BindUniformBuffer(pass, data_host_buffer->EmplaceUniform(uniforms));
 
    data_host_buffer->Reset();
    return pass.Draw().ok();
  };
  OpenPlaygroundHere(callback);
}

References impeller::ShaderStageIOSlot::binding, callback, context, impeller::Degrees::degrees, impeller::k16bit, impeller::kBackFace, impeller::kCounterClockwise, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakePerspective(), impeller::Matrix::MakeRotationX(), impeller::Matrix::MakeRotationY(), impeller::Matrix::MakeRotationZ(), impeller::Matrix::MakeTranslation(), impeller::ShaderStageIOSlot::offset, pipeline, impeller::ShaderStageBufferLayout::stride, impeller::Vector3::x, impeller::Vector3::y, and impeller::Vector3::z.

◆ TEST_P() [598/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderToMipLevel
	)

Definition at line 1654 of file renderer_unittests.cc.

                                          {
  if (GetBackend() == PlaygroundBackend::kOpenGLES ||
      GetBackend() == PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP() << "Rendering to non-zero mip levels is gated on a GLES "
                    "capability; covered by the Metal and Vulkan backends.";
  }
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
  desc.size = {100, 100};
  desc.mip_count = 2u;
  desc.usage = TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
  auto texture = context->GetResourceAllocator()->CreateTexture(desc);
  ASSERT_TRUE(texture);
 
  ColorAttachment color0;
  color0.texture = texture;
  color0.mip_level = 1u;
  color0.load_action = LoadAction::kClear;
  color0.store_action = StoreAction::kStore;
  color0.clear_color = Color::Green();
  RenderTarget target;
  target.SetColorAttachment(color0, 0u);
  // The render area follows the mip level dimensions.
  EXPECT_EQ(target.GetRenderTargetSize(), ISize(50, 50));
 
  auto buffer = context->CreateCommandBuffer();
  auto pass = buffer->CreateRenderPass(target);
  ASSERT_TRUE(pass && pass->IsValid());
  pass->EncodeCommands();
  EXPECT_TRUE(context->GetCommandQueue()->Submit({buffer}).ok());
}

References flutter::buffer, impeller::ColorAttachment::clear_color, context, impeller::TextureDescriptor::format, impeller::Color::Green(), impeller::kClear, impeller::kDevicePrivate, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::kStore, impeller::Attachment::load_action, impeller::TextureDescriptor::mip_count, impeller::Attachment::mip_level, impeller::RenderTarget::SetColorAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, target, impeller::Attachment::texture, texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [599/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderToTexture
	)

Definition at line 324 of file renderer_unittests.cc.

                                         {
  using VS = BoxFadeVertexShader;
  using FS = BoxFadeFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  using BoxPipelineBuilder = PipelineBuilder<VS, FS>;
  auto pipeline_desc =
      BoxPipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  pipeline_desc->SetSampleCount(SampleCount::kCount1);
  pipeline_desc->ClearDepthAttachment();
  pipeline_desc->SetStencilPixelFormat(PixelFormat::kS8UInt);
 
  ASSERT_TRUE(pipeline_desc.has_value());
  auto box_pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
  ASSERT_TRUE(box_pipeline);
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
 
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  vertex_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  std::shared_ptr<RenderPass> r2t_pass;
  auto cmd_buffer = context->CreateCommandBuffer();
  ASSERT_TRUE(cmd_buffer);
  {
    ColorAttachment color0;
    color0.load_action = LoadAction::kClear;
    color0.store_action = StoreAction::kStore;
 
    TextureDescriptor texture_descriptor;
    ASSERT_NE(pipeline_desc->GetColorAttachmentDescriptor(0u), nullptr);
    texture_descriptor.format =
        pipeline_desc->GetColorAttachmentDescriptor(0u)->format;
    texture_descriptor.storage_mode = StorageMode::kHostVisible;
    texture_descriptor.size = {400, 400};
    texture_descriptor.mip_count = 1u;
    texture_descriptor.usage = TextureUsage::kRenderTarget;
 
    color0.texture =
        context->GetResourceAllocator()->CreateTexture(texture_descriptor);
 
    ASSERT_TRUE(color0.IsValid());
 
    color0.texture->SetLabel("r2t_target");
 
    StencilAttachment stencil0;
    stencil0.load_action = LoadAction::kClear;
    stencil0.store_action = StoreAction::kDontCare;
    TextureDescriptor stencil_texture_desc;
    stencil_texture_desc.storage_mode = StorageMode::kDeviceTransient;
    stencil_texture_desc.size = texture_descriptor.size;
    stencil_texture_desc.format = PixelFormat::kS8UInt;
    stencil_texture_desc.usage = TextureUsage::kRenderTarget;
    stencil0.texture =
        context->GetResourceAllocator()->CreateTexture(stencil_texture_desc);
 
    RenderTarget r2t_desc;
    r2t_desc.SetColorAttachment(color0, 0u);
    r2t_desc.SetStencilAttachment(stencil0);
    r2t_pass = cmd_buffer->CreateRenderPass(r2t_desc);
    ASSERT_TRUE(r2t_pass && r2t_pass->IsValid());
  }
 
  r2t_pass->SetCommandLabel("Box");
  r2t_pass->SetPipeline(box_pipeline);
  r2t_pass->SetVertexBuffer(vertex_buffer);
 
  FS::FrameInfo frame_info;
  frame_info.current_time = GetSecondsElapsed();
  frame_info.cursor_position = GetCursorPosition();
  frame_info.window_size.x = GetWindowSize().width;
  frame_info.window_size.y = GetWindowSize().height;
 
  FS::BindFrameInfo(*r2t_pass, data_host_buffer->EmplaceUniform(frame_info));
  FS::BindContents1(*r2t_pass, boston, sampler);
  FS::BindContents2(*r2t_pass, bridge, sampler);
 
  VS::UniformBuffer uniforms;
  uniforms.mvp = Matrix::MakeOrthographic(ISize{1024, 768}) *
                 Matrix::MakeTranslation({50.0f, 50.0f, 0.0f});
  VS::BindUniformBuffer(*r2t_pass, data_host_buffer->EmplaceUniform(uniforms));
  ASSERT_TRUE(r2t_pass->Draw().ok());
  ASSERT_TRUE(r2t_pass->EncodeCommands());
  ASSERT_TRUE(context->FlushCommandBuffers());
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::TextureDescriptor::format, impeller::Attachment::IsValid(), impeller::kClear, impeller::kCount1, impeller::kDeviceTransient, impeller::kDontCare, impeller::kHostVisible, impeller::kRenderTarget, impeller::kS8UInt, impeller::kStore, impeller::Attachment::load_action, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeTranslation(), impeller::TextureDescriptor::mip_count, impeller::RenderTarget::SetColorAttachment(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), impeller::RenderTarget::SetStencilAttachment(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, impeller::Attachment::texture, and impeller::TextureDescriptor::usage.

◆ TEST_P() [600/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanRenderToTextureSlice
	)

Definition at line 1622 of file renderer_unittests.cc.

                                              {
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.type = TextureType::kTextureCube;
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
  desc.size = {100, 100};
  desc.usage = TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
  auto texture = context->GetResourceAllocator()->CreateTexture(desc);
  ASSERT_TRUE(texture);
 
  ColorAttachment color0;
  color0.texture = texture;
  color0.slice = 3u;  // +Y face.
  color0.load_action = LoadAction::kClear;
  color0.store_action = StoreAction::kStore;
  color0.clear_color = Color::Green();
  RenderTarget target;
  target.SetColorAttachment(color0, 0u);
 
  auto buffer = context->CreateCommandBuffer();
  auto pass = buffer->CreateRenderPass(target);
  ASSERT_TRUE(pass && pass->IsValid());
  pass->EncodeCommands();
  EXPECT_TRUE(context->GetCommandQueue()->Submit({buffer}).ok());
}

References flutter::buffer, impeller::ColorAttachment::clear_color, context, impeller::TextureDescriptor::format, impeller::Color::Green(), impeller::kClear, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kRenderTarget, impeller::kShaderRead, impeller::kStore, impeller::kTextureCube, impeller::Attachment::load_action, impeller::RenderTarget::SetColorAttachment(), impeller::TextureDescriptor::size, impeller::Attachment::slice, impeller::TextureDescriptor::storage_mode, impeller::Attachment::store_action, target, impeller::Attachment::texture, texture, impeller::TextureDescriptor::type, and impeller::TextureDescriptor::usage.

◆ TEST_P() [601/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneThenSwizzleWithSubpasses
	)

Definition at line 1485 of file renderer_unittests.cc.

                                                           {
  switch (GetBackend()) {
    case PlaygroundBackend::kMetal:
    case PlaygroundBackend::kMetalSDF:
    case PlaygroundBackend::kVulkan:
      break;
    case PlaygroundBackend::kOpenGLES:
    case PlaygroundBackend::kOpenGLESSDF:
      GTEST_SKIP() << "Platform is crashing in CI on this example "
                   << "(see https://github.com/flutter/flutter/issues/189287).";
  }
  // Define shader types
  using TextureVS = TextureVertexShader;
  using TextureFS = TextureFragmentShader;
 
  using SwizzleVS = SepiaVertexShader;
  using SwizzleFS = SwizzleFragmentShader;
 
  using SepiaVS = SepiaVertexShader;
  using SepiaFS = SepiaFragmentShader;
 
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  if (!context->GetCapabilities()->SupportsFramebufferFetch()) {
    GTEST_SKIP() << "This test uses framebuffer fetch and the backend doesn't "
                    "support it.";
    return;
  }
 
  // Create pipelines.
  auto texture_pipeline =
      CreateDefaultPipeline<TextureVS, TextureFS>(this, context);
  auto swizzle_pipeline =
      CreateDefaultPipeline<SwizzleVS, SwizzleFS>(this, context);
  auto sepia_pipeline = CreateDefaultPipeline<SepiaVS, SepiaFS>(this, context);
 
  ASSERT_TRUE(texture_pipeline);
  ASSERT_TRUE(swizzle_pipeline);
  ASSERT_TRUE(sepia_pipeline);
 
  // Vertex buffer builders.
  VertexBufferBuilder<TextureVS::PerVertexData> texture_vtx_builder;
  texture_vtx_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
 
  VertexBufferBuilder<SepiaVS::PerVertexData> sepia_vtx_builder;
  sepia_vtx_builder.AddVertices({
      {{100, 100, 0.0}},  // 1
      {{800, 100, 0.0}},  // 2
      {{800, 800, 0.0}},  // 3
      {{100, 100, 0.0}},  // 1
      {{800, 800, 0.0}},  // 3
      {{100, 800, 0.0}},  // 4
  });
 
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(boston);
 
  const auto& sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto data_buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
  SinglePassCallback callback = [&](RenderPass& pass) {
    // Draw the texture.
    {
      pass.SetPipeline(texture_pipeline);
      pass.SetVertexBuffer(texture_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
      TextureVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     Matrix::MakeScale(GetContentScale());
      TextureVS::BindUniformBuffer(pass, data_buffer->EmplaceUniform(uniforms));
      TextureFS::BindTextureContents(pass, boston, sampler);
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    // Draw the sepia toner.
    {
      pass.SetPipeline(sepia_pipeline);
      pass.SetVertexBuffer(sepia_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
      SepiaVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     Matrix::MakeScale(GetContentScale());
      SepiaVS::BindUniformBuffer(pass, data_buffer->EmplaceUniform(uniforms));
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    // Draw the swizzle.
    {
      pass.SetPipeline(swizzle_pipeline);
      pass.SetVertexBuffer(sepia_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
      SwizzleVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     Matrix::MakeScale(GetContentScale());
      SwizzleVS::BindUniformBuffer(pass, data_buffer->EmplaceUniform(uniforms));
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kVulkan, impeller::Matrix::MakeOrthographic(), and impeller::Matrix::MakeScale().

◆ TEST_P() [602/662]

impeller::testing::TEST_P	(	RendererTest	,
		CanSepiaToneWithSubpasses
	)

Definition at line 1395 of file renderer_unittests.cc.

                                                {
  // Define shader types
  using TextureVS = TextureVertexShader;
  using TextureFS = TextureFragmentShader;
 
  using SepiaVS = SepiaVertexShader;
  using SepiaFS = SepiaFragmentShader;
 
  auto context = GetContext();
  ASSERT_TRUE(context);
 
  if (!context->GetCapabilities()->SupportsFramebufferFetch()) {
    GTEST_SKIP() << "This test uses framebuffer fetch and the backend doesn't "
                    "support it.";
    return;
  }
 
  // Create pipelines.
  auto texture_pipeline =
      CreateDefaultPipeline<TextureVS, TextureFS>(this, context);
  auto sepia_pipeline = CreateDefaultPipeline<SepiaVS, SepiaFS>(this, context);
 
  ASSERT_TRUE(texture_pipeline);
  ASSERT_TRUE(sepia_pipeline);
 
  // Vertex buffer builders.
  VertexBufferBuilder<TextureVS::PerVertexData> texture_vtx_builder;
  texture_vtx_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
 
  VertexBufferBuilder<SepiaVS::PerVertexData> sepia_vtx_builder;
  sepia_vtx_builder.AddVertices({
      {{100, 100, 0.0}},  // 1
      {{800, 100, 0.0}},  // 2
      {{800, 800, 0.0}},  // 3
      {{100, 100, 0.0}},  // 1
      {{800, 800, 0.0}},  // 3
      {{100, 800, 0.0}},  // 4
  });
 
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(boston);
 
  const auto& sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  auto buffer = HostBuffer::Create(
      context->GetResourceAllocator(), context->GetIdleWaiter(),
      context->GetCapabilities()->GetMinimumUniformAlignment());
  SinglePassCallback callback = [&](RenderPass& pass) {
    // Draw the texture.
    {
      pass.SetPipeline(texture_pipeline);
      pass.SetVertexBuffer(texture_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
      TextureVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     Matrix::MakeScale(GetContentScale());
      TextureVS::BindUniformBuffer(pass, buffer->EmplaceUniform(uniforms));
      TextureFS::BindTextureContents(pass, boston, sampler);
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    // Draw the sepia toner.
    {
      pass.SetPipeline(sepia_pipeline);
      pass.SetVertexBuffer(sepia_vtx_builder.CreateVertexBuffer(
          *context->GetResourceAllocator()));
      SepiaVS::UniformBuffer uniforms;
      uniforms.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     Matrix::MakeScale(GetContentScale());
      SepiaVS::BindUniformBuffer(pass, buffer->EmplaceUniform(uniforms));
      if (!pass.Draw().ok()) {
        return false;
      }
    }
 
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), flutter::buffer, callback, context, impeller::HostBuffer::Create(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Matrix::MakeOrthographic(), and impeller::Matrix::MakeScale().

◆ TEST_P() [603/662]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexBehavior
	)

Definition at line 1103 of file renderer_unittests.cc.

                                           {
  using VS = BoxFadeVertexShader;
 
  // Do not create any index buffer if no indices were provided.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  ASSERT_EQ(vertex_builder.GetIndexType(), IndexType::kNone);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexType(), and impeller::kNone.

◆ TEST_P() [604/662]

impeller::testing::TEST_P	(	RendererTest	,
		DefaultIndexSize
	)

Definition at line 1093 of file renderer_unittests.cc.

                                       {
  using VS = BoxFadeVertexShader;
 
  // Default to 16bit index buffer size, as this is a reasonable default and
  // supported on all backends without extensions.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.AppendIndex(0u);
  ASSERT_EQ(vertex_builder.GetIndexType(), IndexType::k16bit);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendIndex(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexType(), and impeller::k16bit.

◆ TEST_P() [605/662]

impeller::testing::TEST_P	(	RendererTest	,
		InactiveUniforms
	)

Definition at line 1046 of file renderer_unittests.cc.

                                       {
  using VS = InactiveUniformsVertexShader;
  using FS = InactiveUniformsFragmentShader;
 
  auto context = GetContext();
  auto pipeline_descriptor =
      PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_descriptor.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*pipeline_descriptor));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    auto size = pass.GetRenderTargetSize();
 
    pass.SetPipeline(pipeline);
    pass.SetCommandLabel("Inactive Uniform");
 
    VertexBufferBuilder<VS::PerVertexData> builder;
    builder.AddVertices({{Point()},
                         {Point(0, size.height)},
                         {Point(size.width, 0)},
                         {Point(size.width, 0)},
                         {Point(0, size.height)},
                         {Point(size.width, size.height)}});
    pass.SetVertexBuffer(
        builder.CreateVertexBuffer(*data_host_buffer, *indexes_host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp =
        pass.GetOrthographicTransform() * Matrix::MakeScale(GetContentScale());
    VS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo fs_uniform = {.unused_color = Color::Red(),
                               .color = Color::Green()};
    FS::BindFragInfo(pass, data_host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw().ok();
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::Color::Green(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), pipeline, impeller::Color::Red(), and flutter::size.

◆ TEST_P() [606/662]

impeller::testing::TEST_P	(	RendererTest	,
		Planet
	)

Definition at line 922 of file renderer_unittests.cc.

                             {
  using VS = PlanetVertexShader;
  using FS = PlanetFragmentShader;
 
  auto context = GetContext();
  auto pipeline_descriptor =
      PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_descriptor.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*pipeline_descriptor));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    static Scalar speed = 0.1;
    static Scalar planet_size = 550.0;
    static bool show_normals = false;
    static bool show_noise = false;
    static Scalar seed_value = 42.0;
 
    auto size = pass.GetRenderTargetSize();
 
    if (IsPlaygroundEnabled()) {
      ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
      ImGui::SliderFloat("Speed", &speed, 0.0, 10.0);
      ImGui::SliderFloat("Planet Size", &planet_size, 0.1, 1000);
      ImGui::Checkbox("Show Normals", &show_normals);
      ImGui::Checkbox("Show Noise", &show_noise);
      ImGui::InputFloat("Seed Value", &seed_value);
      ImGui::End();
    }
 
    pass.SetPipeline(pipeline);
    pass.SetCommandLabel("Planet scene");
    VertexBufferBuilder<VS::PerVertexData> builder;
    builder.AddVertices({{Point()},
                         {Point(0, size.height)},
                         {Point(size.width, 0)},
                         {Point(size.width, 0)},
                         {Point(0, size.height)},
                         {Point(size.width, size.height)}});
    pass.SetVertexBuffer(
        builder.CreateVertexBuffer(*data_host_buffer, *indexes_host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp = pass.GetOrthographicTransform();
    VS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo fs_uniform;
    fs_uniform.resolution = Point(size);
    fs_uniform.time = GetSecondsElapsed();
    fs_uniform.speed = speed;
    fs_uniform.planet_size = planet_size;
    fs_uniform.show_normals = show_normals ? 1.0 : 0.0;
    fs_uniform.show_noise = show_noise ? 1.0 : 0.0;
    fs_uniform.seed_value = seed_value;
    FS::BindFragInfo(pass, data_host_buffer->EmplaceUniform(fs_uniform));
 
    pass.Draw().ok();
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), pipeline, and flutter::size.

◆ TEST_P() [607/662]

impeller::testing::TEST_P	(	RendererTest	,
		RenderTargetCreateOffscreenMSAASetsDefaultDepthStencilFormat
	)

Definition at line 1360 of file renderer_unittests.cc.

                                                                     {
  auto context = GetContext();
  auto render_target_cache = std::make_shared<RenderTargetAllocator>(
      GetContext()->GetResourceAllocator());
 
  RenderTarget render_target = render_target_cache->CreateOffscreenMSAA(
      *context, {100, 100}, /*mip_count=*/1);
  EXPECT_EQ(render_target.GetDepthAttachment()
                ->texture->GetTextureDescriptor()
                .format,
            GetContext()->GetCapabilities()->GetDefaultDepthStencilFormat());
}

References context, and impeller::RenderTarget::GetDepthAttachment().

◆ TEST_P() [608/662]

impeller::testing::TEST_P	(	RendererTest	,
		StencilMask
	)

Definition at line 1181 of file renderer_unittests.cc.

                                  {
  using VS = BoxFadeVertexShader;
  using FS = BoxFadeFragmentShader;
  auto context = GetContext();
  ASSERT_TRUE(context);
  using BoxFadePipelineBuilder = PipelineBuilder<VS, FS>;
  auto desc = BoxFadePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());
 
  // Vertex buffer.
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  vertex_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
  auto vertex_buffer =
      vertex_builder.CreateVertexBuffer(*context->GetResourceAllocator());
  ASSERT_TRUE(vertex_buffer);
 
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);
 
  auto bridge = CreateTextureForFixture("bay_bridge.jpg");
  auto boston = CreateTextureForFixture("boston.jpg");
  ASSERT_TRUE(bridge && boston);
  raw_ptr<const Sampler> sampler = context->GetSamplerLibrary()->GetSampler({});
  ASSERT_TRUE(sampler);
 
  static bool mirror = false;
  static int stencil_reference_write = 0xFF;
  static int stencil_reference_read = 0x1;
  std::vector<uint8_t> stencil_contents;
  static int last_stencil_contents_reference_value = 0;
  static int current_front_compare =
      CompareFunctionUI().IndexOf(CompareFunction::kLessEqual);
  static int current_back_compare =
      CompareFunctionUI().IndexOf(CompareFunction::kLessEqual);
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  Playground::RenderCallback callback = [&](RenderTarget& render_target) {
    auto buffer = context->CreateCommandBuffer();
    if (!buffer) {
      return false;
    }
    buffer->SetLabel("Playground Command Buffer");
 
    {
      // Configure the stencil attachment for the test.
      RenderTarget::AttachmentConfig stencil_config;
      stencil_config.load_action = LoadAction::kLoad;
      stencil_config.store_action = StoreAction::kDontCare;
      stencil_config.storage_mode = StorageMode::kHostVisible;
      render_target.SetupDepthStencilAttachments(
          *context, *context->GetResourceAllocator(),
          render_target.GetRenderTargetSize(), true, "stencil", stencil_config);
      // Fill the stencil buffer with an checkerboard pattern.
      const auto target_width = render_target.GetRenderTargetSize().width;
      const auto target_height = render_target.GetRenderTargetSize().height;
      const size_t target_size = target_width * target_height;
      if (stencil_contents.size() != target_size ||
          last_stencil_contents_reference_value != stencil_reference_write) {
        stencil_contents.resize(target_size);
        last_stencil_contents_reference_value = stencil_reference_write;
        for (int y = 0; y < target_height; y++) {
          for (int x = 0; x < target_width; x++) {
            const auto index = y * target_width + x;
            const auto kCheckSize = 64;
            const auto value =
                (((y / kCheckSize) + (x / kCheckSize)) % 2 == 0) *
                stencil_reference_write;
            stencil_contents[index] = value;
          }
        }
      }
      if (!render_target.GetStencilAttachment()->texture->SetContents(
              stencil_contents.data(), stencil_contents.size(), 0, false)) {
        VALIDATION_LOG << "Could not upload stencil contents to device memory";
        return false;
      }
      auto pass = buffer->CreateRenderPass(render_target);
      if (!pass) {
        return false;
      }
      pass->SetLabel("Stencil Buffer");
      if (IsPlaygroundEnabled()) {
        ImGui::Begin("Controls", nullptr, ImGuiWindowFlags_AlwaysAutoResize);
        ImGui::SliderInt("Stencil Write Value", &stencil_reference_write, 0,
                         0xFF);
        ImGui::SliderInt("Stencil Compare Value", &stencil_reference_read, 0,
                         0xFF);
        ImGui::Checkbox("Back face mode", &mirror);
        ImGui::ListBox("Front face compare function", &current_front_compare,
                       CompareFunctionUI().labels(),
                       CompareFunctionUI().size());
        ImGui::ListBox("Back face compare function", &current_back_compare,
                       CompareFunctionUI().labels(),
                       CompareFunctionUI().size());
        ImGui::End();
      }
 
      StencilAttachmentDescriptor front;
      front.stencil_compare =
          CompareFunctionUI().FunctionOf(current_front_compare);
      StencilAttachmentDescriptor back;
      back.stencil_compare =
          CompareFunctionUI().FunctionOf(current_back_compare);
      desc->SetStencilAttachmentDescriptors(front, back);
      auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
 
      assert(pipeline && pipeline->IsValid());
 
      pass->SetCommandLabel("Box");
      pass->SetPipeline(pipeline);
      pass->SetStencilReference(stencil_reference_read);
      pass->SetVertexBuffer(vertex_buffer);
 
      VS::UniformBuffer uniforms;
      EXPECT_EQ(pass->GetOrthographicTransform(),
                Matrix::MakeOrthographic(pass->GetRenderTargetSize()));
      uniforms.mvp = pass->GetOrthographicTransform() *
                     Matrix::MakeScale(GetContentScale());
      if (mirror) {
        uniforms.mvp = Matrix::MakeScale(Vector2(-1, 1)) * uniforms.mvp;
      }
      VS::BindUniformBuffer(*pass, data_host_buffer->EmplaceUniform(uniforms));
 
      FS::FrameInfo frame_info;
      frame_info.current_time = GetSecondsElapsed();
      frame_info.cursor_position = GetCursorPosition();
      frame_info.window_size.x = GetWindowSize().width;
      frame_info.window_size.y = GetWindowSize().height;
 
      FS::BindFrameInfo(*pass, data_host_buffer->EmplaceUniform(frame_info));
      FS::BindContents1(*pass, boston, sampler);
      FS::BindContents2(*pass, bridge, sampler);
      if (!pass->Draw().ok()) {
        return false;
      }
      pass->EncodeCommands();
    }
 
    if (!context->GetCommandQueue()->Submit({buffer}).ok()) {
      return false;
    }
    data_host_buffer->Reset();
    return true;
  };
 
  if ((true)) {  // Disables trailing code without compiler warning.
    GTEST_SKIP() << "See: https://github.com/flutter/flutter/issues/188884";
  }
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), flutter::buffer, callback, CompareFunctionUI(), context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::testing::CompareFunctionUIData::FunctionOf(), impeller::testing::CompareFunctionUIData::IndexOf(), impeller::kCount4, impeller::kDontCare, impeller::kHostVisible, impeller::kLessEqual, impeller::kLoad, impeller::RenderTarget::AttachmentConfig::load_action, impeller::Matrix::MakeOrthographic(), impeller::Matrix::MakeScale(), pipeline, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel(), flutter::size, impeller::StencilAttachmentDescriptor::stencil_compare, impeller::RenderTarget::AttachmentConfig::storage_mode, impeller::RenderTarget::AttachmentConfig::store_action, VALIDATION_LOG, value, x, and y.

◆ TEST_P() [609/662]

impeller::testing::TEST_P	(	RendererTest	,
		TheImpeller
	)

Definition at line 860 of file renderer_unittests.cc.

                                  {
  using VS = ImpellerVertexShader;
  using FS = ImpellerFragmentShader;
 
  auto context = GetContext();
  auto pipeline_descriptor =
      PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(pipeline_descriptor.has_value());
  ASSERT_TRUE(InitializePipelineDescriptorForRendering(*pipeline_descriptor));
  auto pipeline =
      context->GetPipelineLibrary()->GetPipeline(pipeline_descriptor).Get();
  ASSERT_TRUE(pipeline && pipeline->IsValid());
 
  auto blue_noise = CreateTextureForFixture("blue_noise.png");
  SamplerDescriptor noise_sampler_desc;
  noise_sampler_desc.width_address_mode = SamplerAddressMode::kRepeat;
  noise_sampler_desc.height_address_mode = SamplerAddressMode::kRepeat;
  raw_ptr<const Sampler> noise_sampler =
      context->GetSamplerLibrary()->GetSampler(noise_sampler_desc);
 
  auto cube_map = CreateTextureCubeForFixture(
      {"table_mountain_px.png", "table_mountain_nx.png",
       "table_mountain_py.png", "table_mountain_ny.png",
       "table_mountain_pz.png", "table_mountain_nz.png"});
  raw_ptr<const Sampler> cube_map_sampler =
      context->GetSamplerLibrary()->GetSampler({});
 
  auto [data_host_buffer, indexes_host_buffer] = createHostBuffers(context);
  SinglePassCallback callback = [&](RenderPass& pass) {
    auto size = pass.GetRenderTargetSize();
 
    pass.SetPipeline(pipeline);
    pass.SetCommandLabel("Impeller SDF scene");
    VertexBufferBuilder<VS::PerVertexData> builder;
    builder.AddVertices({{Point()},
                         {Point(0, size.height)},
                         {Point(size.width, 0)},
                         {Point(size.width, 0)},
                         {Point(0, size.height)},
                         {Point(size.width, size.height)}});
    pass.SetVertexBuffer(
        builder.CreateVertexBuffer(*data_host_buffer, *indexes_host_buffer));
 
    VS::FrameInfo frame_info;
    EXPECT_EQ(pass.GetOrthographicTransform(), Matrix::MakeOrthographic(size));
    frame_info.mvp = pass.GetOrthographicTransform();
    VS::BindFrameInfo(pass, data_host_buffer->EmplaceUniform(frame_info));
 
    FS::FragInfo fs_uniform;
    fs_uniform.texture_size = Point(size);
    fs_uniform.time = GetSecondsElapsed();
    FS::BindFragInfo(pass, data_host_buffer->EmplaceUniform(fs_uniform));
    FS::BindBlueNoise(pass, blue_noise, noise_sampler);
    FS::BindCubeMap(pass, cube_map, cube_map_sampler);
 
    pass.Draw().ok();
    data_host_buffer->Reset();
    return true;
  };
  OpenPlaygroundHere(callback);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), callback, context, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), impeller::SamplerDescriptor::height_address_mode, impeller::kRepeat, impeller::PipelineBuilder< VertexShader_, FragmentShader_ >::MakeDefaultPipelineDescriptor(), impeller::Matrix::MakeOrthographic(), pipeline, flutter::size, and impeller::SamplerDescriptor::width_address_mode.

◆ TEST_P() [610/662]

impeller::testing::TEST_P	(	RendererTest	,
		VertexBufferBuilder
	)

Definition at line 1111 of file renderer_unittests.cc.

                                          {
  // Does not create index buffer if one is provided.
  using VS = BoxFadeVertexShader;
  VertexBufferBuilder<VS::PerVertexData> vertex_builder;
  vertex_builder.SetLabel("Box");
  vertex_builder.AddVertices({
      {{100, 100, 0.0}, {0.0, 0.0}},  // 1
      {{800, 100, 0.0}, {1.0, 0.0}},  // 2
      {{800, 800, 0.0}, {1.0, 1.0}},  // 3
      {{100, 800, 0.0}, {0.0, 1.0}},  // 4
  });
  vertex_builder.AppendIndex(0);
  vertex_builder.AppendIndex(1);
  vertex_builder.AppendIndex(2);
  vertex_builder.AppendIndex(1);
  vertex_builder.AppendIndex(2);
  vertex_builder.AppendIndex(3);
 
  ASSERT_EQ(vertex_builder.GetIndexCount(), 6u);
  ASSERT_EQ(vertex_builder.GetVertexCount(), 4u);
}

References impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AddVertices(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendIndex(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetIndexCount(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::GetVertexCount(), and impeller::VertexBufferBuilder< VertexType_, IndexType_ >::SetLabel().

◆ TEST_P() [611/662]

impeller::testing::TEST_P	(	RenderPassGLESWithDiscardFrameBufferExtTest	,
		DiscardFramebufferExt
	)

Definition at line 83 of file render_pass_gles_unittests.cc.

                                                                           {
  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();
  auto& mock_gl_impl_ref = *mock_gl_impl;
  auto mock_gl =
      MockGLES::Init(std::move(mock_gl_impl), {{"GL_EXT_discard_framebuffer"}},
                     "OpenGL ES 2.0");
 
  auto context = CreateFakeGLESContext();
  auto dummy_worker = std::make_shared<MockWorker>();
  context->AddReactorWorker(dummy_worker);
  auto reactor = context->GetReactor();
 
  const auto command_buffer =
      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();
  auto render_target = RenderTarget{};
  const auto description = TextureDescriptor{
      .format = PixelFormat::kR8G8B8A8UNormInt, .size = {10, 10}};
 
  const auto& test_params = GetParam();
  auto framebuffer_texture =
      TextureGLES::WrapFBO(reactor, description, test_params.frame_buffer_id);
 
  auto color_attachment = ColorAttachment{Attachment{
      .texture = framebuffer_texture, .store_action = StoreAction::kDontCare}};
  render_target.SetColorAttachment(color_attachment, 0);
  const auto render_pass = command_buffer->CreateRenderPass(render_target);
 
  EXPECT_CALL(mock_gl_impl_ref, GetIntegerv(GL_FRAMEBUFFER_BINDING, _))
      .WillOnce(SetArgPointee<1>(test_params.frame_buffer_id));
 
  EXPECT_CALL(mock_gl_impl_ref, DiscardFramebufferEXT(GL_FRAMEBUFFER, _, _))
      .With(Args<2, 1>(ElementsAreArray(test_params.expected_attachments)))
      .Times(1);
  ASSERT_TRUE(render_pass->EncodeCommands());
  ASSERT_TRUE(reactor->React());
}

References command_buffer, context, dummy_worker, impeller::TextureDescriptor::format, impeller::testing::MockGLES::Init(), impeller::kDontCare, impeller::kR8G8B8A8UNormInt, mock_gl, mock_gl_impl_ref, reactor, render_pass, impeller::Attachment::texture, and impeller::TextureGLES::WrapFBO().

◆ TEST_P() [612/662]

impeller::testing::TEST_P	(	RenderPassGLESWithDiscardFrameBufferExtTest	,
		InvalidateFramebuffer
	)

Definition at line 133 of file render_pass_gles_unittests.cc.

                                                                           {
  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();
  auto& mock_gl_impl_ref = *mock_gl_impl;
  auto mock_gl =
      MockGLES::Init(std::move(mock_gl_impl), std::nullopt, "OpenGL ES 3.0");
 
  auto context = CreateFakeGLESContext();
  auto dummy_worker = std::make_shared<MockWorker>();
  context->AddReactorWorker(dummy_worker);
  auto reactor = context->GetReactor();
 
  const auto command_buffer =
      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();
  auto render_target = RenderTarget{};
  const auto description = TextureDescriptor{
      .format = PixelFormat::kR8G8B8A8UNormInt, .size = {10, 10}};
 
  const auto& test_params = GetParam();
  auto framebuffer_texture =
      TextureGLES::WrapFBO(reactor, description, test_params.frame_buffer_id);
 
  auto color_attachment = ColorAttachment{Attachment{
      .texture = framebuffer_texture, .store_action = StoreAction::kDontCare}};
  render_target.SetColorAttachment(color_attachment, 0);
  const auto render_pass = command_buffer->CreateRenderPass(render_target);
 
  EXPECT_CALL(mock_gl_impl_ref, GetIntegerv(GL_FRAMEBUFFER_BINDING, _))
      .WillOnce(SetArgPointee<1>(test_params.frame_buffer_id));
 
  // InvalidateFramebuffer should be called instead of DiscardFramebufferEXT
  EXPECT_CALL(mock_gl_impl_ref, InvalidateFramebuffer(GL_FRAMEBUFFER, _, _))
      .With(Args<2, 1>(ElementsAreArray(test_params.expected_attachments)))
      .Times(1);
  EXPECT_CALL(mock_gl_impl_ref, DiscardFramebufferEXT(GL_FRAMEBUFFER, _, _))
      .Times(0);
 
  ASSERT_TRUE(render_pass->EncodeCommands());
  ASSERT_TRUE(reactor->React());
}

References command_buffer, context, dummy_worker, impeller::TextureDescriptor::format, impeller::testing::MockGLES::Init(), impeller::kDontCare, impeller::kR8G8B8A8UNormInt, mock_gl, mock_gl_impl_ref, reactor, render_pass, impeller::Attachment::texture, and impeller::TextureGLES::WrapFBO().

◆ TEST_P() [613/662]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachedTextureGetsNewAttachmentConfig
	)

Definition at line 123 of file render_target_cache_unittests.cc.

                                                                    {
  auto render_target_cache = RenderTargetCache(
      GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
 
  render_target_cache.Start();
  RenderTarget::AttachmentConfig color_attachment_config =
      RenderTarget::kDefaultColorAttachmentConfig;
  RenderTarget target1 = render_target_cache.CreateOffscreen(
      *GetContext(), {100, 100}, 1, "Offscreen1", color_attachment_config);
  render_target_cache.End();
 
  render_target_cache.Start();
  color_attachment_config.clear_color = Color::Red();
  RenderTarget target2 = render_target_cache.CreateOffscreen(
      *GetContext(), {100, 100}, 1, "Offscreen2", color_attachment_config);
  render_target_cache.End();
 
  ColorAttachment color1 = target1.GetColorAttachment(0);
  ColorAttachment color2 = target2.GetColorAttachment(0);
  // The second color attachment should reuse the first attachment's texture
  // but with attributes from the second AttachmentConfig.
  EXPECT_EQ(color2.texture, color1.texture);
  EXPECT_EQ(color2.clear_color, Color::Red());
}

References impeller::ColorAttachment::clear_color, impeller::RenderTarget::AttachmentConfig::clear_color, impeller::RenderTarget::GetColorAttachment(), impeller::RenderTarget::kDefaultColorAttachmentConfig, impeller::Color::Red(), and impeller::Attachment::texture.

◆ TEST_P() [614/662]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachesUsedTexturesAcrossFrames
	)

Definition at line 53 of file render_target_cache_unittests.cc.

                                                              {
  auto render_target_cache = RenderTargetCache(
      GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
 
  render_target_cache.Start();
  // Create two render targets of the same exact size/shape. Both should be
  // marked as used this frame, so the cached data set will contain two.
  render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
 
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
 
  render_target_cache.End();
  render_target_cache.Start();
 
  // Next frame, only create one texture. The set will still contain two,
  // but one will be removed at the end of the frame.
  render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
 
  render_target_cache.End();
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 1u);
}

◆ TEST_P() [615/662]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CachesUsedTexturesAcrossFramesWithKeepAlive
	)

Definition at line 77 of file render_target_cache_unittests.cc.

                                                                           {
  auto render_target_cache = RenderTargetCache(
      GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/3);
 
  render_target_cache.Start();
  // Create two render targets of the same exact size/shape. Both should be
  // marked as used this frame, so the cached data set will contain two.
  render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
  render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
 
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
 
  render_target_cache.End();
  render_target_cache.Start();
 
  // The unused texture is kept alive until the keep alive countdown
  // reaches 0.
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
 
  for (auto i = 0; i < 3; i++) {
    render_target_cache.Start();
    render_target_cache.End();
    EXPECT_EQ(render_target_cache.CachedTextureCount(), 2u);
  }
  // After the countdown has elapsed the texture is removed.
  render_target_cache.Start();
  render_target_cache.End();
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 0u);
}

References i.

◆ TEST_P() [616/662]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		CreateWithEmptySize
	)

Definition at line 148 of file render_target_cache_unittests.cc.

                                                   {
  auto render_target_cache = RenderTargetCache(
      GetContext()->GetResourceAllocator(), /*keep_alive_frame_count=*/0);
 
  render_target_cache.Start();
  RenderTarget empty_target =
      render_target_cache.CreateOffscreen(*GetContext(), {100, 0}, 1);
  RenderTarget empty_target_msaa =
      render_target_cache.CreateOffscreenMSAA(*GetContext(), {0, 0}, 1);
  render_target_cache.End();
 
  {
    ScopedValidationDisable disable_validation;
    EXPECT_FALSE(empty_target.IsValid());
    EXPECT_FALSE(empty_target_msaa.IsValid());
  }
}

References impeller::RenderTarget::IsValid().

◆ TEST_P() [617/662]

impeller::testing::TEST_P	(	RenderTargetCacheTest	,
		DoesNotPersistFailedAllocations
	)

Definition at line 107 of file render_target_cache_unittests.cc.

                                                               {
  ScopedValidationDisable disable;
  auto allocator = std::make_shared<TestAllocator>();
  auto render_target_cache =
      RenderTargetCache(allocator, /*keep_alive_frame_count=*/0);
 
  render_target_cache.Start();
  allocator->should_fail = true;
 
  auto render_target =
      render_target_cache.CreateOffscreen(*GetContext(), {100, 100}, 1);
 
  EXPECT_FALSE(render_target.IsValid());
  EXPECT_EQ(render_target_cache.CachedTextureCount(), 0u);
}

References allocator.

◆ TEST_P() [618/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanCreatePipelineFromRuntimeStage
	)

Definition at line 446 of file runtime_stage_unittests.cc.

                                                            {
  auto stages_result = OpenAssetAsRuntimeStage("ink_sparkle.frag.iplr");
  ABSL_ASSERT_OK(stages_result);
  auto stage = stages_result.value()[GetRuntimeStageBackend()];
 
  ASSERT_TRUE(stage);
  ASSERT_NE(stage, nullptr);
  ASSERT_TRUE(RegisterStage(*stage));
  auto library = GetContext()->GetShaderLibrary();
  using VS = RuntimeEffectVertexShader;
  PipelineDescriptor desc;
  desc.SetLabel("Runtime Stage InkSparkle");
  desc.AddStageEntrypoint(
      library->GetFunction(VS::kEntrypointName, ShaderStage::kVertex));
  desc.AddStageEntrypoint(
      library->GetFunction(stage->GetEntrypoint(), ShaderStage::kFragment));
  auto vertex_descriptor = std::make_shared<VertexDescriptor>();
  vertex_descriptor->SetStageInputs(VS::kAllShaderStageInputs,
                                    VS::kInterleavedBufferLayout);
 
  std::array<DescriptorSetLayout, 2> descriptor_set_layouts = {
      VS::kDescriptorSetLayouts[0],
      DescriptorSetLayout{
          .binding = 64u,
          .descriptor_type = DescriptorType::kUniformBuffer,
          .shader_stage = ShaderStage::kFragment,
      },
  };
  vertex_descriptor->RegisterDescriptorSetLayouts(descriptor_set_layouts);
 
  desc.SetVertexDescriptor(std::move(vertex_descriptor));
  ColorAttachmentDescriptor color0;
  color0.format = GetContext()->GetCapabilities()->GetDefaultColorFormat();
  StencilAttachmentDescriptor stencil0;
  stencil0.stencil_compare = CompareFunction::kEqual;
  desc.SetColorAttachmentDescriptor(0u, color0);
  desc.SetStencilAttachmentDescriptors(stencil0);
  const auto stencil_fmt =
      GetContext()->GetCapabilities()->GetDefaultStencilFormat();
  desc.SetStencilPixelFormat(stencil_fmt);
  auto pipeline = GetContext()->GetPipelineLibrary()->GetPipeline(desc).Get();
  ASSERT_NE(pipeline, nullptr);
}

References impeller::PipelineDescriptor::AddStageEntrypoint(), impeller::DescriptorSetLayout::binding, impeller::ColorAttachmentDescriptor::format, impeller::kEqual, impeller::kFragment, impeller::kUniformBuffer, impeller::kVertex, pipeline, impeller::PipelineDescriptor::SetColorAttachmentDescriptor(), impeller::PipelineDescriptor::SetLabel(), impeller::PipelineDescriptor::SetStencilAttachmentDescriptors(), impeller::PipelineDescriptor::SetStencilPixelFormat(), impeller::PipelineDescriptor::SetVertexDescriptor(), and impeller::StencilAttachmentDescriptor::stencil_compare.

◆ TEST_P() [619/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniforms
	)

Definition at line 96 of file runtime_stage_unittests.cc.

                                          {
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping(
          "all_supported_uniforms.frag.iplr");
  ASSERT_TRUE(fixture);
  ASSERT_GT(fixture->GetSize(), 0u);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
 
  ASSERT_TRUE(stage);
  switch (GetBackend()) {
    case PlaygroundBackend::kMetal:
      [[fallthrough]];
    case PlaygroundBackend::kMetalSDF:
      [[fallthrough]];
    case PlaygroundBackend::kOpenGLES:
      [[fallthrough]];
    case PlaygroundBackend::kOpenGLESSDF: {
      ASSERT_EQ(stage->GetUniforms().size(), 14u);
      {
        // uFloat
        auto uni = stage->GetUniform("uFloat");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 0u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uVec2
        auto uni = stage->GetUniform("uVec2");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 1u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uVec3
        auto uni = stage->GetUniform("uVec3");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 3u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 2u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        auto padding = uni->padding_layout;
        if (GetBackend() == PlaygroundBackend::kMetal ||
            GetBackend() == PlaygroundBackend::kMetalSDF) {
          EXPECT_EQ(padding.size(), 4u);
          EXPECT_EQ(padding[0], RuntimePaddingType::kFloat);
          EXPECT_EQ(padding[1], RuntimePaddingType::kFloat);
          EXPECT_EQ(padding[2], RuntimePaddingType::kFloat);
          EXPECT_EQ(padding[3], RuntimePaddingType::kPadding);
        } else {
          EXPECT_TRUE(padding.empty());
        }
      }
      {
        // uVec4
        auto uni = stage->GetUniform("uVec4");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 3u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uMat2
        auto uni = stage->GetUniform("uMat2");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 2u);
        EXPECT_EQ(uni->location, 4u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uMat3
        auto uni = stage->GetUniform("uMat3");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 3u);
        EXPECT_EQ(uni->dimensions.cols, 3u);
        EXPECT_EQ(uni->location, 5u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        // uMat4
        auto uni = stage->GetUniform("uMat4");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 4u);
        EXPECT_EQ(uni->location, 6u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uFloatArray
        auto uni = stage->GetUniform("uFloatArray");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 1u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 7u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        auto uni = stage->GetUniform("uVec2Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 9u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uVec3Array
        auto uni = stage->GetUniform("uVec3Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 3u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 11u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        // uVec4Array
        auto uni = stage->GetUniform("uVec4Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 1u);
        EXPECT_EQ(uni->location, 13u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uMat2Array
        auto uni = stage->GetUniform("uMat2Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 2u);
        EXPECT_EQ(uni->dimensions.cols, 2u);
        EXPECT_EQ(uni->location, 15u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      {
        // uMat3Array
        auto uni = stage->GetUniform("uMat3Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 3u);
        EXPECT_EQ(uni->dimensions.cols, 3u);
        EXPECT_EQ(uni->location, 17u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
      }
      {
        // uMat4Array
        auto uni = stage->GetUniform("uMat4Array");
        ASSERT_NE(uni, nullptr);
        EXPECT_EQ(uni->dimensions.rows, 4u);
        EXPECT_EQ(uni->dimensions.cols, 4u);
        EXPECT_EQ(uni->location, 19u);
        EXPECT_EQ(uni->type, RuntimeUniformType::kFloat);
        EXPECT_TRUE(uni->padding_layout.empty());
      }
      break;
    }
    case PlaygroundBackend::kVulkan: {
      EXPECT_EQ(stage->GetUniforms().size(), 1u);
      const RuntimeUniformDescription* uni =
          stage->GetUniform(RuntimeStage::kVulkanUBOName);
      ASSERT_TRUE(uni);
      EXPECT_EQ(uni->type, RuntimeUniformType::kStruct);
      EXPECT_EQ(uni->struct_float_count, 26u);
 
      EXPECT_EQ(uni->GetGPUSize(), 640u);
      std::vector<RuntimePaddingType> layout(uni->GetGPUSize() / sizeof(float),
                                             RuntimePaddingType::kFloat);
      // uFloat and uVec2 are packed into a vec4 with 1 byte of padding between.
      layout[1] = RuntimePaddingType::kPadding;
      // uVec3 is packed as a vec4 with 1 byte of padding.
      layout[7] = RuntimePaddingType::kPadding;
      // uMat2 is packed as two vec4s, with the last 2 bytes of each being
      // padding.
      layout[14] = RuntimePaddingType::kPadding;
      layout[15] = RuntimePaddingType::kPadding;
      layout[18] = RuntimePaddingType::kPadding;
      layout[19] = RuntimePaddingType::kPadding;
      // uMat3 is packed as 3 vec4s, with the last byte of each being padding
      layout[23] = RuntimePaddingType::kPadding;
      layout[27] = RuntimePaddingType::kPadding;
      layout[31] = RuntimePaddingType::kPadding;
      // uFloatArray is packed as 2 vec4s, with the last 3 bytes of each
      // being padding.
      layout[49] = RuntimePaddingType::kPadding;
      layout[50] = RuntimePaddingType::kPadding;
      layout[51] = RuntimePaddingType::kPadding;
      layout[53] = RuntimePaddingType::kPadding;
      layout[54] = RuntimePaddingType::kPadding;
      layout[55] = RuntimePaddingType::kPadding;
      // uVec2Array is packed as 2 vec4s, with 2 bytes of padding at the end of
      // each.
      layout[58] = RuntimePaddingType::kPadding;
      layout[59] = RuntimePaddingType::kPadding;
      layout[62] = RuntimePaddingType::kPadding;
      layout[63] = RuntimePaddingType::kPadding;
      // uVec3Array is packed as 2 vec4s, with the last byte of each as padding.
      layout[67] = RuntimePaddingType::kPadding;
      layout[71] = RuntimePaddingType::kPadding;
      // uVec4Array has no padding.
      // uMat2Array[2] is packed as 4 vec4s, With the last 2 bytes of each being
      // padding.
      layout[82] = RuntimePaddingType::kPadding;
      layout[83] = RuntimePaddingType::kPadding;
      layout[86] = RuntimePaddingType::kPadding;
      layout[87] = RuntimePaddingType::kPadding;
      layout[90] = RuntimePaddingType::kPadding;
      layout[91] = RuntimePaddingType::kPadding;
      layout[94] = RuntimePaddingType::kPadding;
      layout[95] = RuntimePaddingType::kPadding;
      // uMat3Array[2] is packed as 6 vec4s, with the last byte of each being
      // padding.
      layout[99] = RuntimePaddingType::kPadding;
      layout[103] = RuntimePaddingType::kPadding;
      layout[107] = RuntimePaddingType::kPadding;
      layout[111] = RuntimePaddingType::kPadding;
      layout[115] = RuntimePaddingType::kPadding;
      layout[119] = RuntimePaddingType::kPadding;
      // uMat4Array[2] is packed as 8 vec4s with no padding.
      layout[152] = RuntimePaddingType::kPadding;
      layout[153] = RuntimePaddingType::kPadding;
      layout[154] = RuntimePaddingType::kPadding;
      layout[155] = RuntimePaddingType::kPadding;
      layout[156] = RuntimePaddingType::kPadding;
      layout[157] = RuntimePaddingType::kPadding;
      layout[158] = RuntimePaddingType::kPadding;
      layout[159] = RuntimePaddingType::kPadding;
 
      EXPECT_THAT(uni->padding_layout, ::testing::ElementsAreArray(layout));
 
      std::vector<std::pair<std::string, unsigned int>> expected_uniforms = {
          {"uFloat", 4},      {"uVec2", 8},       {"uVec3", 12},
          {"uVec4", 16},      {"uMat2", 16},      {"uMat3", 36},
          {"uMat4", 64},      {"uFloatArray", 8}, {"uVec2Array", 16},
          {"uVec3Array", 24}, {"uVec4Array", 32}, {"uMat2Array", 32},
          {"uMat3Array", 72}, {"uMat4Array", 128}};
 
      ASSERT_EQ(uni->struct_fields.size(), expected_uniforms.size());
 
      for (size_t i = 0; i < expected_uniforms.size(); ++i) {
        const auto& element = uni->struct_fields[i];
        const auto& expected = expected_uniforms[i];
 
        EXPECT_EQ(element.name, expected.first) << "index: " << i;
        EXPECT_EQ(element.byte_size, expected.second) << "index: " << i;
      }
      break;
    }
  }
}

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::RuntimeUniformDescription::GetGPUSize(), i, impeller::kFloat, impeller::kMetal, impeller::kMetalSDF, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::kPadding, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, flutter::testing::OpenFixtureAsMapping(), padding, impeller::RuntimeUniformDescription::padding_layout, impeller::RuntimeUniformDescription::struct_fields, impeller::RuntimeUniformDescription::struct_float_count, and impeller::RuntimeUniformDescription::type.

◆ TEST_P() [620/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerAfterUBO
	)

Definition at line 384 of file runtime_stage_unittests.cc.

                                                         {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only relevant for Vulkan";
  }
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping(
          "uniforms_and_sampler_2.frag.iplr");
  ASSERT_TRUE(fixture);
  ASSERT_GT(fixture->GetSize(), 0u);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
 
  EXPECT_EQ(stage->GetUniforms().size(), 2u);
  auto uni = stage->GetUniform(RuntimeStage::kVulkanUBOName);
  ASSERT_TRUE(uni);
  // Struct must be offset at 45.
  EXPECT_EQ(uni->type, RuntimeUniformType::kStruct);
  EXPECT_EQ(uni->binding, 64u);
  // Sampler should be offset at 64 but due to current bug
  // has offset of 0, the correct offset is computed at runtime.
  auto sampler_uniform = stage->GetUniform("u_texture");
  EXPECT_EQ(sampler_uniform->type, RuntimeUniformType::kSampledImage);
  EXPECT_EQ(sampler_uniform->binding, 65u);
}

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kSampledImage, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [621/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadUniformsSamplerBeforeUBO
	)

Definition at line 358 of file runtime_stage_unittests.cc.

                                                          {
  if (GetBackend() != PlaygroundBackend::kVulkan) {
    GTEST_SKIP() << "Test only relevant for Vulkan";
  }
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping(
          "uniforms_and_sampler_1.frag.iplr");
  ASSERT_TRUE(fixture);
  ASSERT_GT(fixture->GetSize(), 0u);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
 
  EXPECT_EQ(stage->GetUniforms().size(), 2u);
  auto uni = stage->GetUniform(RuntimeStage::kVulkanUBOName);
  ASSERT_TRUE(uni);
  // Struct must be offset at 65.
  EXPECT_EQ(uni->type, RuntimeUniformType::kStruct);
  EXPECT_EQ(uni->binding, 65u);
  // Sampler should be offset at 64 but due to current bug
  // has offset of 0, the correct offset is computed at runtime.
  auto sampler_uniform = stage->GetUniform("u_texture");
  EXPECT_EQ(sampler_uniform->type, RuntimeUniformType::kSampledImage);
  EXPECT_EQ(sampler_uniform->binding, 64u);
}

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kSampledImage, impeller::kStruct, impeller::kVulkan, impeller::RuntimeStage::kVulkanUBOName, and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [622/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanReadValidBlob
	)

Definition at line 34 of file runtime_stage_unittests.cc.

                                           {
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("ink_sparkle.frag.iplr");
  ASSERT_TRUE(fixture);
  ASSERT_GT(fixture->GetSize(), 0u);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(stage);
  ASSERT_EQ(stage->GetShaderStage(), RuntimeShaderStage::kFragment);
}

References impeller::RuntimeStage::DecodeRuntimeStages(), impeller::kFragment, and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [623/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanRegisterStage
	)

Definition at line 410 of file runtime_stage_unittests.cc.

                                           {
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("ink_sparkle.frag.iplr");
  ASSERT_TRUE(fixture);
  ASSERT_GT(fixture->GetSize(), 0u);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(stage);
  std::promise<bool> registration;
  auto future = registration.get_future();
  auto library = GetContext()->GetShaderLibrary();
  library->RegisterFunction(
      stage->GetEntrypoint(),                  //
      ToShaderStage(stage->GetShaderStage()),  //
      stage->GetCodeMapping(),                 //
      fml::MakeCopyable([reg = std::move(registration)](bool result) mutable {
        reg.set_value(result);
      }));
  ASSERT_TRUE(future.get());
  {
    auto function =
        library->GetFunction(stage->GetEntrypoint(), ShaderStage::kFragment);
    ASSERT_NE(function, nullptr);
  }
 
  // Check if unregistering works.
 
  library->UnregisterFunction(stage->GetEntrypoint(), ShaderStage::kFragment);
  {
    auto function =
        library->GetFunction(stage->GetEntrypoint(), ShaderStage::kFragment);
    ASSERT_EQ(function, nullptr);
  }
}

References impeller::RuntimeStage::DecodeRuntimeStages(), function, impeller::kFragment, fml::MakeCopyable(), flutter::testing::OpenFixtureAsMapping(), and impeller::ToShaderStage().

◆ TEST_P() [624/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		CanRejectInvalidBlob
	)

Definition at line 59 of file runtime_stage_unittests.cc.

                                               {
  ScopedValidationDisable disable_validation;
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("ink_sparkle.frag.iplr");
  ASSERT_TRUE(fixture);
  auto junk_allocation = std::make_shared<Allocation>();
  ASSERT_TRUE(junk_allocation->Truncate(Bytes{fixture->GetSize()}, false));
  // Not meant to be secure. Just reject obviously bad blobs using magic
  // numbers.
  ::memset(junk_allocation->GetBuffer(), 127,
           junk_allocation->GetLength().GetByteSize());
  auto stages = RuntimeStage::DecodeRuntimeStages(
      CreateMappingFromAllocation(junk_allocation));
  ASSERT_FALSE(stages.ok());
}

References impeller::CreateMappingFromAllocation(), impeller::RuntimeStage::DecodeRuntimeStages(), and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [625/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		ContainsExpectedShaderTypes
	)

Definition at line 490 of file runtime_stage_unittests.cc.

                                                      {
  auto stages_result = OpenAssetAsRuntimeStage("ink_sparkle.frag.iplr");
  ABSL_ASSERT_OK(stages_result);
  auto stages = stages_result.value();
  EXPECT_TRUE(stages[RuntimeStageBackend::kSkSL]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kOpenGLES]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kMetal]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kVulkan]);
}

References impeller::kMetal, impeller::kOpenGLES, impeller::kSkSL, and impeller::kVulkan.

◆ TEST_P() [626/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		ContainsExpectedShaderTypesNoSksl
	)

Definition at line 500 of file runtime_stage_unittests.cc.

                                                            {
  auto stages_result =
      OpenAssetAsRuntimeStage("runtime_stage_simple_no_sksl.frag.iplr");
  ABSL_ASSERT_OK(stages_result);
  auto stages = stages_result.value();
  EXPECT_FALSE(stages[RuntimeStageBackend::kSkSL]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kOpenGLES]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kMetal]);
  EXPECT_TRUE(stages[RuntimeStageBackend::kVulkan]);
}

References impeller::kMetal, impeller::kOpenGLES, impeller::kSkSL, and impeller::kVulkan.

◆ TEST_P() [627/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		RejectInvalidFormatVersion
	)

Definition at line 46 of file runtime_stage_unittests.cc.

                                                     {
  flatbuffers::FlatBufferBuilder builder;
  fb::RuntimeStagesBuilder stages_builder(builder);
  stages_builder.add_format_version(0);
  auto stages = stages_builder.Finish();
  builder.Finish(stages, fb::RuntimeStagesIdentifier());
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      builder.GetBufferPointer(), builder.GetSize());
  auto runtime_stages = RuntimeStage::DecodeRuntimeStages(mapping);
  EXPECT_FALSE(runtime_stages.ok());
  EXPECT_EQ(runtime_stages.status().code(), absl::StatusCode::kInvalidArgument);
}

References impeller::RuntimeStage::DecodeRuntimeStages().

◆ TEST_P() [628/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		RejectsCorruptBufferWithValidIdentifier
	)

Definition at line 75 of file runtime_stage_unittests.cc.

                                                                  {
  ScopedValidationDisable disable_validation;
  // Construct a buffer with a valid "IPLR" file identifier at bytes 4-7
  // but a root table offset that points beyond the buffer. This passes
  // the identifier check but fails FlatBuffer structural verification.
  auto data = std::make_shared<std::vector<uint8_t>>(32, 0);
  (*data)[4] = 'I';
  (*data)[5] = 'P';
  (*data)[6] = 'L';
  (*data)[7] = 'R';
  // Root offset (little-endian uint32 at offset 0) pointing out of bounds.
  (*data)[0] = 0xFF;
  (*data)[1] = 0xFF;
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      data->data(), data->size(), [data](auto, auto) {});
  auto stages = RuntimeStage::DecodeRuntimeStages(mapping);
  ASSERT_FALSE(stages.ok());
  EXPECT_EQ(stages.status().code(), absl::StatusCode::kInvalidArgument);
}

References flutter::data, and impeller::RuntimeStage::DecodeRuntimeStages().

◆ TEST_P() [629/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		RuntimeStageHasUniqueLibraryIdByDefault
	)

Definition at line 571 of file runtime_stage_unittests.cc.

                                                                  {
  // Two stages decoded independently must get distinct fallback library ids
  // so that programmatically-constructed stages cannot collide with each
  // other in the shared shader library.
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("ink_sparkle.frag.iplr");
  ASSERT_TRUE(fixture);
  auto stages_a = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages_a);
  auto stages_b = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages_b);
  auto stage_a = stages_a.value()[GetRuntimeStageBackend()];
  auto stage_b = stages_b.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(stage_a);
  ASSERT_TRUE(stage_b);
  EXPECT_FALSE(stage_a->GetLibraryId().empty());
  EXPECT_FALSE(stage_b->GetLibraryId().empty());
  EXPECT_NE(stage_a->GetLibraryId(), stage_b->GetLibraryId());
}

References impeller::RuntimeStage::DecodeRuntimeStages(), and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [630/662]

impeller::testing::TEST_P	(	RuntimeStageTest	,
		RuntimeStageLibraryIdCanBeOverridden
	)

Definition at line 591 of file runtime_stage_unittests.cc.

                                                               {
  // FragmentProgram::initFromAsset overrides the fallback id with the asset
  // path so that hot reload of the same asset evicts and replaces the same
  // registry slot rather than leaking a new one.
  const std::shared_ptr<fml::Mapping> fixture =
      flutter::testing::OpenFixtureAsMapping("ink_sparkle.frag.iplr");
  ASSERT_TRUE(fixture);
  auto stages = RuntimeStage::DecodeRuntimeStages(fixture);
  ABSL_ASSERT_OK(stages);
  auto stage = stages.value()[GetRuntimeStageBackend()];
  ASSERT_TRUE(stage);
  stage->SetLibraryId("packages/my_pkg/assets/shader.frag");
  EXPECT_EQ(stage->GetLibraryId(), "packages/my_pkg/assets/shader.frag");
}

References impeller::RuntimeStage::DecodeRuntimeStages(), and flutter::testing::OpenFixtureAsMapping().

◆ TEST_P() [631/662]

impeller::testing::TEST_P	(	SurfaceGLESTest	,
		CanWrapNonZeroFBO
	)

Definition at line 16 of file surface_gles_unittests.cc.

                                           {
  const GLuint fbo = 1988;
  auto surface =
      SurfaceGLES::WrapFBO(GetContext(), []() { return true; }, fbo,
                           PixelFormat::kR8G8B8A8UNormInt, {100, 100});
  ASSERT_TRUE(!!surface);
  ASSERT_TRUE(surface->IsValid());
  ASSERT_TRUE(surface->GetRenderTarget().HasColorAttachment(0));
  const auto& texture = TextureGLES::Cast(
      *(surface->GetRenderTarget().GetColorAttachment(0).texture));
  auto wrapped = texture.GetFBO();
  ASSERT_TRUE(wrapped.has_value());
  // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
  ASSERT_EQ(wrapped.value(), fbo);
}

References impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::kR8G8B8A8UNormInt, surface, texture, and impeller::SurfaceGLES::WrapFBO().

◆ TEST_P() [632/662]

impeller::testing::TEST_P	(	SwapchainTransientsMTLTest	,
		CanAllocateSwapchainTextures
	)

Definition at line 27 of file swapchain_transients_mtl_unittests.mm.

                                                                 {
  const auto& transients = std::make_shared<SwapchainTransientsMTL>(
      GetContext()->GetResourceAllocator());
 
  transients->SetSizeAndFormat({1, 1}, PixelFormat::kB8G8R8A8UNormInt);
 
  auto resolve = transients->GetResolveTexture();
  EXPECT_NE(resolve, nullptr);
  EXPECT_NE(transients->GetMSAATexture(), nullptr);
  EXPECT_NE(transients->GetDepthStencilTexture(), nullptr);
 
  // Texture properties are correct for resolve.
  EXPECT_EQ(resolve->GetTextureDescriptor().size, ISize(1, 1));
  EXPECT_EQ(resolve->GetTextureDescriptor().format,
            PixelFormat::kB8G8R8A8UNormInt);
  EXPECT_EQ(resolve->GetTextureDescriptor().sample_count, SampleCount::kCount1);
  EXPECT_EQ(resolve->GetTextureDescriptor().storage_mode,
            StorageMode::kDevicePrivate);
 
  // Texture properties are correct for MSAA.
  auto msaa = transients->GetMSAATexture();
  EXPECT_EQ(msaa->GetTextureDescriptor().size, ISize(1, 1));
  EXPECT_EQ(msaa->GetTextureDescriptor().format,
            PixelFormat::kB8G8R8A8UNormInt);
  EXPECT_EQ(msaa->GetTextureDescriptor().sample_count, SampleCount::kCount4);
  EXPECT_EQ(msaa->GetTextureDescriptor().storage_mode,
            StorageMode::kDeviceTransient);
 
  // Texture properties are correct for Depth+Stencil.
  auto depth_stencil = transients->GetDepthStencilTexture();
  EXPECT_EQ(depth_stencil->GetTextureDescriptor().size, ISize(1, 1));
  EXPECT_EQ(depth_stencil->GetTextureDescriptor().format,
            PixelFormat::kD32FloatS8UInt);
  EXPECT_EQ(depth_stencil->GetTextureDescriptor().sample_count,
            SampleCount::kCount4);
  EXPECT_EQ(depth_stencil->GetTextureDescriptor().storage_mode,
            StorageMode::kDeviceTransient);
 
  // Textures are cached.
  EXPECT_EQ(transients->GetResolveTexture(), resolve);
 
  // Texture cache is invalidated when size changes.
  transients->SetSizeAndFormat({2, 2}, PixelFormat::kB8G8R8A8UNormInt);
  EXPECT_NE(resolve, transients->GetResolveTexture());
  resolve = transients->GetResolveTexture();
 
  // Texture cache is invalidated when pixel format changes.
  transients->SetSizeAndFormat({2, 2}, PixelFormat::kB10G10R10A10XR);
  EXPECT_NE(resolve, transients->GetResolveTexture());
}

References impeller::kB10G10R10A10XR, impeller::kB8G8R8A8UNormInt, impeller::kCount1, impeller::kCount4, impeller::kD32FloatS8UInt, impeller::kDevicePrivate, and impeller::kDeviceTransient.

◆ TEST_P() [633/662]

impeller::testing::TEST_P	(	TessellatorPlaygroundTest	,
		TessellateConvex16or32Bit
	)

Definition at line 26 of file tessellator_playground_unittests.cc.

                                                             {
  auto tessellator16 = std::make_shared<Tessellator>(false);
  auto tessellator32 = std::make_shared<Tessellator>(true);
 
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  auto indexes_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
 
  auto path = flutter::DlPath::MakeRect(Rect::MakeLTRB(0, 0, 10, 10));
 
  auto vertex_buffer16 = tessellator16->TessellateConvex(
      path, *data_host_buffer, *indexes_host_buffer, 1.0, false, false);
  auto vertex_buffer32 = tessellator32->TessellateConvex(
      path, *data_host_buffer, *indexes_host_buffer, 1.0, false, false);
 
  const std::vector<Point> expected = {
      {0, 0}, {10, 0}, {10, 10}, {0, 10}, {0, 0}};
  const std::vector<uint16_t> expected_indices = {0, 1, 3, 2};
 
  EXPECT_EQ(vertex_buffer16.index_type, IndexType::k16bit);
  EXPECT_EQ(expected, CopyBufferView<Point>(vertex_buffer16.vertex_buffer));
  EXPECT_EQ(expected_indices,
            CopyBufferView<uint16_t>(vertex_buffer16.index_buffer));
 
  EXPECT_EQ(vertex_buffer32.index_type, IndexType::k32bit);
  EXPECT_EQ(expected, CopyBufferView<Point>(vertex_buffer32.vertex_buffer));
  EXPECT_EQ(
      std::vector<uint32_t>(expected_indices.begin(), expected_indices.end()),
      CopyBufferView<uint32_t>(vertex_buffer32.index_buffer));
}

References impeller::HostBuffer::Create(), impeller::k16bit, impeller::k32bit, impeller::TRect< Scalar >::MakeLTRB(), flutter::DlPath::MakeRect(), and flutter::path.

◆ TEST_P() [634/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		MaintainsShape
	)

Definition at line 186 of file text_contents_unittests.cc.

                                         {
  std::shared_ptr<TextFrame> text_frame =
      MakeTextFrame("th", "ahem.ttf", TextOptions{.font_size = 50});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
 
  for (int i = 0; i <= 1000; ++i) {
    Scalar scale = (440.0f + i) / 1000.0f;
    Matrix transform = Matrix::MakeScale({scale, scale, 1.0f});
    Rect position_rect[2];
    Rect uv_rect[2];
 
    {
      std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(12);
 
      std::shared_ptr<GlyphAtlas> atlas =
          CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                           GlyphAtlas::Type::kAlphaBitmap, transform,
                           atlas_context, text_frame, /*offset=*/{0, 0});
      ISize texture_size = atlas->GetTexture()->GetSize();
 
      TextContents::ComputeVertexData(
          /*vtx_contents=*/data.data(),
          /*entity_transform=*/transform,
          /*frame=*/text_frame,
          /*position=*/Point(0, 0),
          /*screen_transform=*/transform,
          /*glyph_properties=*/GlyphProperties{},
          /*atlas=*/atlas);
      position_rect[0] = PerVertexDataPositionToRect(data.begin());
      uv_rect[0] = PerVertexDataUVToRect(data.begin(), texture_size);
      position_rect[1] = PerVertexDataPositionToRect(data.begin() + 4);
      uv_rect[1] = PerVertexDataUVToRect(data.begin() + 4, texture_size);
    }
    EXPECT_NEAR(GetAspectRatio(position_rect[1]), GetAspectRatio(uv_rect[1]),
                0.001)
        << i;
  }
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, i, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), and transform.

◆ TEST_P() [635/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleComputeVertexData
	)

Definition at line 108 of file text_contents_unittests.cc.

                                                  {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
 
  std::shared_ptr<TextFrame> text_frame =
      MakeTextFrame("1", "ahem.ttf", TextOptions{.font_size = 50});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       text_frame, /*offset=*/{0, 0});
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(data.data(),
                                  /*entity_transform=*/Matrix(),
                                  /*frame=*/text_frame,
                                  /*position=*/Point(0, 0),
                                  /*screen_transform=*/Matrix(),
                                  /*glyph_properties=*/GlyphProperties{},
                                  /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  // The -1 offset comes from Skia in `ComputeGlyphSize`. So since the font size
  // is 50, the math appears to be to get back a 50x50 rect and apply 1 pixel
  // of padding.
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [636/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleComputeVertexData2x
	)

Definition at line 148 of file text_contents_unittests.cc.

                                                    {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
  std::shared_ptr<TextFrame> text_frame =
      MakeTextFrame("1", "ahem.ttf", TextOptions{.font_size = 50});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  Matrix render_transform = Matrix::MakeScale({2.0f, 2.0f, 1.0f});
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, render_transform,
                       atlas_context, text_frame, /*offset=*/{0, 0});
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(
      /*vtx_contents=*/data.data(),
      /*entity_transform=*/render_transform,
      /*frame=*/text_frame,
      /*position=*/Point(0, 0),
      /*screen_transform=*/render_transform,
      /*glyph_properties=*/GlyphProperties{},
      /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -81, 102, 102));
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 102, 102));
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [637/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel
	)

Definition at line 232 of file text_contents_unittests.cc.

                                         {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
 
  std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
      "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  Point offset = Point(0.5, 0);
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       text_frame, offset);
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(
      /*vtx_contents=*/data.data(),
      /*entity_transform=*/Matrix(),
      /*frame=*/text_frame,
      /*position=*/offset,
      /*screen_transform=*/Matrix(),
      /*glyph_properties=*/GlyphProperties{},
      /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  // The values at Point(0, 0).
  // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
  // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [638/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel26
	)

Definition at line 319 of file text_contents_unittests.cc.

                                           {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
 
  std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
      "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  Point offset = Point(0.26, 0);
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       text_frame, offset);
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(
      /*vtx_contents=*/data.data(),
      /*entity_transform=*/Matrix(),
      /*frame=*/text_frame,
      /*position=*/offset,
      /*screen_transform=*/Matrix(),
      /*glyph_properties=*/GlyphProperties{},
      /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  // The values without subpixel.
  // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
  // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [639/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel3x
	)

Definition at line 274 of file text_contents_unittests.cc.

                                           {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
 
  std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
      "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  Matrix transform = Matrix::MakeScale({3.0f, 3.0f, 1.0f});
  Point offset = {0.16667, 0};
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, transform, atlas_context,
                       text_frame, offset);
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(
      /*vtx_contents=*/data.data(),
      /*entity_transform=*/transform,
      /*frame=*/text_frame,
      /*position=*/offset,
      /*screen_transform=*/transform,
      /*glyph_properties=*/GlyphProperties{},
      /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  // Values at Point(0, 0)
  // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -121, 152, 152));
  // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 152, 152));
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -121, 154, 152))
      << "position size:" << position_rect.GetSize();
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 154, 152))
      << "position size:" << position_rect.GetSize();
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), impeller::TRect< Scalar >::MakeXYWH(), and transform.

◆ TEST_P() [640/662]

impeller::testing::TEST_P	(	TextContentsTest	,
		SimpleSubpixel80
	)

Definition at line 361 of file text_contents_unittests.cc.

                                           {
#ifndef FML_OS_MACOSX
  GTEST_SKIP() << "Results aren't stable across linux and macos.";
#endif
 
  std::vector<GlyphAtlasPipeline::VertexShader::PerVertexData> data(4);
 
  std::shared_ptr<TextFrame> text_frame = MakeTextFrame(
      "1", "ahem.ttf", TextOptions{.font_size = 50, .is_subpixel = true});
 
  std::shared_ptr<TypographerContext> context = TypographerContextSkia::Make();
  std::shared_ptr<GlyphAtlasContext> atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  std::shared_ptr<HostBuffer> data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  Point offset = Point(0.80, 0);
  std::shared_ptr<GlyphAtlas> atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       text_frame, offset);
 
  ISize texture_size = atlas->GetTexture()->GetSize();
  TextContents::ComputeVertexData(
      /*vtx_contents=*/data.data(),
      /*entity_transform=*/Matrix(),
      /*frame=*/text_frame,
      /*position=*/offset,
      /*screen_transform=*/Matrix(),
      /*glyph_properties=*/GlyphProperties{},
      /*atlas=*/atlas);
 
  Rect position_rect = PerVertexDataPositionToRect(data.begin());
  Rect uv_rect = PerVertexDataUVToRect(data.begin(), texture_size);
  // The values without subpixel.
  // EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-1, -41, 52, 52));
  // EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 52, 52));
  EXPECT_RECT_NEAR(position_rect, Rect::MakeXYWH(-2, -41, 54, 52));
  EXPECT_RECT_NEAR(uv_rect, Rect::MakeXYWH(1.0, 1.0, 54, 52));
}

References impeller::TextContents::ComputeVertexData(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::data, EXPECT_RECT_NEAR, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::TRect< Scalar >::MakeXYWH().

◆ TEST_P() [641/662]

impeller::testing::TEST_P	(	TextureGLESTest	,
		Binds2DTexture
	)

Definition at line 102 of file texture_gles_unittests.cc.

                                        {
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.size = {100, 100};
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
  desc.type = TextureType::kTexture2DMultisample;
  desc.sample_count = SampleCount::kCount4;
 
  auto texture = GetContext()->GetResourceAllocator()->CreateTexture(desc);
 
  ASSERT_TRUE(texture);
 
  if (GetContext()->GetCapabilities()->SupportsImplicitResolvingMSAA()) {
    EXPECT_EQ(
        TextureGLES::Cast(*texture).ComputeTypeForBinding(GL_READ_FRAMEBUFFER),
        TextureGLES::Type::kTexture);
    EXPECT_EQ(TextureGLES::Cast(*texture).ComputeTypeForBinding(GL_FRAMEBUFFER),
              TextureGLES::Type::kTextureMultisampled);
  } else {
    EXPECT_EQ(
        TextureGLES::Cast(*texture).ComputeTypeForBinding(GL_READ_FRAMEBUFFER),
        TextureGLES::Type::kRenderBufferMultisampled);
    EXPECT_EQ(TextureGLES::Cast(*texture).ComputeTypeForBinding(GL_FRAMEBUFFER),
              TextureGLES::Type::kRenderBufferMultisampled);
  }
}

References impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::TextureGLES::ComputeTypeForBinding(), impeller::TextureDescriptor::format, impeller::kCount4, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::TextureGLES::kRenderBufferMultisampled, impeller::TextureGLES::kTexture, impeller::kTexture2DMultisample, impeller::TextureGLES::kTextureMultisampled, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::type.

◆ TEST_P() [642/662]

impeller::testing::TEST_P	(	TextureGLESTest	,
		CanSetSyncFence
	)

Definition at line 22 of file texture_gles_unittests.cc.

                                         {
  ContextGLES& context_gles = ContextGLES::Cast(*GetContext());
  if (!context_gles.GetReactor()
           ->GetProcTable()
           .GetDescription()
           ->GetGlVersion()
           .IsAtLeast(Version{3, 0, 0})) {
    GTEST_SKIP() << "GL Version too low to test sync fence.";
  }
 
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.size = {100, 100};
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
 
  auto texture = GetContext()->GetResourceAllocator()->CreateTexture(desc);
  ASSERT_TRUE(!!texture);
 
  EXPECT_TRUE(GetContext()->AddTrackingFence(texture));
  EXPECT_TRUE(context_gles.GetReactor()->React());
 
  std::optional<HandleGLES> sync_fence =
      TextureGLES::Cast(*texture).GetSyncFence();
  ASSERT_TRUE(sync_fence.has_value());
  if (!sync_fence.has_value()) {
    return;
  }
  EXPECT_EQ(sync_fence.value().GetType(), HandleType::kFence);
 
  std::optional<GLsync> sync =
      context_gles.GetReactor()->GetGLFence(sync_fence.value());
  ASSERT_TRUE(sync.has_value());
  if (!sync.has_value()) {
    return;
  }
 
  // Now queue up operation that binds texture to verify that sync fence is
  // waited and removed.
 
  EXPECT_TRUE(
      context_gles.GetReactor()->AddOperation([&](const ReactorGLES& reactor) {
        return TextureGLES::Cast(*texture).Bind();
      }));
 
  sync_fence = TextureGLES::Cast(*texture).GetSyncFence();
  ASSERT_FALSE(sync_fence.has_value());
}

References impeller::BackendCast< ContextGLES, Context >::Cast(), impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::TextureDescriptor::format, impeller::ContextGLES::GetReactor(), impeller::TextureGLES::GetSyncFence(), impeller::kDevicePrivate, impeller::kFence, impeller::kR8G8B8A8UNormInt, reactor, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and texture.

◆ TEST_P() [643/662]

impeller::testing::TEST_P	(	TextureGLESTest	,
		CreatingAndBindingEmptyTexturesDoesNotCrash
	)

Definition at line 151 of file texture_gles_unittests.cc.

                                                                     {
  ContextGLES& context_gles = ContextGLES::Cast(*GetContext());
  const ProcTableGLES& gl = context_gles.GetReactor()->GetProcTable();
  GLuint texture_name;
  gl.GenTextures(1, &texture_name);
 
  TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = StorageMode::kDevicePrivate;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = ISize(0, 0);
  texture_descriptor.mip_count = 1u;
 
  impeller::HandleGLES texture_handle = context_gles.GetReactor()->CreateHandle(
      impeller::HandleType::kTexture, texture_name);
  auto texture = TextureGLES::WrapTexture(context_gles.GetReactor(),
                                          texture_descriptor, texture_handle);
  // The texture descriptor is invalid because its size is empty, so WrapTexture
  // will return null.
  ASSERT_EQ(texture, nullptr);
}

References impeller::BackendCast< ContextGLES, Context >::Cast(), impeller::TextureDescriptor::format, impeller::ContextGLES::GetReactor(), impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kTexture, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureGLES::WrapTexture().

◆ TEST_P() [644/662]

impeller::testing::TEST_P	(	TextureGLESTest	,
		Leak
	)

Definition at line 129 of file texture_gles_unittests.cc.

                              {
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.size = {100, 100};
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
  desc.type = TextureType::kTexture2D;
  desc.sample_count = SampleCount::kCount1;
 
  auto texture = GetContext()->GetResourceAllocator()->CreateTexture(desc);
 
  ASSERT_TRUE(texture);
 
  std::optional<GLuint> handle = TextureGLES::Cast(*texture).GetGLHandle();
  EXPECT_TRUE(handle.has_value());
 
  TextureGLES::Cast(*texture).Leak();
 
  ScopedValidationDisable disable_validation;
  handle = TextureGLES::Cast(*texture).GetGLHandle();
  EXPECT_FALSE(handle.has_value());
}

References impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::TextureDescriptor::format, impeller::TextureGLES::GetGLHandle(), impeller::kCount1, impeller::kDevicePrivate, impeller::kR8G8B8A8UNormInt, impeller::kTexture2D, impeller::TextureGLES::Leak(), impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, and impeller::TextureDescriptor::type.

◆ TEST_P() [645/662]

impeller::testing::TEST_P	(	TextureGLESTest	,
		TextureDtorDeletesFence
	)

Definition at line 70 of file texture_gles_unittests.cc.

                                                 {
  ContextGLES& context_gles = ContextGLES::Cast(*GetContext());
  if (!context_gles.GetReactor()
           ->GetProcTable()
           .GetDescription()
           ->GetGlVersion()
           .IsAtLeast(Version{3, 0, 0})) {
    GTEST_SKIP() << "GL Version too low to test sync fence.";
  }
 
  TextureDescriptor desc;
  desc.storage_mode = StorageMode::kDevicePrivate;
  desc.size = {100, 100};
  desc.format = PixelFormat::kR8G8B8A8UNormInt;
 
  auto texture = GetContext()->GetResourceAllocator()->CreateTexture(desc);
  ASSERT_TRUE(!!texture);
 
  HandleGLES fence =
      context_gles.GetReactor()->CreateHandle(HandleType::kFence);
  bool fence_collected = false;
  context_gles.GetReactor()->RegisterCleanupCallback(
      fence, [&]() { fence_collected = true; });
  TextureGLES::Cast(*texture).SetFence(fence);
 
  texture.reset();
  ASSERT_TRUE(context_gles.GetReactor()->AddOperation(
      [](const ReactorGLES& reactor) {}));
  ASSERT_TRUE(context_gles.GetReactor()->React());
  EXPECT_TRUE(fence_collected);
}

References impeller::BackendCast< ContextGLES, Context >::Cast(), impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::TextureDescriptor::format, impeller::ContextGLES::GetReactor(), impeller::kDevicePrivate, impeller::kFence, impeller::kR8G8B8A8UNormInt, reactor, impeller::TextureGLES::SetFence(), impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, and texture.

◆ TEST_P() [646/662]

impeller::testing::TEST_P	(	TypographerTest	,
		AlphaBitmapAtlasSkiaBitmapIsA8
	)

Definition at line 595 of file typographer_unittests.cc.

                                                        {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("A", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
 
  SkImageInfo image_info = TypographerContextSkia::GetImageInfo(
      *atlas, Size{100, 100}, /*support_light_glyphs=*/false);
  EXPECT_EQ(image_info.colorType(), kAlpha_8_SkColorType);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::TypographerContextSkia::GetImageInfo(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [647/662]

impeller::testing::TEST_P	(	TypographerTest	,
		AlphaBitmapAtlasWithLightGlyphsSkiaBitmapIsRGBA8888
	)

Definition at line 616 of file typographer_unittests.cc.

                                                                             {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("A", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
 
  SkImageInfo image_info = TypographerContextSkia::GetImageInfo(
      *atlas, Size{100, 100}, /*support_light_glyphs=*/true);
  EXPECT_EQ(image_info.colorType(), kRGBA_8888_SkColorType);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::TypographerContextSkia::GetImageInfo(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [648/662]

impeller::testing::TEST_P	(	TypographerTest	,
		CanConvertTextBlob
	)

Definition at line 68 of file typographer_unittests.cc.

                                            {
  SkFont font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString(
      "the quick brown fox jumped over the lazy dog.", font);
  ASSERT_TRUE(blob);
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
  ASSERT_EQ(frame->GetRunCount(), 1u);
  for (const auto& run : frame->GetRuns()) {
    ASSERT_TRUE(run.IsValid());
    ASSERT_EQ(run.GetGlyphCount(), 45u);
  }
}

References flutter::testing::CreateTestFontOfSize(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [649/662]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateGlyphAtlas
	)

Definition at line 86 of file typographer_unittests.cc.

                                             {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("hello", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
 
  ASSERT_NE(atlas, nullptr);
  ASSERT_NE(atlas->GetTexture(), nullptr);
  ASSERT_EQ(atlas->GetType(), GlyphAtlas::Type::kAlphaBitmap);
  ASSERT_EQ(atlas->GetGlyphCount(), 4llu);
 
  std::optional<impeller::ScaledFont> first_scaled_font;
  std::optional<impeller::SubpixelGlyph> first_glyph;
  Rect first_rect;
  atlas->IterateGlyphs([&](const ScaledFont& scaled_font,
                           const SubpixelGlyph& glyph,
                           const Rect& rect) -> bool {
    first_scaled_font = scaled_font;
    first_glyph = glyph;
    first_rect = rect;
    return false;
  });
 
  ASSERT_TRUE(first_scaled_font.has_value());
  ASSERT_TRUE(atlas
                  ->FindFontGlyphBounds(
                      {first_scaled_font.value(), first_glyph.value()})
                  .has_value());
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [650/662]

impeller::testing::TEST_P	(	TypographerTest	,
		CanCreateRenderContext
	)

Definition at line 81 of file typographer_unittests.cc.

                                                {
  auto context = TypographerContextSkia::Make();
  ASSERT_TRUE(context && context->IsValid());
}

References context, and impeller::TypographerContextSkia::Make().

◆ TEST_P() [651/662]

impeller::testing::TEST_P	(	TypographerTest	,
		ColorBitmapAtlasSkiaBitmapIsRGBA8888
	)

Definition at line 574 of file typographer_unittests.cc.

                                                              {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kColorBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("A", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kColorBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
 
  SkImageInfo image_info = TypographerContextSkia::GetImageInfo(
      *atlas, Size{100, 100}, /*support_light_glyphs=*/false);
  EXPECT_EQ(image_info.colorType(), kRGBA_8888_SkColorType);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::TypographerContextSkia::GetImageInfo(), impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [652/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasIsRecycledIfUnchanged
	)

Definition at line 189 of file typographer_unittests.cc.

                                                         {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("spooky skellingtons", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
  ASSERT_NE(atlas, nullptr);
  ASSERT_NE(atlas->GetTexture(), nullptr);
  ASSERT_EQ(atlas, atlas_context->GetGlyphAtlas());
 
  // now attempt to re-create an atlas with the same text blob.
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
  ASSERT_EQ(atlas, next_atlas);
  ASSERT_EQ(atlas_context->GetGlyphAtlas(), atlas);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [653/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureIsRecycledIfUnchanged
	)

Definition at line 269 of file typographer_unittests.cc.

                                                                {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("spooky 1", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
  auto old_packer = atlas_context->GetRectPacker();
 
  ASSERT_NE(atlas, nullptr);
  ASSERT_NE(atlas->GetTexture(), nullptr);
  ASSERT_EQ(atlas, atlas_context->GetGlyphAtlas());
 
  auto* first_texture = atlas->GetTexture().get();
 
  // Now create a new glyph atlas with a nearly identical blob.
 
  auto blob2 = SkTextBlob::MakeFromString("spooky 2", sk_font);
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob2));
  ASSERT_EQ(atlas, next_atlas);
  auto* second_texture = next_atlas->GetTexture().get();
 
  auto new_packer = atlas_context->GetRectPacker();
 
  ASSERT_EQ(second_texture, first_texture);
  ASSERT_EQ(old_packer, new_packer);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [654/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasTextureWillGrowTilMaxTextureSize
	)

Definition at line 477 of file typographer_unittests.cc.

                                                                    {
  if (GetBackend() == PlaygroundBackend::kOpenGLES ||
      GetBackend() == PlaygroundBackend::kOpenGLESSDF) {
    GTEST_SKIP() << "Atlas growth isn't supported for OpenGLES currently.";
  }
 
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("A", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
 
  SkFont sk_font_small = flutter::testing::CreateTestFontOfSize(10);
 
  ISize prev_atlas_size;
  for (int i = 0; i < 100; i++) {
    SkTextBlobBuilder builder;
 
    auto add_char = [&](const SkFont& sk_font, char c) {
      int count = sk_font.countText(&c, 1, SkTextEncoding::kUTF8);
      auto buffer = builder.allocRunPos(sk_font, count);
      sk_font.textToGlyphs(&c, 1, SkTextEncoding::kUTF8,
                           {buffer.glyphs, count});
      sk_font.getPos({buffer.glyphs, count}, {buffer.points(), count},
                     {0, 0} /*=origin*/);
    };
 
    SkFont sk_font = flutter::testing::CreateTestFontOfSize(50 + i);
    add_char(sk_font, 'A');
    add_char(sk_font_small, 'B');
    auto blob = builder.make();
 
    Matrix transform = Matrix::MakeScale({50.0f + i, 50.0f + i, 1.0f});
    atlas =
        CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                         GlyphAtlas::Type::kAlphaBitmap, transform,
                         atlas_context, MakeTextFrameFromTextBlobSkia(blob));
    ASSERT_TRUE(!!atlas);
    ISize atlas_size = atlas->GetTexture()->GetTextureDescriptor().size;
    if (atlas_size.width < prev_atlas_size.width ||
        atlas_size.height < prev_atlas_size.height) {
      // We've triggered an atlas flush and recreate. We're done.
 
      // The final atlas should contain both the "A" glyph (which was not
      // present in the previous atlas) and the "B" glyph (which existed
      // in the previous atlas).
      ASSERT_EQ(atlas->GetGlyphCount(), 2u);
      return;
    }
    prev_atlas_size = atlas_size;
  }
 
  // We never triggered the atlas recreate after 100 text calls.
  // Either something is wrong with the atlas code or we need to fix this test.
  GTEST_FAIL() << "Test did not encounter an atlas growth situation";
}

References flutter::buffer, c, context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::TSize< T >::height, i, impeller::GlyphAtlas::kAlphaBitmap, impeller::kOpenGLES, impeller::kOpenGLESSDF, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), impeller::MakeTextFrameFromTextBlobSkia(), transform, and impeller::TSize< T >::width.

◆ TEST_P() [655/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithLotsOfdUniqueGlyphSize
	)

Definition at line 218 of file typographer_unittests.cc.

                                                              {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  ASSERT_TRUE(context && context->IsValid());
 
  const char* test_string =
      "QWERTYUIOPASDFGHJKLZXCVBNMqewrtyuiopasdfghjklzxcvbnm,.<>[]{};':"
      "2134567890-=!@#$%^&*()_+"
      "œ∑´®†¥¨ˆøπ““‘‘åß∂ƒ©˙∆˚¬…æ≈ç√∫˜µ≤≥≥≥≥÷¡™£¢∞§¶•ªº–≠⁄€‹›ﬁﬂ‡°·‚—±Œ„´‰Á¨Ø∏”’/"
      "* Í˝ */¸˛Ç◊ı˜Â¯˘¿";
 
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString(test_string, sk_font);
  ASSERT_TRUE(blob);
 
  size_t size_count = 8;
  std::vector<RenderableText> render_frames;
  for (size_t index = 0; index < size_count; index += 1) {
    Scalar scale = 6.0f * index / 10.0f;
    render_frames.emplace_back(MakeTextFrameFromTextBlobSkia(blob),
                               Matrix::MakeScale({scale, scale, 1.0f}),
                               GlyphProperties{});
  };
  auto atlas = context->CreateGlyphAtlas(
      *GetContext(), GlyphAtlas::Type::kAlphaBitmap, *data_host_buffer,
      atlas_context, render_frames);
  ASSERT_NE(atlas, nullptr);
  ASSERT_NE(atlas->GetTexture(), nullptr);
 
  std::set<uint16_t> unique_glyphs;
  std::vector<uint16_t> total_glyphs;
  atlas->IterateGlyphs([&](const ScaledFont& scaled_font,
                           const SubpixelGlyph& glyph, const Rect& rect) {
    unique_glyphs.insert(glyph.glyph.index);
    total_glyphs.push_back(glyph.glyph.index);
    return true;
  });
 
  // These numbers may be different due to subpixel positions.
  EXPECT_LE(unique_glyphs.size() * size_count, atlas->GetGlyphCount());
  EXPECT_EQ(total_glyphs.size(), atlas->GetGlyphCount());
 
  EXPECT_TRUE(atlas->GetGlyphCount() > 0);
  EXPECT_TRUE(atlas->GetTexture()->GetSize().width > 0);
  EXPECT_TRUE(atlas->GetTexture()->GetSize().height > 0);
}

References context, impeller::HostBuffer::Create(), flutter::testing::CreateTestFontOfSize(), impeller::SubpixelGlyph::glyph, impeller::Glyph::index, impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::Matrix::MakeScale(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [656/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphAtlasWithOddUniqueGlyphSize
	)

Definition at line 167 of file typographer_unittests.cc.

                                                          {
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  ASSERT_TRUE(context && context->IsValid());
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString("AGH", sk_font);
  ASSERT_TRUE(blob);
  auto atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       MakeTextFrameFromTextBlobSkia(blob));
  ASSERT_NE(atlas, nullptr);
  ASSERT_NE(atlas->GetTexture(), nullptr);
 
  EXPECT_EQ(atlas->GetTexture()->GetSize().width, 4096u);
  EXPECT_EQ(atlas->GetTexture()->GetSize().height, 1024u);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [657/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsIgnoredForNonEmojiFonts
	)

Definition at line 344 of file typographer_unittests.cc.

                                                             {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  sk_sp<SkTypeface> typeface =
      font_mgr->matchFamilyStyle("Arial", SkFontStyle::Normal());
  SkFont sk_font(typeface, 0.5f);
 
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kColorBitmap);
 
  // Create two frames with the same character and a different color, but as a
  // non-emoji font the text frame constructor will ignore it.
  auto frame =
      MakeTextFrameFromTextBlobSkia(SkTextBlob::MakeFromString("A", sk_font));
  auto frame_2 =
      MakeTextFrameFromTextBlobSkia(SkTextBlob::MakeFromString("A", sk_font));
  std::vector<GlyphProperties> properties = {
      GlyphProperties{},
      GlyphProperties{},
  };
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kColorBitmap, Matrix(), atlas_context,
                       {frame, frame_2}, properties);
 
  EXPECT_EQ(next_atlas->GetGlyphCount(), 1u);
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), txt::GetDefaultFontManager(), impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [658/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphColorIsPartOfCacheKey
	)

Definition at line 308 of file typographer_unittests.cc.

                                                    {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
#if FML_OS_MACOSX
  auto mapping = flutter::testing::OpenFixtureAsSkData("Apple Color Emoji.ttc");
#else
  auto mapping = flutter::testing::OpenFixtureAsSkData("NotoColorEmoji.ttf");
#endif
  ASSERT_TRUE(mapping);
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont emoji_font(font_mgr->makeFromData(mapping), 50.0);
 
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kColorBitmap);
 
  // Create two frames with the same character and a different color, expect
  // that it adds a character.
  auto frame = MakeTextFrameFromTextBlobSkia(
      SkTextBlob::MakeFromString("😂", emoji_font));
  auto frame_2 = MakeTextFrameFromTextBlobSkia(
      SkTextBlob::MakeFromString("😂", emoji_font));
  std::vector<GlyphProperties> properties = {
      GlyphProperties{.tone_or_color = Color::Red()},
      GlyphProperties{.tone_or_color = Color::Blue()},
  };
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kColorBitmap, Matrix(), atlas_context,
                       {frame, frame_2}, properties);
 
  EXPECT_EQ(next_atlas->GetGlyphCount(), 2u);
}

References impeller::Color::Blue(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), txt::GetDefaultFontManager(), impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), impeller::MakeTextFrameFromTextBlobSkia(), flutter::testing::OpenFixtureAsSkData(), impeller::Color::Red(), and impeller::GlyphProperties::tone_or_color.

◆ TEST_P() [659/662]

impeller::testing::TEST_P	(	TypographerTest	,
		GlyphIsLightIsPartOfCacheKey
	)

Definition at line 376 of file typographer_unittests.cc.

                                                      {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
 
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
  auto blob1 = SkTextBlob::MakeFromString("A", sk_font);
  auto blob2 = SkTextBlob::MakeFromString("A", sk_font);
  auto frame1 = MakeTextFrameFromTextBlobSkia(blob1);
  auto frame2 = MakeTextFrameFromTextBlobSkia(blob2);
 
  std::vector<GlyphProperties> properties = {
      GlyphProperties{},
      GlyphProperties{},
  };
  // One light color, one dark color
  properties[0].tone_or_color = GlyphProperties::ComputeTone(Color::Beige());
  properties[1].tone_or_color = GlyphProperties::ComputeTone(Color::Crimson());
 
  auto next_atlas =
      CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                       GlyphAtlas::Type::kAlphaBitmap, Matrix(), atlas_context,
                       {frame1, frame2}, properties);
 
#if defined(FML_OS_MACOSX)
  // On Apple platforms, they should be separated into 2 entries
  EXPECT_EQ(next_atlas->GetGlyphCount(), 2u);
#else
  // On other platforms, both are classified as "dark" (false) and share 1 entry
  EXPECT_EQ(next_atlas->GetGlyphCount(), 1u);
#endif
}

References impeller::Color::Beige(), impeller::GlyphProperties::ComputeTone(), context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::Color::Crimson(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), impeller::MakeTextFrameFromTextBlobSkia(), and impeller::GlyphProperties::tone_or_color.

◆ TEST_P() [660/662]

impeller::testing::TEST_P	(	TypographerTest	,
		InvalidAtlasForcesRepopulation
	)

Definition at line 543 of file typographer_unittests.cc.

                                                        {
  SkFont font = flutter::testing::CreateTestFontOfSize(12);
  auto blob = SkTextBlob::MakeFromString(
      "the quick brown fox jumped over the lazy dog.", font);
  ASSERT_TRUE(blob);
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
 
  auto context = TypographerContextSkia::Make();
  auto atlas_context =
      context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
 
  auto atlas = CreateGlyphAtlas(*GetContext(), context.get(), *data_host_buffer,
                                GlyphAtlas::Type::kAlphaBitmap, Matrix(),
                                atlas_context, frame);
 
  auto second_context = TypographerContextSkia::Make();
  auto second_atlas_context =
      second_context->CreateGlyphAtlasContext(GlyphAtlas::Type::kAlphaBitmap);
 
  EXPECT_FALSE(second_atlas_context->GetGlyphAtlas()->IsValid());
 
  atlas = CreateGlyphAtlas(*GetContext(), second_context.get(),
                           *data_host_buffer, GlyphAtlas::Type::kAlphaBitmap,
                           Matrix(), second_atlas_context, frame);
 
  EXPECT_TRUE(second_atlas_context->GetGlyphAtlas()->IsValid());
}

References context, impeller::HostBuffer::Create(), CreateGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), impeller::GlyphAtlas::kAlphaBitmap, impeller::TypographerContextSkia::Make(), and impeller::MakeTextFrameFromTextBlobSkia().

◆ TEST_P() [661/662]

impeller::testing::TEST_P	(	TypographerTest	,
		LazyAtlasTracksColor
	)

Definition at line 126 of file typographer_unittests.cc.

                                              {
  auto data_host_buffer = HostBuffer::Create(
      GetContext()->GetResourceAllocator(), GetContext()->GetIdleWaiter(),
      GetContext()->GetCapabilities()->GetMinimumUniformAlignment());
#if FML_OS_MACOSX
  auto mapping = flutter::testing::OpenFixtureAsSkData("Apple Color Emoji.ttc");
#else
  auto mapping = flutter::testing::OpenFixtureAsSkData("NotoColorEmoji.ttf");
#endif
  ASSERT_TRUE(mapping);
  sk_sp<SkFontMgr> font_mgr = txt::GetDefaultFontManager();
  SkFont emoji_font(font_mgr->makeFromData(mapping), 50.0);
  SkFont sk_font = flutter::testing::CreateTestFontOfSize(12);
 
  auto blob = SkTextBlob::MakeFromString("hello", sk_font);
  ASSERT_TRUE(blob);
  auto frame = MakeTextFrameFromTextBlobSkia(blob);
 
  ASSERT_FALSE(frame->GetAtlasType() == GlyphAtlas::Type::kColorBitmap);
 
  LazyGlyphAtlas lazy_atlas(TypographerContextSkia::Make());
 
  lazy_atlas.AddTextFrame(frame, {0, 0}, Matrix(), {});
 
  frame = MakeTextFrameFromTextBlobSkia(
      SkTextBlob::MakeFromString("😀 ", emoji_font));
 
  ASSERT_TRUE(frame->GetAtlasType() == GlyphAtlas::Type::kColorBitmap);
 
  lazy_atlas.AddTextFrame(frame, {0, 0}, Matrix(), {});
 
  // Creates different atlases for color and red bitmap.
  auto color_atlas = lazy_atlas.CreateOrGetGlyphAtlas(
      *GetContext(), *data_host_buffer, GlyphAtlas::Type::kColorBitmap);
 
  auto bitmap_atlas = lazy_atlas.CreateOrGetGlyphAtlas(
      *GetContext(), *data_host_buffer, GlyphAtlas::Type::kAlphaBitmap);
 
  ASSERT_FALSE(color_atlas == bitmap_atlas);
}

References impeller::LazyGlyphAtlas::AddTextFrame(), impeller::HostBuffer::Create(), impeller::LazyGlyphAtlas::CreateOrGetGlyphAtlas(), flutter::testing::CreateTestFontOfSize(), txt::GetDefaultFontManager(), impeller::GlyphAtlas::kAlphaBitmap, impeller::GlyphAtlas::kColorBitmap, impeller::TypographerContextSkia::Make(), impeller::MakeTextFrameFromTextBlobSkia(), and flutter::testing::OpenFixtureAsSkData().

◆ TEST_P() [662/662]

impeller::testing::TEST_P	(	TypographerTest	,
		RectanglePackerAddsNonoverlapingRectangles
	)

Definition at line 412 of file typographer_unittests.cc.

                                                                    {
  auto packer = RectanglePacker::Factory(200, 100);
  ASSERT_NE(packer, nullptr);
  ASSERT_EQ(packer->PercentFull(), 0);
 
  const SkIRect packer_area = SkIRect::MakeXYWH(0, 0, 200, 100);
 
  IPoint16 first_output = {-1, -1};  // Fill with sentinel values
  ASSERT_TRUE(packer->AddRect(20, 20, &first_output));
  // Make sure the rectangle is placed such that it is inside the bounds of
  // the packer's area.
  const SkIRect first_rect =
      SkIRect::MakeXYWH(first_output.x(), first_output.y(), 20, 20);
  ASSERT_TRUE(SkIRect::Intersects(packer_area, first_rect));
 
  // Initial area was 200 x 100 = 20_000
  // We added 20x20 = 400. 400 / 20_000 == 0.02 == 2%
  ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.02));
 
  IPoint16 second_output = {-1, -1};
  ASSERT_TRUE(packer->AddRect(140, 90, &second_output));
  const SkIRect second_rect =
      SkIRect::MakeXYWH(second_output.x(), second_output.y(), 140, 90);
  // Make sure the rectangle is placed such that it is inside the bounds of
  // the packer's area but not in the are of the first rectangle.
  ASSERT_TRUE(SkIRect::Intersects(packer_area, second_rect));
  ASSERT_FALSE(SkIRect::Intersects(first_rect, second_rect));
 
  // We added another 90 x 140 = 12_600 units, now taking us to 13_000
  // 13_000 / 20_000 == 0.65 == 65%
  ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.65));
 
  // There's enough area to add this rectangle, but no space big enough for
  // the 50 units of width.
  IPoint16 output;
  ASSERT_FALSE(packer->AddRect(50, 50, &output));
  // Should be unchanged.
  ASSERT_TRUE(flutter::testing::NumberNear(packer->PercentFull(), 0.65));
 
  packer->Reset();
  // Should be empty now.
  ASSERT_EQ(packer->PercentFull(), 0);
}

References impeller::RectanglePacker::Factory(), flutter::testing::NumberNear(), impeller::IPoint16::x(), and impeller::IPoint16::y().

◆ toColor()

flutter::DlColor impeller::testing::toColor ( const float * components )

Definition at line 40 of file dl_unittests.cc.

                                                {
  return flutter::DlColor(Color::ToIColor(
      Color(components[0], components[1], components[2], components[3])));
}

References impeller::Color::ToIColor().

Referenced by TEST_P().

Variable Documentation

◆ g_extensions

std::vector<const char*> impeller::testing::g_extensions

static

Definition at line 22 of file mock_gles.cc.

Referenced by impeller::testing::MockGLES::Init(), impeller::testing::MockGLES::Init(), mockGetIntegerv(), and mockGetStringi().

◆ g_extensions_string

std::string impeller::testing::g_extensions_string

static

Definition at line 25 of file mock_gles.cc.

Referenced by impeller::testing::MockGLES::Init(), impeller::testing::MockGLES::Init(), and mockGetString().

◆ g_mock_gles

std::weak_ptr<MockGLES> impeller::testing::g_mock_gles

static

Definition at line 20 of file mock_gles.cc.

Referenced by impeller::testing::MockGLES::Init(), and impeller::testing::MockGLES::Init().

◆ g_test_lock

std::mutex impeller::testing::g_test_lock

static

Definition at line 18 of file mock_gles.cc.

Referenced by impeller::testing::MockGLES::Init(), impeller::testing::MockGLES::Init(), and impeller::testing::MockGLES::~MockGLES().

◆ g_version

const char* impeller::testing::g_version

static

Definition at line 24 of file mock_gles.cc.

Referenced by impeller::testing::MockGLES::Init(), impeller::testing::MockGLES::Init(), and mockGetString().

◆ golden_cubic_and_quad_points

std::vector<Point> impeller::testing::golden_cubic_and_quad_points

Definition at line 15 of file golden_paths.h.

                                                {
    {139.982, 19.5003}, {140.018, 20.4997}, {131.747, 19.8026},
    {131.783, 20.802},  {131.715, 19.8048}, {131.815, 20.7998},
    {123.622, 20.6102}, {123.721, 21.6053}, {123.59, 20.6145},
    {123.753, 21.601},  {115.652, 21.9306}, {115.816, 22.9171},
    {115.619, 21.9372}, {115.848, 22.9105}, {107.85, 23.7687},
    {108.08, 24.742},   {107.817, 23.7777}, {108.113, 24.733},
    {100.23, 26.1264},  {100.526, 27.0817}, {100.197, 26.1378},
    {100.558, 27.0703}, {92.8037, 29.0025}, {93.165, 29.935},
    {92.7736, 29.0154}, {93.1952, 29.9221}, {85.708, 32.3003},
    {86.1296, 33.2071}, {85.68, 32.3144},   {86.1576, 33.193},
    {78.8865, 36.008},  {79.3641, 36.8865}, {78.8588, 36.0242},
    {79.3918, 36.8703}, {72.3485, 40.125},  {72.8815, 40.9711},
    {72.3216, 40.1432}, {72.9084, 40.9529}, {66.1045, 44.6479},
    {66.6913, 45.4577}, {66.0788, 44.6679}, {66.717, 45.4378},
    {60.1632, 49.5711}, {60.8014, 50.341},  {60.139, 49.5924},
    {60.8255, 50.3196}, {54.5317, 54.8864}, {55.2183, 55.6136},
    {54.5094, 54.909},  {55.2406, 55.591},  {49.254, 60.5436},
    {49.9853, 61.2257}, {49.2329, 60.5677}, {50.0063, 61.2016},
    {44.3684, 66.5025}, {45.1418, 67.1364}, {44.3488, 66.5281},
    {45.1614, 67.1108}, {39.8827, 72.7564}, {40.6954, 73.3391},
    {39.8648, 72.7832}, {40.7133, 73.3123}, {35.8029, 79.297},
    {36.6515, 79.8261}, {35.7869, 79.3246}, {36.6675, 79.7985},
    {32.1328, 86.1144}, {33.0134, 86.5883}, {32.1188, 86.1424},
    {33.0273, 86.5603}, {28.8739, 93.1973}, {29.7824, 93.6152},
    {28.8613, 93.2272}, {29.795, 93.5853},  {26.0399, 100.583},
    {26.9736, 100.941}, {26.0288, 100.615}, {26.9847, 100.908},
    {23.7144, 108.15},  {24.6704, 108.444}, {23.7056, 108.183},
    {24.6792, 108.411}, {21.9002, 115.886}, {22.8738, 116.115},
    {21.8937, 115.919}, {22.8804, 116.082}, {20.5962, 123.779},
    {21.5828, 123.942}, {20.592, 123.812},  {21.5871, 123.91},
    {19.7985, 131.816}, {20.7936, 131.914}, {19.7964, 131.847},
    {20.7957, 131.883}, {19.5003, 139.982}, {20.4997, 140.018},
    {20.2883, 140.409}, {19.7117, 139.591}, {29.9421, 133.595},
    {29.3655, 132.778}, {29.9544, 133.586}, {29.3532, 132.787},
    {39.1905, 126.639}, {38.5894, 125.839}, {39.2039, 126.628},
    {38.576, 125.85},   {47.9822, 119.545}, {47.3542, 118.767},
    {47.9968, 119.533}, {47.3396, 118.779}, {56.2739, 112.316},
    {55.6167, 111.562}, {56.2898, 112.302}, {55.6008, 111.577},
    {64.0197, 104.952}, {63.3307, 104.228}, {64.0369, 104.935},
    {63.3134, 104.245}, {71.1714, 97.4578}, {70.4479, 96.7675},
    {71.1899, 97.4373}, {70.4294, 96.7879}, {77.6791, 89.8381},
    {76.9187, 89.1887}, {77.6987, 89.8137}, {76.8991, 89.2131},
    {83.4923, 82.1009}, {82.6928, 81.5003}, {83.5125, 82.0718},
    {82.6725, 81.5293}, {88.5609, 74.2563}, {87.7209, 73.7138},
    {88.5812, 74.2221}, {87.7007, 73.748},  {92.8369, 66.3173},
    {91.9564, 65.8432}, {92.8562, 66.2772}, {91.9371, 65.8833},
    {96.2756, 58.299},  {95.3564, 57.9051}, {96.2927, 58.253},
    {95.3393, 57.951},  {98.8374, 50.2196}, {97.8841, 49.9176},
    {98.8508, 50.1681}, {97.8708, 49.969},  {100.49, 42.0995},
    {99.51, 41.9005},   {100.49, 42.0995},  {99.51, 41.9005},
};

◆ kExtensions

auto const impeller::testing::kExtensions

Initial value:

= std::vector<const char*>{
    "GL_KHR_debug"  
}

Definition at line 38 of file mock_gles.cc.

                                               {
    "GL_KHR_debug"  //
};

Referenced by impeller::testing::MockGLES::Init(), and impeller::testing::MockGLES::Init().

◆ kFontFixture

constexpr std::string_view impeller::testing::kFontFixture

staticconstexpr

Initial value:

=
 
    "NotoColorEmoji.ttf"

Definition at line 378 of file aiks_dl_text_unittests.cc.

Referenced by TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), TEST_P(), and TEST_P().

◆ kMagicFailingAllocation

constexpr const size_t impeller::testing::kMagicFailingAllocation = 1024000 * 2

staticconstexpr

Definition at line 191 of file host_buffer_unittests.cc.

Referenced by impeller::testing::FailingAllocator::OnCreateBuffer(), and TEST_P().

◆ kMockResolverGLES

const ProcTableGLES::Resolver impeller::testing::kMockResolverGLES

Definition at line 459 of file mock_gles.cc.

                                                                     {
  if (strcmp(name, "glPopDebugGroupKHR") == 0) {
    return reinterpret_cast<void*>(&mockPopDebugGroupKHR);
  } else if (strcmp(name, "glPushDebugGroupKHR") == 0) {
    return reinterpret_cast<void*>(&mockPushDebugGroupKHR);
  } else if (strcmp(name, "glGetString") == 0) {
    return reinterpret_cast<void*>(&mockGetString);
  } else if (strcmp(name, "glGetStringi") == 0) {
    return reinterpret_cast<void*>(&mockGetStringi);
  } else if (strcmp(name, "glGetIntegerv") == 0) {
    return reinterpret_cast<void*>(&mockGetIntegerv);
  } else if (strcmp(name, "glGetError") == 0) {
    return reinterpret_cast<void*>(&mockGetError);
  } else if (strcmp(name, "glGenQueriesEXT") == 0) {
    return reinterpret_cast<void*>(&mockGenQueriesEXT);
  } else if (strcmp(name, "glBeginQueryEXT") == 0) {
    return reinterpret_cast<void*>(&mockBeginQueryEXT);
  } else if (strcmp(name, "glEndQueryEXT") == 0) {
    return reinterpret_cast<void*>(&mockEndQueryEXT);
  } else if (strcmp(name, "glDeleteQueriesEXT") == 0) {
    return reinterpret_cast<void*>(&mockDeleteQueriesEXT);
  } else if (strcmp(name, "glDeleteTextures") == 0) {
    return reinterpret_cast<void*>(&mockDeleteTextures);
  } else if (strcmp(name, "glGetQueryObjectui64vEXT") == 0) {
    return reinterpret_cast<void*>(mockGetQueryObjectui64vEXT);
  } else if (strcmp(name, "glGetQueryObjectuivEXT") == 0) {
    return reinterpret_cast<void*>(mockGetQueryObjectuivEXT);
  } else if (strcmp(name, "glUniform1fv") == 0) {
    return reinterpret_cast<void*>(mockUniform1fv);
  } else if (strcmp(name, "glUniform2fv") == 0) {
    return reinterpret_cast<void*>(mockUniform2fv);
  } else if (strcmp(name, "glUniform3fv") == 0) {
    return reinterpret_cast<void*>(mockUniform3fv);
  } else if (strcmp(name, "glUniform4fv") == 0) {
    return reinterpret_cast<void*>(mockUniform4fv);
  } else if (strcmp(name, "glUniformMatrix2fv") == 0) {
    return reinterpret_cast<void*>(mockUniformMatrix2fv);
  } else if (strcmp(name, "glUniformMatrix3fv") == 0) {
    return reinterpret_cast<void*>(mockUniformMatrix3fv);
  } else if (strcmp(name, "glUniformMatrix4fv") == 0) {
    return reinterpret_cast<void*>(mockUniformMatrix4fv);
  } else if (strcmp(name, "glGenTextures") == 0) {
    return reinterpret_cast<void*>(mockGenTextures);
  } else if (strcmp(name, "glTexSubImage2D") == 0) {
    return reinterpret_cast<void*>(mockTexSubImage2D);
  } else if (strcmp(name, "glTexImage2D") == 0) {
    return reinterpret_cast<void*>(mockTexImage2D);
  } else if (strcmp(name, "glBindTexture") == 0) {
    return reinterpret_cast<void*>(mockBindTexture);
  } else if (strcmp(name, "glObjectLabelKHR") == 0) {
    return reinterpret_cast<void*>(mockObjectLabelKHR);
  } else if (strcmp(name, "glGenBuffers") == 0) {
    return reinterpret_cast<void*>(mockGenBuffers);
  } else if (strcmp(name, "glBufferSubData") == 0) {
    return reinterpret_cast<void*>(mockBufferSubData);
  } else if (strcmp(name, "glIsTexture") == 0) {
    return reinterpret_cast<void*>(mockIsTexture);
  } else if (strcmp(name, "glCheckFramebufferStatus") == 0) {
    return reinterpret_cast<void*>(mockCheckFramebufferStatus);
  } else if (strcmp(name, "glReadPixels") == 0) {
    return reinterpret_cast<void*>(mockReadPixels);
  } else if (strcmp(name, "glGenFramebuffers") == 0) {
    return reinterpret_cast<void*>(mockGenFramebuffers);
  } else if (strcmp(name, "glBindFramebuffer") == 0) {
    return reinterpret_cast<void*>(mockBindFramebuffer);
  } else if (strcmp(name, "glDiscardFramebufferEXT") == 0) {
    return reinterpret_cast<void*>(mockDiscardFramebufferEXT);
  } else if (strcmp(name, "glInvalidateFramebuffer") == 0) {
    return reinterpret_cast<void*>(mockInvalidateFramebuffer);
  } else if (strcmp(name, "glViewport") == 0) {
    return reinterpret_cast<void*>(mockViewport);
  } else if (strcmp(name, "glDrawArrays") == 0) {
    return reinterpret_cast<void*>(mockDrawArrays);
  } else if (strcmp(name, "glDrawElements") == 0) {
    return reinterpret_cast<void*>(mockDrawElements);
  } else if (strcmp(name, "glDrawArraysInstanced") == 0) {
    return reinterpret_cast<void*>(mockDrawArraysInstanced);
  } else if (strcmp(name, "glDrawElementsInstanced") == 0) {
    return reinterpret_cast<void*>(mockDrawElementsInstanced);
  } else if (strcmp(name, "glVertexAttribDivisor") == 0) {
    return reinterpret_cast<void*>(mockVertexAttribDivisor);
  } else {
    return reinterpret_cast<void*>(&doNothing);
  }
};

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ kMockResolverGLESWithoutInstancing

const ProcTableGLES::Resolver impeller::testing::kMockResolverGLESWithoutInstancing

Initial value:

=
    [](const char* name) -> void* {
  
  
  
  if (strcmp(name, "glDrawArraysInstancedEXT") == 0 ||
      strcmp(name, "glDrawArraysInstanced") == 0 ||
      strcmp(name, "glDrawElementsInstancedEXT") == 0 ||
      strcmp(name, "glDrawElementsInstanced") == 0 ||
      strcmp(name, "glVertexAttribDivisorEXT") == 0 ||
      strcmp(name, "glVertexAttribDivisor") == 0) {
    return nullptr;
  }
  return kMockResolverGLES(name);
}

A resolver that behaves like |kMockResolverGLES| but hides the hardware instancing entry points, so the OpenGL ES backend exercises its instanced-draw emulation fallback.

Definition at line 545 of file mock_gles.cc.

                                  {
  // Hide the hardware instancing entry points so the OpenGL ES backend takes
  // its emulation path. The proc table retries these names with the "EXT"
  // suffix stripped, so both spellings are rejected here.
  if (strcmp(name, "glDrawArraysInstancedEXT") == 0 ||
      strcmp(name, "glDrawArraysInstanced") == 0 ||
      strcmp(name, "glDrawElementsInstancedEXT") == 0 ||
      strcmp(name, "glDrawElementsInstanced") == 0 ||
      strcmp(name, "glVertexAttribDivisorEXT") == 0 ||
      strcmp(name, "glVertexAttribDivisor") == 0) {
    return nullptr;
  }
  return kMockResolverGLES(name);
};

Referenced by TEST_F(), and TEST_F().

◆ kMockShadingLanguageVersion

const auto impeller::testing::kMockShadingLanguageVersion = "GLSL ES 1.0"

Definition at line 37 of file mock_gles.cc.

Referenced by mockGetString().

◆ kMockVendor

auto const impeller::testing::kMockVendor = "MockGLES"

Definition at line 36 of file mock_gles.cc.

Referenced by mockGetString().

◆ kPaintVariations

const std::map<std::string, MaskBlurTestConfig> impeller::testing::kPaintVariations

static

Definition at line 685 of file aiks_dl_blur_unittests.cc.

                                                                      {
    // 1. Normal style, translucent, zero sigma.
    {"NormalTranslucentZeroSigma",
     {.style = DlBlurStyle::kNormal, .sigma = 0.0f, .alpha = 0.5f}},
    // 2. Normal style, translucent.
    {"NormalTranslucent",
     {.style = DlBlurStyle::kNormal, .sigma = 8.0f, .alpha = 0.5f}},
    // 3. Solid style, translucent.
    {"SolidTranslucent",
     {.style = DlBlurStyle::kSolid, .sigma = 8.0f, .alpha = 0.5f}},
    // 4. Solid style, opaque.
    {"SolidOpaque", {.style = DlBlurStyle::kSolid, .sigma = 8.0f}},
    // 5. Solid style, translucent, color & image filtered.
    {"SolidTranslucentWithFilters",
     {.style = DlBlurStyle::kSolid,
      .sigma = 8.0f,
      .alpha = 0.5f,
      .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp),
      .invert_colors = true}},
    // 6. Solid style, translucent, exclusion blended.
    {"SolidTranslucentExclusionBlend",
     {.style = DlBlurStyle::kSolid,
      .sigma = 8.0f,
      .alpha = 0.5f,
      .blend_mode = DlBlendMode::kExclusion}},
    // 7. Inner style, translucent.
    {"InnerTranslucent",
     {.style = DlBlurStyle::kInner, .sigma = 8.0f, .alpha = 0.5f}},
    // 8. Inner style, translucent, blurred.
    {"InnerTranslucentWithBlurImageFilter",
     {.style = DlBlurStyle::kInner,
      .sigma = 8.0f,
      .alpha = 0.5f,
      .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp)}},
    // 9. Outer style, translucent.
    {"OuterTranslucent",
     {.style = DlBlurStyle::kOuter, .sigma = 8.0f, .alpha = 0.5f}},
    // 10. Outer style, opaque, image filtered.
    {"OuterOpaqueWithBlurImageFilter",
     {.style = DlBlurStyle::kOuter,
      .sigma = 8.0f,
      .image_filter = DlImageFilter::MakeBlur(3, 3, DlTileMode::kClamp)}}};

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ AiksTest

◆ AllocatorMTLTest

◆ BlitPassTest

◆ ComputeTest

◆ ContextMTLTest

◆ DeviceBufferTest

◆ DisplayListTest

◆ DriverInfoVKTest

◆ EntityPassTargetTest

◆ EntityTest

◆ HostBufferTest

◆ PipelineCacheDataVKPlaygroundTest

◆ PipelineLibraryGLESTest

◆ RendererGoldenTest

◆ RendererTest

◆ RenderTargetCacheTest

◆ RuntimeStageTest

◆ SaveLayerUtilsTest

◆ SurfaceGLESTest

◆ SwapchainTransientsMTLTest

◆ TessellatorPlaygroundTest

◆ TextContentsTest

◆ TextureGLESTest

◆ TypographerTest

Function Documentation

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [1/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [2/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [3/4]

◆ APPLY_COLOR_FILTER_GRADIENT_TEST() [4/4]

◆ BlendModeTest()

◆ CanBatchSubmitTest()

◆ CanRenderConicalGradientWithDithering()

◆ CanRenderLinearGradientWithDithering()

◆ CanRenderRadialGradientWithDithering()

◆ CanRenderSweepGradientWithDithering()

◆ CanUseFramebufferFetch()

◆ CanUseMipgeneration()

◆ CanUsePrimitiveRestartSubmitTest()

◆ CAPABILITY_TEST() [1/12]

◆ CAPABILITY_TEST() [2/12]

◆ CAPABILITY_TEST() [3/12]

◆ CAPABILITY_TEST() [4/12]

◆ CAPABILITY_TEST() [5/12]

◆ CAPABILITY_TEST() [6/12]

◆ CAPABILITY_TEST() [7/12]

◆ CAPABILITY_TEST() [8/12]

◆ CAPABILITY_TEST() [9/12]

◆ CAPABILITY_TEST() [10/12]

◆ CAPABILITY_TEST() [11/12]

◆ CAPABILITY_TEST() [12/12]

◆ CompareFunctionUI()

◆ CopyBufferView()

◆ CreateDefaultPipeline()

◆ CreateGlyphAtlas() [1/2]

◆ CreateGlyphAtlas() [2/2]

◆ CreateMappingFromString()

◆ CreateStringFromMapping()

◆ CreateSurface()

◆ CreateTestCanvas()

◆ CreateTestYUVTextures()

◆ DoGradientOvalStrokeMaskBlur()

◆ doNothing()

◆ DrainMicrotasks()

◆ DrawCompressedTextureGolden()

◆ DrawManuallyMippedTextureGolden()

◆ flip_lr()

◆ flip_lrtb()

◆ flip_tb()

◆ FML_TEST_CLASS() [1/4]

◆ FML_TEST_CLASS() [2/4]

◆ FML_TEST_CLASS() [3/4]

◆ FML_TEST_CLASS() [4/4]

◆ GetBlendModeSelection()

◆ GetImageMemoryBarriers()

◆ GetMockVulkanFunctions()